strict=True

Author: kevinjqliu

pyiceberg/avro/resolver.py

@@ -281,7 +281,7 @@ def struct(self, file_schema: StructType, record_struct: IcebergType | None, fil
         record_struct_positions: Dict[int, int] = {field.field_id: pos for pos, field in enumerate(record_struct.fields)}
         results: List[Tuple[int | None, Writer]] = []
 
-        for writer, file_field in zip(file_writers, file_schema.fields):
+        for writer, file_field in zip(file_writers, file_schema.fields, strict=True):
             if file_field.field_id in record_struct_positions:
                 results.append((record_struct_positions[file_field.field_id], writer))
             elif file_field.required:
@@ -408,7 +408,7 @@ def struct(self, struct: StructType, expected_struct: IcebergType | None, field_
                 # Check if we need to convert it to an Enum
                 result_reader if not (enum_type := self.read_enums.get(field.field_id)) else EnumReader(enum_type, result_reader),
             )
-            for field, result_reader in zip(struct.fields, field_readers)
+            for field, result_reader in zip(struct.fields, field_readers, strict=True)
         ]
 
         file_fields = {field.field_id for field in struct.fields}

pyiceberg/io/pyarrow.py

@@ -1898,7 +1898,7 @@ def struct(self, struct: StructType, struct_array: pa.Array | None, field_result
             return None
         field_arrays: List[pa.Array] = []
         fields: List[pa.Field] = []
-        for field, field_array in zip(struct.fields, field_results):
+        for field, field_array in zip(struct.fields, field_results, strict=True):
             if field_array is not None:
                 array = self._cast_if_needed(field, field_array)
                 field_arrays.append(array)
@@ -2840,7 +2840,7 @@ def _determine_partitions(spec: PartitionSpec, schema: Schema, arrow_table: pa.T
     # to avoid conflicts
     partition_fields = [f"_partition_{field.name}" for field in spec.fields]
 
-    for partition, name in zip(spec.fields, partition_fields):
+    for partition, name in zip(spec.fields, partition_fields, strict=True):
         source_field = schema.find_field(partition.source_id)
         full_field_name = schema.find_column_name(partition.source_id)
         if full_field_name is None:
@@ -2854,7 +2854,7 @@ def _determine_partitions(spec: PartitionSpec, schema: Schema, arrow_table: pa.T
         partition_key = PartitionKey(
             field_values=[
                 PartitionFieldValue(field=field, value=unique_partition[name])
-                for field, name in zip(spec.fields, partition_fields)
+                for field, name in zip(spec.fields, partition_fields, strict=True)
             ],
             partition_spec=spec,
             schema=schema,
@@ -2868,7 +2868,7 @@ def _determine_partitions(spec: PartitionSpec, schema: Schema, arrow_table: pa.T
                         if unique_partition[partition_field_name] is not None
                         else pc.field(partition_field_name).is_null()
                     )
-                    for field, partition_field_name in zip(spec.fields, partition_fields)
+                    for field, partition_field_name in zip(spec.fields, partition_fields, strict=True)
                 ],
             )
         )

pyiceberg/partitioning.py

@@ -202,7 +202,7 @@ def compatible_with(self, other: PartitionSpec) -> bool:
             this_field.source_id == that_field.source_id
             and this_field.transform == that_field.transform
             and this_field.name == that_field.name
-            for this_field, that_field in zip(self.fields, other.fields)
+            for this_field, that_field in zip(self.fields, other.fields, strict=True)
         )
 
     def partition_type(self, schema: Schema) -> StructType:
@@ -242,7 +242,7 @@ def partition_to_path(self, data: Record, schema: Schema) -> str:
             value_strs.append(quote_plus(value_str, safe=""))
             field_strs.append(quote_plus(partition_field.name, safe=""))
 
-        path = "/".join([field_str + "=" + value_str for field_str, value_str in zip(field_strs, value_strs)])
+        path = "/".join([field_str + "=" + value_str for field_str, value_str in zip(field_strs, value_strs, strict=True)])
         return path
 
 

pyiceberg/schema.py

@@ -125,7 +125,7 @@ def __eq__(self, other: Any) -> bool:
             return False
 
         identifier_field_ids_is_equal = self.identifier_field_ids == other.identifier_field_ids
-        schema_is_equal = all(lhs == rhs for lhs, rhs in zip(self.columns, other.columns))
+        schema_is_equal = all(lhs == rhs for lhs, rhs in zip(self.columns, other.columns, strict=True))
 
         return identifier_field_ids_is_equal and schema_is_equal
 
@@ -1317,7 +1317,7 @@ def schema(self, schema: Schema, struct_result: Callable[[], StructType]) -> Sch
     def struct(self, struct: StructType, field_results: List[Callable[[], IcebergType]]) -> StructType:
         new_ids = [self._get_and_increment(field.field_id) for field in struct.fields]
         new_fields = []
-        for field_id, field, field_type in zip(new_ids, struct.fields, field_results):
+        for field_id, field, field_type in zip(new_ids, struct.fields, field_results, strict=True):
             new_fields.append(
                 NestedField(
                     field_id=field_id,

pyiceberg/table/metadata.py

@@ -337,7 +337,9 @@ def _generate_snapshot_id() -> int:
     """
     rnd_uuid = uuid.uuid4()
     snapshot_id = int.from_bytes(
-        bytes(lhs ^ rhs for lhs, rhs in zip(rnd_uuid.bytes[0:8], rnd_uuid.bytes[8:16])), byteorder="little", signed=True
+        bytes(lhs ^ rhs for lhs, rhs in zip(rnd_uuid.bytes[0:8], rnd_uuid.bytes[8:16], strict=True)),
+        byteorder="little",
+        signed=True,
     )
     snapshot_id = snapshot_id if snapshot_id >= 0 else snapshot_id * -1
 

pyiceberg/table/name_mapping.py

@@ -155,7 +155,7 @@ def schema(self, schema: Schema, struct_result: List[MappedField]) -> List[Mappe
     def struct(self, struct: StructType, field_results: List[List[MappedField]]) -> List[MappedField]:
         return [
             MappedField(field_id=field.field_id, names=[field.name], fields=result)
-            for field, result in zip(struct.fields, field_results)
+            for field, result in zip(struct.fields, field_results, strict=True)
         ]
 
     def field(self, field: NestedField, field_result: List[MappedField]) -> List[MappedField]:

pyiceberg/table/upsert_util.py

@@ -103,7 +103,9 @@ def get_rows_to_update(source_table: pa.Table, target_table: pa.Table, join_cols
     # Step 4: Compare all rows using Python
     to_update_indices = []
     for source_idx, target_idx in zip(
-        matching_indices[SOURCE_INDEX_COLUMN_NAME].to_pylist(), matching_indices[TARGET_INDEX_COLUMN_NAME].to_pylist()
+        matching_indices[SOURCE_INDEX_COLUMN_NAME].to_pylist(),
+        matching_indices[TARGET_INDEX_COLUMN_NAME].to_pylist(),
+        strict=True,
     ):
         source_row = source_table.slice(source_idx, 1)
         target_row = target_table.slice(target_idx, 1)

pyiceberg/utils/lazydict.py

@@ -46,7 +46,7 @@ def __init__(self, contents: Sequence[Sequence[K | V]]):
     def _build_dict(self) -> Dict[K, V]:
         self._dict = {}
         for item in self._contents:
-            self._dict.update(dict(zip(cast(Sequence[K], item[::2]), cast(Sequence[V], item[1::2]))))
+            self._dict.update(dict(zip(cast(Sequence[K], item[::2]), cast(Sequence[V], item[1::2]), strict=True)))
 
         return self._dict