Python: Minor changes to types classes, follow up to #3234 (#3350)

Author: jun-he

python/src/iceberg/types.py

@@ -34,7 +34,7 @@ def is_primitive(self) -> bool:
 
 class FixedType(Type):
     def __init__(self, length: int):
-        super().__init__(f"fixed[{length}]", f"FixedType({length})", is_primitive=True)
+        super().__init__(f"fixed[{length}]", f"FixedType(length={length})", is_primitive=True)
         self._length = length
 
     @property
@@ -44,7 +44,8 @@ def length(self) -> int:
 
 class DecimalType(Type):
     def __init__(self, precision: int, scale: int):
-        super().__init__(f"decimal({precision}, {scale})", f"DecimalType({precision}, {scale})", is_primitive=True)
+        super().__init__(f"decimal({precision}, {scale})",
+                         f"DecimalType(precision={precision}, scale={scale})", is_primitive=True)
         self._precision = precision
         self._scale = scale
 
@@ -58,7 +59,7 @@ def scale(self) -> int:
 
 
 class NestedField(object):
-    def __init__(self, is_optional: bool, field_id: int, name: str, field_type: Type, doc=None):
+    def __init__(self, is_optional: bool, field_id: int, name: str, field_type: Type, doc: str = None):
         self._is_optional = is_optional
         self._id = field_id
         self._name = name
@@ -86,8 +87,8 @@ def type(self) -> Type:
         return self._type
 
     def __repr__(self):
-        return (f"NestedField({self._is_optional}, {self._id}, "
-                f"{repr(self._name)}, {repr(self._type)}, {repr(self._doc)})")
+        return (f"NestedField(is_optional={self._is_optional}, field_id={self._id}, "
+                f"name={repr(self._name)}, field_type={repr(self._type)}, doc={repr(self._doc)})")
 
     def __str__(self):
         return (f"{self._id}: {self._name}: {'optional' if self._is_optional else 'required'} {self._type}"
@@ -96,7 +97,7 @@ def __str__(self):
 
 class StructType(Type):
     def __init__(self, fields: list):
-        super().__init__(f"struct<{', '.join(map(str, fields))}>", f"StructType({repr(fields)})")
+        super().__init__(f"struct<{', '.join(map(str, fields))}>", f"StructType(fields={repr(fields)})")
         self._fields = fields
 
     @property
@@ -105,21 +106,21 @@ def fields(self) -> list:
 
 
 class ListType(Type):
-    def __init__(self, element_field: NestedField):
-        super().__init__(f"list<{element_field.type}>", f"ListType({repr(element_field)})")
-        self._element_field = element_field
+    def __init__(self, element: NestedField):
+        super().__init__(f"list<{element.type}>", f"ListType(element={repr(element)})")
+        self._element_field = element
 
     @property
     def element(self) -> NestedField:
         return self._element_field
 
 
 class MapType(Type):
-    def __init__(self, key_field: NestedField, value_field: NestedField):
-        super().__init__(f"map<{key_field.type}, {value_field.type}>",
-                         f"MapType({repr(key_field)}, {repr(value_field)})")
-        self._key_field = key_field
-        self._value_field = value_field
+    def __init__(self, key: NestedField, value: NestedField):
+        super().__init__(f"map<{key.type}, {value.type}>",
+                         f"MapType(key={repr(key)}, value={repr(value)})")
+        self._key_field = key
+        self._value_field = value
 
     @property
     def key(self) -> NestedField:

python/tests/test_types.py

@@ -29,15 +29,19 @@ def test_repr_primitive_types(input_type):
 
 
 def test_fixed_type():
-    type_var = FixedType(5)
+    type_var = FixedType(length=5)
     assert type_var.length == 5
+    assert str(type_var) == "fixed[5]"
+    assert repr(type_var) == "FixedType(length=5)"
     assert str(type_var) == str(eval(repr(type_var)))
 
 
 def test_decimal_type():
-    type_var = DecimalType(9, 2)
+    type_var = DecimalType(precision=9, scale=2)
     assert type_var.precision == 9
     assert type_var.scale == 2
+    assert str(type_var) == 'decimal(9, 2)'
+    assert repr(type_var) == "DecimalType(precision=9, scale=2)"
     assert str(type_var) == str(eval(repr(type_var)))