drop fields kwarg

Author: dpkp

kafka/protocol/new/api_array.py

@@ -7,18 +7,18 @@
 
 class ApiArray(Field):
     @classmethod
-    def parse_json(cls, json, fields=None):
+    def parse_json(cls, json):
         if json['type'].startswith('[]'):
             inner_type_str = json['type'][2:]
             if inner_type_str.startswith('[]'): # this would be strange...
                 return None
             inner_json = {**json, 'type': inner_type_str}
-            inner_type = super().parse_json(inner_json, fields=fields)
+            inner_type = super().parse_json(inner_json)
             if inner_type is not None:
-                return cls(json, fields=fields, array_of=inner_type)
+                return cls(json, array_of=inner_type)
 
-    def __init__(self, json, fields=None, array_of=None):
-        super().__init__(json, fields=fields)
+    def __init__(self, json, array_of=None):
+        super().__init__(json)
         self.array_of = array_of # Field (ApiStruct or FieldBasicType)
 
     def is_array(self):

kafka/protocol/new/api_struct.py

@@ -8,17 +8,17 @@
 
 class ApiStruct(Field):
     @classmethod
-    def parse_json(cls, json, fields=None):
+    def parse_json(cls, json):
         if json['type'] in ('request', 'response', 'header') or json['type'][0].isupper():
-            if fields is not None or json.get('fields') is not None:
-                return cls(json, fields=fields)
+            if 'fields' in json:
+                return cls(json)
 
     # Cases
     # oldschool  - standard types, no tagged fields
     # newschool  - compact types, tagged fields
     # nested tag - compact types, no (nested) tagged fields
-    def __init__(self, json, fields=None):
-        super().__init__(json, fields=fields)
+    def __init__(self, json):
+        super().__init__(json)
         self._field_map = {field.name: field for field in self._fields if field is not None}
         self._data_class = None
 

kafka/protocol/new/field.py

@@ -12,14 +12,12 @@ def parse_json_fields(cls, json):
         return tuple(map(Field.parse_json, json.get('fields', []))) or None # Note: DFS Field construction
 
     @classmethod
-    def parse_json(cls, json, fields=None):
+    def parse_json(cls, json):
         if 'type' not in json:
             raise ValueError('No type found in json')
         type_str = json['type']
-        if fields is None and json.get('fields') is not None:
-            fields = cls.parse_json_fields(json)
         for field_type in cls.FIELD_TYPES:
-            maybe_type = field_type.parse_json(json, fields=fields)
+            maybe_type = field_type.parse_json(json)
             if maybe_type is not None:
                 return maybe_type
         else:
@@ -42,7 +40,7 @@ def parse_versions(cls, versions):
         else:
             return tuple(map(int, versions.split('-')))
 
-    def __init__(self, json, fields=None):
+    def __init__(self, json):
         self._json = json
         self._name = json['name']
         # versions tells when to include the field in encode / decode
@@ -63,9 +61,10 @@ def __init__(self, json, fields=None):
         self._flexible_versions = self.parse_versions(json.get('flexibleVersions'))
         self._nullable_versions = self.parse_versions(json.get('nullableVersions'))
         self._type_str = json['type']
-        if fields is None and json.get('fields') is not None:
-            fields = self.parse_json_fields(json)
-        self._fields = fields
+        if 'fields' in json:
+            self._fields = self.parse_json_fields(json)
+        else:
+            self._fields = None
         self._ignorable = json.get('ignorable')
         self._entity_type = json.get('entityType')
         self._about = json.get('about', '')

kafka/protocol/new/field_basic.py

@@ -25,14 +25,14 @@ class FieldBasicType(Field):
     }
 
     @classmethod
-    def parse_json(cls, json, fields=None):
-        if fields is None and json['type'] in cls.TYPES:
+    def parse_json(cls, json):
+        if 'fields' not in json and json['type'] in cls.TYPES:
             return cls(json)
 
-    def __init__(self, json, fields=None):
-        if fields is not None or json.get('fields') is not None:
-            raise ValueError('Non-empty fields not allowed in FieldBasicType!')
-        super().__init__(json, fields=None)
+    def __init__(self, json):
+        if 'fields' in json:
+            raise ValueError('Fields not allowed in FieldBasicType!')
+        super().__init__(json)
         if self._type_str not in self.TYPES:
             raise ValueError('Unrecognized type: %s' % self._type_str)
         self._type = self.TYPES[self._type_str]