Remove redundant CDC chunk-size/norm-level validation

PyArrow already validates these values itself (e.g. max_chunk_size
must be greater than min_chunk_size) and raises a clear OSError, and
iceberg-rust's equivalent ParquetWriterBuilder::from_table_properties
doesn't duplicate this validation either -- defer to PyArrow instead
of maintaining a second, slightly different copy of the same checks.

Author: kszucs

pyiceberg/io/pyarrow.py

@@ -2874,35 +2874,24 @@ def _get_parquet_writer_kwargs(table_properties: Properties) -> dict[str, Any]:
         default=TableProperties.PARQUET_CDC_ENABLED_DEFAULT,
     ):
         _require_pyarrow_version("21.0.0", "Parquet content-defined chunking")
-        min_chunk_size = property_as_int(
-            properties=table_properties,
-            property_name=TableProperties.PARQUET_CDC_MIN_CHUNK_SIZE,
-            default=TableProperties.PARQUET_CDC_MIN_CHUNK_SIZE_DEFAULT,
-        )
-        max_chunk_size = property_as_int(
-            properties=table_properties,
-            property_name=TableProperties.PARQUET_CDC_MAX_CHUNK_SIZE,
-            default=TableProperties.PARQUET_CDC_MAX_CHUNK_SIZE_DEFAULT,
-        )
-        norm_level = property_as_int(
-            properties=table_properties,
-            property_name=TableProperties.PARQUET_CDC_NORM_LEVEL,
-            default=TableProperties.PARQUET_CDC_NORM_LEVEL_DEFAULT,
-        )
-        if min_chunk_size is not None and min_chunk_size <= 0:
-            raise ValueError(f"{TableProperties.PARQUET_CDC_MIN_CHUNK_SIZE} must be greater than 0, got {min_chunk_size}")
-        if max_chunk_size is not None and min_chunk_size is not None and max_chunk_size <= min_chunk_size:
-            raise ValueError(
-                f"{TableProperties.PARQUET_CDC_MAX_CHUNK_SIZE} ({max_chunk_size}) must be greater than "
-                f"{TableProperties.PARQUET_CDC_MIN_CHUNK_SIZE} ({min_chunk_size})"
-            )
-        if norm_level is not None and norm_level < 0:
-            raise ValueError(f"{TableProperties.PARQUET_CDC_NORM_LEVEL} must be greater than or equal to 0, got {norm_level}")
-
+        # PyArrow itself validates these values (e.g. max-chunk-size > min-chunk-size) and raises a
+        # clear OSError, so there's no need to duplicate that validation here.
         parquet_writer_kwargs["use_content_defined_chunking"] = {
-            "min_chunk_size": min_chunk_size,
-            "max_chunk_size": max_chunk_size,
-            "norm_level": norm_level,
+            "min_chunk_size": property_as_int(
+                properties=table_properties,
+                property_name=TableProperties.PARQUET_CDC_MIN_CHUNK_SIZE,
+                default=TableProperties.PARQUET_CDC_MIN_CHUNK_SIZE_DEFAULT,
+            ),
+            "max_chunk_size": property_as_int(
+                properties=table_properties,
+                property_name=TableProperties.PARQUET_CDC_MAX_CHUNK_SIZE,
+                default=TableProperties.PARQUET_CDC_MAX_CHUNK_SIZE_DEFAULT,
+            ),
+            "norm_level": property_as_int(
+                properties=table_properties,
+                property_name=TableProperties.PARQUET_CDC_NORM_LEVEL,
+                default=TableProperties.PARQUET_CDC_NORM_LEVEL_DEFAULT,
+            ),
         }
 
     return parquet_writer_kwargs

tests/io/test_pyarrow.py

@@ -5334,36 +5334,19 @@ def test_get_parquet_writer_kwargs_cdc_enabled_unsupported_pyarrow_version(monke
         _get_parquet_writer_kwargs({TableProperties.PARQUET_CDC_ENABLED: "true"})
 
 
-@pytest.mark.parametrize(
-    "table_properties,match",
-    [
-        (
-            {
-                TableProperties.PARQUET_CDC_ENABLED: "true",
-                TableProperties.PARQUET_CDC_MIN_CHUNK_SIZE: "0",
-            },
-            "min-chunk-size must be greater than 0",
-        ),
-        (
-            {
-                TableProperties.PARQUET_CDC_ENABLED: "true",
-                TableProperties.PARQUET_CDC_MIN_CHUNK_SIZE: "8192",
-                TableProperties.PARQUET_CDC_MAX_CHUNK_SIZE: "4096",
-            },
-            "max-chunk-size .* must be greater than .*min-chunk-size",
-        ),
-        (
-            {
-                TableProperties.PARQUET_CDC_ENABLED: "true",
-                TableProperties.PARQUET_CDC_NORM_LEVEL: "-1",
-            },
-            "norm-level must be greater than or equal to 0",
-        ),
-    ],
-)
-def test_get_parquet_writer_kwargs_cdc_invalid_properties(table_properties: dict[str, str], match: str) -> None:
-    with pytest.raises(ValueError, match=match):
-        _get_parquet_writer_kwargs(table_properties)
+def test_get_parquet_writer_kwargs_cdc_invalid_chunk_sizes_raises_from_pyarrow() -> None:
+    """PyArrow validates min/max chunk sizes itself; pyiceberg doesn't duplicate that check."""
+    kwargs = _get_parquet_writer_kwargs(
+        {
+            TableProperties.PARQUET_CDC_ENABLED: "true",
+            TableProperties.PARQUET_CDC_MIN_CHUNK_SIZE: "8192",
+            TableProperties.PARQUET_CDC_MAX_CHUNK_SIZE: "4096",
+        }
+    )
+    table = pa.table({"id": pa.array([1, 2, 3], type=pa.int32())})
+    with pytest.raises(OSError, match="max_chunk_size must be greater than min_chunk_size"):
+        with pq.ParquetWriter(pa.BufferOutputStream(), table.schema, **kwargs) as writer:
+            writer.write_table(table)
 
 
 def test_write_file_with_content_defined_chunking_enabled(tmp_path: Path) -> None: