strict=True in tests

Author: kevinjqliu

tests/integration/test_add_files.py

@@ -713,7 +713,7 @@ def test_add_file_with_valid_nullability_diff(spark: SparkSession, session_catal
     rhs = written_arrow_table.to_pandas()
 
     for column in written_arrow_table.column_names:
-        for left, right in zip(lhs[column].to_list(), rhs[column].to_list()):
+        for left, right in zip(lhs[column].to_list(), rhs[column].to_list(), strict=True):
             assert left == right
 
 
@@ -755,7 +755,7 @@ def test_add_files_with_valid_upcast(
     rhs = written_arrow_table.to_pandas()
 
     for column in written_arrow_table.column_names:
-        for left, right in zip(lhs[column].to_list(), rhs[column].to_list()):
+        for left, right in zip(lhs[column].to_list(), rhs[column].to_list(), strict=True):
             if column == "map":
                 # Arrow returns a list of tuples, instead of a dict
                 right = dict(right)
@@ -802,7 +802,7 @@ def test_add_files_subset_of_schema(spark: SparkSession, session_catalog: Catalo
     rhs = written_arrow_table.to_pandas()
 
     for column in written_arrow_table.column_names:
-        for left, right in zip(lhs[column].to_list(), rhs[column].to_list()):
+        for left, right in zip(lhs[column].to_list(), rhs[column].to_list(), strict=True):
             assert left == right
 
 

tests/integration/test_inspect_table.py

@@ -152,7 +152,7 @@ def _inspect_files_asserts(df: pa.Table, spark_df: DataFrame) -> None:
         if column == "partition":
             # Spark leaves out the partition if the table is unpartitioned
             continue
-        for left, right in zip(lhs[column].to_list(), rhs[column].to_list()):
+        for left, right in zip(lhs[column].to_list(), rhs[column].to_list(), strict=True):
             if isinstance(left, float) and math.isnan(left) and isinstance(right, float) and math.isnan(right):
                 # NaN != NaN in Python
                 continue
@@ -209,7 +209,7 @@ def _check_pyiceberg_df_equals_spark_df(df: pa.Table, spark_df: DataFrame) -> No
     lhs = df.to_pandas().sort_values("last_updated_at")
     rhs = spark_df.toPandas().sort_values("last_updated_at")
     for column in df.column_names:
-        for left, right in zip(lhs[column].to_list(), rhs[column].to_list()):
+        for left, right in zip(lhs[column].to_list(), rhs[column].to_list(), strict=True):
             assert left == right, f"Difference in column {column}: {left} != {right}"
 
 
@@ -284,7 +284,7 @@ def test_inspect_snapshots(
     lhs = spark.table(f"{identifier}.snapshots").toPandas()
     rhs = df.to_pandas()
     for column in df.column_names:
-        for left, right in zip(lhs[column].to_list(), rhs[column].to_list()):
+        for left, right in zip(lhs[column].to_list(), rhs[column].to_list(), strict=True):
             if column == "summary":
                 # Arrow returns a list of tuples, instead of a dict
                 right = dict(right)
@@ -332,7 +332,7 @@ def check_pyiceberg_df_equals_spark_df(df: pa.Table, spark_df: DataFrame) -> Non
         assert len(lhs) == len(rhs)
 
         for column in df.column_names:
-            for left, right in zip(lhs[column].to_list(), rhs[column].to_list()):
+            for left, right in zip(lhs[column].to_list(), rhs[column].to_list(), strict=True):
                 if column == "data_file":
                     for df_column in left.keys():
                         if df_column == "partition":
@@ -485,7 +485,7 @@ def test_inspect_refs(
     lhs = spark.table(f"{identifier}.refs").toPandas()
     rhs = df.to_pandas()
     for column in df.column_names:
-        for left, right in zip(lhs[column].to_list(), rhs[column].to_list()):
+        for left, right in zip(lhs[column].to_list(), rhs[column].to_list(), strict=True):
             if isinstance(left, float) and math.isnan(left) and isinstance(right, float) and math.isnan(right):
                 # NaN != NaN in Python
                 continue
@@ -535,7 +535,7 @@ def test_inspect_partitions_unpartitioned(
     lhs = df.to_pandas()
     rhs = spark.table(f"{identifier}.partitions").toPandas()
     for column in df.column_names:
-        for left, right in zip(lhs[column].to_list(), rhs[column].to_list()):
+        for left, right in zip(lhs[column].to_list(), rhs[column].to_list(), strict=True):
             assert left == right, f"Difference in column {column}: {left} != {right}"
 
 
@@ -755,7 +755,7 @@ def test_inspect_manifests(spark: SparkSession, session_catalog: Catalog, format
     lhs = spark.table(f"{identifier}.manifests").toPandas()
     rhs = df.to_pandas()
     for column in df.column_names:
-        for left, right in zip(lhs[column].to_list(), rhs[column].to_list()):
+        for left, right in zip(lhs[column].to_list(), rhs[column].to_list(), strict=True):
             assert left == right, f"Difference in column {column}: {left} != {right}"
 
 
@@ -793,7 +793,7 @@ def test_inspect_metadata_log_entries(
     assert_frame_equal(left_before_last, right_before_last, check_dtype=False)
     # compare the last row, except for the timestamp
     for column in df.column_names:
-        for left, right in zip(left_last[column], right_last[column]):
+        for left, right in zip(left_last[column], right_last[column], strict=True):
             if column == "timestamp":
                 continue
             assert left == right, f"Difference in column {column}: {left} != {right}"
@@ -861,7 +861,7 @@ def test_inspect_history(spark: SparkSession, session_catalog: Catalog, format_v
     lhs = spark.table(f"{identifier}.history").toPandas()
     rhs = df.to_pandas()
     for column in df.column_names:
-        for left, right in zip(lhs[column].to_list(), rhs[column].to_list()):
+        for left, right in zip(lhs[column].to_list(), rhs[column].to_list(), strict=True):
             if isinstance(left, float) and math.isnan(left) and isinstance(right, float) and math.isnan(right):
                 # NaN != NaN in Python
                 continue

tests/integration/test_partitioning_key.py

@@ -737,7 +737,7 @@ def test_partition_key(
 ) -> None:
     field_values = [
         PartitionFieldValue(field, field.transform.transform(TABLE_SCHEMA.find_field(field.source_id).field_type)(value))
-        for field, value in zip(partition_fields, partition_values)
+        for field, value in zip(partition_fields, partition_values, strict=True)
     ]
     spec = PartitionSpec(*partition_fields)
 

tests/integration/test_rest_manifest.py

@@ -38,7 +38,7 @@
 # direct comparison with the dicts returned by fastavro
 def todict(obj: Any, spec_keys: List[str]) -> Any:
     if type(obj) is Record:
-        return {key: obj[pos] for key, pos in zip(spec_keys, range(len(obj)))}
+        return {key: obj[pos] for key, pos in zip(spec_keys, range(len(obj)), strict=True)}
     if isinstance(obj, dict) or isinstance(obj, LazyDict):
         data = []
         for k, v in obj.items():

tests/integration/test_writes/test_writes.py

@@ -759,7 +759,9 @@ def test_spark_writes_orc_pyiceberg_reads(spark: SparkSession, session_catalog:
     ]
 
     # Verify PyIceberg results contain the expected data (appears twice due to create + append)
-    pyiceberg_data = list(zip(pyiceberg_df["id"], pyiceberg_df["name"], pyiceberg_df["age"], pyiceberg_df["is_active"]))
+    pyiceberg_data = list(
+        zip(pyiceberg_df["id"], pyiceberg_df["name"], pyiceberg_df["age"], pyiceberg_df["is_active"], strict=True)
+    )
     assert pyiceberg_data == expected_data + expected_data  # Data should appear twice
 
     # Verify PyIceberg data types are correct
@@ -1170,7 +1172,7 @@ def test_inspect_snapshots(
     lhs = spark.table(f"{identifier}.snapshots").toPandas()
     rhs = df.to_pandas()
     for column in df.column_names:
-        for left, right in zip(lhs[column].to_list(), rhs[column].to_list()):
+        for left, right in zip(lhs[column].to_list(), rhs[column].to_list(), strict=True):
             if column == "summary":
                 # Arrow returns a list of tuples, instead of a dict
                 right = dict(right)
@@ -1466,7 +1468,7 @@ def test_table_write_schema_with_valid_nullability_diff(
     rhs = written_arrow_table.to_pandas()
 
     for column in written_arrow_table.column_names:
-        for left, right in zip(lhs[column].to_list(), rhs[column].to_list()):
+        for left, right in zip(lhs[column].to_list(), rhs[column].to_list(), strict=True):
             assert left == right
 
 
@@ -1506,7 +1508,7 @@ def test_table_write_schema_with_valid_upcast(
     rhs = written_arrow_table.to_pandas()
 
     for column in written_arrow_table.column_names:
-        for left, right in zip(lhs[column].to_list(), rhs[column].to_list()):
+        for left, right in zip(lhs[column].to_list(), rhs[column].to_list(), strict=True):
             if column == "map":
                 # Arrow returns a list of tuples, instead of a dict
                 right = dict(right)
@@ -1552,7 +1554,7 @@ def test_write_all_timestamp_precision(
     rhs = written_arrow_table.to_pandas()
 
     for column in written_arrow_table.column_names:
-        for left, right in zip(lhs[column].to_list(), rhs[column].to_list()):
+        for left, right in zip(lhs[column].to_list(), rhs[column].to_list(), strict=True):
             if pd.isnull(left):
                 assert pd.isnull(right)
             else:

tests/io/test_pyarrow.py

@@ -1076,16 +1076,16 @@ def test_projection_add_column(file_int: str) -> None:
     for col in result_table.columns:
         assert len(col) == 3
 
-    for actual, expected in zip(result_table.columns[0], [None, None, None]):
+    for actual, expected in zip(result_table.columns[0], [None, None, None], strict=True):
         assert actual.as_py() == expected
 
-    for actual, expected in zip(result_table.columns[1], [None, None, None]):
+    for actual, expected in zip(result_table.columns[1], [None, None, None], strict=True):
         assert actual.as_py() == expected
 
-    for actual, expected in zip(result_table.columns[2], [None, None, None]):
+    for actual, expected in zip(result_table.columns[2], [None, None, None], strict=True):
         assert actual.as_py() == expected
 
-    for actual, expected in zip(result_table.columns[3], [None, None, None]):
+    for actual, expected in zip(result_table.columns[3], [None, None, None], strict=True):
         assert actual.as_py() == expected
     assert (
         repr(result_table.schema)
@@ -1106,7 +1106,9 @@ def test_read_list(schema_list: Schema, file_list: str) -> None:
     result_table = project(schema_list, [file_list])
 
     assert len(result_table.columns[0]) == 3
-    for actual, expected in zip(result_table.columns[0], [list(range(1, 10)), list(range(2, 20)), list(range(3, 30))]):
+    for actual, expected in zip(
+        result_table.columns[0], [list(range(1, 10)), list(range(2, 20)), list(range(3, 30))], strict=True
+    ):
         assert actual.as_py() == expected
 
     assert (
@@ -1120,7 +1122,7 @@ def test_read_map(schema_map: Schema, file_map: str) -> None:
     result_table = project(schema_map, [file_map])
 
     assert len(result_table.columns[0]) == 3
-    for actual, expected in zip(result_table.columns[0], [[("a", "b")], [("c", "d")], [("e", "f"), ("g", "h")]]):
+    for actual, expected in zip(result_table.columns[0], [[("a", "b")], [("c", "d")], [("e", "f"), ("g", "h")]], strict=True):
         assert actual.as_py() == expected
 
     assert (
@@ -1177,7 +1179,7 @@ def test_projection_rename_column(schema_int: Schema, file_int: str) -> None:
     )
     result_table = project(schema, [file_int])
     assert len(result_table.columns[0]) == 3
-    for actual, expected in zip(result_table.columns[0], [0, 1, 2]):
+    for actual, expected in zip(result_table.columns[0], [0, 1, 2], strict=True):
         assert actual.as_py() == expected
 
     assert repr(result_table.schema) == "other_name: int32 not null"
@@ -1186,7 +1188,7 @@ def test_projection_rename_column(schema_int: Schema, file_int: str) -> None:
 def test_projection_concat_files(schema_int: Schema, file_int: str) -> None:
     result_table = project(schema_int, [file_int, file_int])
 
-    for actual, expected in zip(result_table.columns[0], [0, 1, 2, 0, 1, 2]):
+    for actual, expected in zip(result_table.columns[0], [0, 1, 2, 0, 1, 2], strict=True):
         assert actual.as_py() == expected
     assert len(result_table.columns[0]) == 6
     assert repr(result_table.schema) == "id: int32"
@@ -1350,7 +1352,7 @@ def test_projection_filter_add_column(schema_int: Schema, file_int: str, file_st
     """We have one file that has the column, and the other one doesn't"""
     result_table = project(schema_int, [file_int, file_string])
 
-    for actual, expected in zip(result_table.columns[0], [0, 1, 2, None, None, None]):
+    for actual, expected in zip(result_table.columns[0], [0, 1, 2, None, None, None], strict=True):
         assert actual.as_py() == expected
     assert len(result_table.columns[0]) == 6
     assert repr(result_table.schema) == "id: int32"
@@ -1360,7 +1362,7 @@ def test_projection_filter_add_column_promote(file_int: str) -> None:
     schema_long = Schema(NestedField(1, "id", LongType(), required=True))
     result_table = project(schema_long, [file_int])
 
-    for actual, expected in zip(result_table.columns[0], [0, 1, 2]):
+    for actual, expected in zip(result_table.columns[0], [0, 1, 2], strict=True):
         assert actual.as_py() == expected
     assert len(result_table.columns[0]) == 3
     assert repr(result_table.schema) == "id: int64 not null"
@@ -1388,7 +1390,7 @@ def test_projection_nested_struct_subset(file_struct: str) -> None:
 
     result_table = project(schema, [file_struct])
 
-    for actual, expected in zip(result_table.columns[0], [52.371807, 52.387386, 52.078663]):
+    for actual, expected in zip(result_table.columns[0], [52.371807, 52.387386, 52.078663], strict=True):
         assert actual.as_py() == {"lat": expected}
 
     assert len(result_table.columns[0]) == 3
@@ -1413,7 +1415,7 @@ def test_projection_nested_new_field(file_struct: str) -> None:
 
     result_table = project(schema, [file_struct])
 
-    for actual, expected in zip(result_table.columns[0], [None, None, None]):
+    for actual, expected in zip(result_table.columns[0], [None, None, None], strict=True):
         assert actual.as_py() == {"null": expected}
     assert len(result_table.columns[0]) == 3
     assert (
@@ -1445,6 +1447,7 @@ def test_projection_nested_struct(schema_struct: Schema, file_struct: str) -> No
             {"lat": 52.387386, "long": 4.646219, "null": None},
             {"lat": 52.078663, "long": 4.288788, "null": None},
         ],
+        strict=True,
     ):
         assert actual.as_py() == expected
     assert len(result_table.columns[0]) == 3
@@ -1536,6 +1539,7 @@ def test_projection_maps_of_structs(schema_map_of_structs: Schema, file_map_of_s
                 ("4", {"latitude": 52.387386, "longitude": 4.646219, "altitude": None}),
             ],
         ],
+        strict=True,
     ):
         assert actual.as_py() == expected
     assert (
@@ -1563,7 +1567,7 @@ def test_projection_nested_struct_different_parent_id(file_struct: str) -> None:
     )
 
     result_table = project(schema, [file_struct])
-    for actual, expected in zip(result_table.columns[0], [None, None, None]):
+    for actual, expected in zip(result_table.columns[0], [None, None, None], strict=True):
         assert actual.as_py() == expected
     assert len(result_table.columns[0]) == 3
     assert (
@@ -1579,10 +1583,7 @@ def test_projection_filter_on_unprojected_field(schema_int_str: Schema, file_int
 
     result_table = project(schema, [file_int_str], GreaterThan("data", "1"), schema_int_str)
 
-    for actual, expected in zip(
-        result_table.columns[0],
-        [2],
-    ):
+    for actual, expected in zip(result_table.columns[0], [2], strict=True):
         assert actual.as_py() == expected
     assert len(result_table.columns[0]) == 1
     assert repr(result_table.schema) == "id: int32 not null"

tests/test_types.py

@@ -698,7 +698,7 @@ def test_deepcopy_of_singleton_fixed_type() -> None:
     list_of_fixed_types = [FixedType(22), FixedType(19)]
     copied_list = deepcopy(list_of_fixed_types)
 
-    for lhs, rhs in zip(list_of_fixed_types, copied_list):
+    for lhs, rhs in zip(list_of_fixed_types, copied_list, strict=True):
         assert id(lhs) == id(rhs)