From 81726304bf45e571d56847bee4dea02aa0bef5ca Mon Sep 17 00:00:00 2001 From: Fokko Date: Sun, 8 Jun 2025 21:37:25 +0200 Subject: [PATCH] Bump Ruff to the latest version Makes the code look nicer --- .pre-commit-config.yaml | 2 +- tests/catalog/test_rest.py | 48 +-- tests/expressions/test_visitors.py | 480 ++++++++++++++--------------- tests/table/test_init.py | 18 +- tests/table/test_upsert.py | 4 +- tests/test_types.py | 6 +- tests/utils/test_manifest.py | 6 +- 7 files changed, 282 insertions(+), 282 deletions(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 66f830e2b8..63697b098f 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -27,7 +27,7 @@ repos: - id: check-yaml - id: check-ast - repo: https://github.com/astral-sh/ruff-pre-commit - rev: v0.8.6 + rev: v0.11.13 hooks: - id: ruff args: [ --fix, --exit-non-zero-on-fix ] diff --git a/tests/catalog/test_rest.py b/tests/catalog/test_rest.py index 1ad6f57d36..ed91dd15a1 100644 --- a/tests/catalog/test_rest.py +++ b/tests/catalog/test_rest.py @@ -323,19 +323,19 @@ def test_properties_sets_headers(requests_mock: Mocker) -> None: **{"header.Content-Type": "application/vnd.api+json", "header.Customized-Header": "some/value"}, ) - assert ( - catalog._session.headers.get("Content-type") == "application/json" - ), "Expected 'Content-Type' default header not to be overwritten" - assert ( - requests_mock.last_request.headers["Content-type"] == "application/json" - ), "Config request did not include expected 'Content-Type' header" + assert catalog._session.headers.get("Content-type") == "application/json", ( + "Expected 'Content-Type' default header not to be overwritten" + ) + assert requests_mock.last_request.headers["Content-type"] == "application/json", ( + "Config request did not include expected 'Content-Type' header" + ) - assert ( - catalog._session.headers.get("Customized-Header") == "some/value" - ), "Expected 'Customized-Header' header to be 'some/value'" - assert ( - requests_mock.last_request.headers["Customized-Header"] == "some/value" - ), "Config request did not include expected 'Customized-Header' header" + assert catalog._session.headers.get("Customized-Header") == "some/value", ( + "Expected 'Customized-Header' header to be 'some/value'" + ) + assert requests_mock.last_request.headers["Customized-Header"] == "some/value", ( + "Config request did not include expected 'Customized-Header' header" + ) def test_config_sets_headers(requests_mock: Mocker) -> None: @@ -352,19 +352,19 @@ def test_config_sets_headers(requests_mock: Mocker) -> None: catalog = RestCatalog("rest", uri=TEST_URI, warehouse="s3://some-bucket") catalog.create_namespace(namespace) - assert ( - catalog._session.headers.get("Content-type") == "application/json" - ), "Expected 'Content-Type' default header not to be overwritten" - assert ( - requests_mock.last_request.headers["Content-type"] == "application/json" - ), "Create namespace request did not include expected 'Content-Type' header" + assert catalog._session.headers.get("Content-type") == "application/json", ( + "Expected 'Content-Type' default header not to be overwritten" + ) + assert requests_mock.last_request.headers["Content-type"] == "application/json", ( + "Create namespace request did not include expected 'Content-Type' header" + ) - assert ( - catalog._session.headers.get("Customized-Header") == "some/value" - ), "Expected 'Customized-Header' header to be 'some/value'" - assert ( - requests_mock.last_request.headers["Customized-Header"] == "some/value" - ), "Create namespace request did not include expected 'Customized-Header' header" + assert catalog._session.headers.get("Customized-Header") == "some/value", ( + "Expected 'Customized-Header' header to be 'some/value'" + ) + assert requests_mock.last_request.headers["Customized-Header"] == "some/value", ( + "Create namespace request did not include expected 'Customized-Header' header" + ) @pytest.mark.filterwarnings( diff --git a/tests/expressions/test_visitors.py b/tests/expressions/test_visitors.py index 9e0d667b10..273bd24c9b 100644 --- a/tests/expressions/test_visitors.py +++ b/tests/expressions/test_visitors.py @@ -947,95 +947,95 @@ def manifest() -> ManifestFile: def test_all_nulls(schema: Schema, manifest: ManifestFile) -> None: - assert not _ManifestEvalVisitor(schema, NotNull(Reference("all_nulls_missing_nan")), case_sensitive=True).eval( - manifest - ), "Should skip: all nulls column with non-floating type contains all null" + assert not _ManifestEvalVisitor(schema, NotNull(Reference("all_nulls_missing_nan")), case_sensitive=True).eval(manifest), ( + "Should skip: all nulls column with non-floating type contains all null" + ) - assert _ManifestEvalVisitor(schema, NotNull(Reference("all_nulls_missing_nan_float")), case_sensitive=True).eval( - manifest - ), "Should read: no NaN information may indicate presence of NaN value" + assert _ManifestEvalVisitor(schema, NotNull(Reference("all_nulls_missing_nan_float")), case_sensitive=True).eval(manifest), ( + "Should read: no NaN information may indicate presence of NaN value" + ) - assert _ManifestEvalVisitor(schema, NotNull(Reference("some_nulls")), case_sensitive=True).eval( - manifest - ), "Should read: column with some nulls contains a non-null value" + assert _ManifestEvalVisitor(schema, NotNull(Reference("some_nulls")), case_sensitive=True).eval(manifest), ( + "Should read: column with some nulls contains a non-null value" + ) - assert _ManifestEvalVisitor(schema, NotNull(Reference("no_nulls")), case_sensitive=True).eval( - manifest - ), "Should read: non-null column contains a non-null value" + assert _ManifestEvalVisitor(schema, NotNull(Reference("no_nulls")), case_sensitive=True).eval(manifest), ( + "Should read: non-null column contains a non-null value" + ) def test_no_nulls(schema: Schema, manifest: ManifestFile) -> None: - assert _ManifestEvalVisitor(schema, IsNull(Reference("all_nulls_missing_nan")), case_sensitive=True).eval( - manifest - ), "Should read: at least one null value in all null column" + assert _ManifestEvalVisitor(schema, IsNull(Reference("all_nulls_missing_nan")), case_sensitive=True).eval(manifest), ( + "Should read: at least one null value in all null column" + ) - assert _ManifestEvalVisitor(schema, IsNull(Reference("some_nulls")), case_sensitive=True).eval( - manifest - ), "Should read: column with some nulls contains a null value" + assert _ManifestEvalVisitor(schema, IsNull(Reference("some_nulls")), case_sensitive=True).eval(manifest), ( + "Should read: column with some nulls contains a null value" + ) - assert not _ManifestEvalVisitor(schema, IsNull(Reference("no_nulls")), case_sensitive=True).eval( - manifest - ), "Should skip: non-null column contains no null values" + assert not _ManifestEvalVisitor(schema, IsNull(Reference("no_nulls")), case_sensitive=True).eval(manifest), ( + "Should skip: non-null column contains no null values" + ) - assert _ManifestEvalVisitor(schema, IsNull(Reference("both_nan_and_null")), case_sensitive=True).eval( - manifest - ), "Should read: both_nan_and_null column contains no null values" + assert _ManifestEvalVisitor(schema, IsNull(Reference("both_nan_and_null")), case_sensitive=True).eval(manifest), ( + "Should read: both_nan_and_null column contains no null values" + ) def test_is_nan(schema: Schema, manifest: ManifestFile) -> None: - assert _ManifestEvalVisitor(schema, IsNaN(Reference("float")), case_sensitive=True).eval( - manifest - ), "Should read: no information on if there are nan value in float column" + assert _ManifestEvalVisitor(schema, IsNaN(Reference("float")), case_sensitive=True).eval(manifest), ( + "Should read: no information on if there are nan value in float column" + ) - assert _ManifestEvalVisitor(schema, IsNaN(Reference("all_nulls_double")), case_sensitive=True).eval( - manifest - ), "Should read: no NaN information may indicate presence of NaN value" + assert _ManifestEvalVisitor(schema, IsNaN(Reference("all_nulls_double")), case_sensitive=True).eval(manifest), ( + "Should read: no NaN information may indicate presence of NaN value" + ) - assert _ManifestEvalVisitor(schema, IsNaN(Reference("all_nulls_missing_nan_float")), case_sensitive=True).eval( - manifest - ), "Should read: no NaN information may indicate presence of NaN value" + assert _ManifestEvalVisitor(schema, IsNaN(Reference("all_nulls_missing_nan_float")), case_sensitive=True).eval(manifest), ( + "Should read: no NaN information may indicate presence of NaN value" + ) - assert not _ManifestEvalVisitor(schema, IsNaN(Reference("all_nulls_no_nans")), case_sensitive=True).eval( - manifest - ), "Should skip: no nan column doesn't contain nan value" + assert not _ManifestEvalVisitor(schema, IsNaN(Reference("all_nulls_no_nans")), case_sensitive=True).eval(manifest), ( + "Should skip: no nan column doesn't contain nan value" + ) - assert _ManifestEvalVisitor(schema, IsNaN(Reference("all_nans")), case_sensitive=True).eval( - manifest - ), "Should read: all_nans column contains nan value" + assert _ManifestEvalVisitor(schema, IsNaN(Reference("all_nans")), case_sensitive=True).eval(manifest), ( + "Should read: all_nans column contains nan value" + ) - assert _ManifestEvalVisitor(schema, IsNaN(Reference("both_nan_and_null")), case_sensitive=True).eval( - manifest - ), "Should read: both_nan_and_null column contains nan value" + assert _ManifestEvalVisitor(schema, IsNaN(Reference("both_nan_and_null")), case_sensitive=True).eval(manifest), ( + "Should read: both_nan_and_null column contains nan value" + ) - assert not _ManifestEvalVisitor(schema, IsNaN(Reference("no_nan_or_null")), case_sensitive=True).eval( - manifest - ), "Should skip: no_nan_or_null column doesn't contain nan value" + assert not _ManifestEvalVisitor(schema, IsNaN(Reference("no_nan_or_null")), case_sensitive=True).eval(manifest), ( + "Should skip: no_nan_or_null column doesn't contain nan value" + ) def test_not_nan(schema: Schema, manifest: ManifestFile) -> None: - assert _ManifestEvalVisitor(schema, NotNaN(Reference("float")), case_sensitive=True).eval( - manifest - ), "Should read: no information on if there are nan value in float column" + assert _ManifestEvalVisitor(schema, NotNaN(Reference("float")), case_sensitive=True).eval(manifest), ( + "Should read: no information on if there are nan value in float column" + ) - assert _ManifestEvalVisitor(schema, NotNaN(Reference("all_nulls_double")), case_sensitive=True).eval( - manifest - ), "Should read: all null column contains non nan value" + assert _ManifestEvalVisitor(schema, NotNaN(Reference("all_nulls_double")), case_sensitive=True).eval(manifest), ( + "Should read: all null column contains non nan value" + ) - assert _ManifestEvalVisitor(schema, NotNaN(Reference("all_nulls_no_nans")), case_sensitive=True).eval( - manifest - ), "Should read: no_nans column contains non nan value" + assert _ManifestEvalVisitor(schema, NotNaN(Reference("all_nulls_no_nans")), case_sensitive=True).eval(manifest), ( + "Should read: no_nans column contains non nan value" + ) - assert not _ManifestEvalVisitor(schema, NotNaN(Reference("all_nans")), case_sensitive=True).eval( - manifest - ), "Should skip: all nans column doesn't contain non nan value" + assert not _ManifestEvalVisitor(schema, NotNaN(Reference("all_nans")), case_sensitive=True).eval(manifest), ( + "Should skip: all nans column doesn't contain non nan value" + ) - assert _ManifestEvalVisitor(schema, NotNaN(Reference("both_nan_and_null")), case_sensitive=True).eval( - manifest - ), "Should read: both_nan_and_null nans column contains non nan value" + assert _ManifestEvalVisitor(schema, NotNaN(Reference("both_nan_and_null")), case_sensitive=True).eval(manifest), ( + "Should read: both_nan_and_null nans column contains non nan value" + ) - assert _ManifestEvalVisitor(schema, NotNaN(Reference("no_nan_or_null")), case_sensitive=True).eval( - manifest - ), "Should read: no_nan_or_null column contains non nan value" + assert _ManifestEvalVisitor(schema, NotNaN(Reference("no_nan_or_null")), case_sensitive=True).eval(manifest), ( + "Should read: no_nan_or_null column contains non nan value" + ) def test_missing_stats(schema: Schema, manifest_no_stats: ManifestFile) -> None: @@ -1053,15 +1053,15 @@ def test_missing_stats(schema: Schema, manifest_no_stats: ManifestFile) -> None: ] for expr in expressions: - assert _ManifestEvalVisitor(schema, expr, case_sensitive=True).eval( - manifest_no_stats - ), f"Should read when missing stats for expr: {expr}" + assert _ManifestEvalVisitor(schema, expr, case_sensitive=True).eval(manifest_no_stats), ( + f"Should read when missing stats for expr: {expr}" + ) def test_not(schema: Schema, manifest: ManifestFile) -> None: - assert _ManifestEvalVisitor(schema, Not(LessThan(Reference("id"), INT_MIN_VALUE - 25)), case_sensitive=True).eval( - manifest - ), "Should read: not(false)" + assert _ManifestEvalVisitor(schema, Not(LessThan(Reference("id"), INT_MIN_VALUE - 25)), case_sensitive=True).eval(manifest), ( + "Should read: not(false)" + ) assert not _ManifestEvalVisitor(schema, Not(GreaterThan(Reference("id"), INT_MIN_VALUE - 25)), case_sensitive=True).eval( manifest @@ -1118,21 +1118,21 @@ def test_or(schema: Schema, manifest: ManifestFile) -> None: def test_integer_lt(schema: Schema, manifest: ManifestFile) -> None: - assert not _ManifestEvalVisitor(schema, LessThan(Reference("id"), INT_MIN_VALUE - 25), case_sensitive=True).eval( - manifest - ), "Should not read: id range below lower bound (5 < 30)" + assert not _ManifestEvalVisitor(schema, LessThan(Reference("id"), INT_MIN_VALUE - 25), case_sensitive=True).eval(manifest), ( + "Should not read: id range below lower bound (5 < 30)" + ) - assert not _ManifestEvalVisitor(schema, LessThan(Reference("id"), INT_MIN_VALUE), case_sensitive=True).eval( - manifest - ), "Should not read: id range below lower bound (30 is not < 30)" + assert not _ManifestEvalVisitor(schema, LessThan(Reference("id"), INT_MIN_VALUE), case_sensitive=True).eval(manifest), ( + "Should not read: id range below lower bound (30 is not < 30)" + ) - assert _ManifestEvalVisitor(schema, LessThan(Reference("id"), INT_MIN_VALUE + 1), case_sensitive=True).eval( - manifest - ), "Should read: one possible id" + assert _ManifestEvalVisitor(schema, LessThan(Reference("id"), INT_MIN_VALUE + 1), case_sensitive=True).eval(manifest), ( + "Should read: one possible id" + ) - assert _ManifestEvalVisitor(schema, LessThan(Reference("id"), INT_MAX_VALUE), case_sensitive=True).eval( - manifest - ), "Should read: may possible ids" + assert _ManifestEvalVisitor(schema, LessThan(Reference("id"), INT_MAX_VALUE), case_sensitive=True).eval(manifest), ( + "Should read: may possible ids" + ) def test_integer_lt_eq(schema: Schema, manifest: ManifestFile) -> None: @@ -1144,13 +1144,13 @@ def test_integer_lt_eq(schema: Schema, manifest: ManifestFile) -> None: manifest ), "Should not read: id range below lower bound (29 < 30)" - assert _ManifestEvalVisitor(schema, LessThanOrEqual(Reference("id"), INT_MIN_VALUE), case_sensitive=True).eval( - manifest - ), "Should read: one possible id" + assert _ManifestEvalVisitor(schema, LessThanOrEqual(Reference("id"), INT_MIN_VALUE), case_sensitive=True).eval(manifest), ( + "Should read: one possible id" + ) - assert _ManifestEvalVisitor(schema, LessThanOrEqual(Reference("id"), INT_MAX_VALUE), case_sensitive=True).eval( - manifest - ), "Should read: many possible ids" + assert _ManifestEvalVisitor(schema, LessThanOrEqual(Reference("id"), INT_MAX_VALUE), case_sensitive=True).eval(manifest), ( + "Should read: many possible ids" + ) def test_integer_gt(schema: Schema, manifest: ManifestFile) -> None: @@ -1158,17 +1158,17 @@ def test_integer_gt(schema: Schema, manifest: ManifestFile) -> None: manifest ), "Should not read: id range above upper bound (85 < 79)" - assert not _ManifestEvalVisitor(schema, GreaterThan(Reference("id"), INT_MAX_VALUE), case_sensitive=True).eval( - manifest - ), "Should not read: id range above upper bound (79 is not > 79)" + assert not _ManifestEvalVisitor(schema, GreaterThan(Reference("id"), INT_MAX_VALUE), case_sensitive=True).eval(manifest), ( + "Should not read: id range above upper bound (79 is not > 79)" + ) - assert _ManifestEvalVisitor(schema, GreaterThan(Reference("id"), INT_MAX_VALUE - 1), case_sensitive=True).eval( - manifest - ), "Should read: one possible id" + assert _ManifestEvalVisitor(schema, GreaterThan(Reference("id"), INT_MAX_VALUE - 1), case_sensitive=True).eval(manifest), ( + "Should read: one possible id" + ) - assert _ManifestEvalVisitor(schema, GreaterThan(Reference("id"), INT_MAX_VALUE - 4), case_sensitive=True).eval( - manifest - ), "Should read: may possible ids" + assert _ManifestEvalVisitor(schema, GreaterThan(Reference("id"), INT_MAX_VALUE - 4), case_sensitive=True).eval(manifest), ( + "Should read: may possible ids" + ) def test_integer_gt_eq(schema: Schema, manifest: ManifestFile) -> None: @@ -1180,133 +1180,133 @@ def test_integer_gt_eq(schema: Schema, manifest: ManifestFile) -> None: manifest ), "Should not read: id range above upper bound (80 > 79)" - assert _ManifestEvalVisitor(schema, GreaterThanOrEqual(Reference("id"), INT_MAX_VALUE), case_sensitive=True).eval( - manifest - ), "Should read: one possible id" + assert _ManifestEvalVisitor(schema, GreaterThanOrEqual(Reference("id"), INT_MAX_VALUE), case_sensitive=True).eval(manifest), ( + "Should read: one possible id" + ) - assert _ManifestEvalVisitor(schema, GreaterThanOrEqual(Reference("id"), INT_MAX_VALUE), case_sensitive=True).eval( - manifest - ), "Should read: may possible ids" + assert _ManifestEvalVisitor(schema, GreaterThanOrEqual(Reference("id"), INT_MAX_VALUE), case_sensitive=True).eval(manifest), ( + "Should read: may possible ids" + ) def test_integer_eq(schema: Schema, manifest: ManifestFile) -> None: - assert not _ManifestEvalVisitor(schema, EqualTo(Reference("id"), INT_MIN_VALUE - 25), case_sensitive=True).eval( - manifest - ), "Should not read: id below lower bound" + assert not _ManifestEvalVisitor(schema, EqualTo(Reference("id"), INT_MIN_VALUE - 25), case_sensitive=True).eval(manifest), ( + "Should not read: id below lower bound" + ) - assert not _ManifestEvalVisitor(schema, EqualTo(Reference("id"), INT_MIN_VALUE - 1), case_sensitive=True).eval( - manifest - ), "Should not read: id below lower bound" + assert not _ManifestEvalVisitor(schema, EqualTo(Reference("id"), INT_MIN_VALUE - 1), case_sensitive=True).eval(manifest), ( + "Should not read: id below lower bound" + ) - assert _ManifestEvalVisitor(schema, EqualTo(Reference("id"), INT_MIN_VALUE), case_sensitive=True).eval( - manifest - ), "Should read: id equal to lower bound" + assert _ManifestEvalVisitor(schema, EqualTo(Reference("id"), INT_MIN_VALUE), case_sensitive=True).eval(manifest), ( + "Should read: id equal to lower bound" + ) - assert _ManifestEvalVisitor(schema, EqualTo(Reference("id"), INT_MAX_VALUE - 4), case_sensitive=True).eval( - manifest - ), "Should read: id between lower and upper bounds" + assert _ManifestEvalVisitor(schema, EqualTo(Reference("id"), INT_MAX_VALUE - 4), case_sensitive=True).eval(manifest), ( + "Should read: id between lower and upper bounds" + ) - assert _ManifestEvalVisitor(schema, EqualTo(Reference("id"), INT_MAX_VALUE), case_sensitive=True).eval( - manifest - ), "Should read: id equal to upper bound" + assert _ManifestEvalVisitor(schema, EqualTo(Reference("id"), INT_MAX_VALUE), case_sensitive=True).eval(manifest), ( + "Should read: id equal to upper bound" + ) - assert not _ManifestEvalVisitor(schema, EqualTo(Reference("id"), INT_MAX_VALUE + 1), case_sensitive=True).eval( - manifest - ), "Should not read: id above upper bound" + assert not _ManifestEvalVisitor(schema, EqualTo(Reference("id"), INT_MAX_VALUE + 1), case_sensitive=True).eval(manifest), ( + "Should not read: id above upper bound" + ) - assert not _ManifestEvalVisitor(schema, EqualTo(Reference("id"), INT_MAX_VALUE + 6), case_sensitive=True).eval( - manifest - ), "Should not read: id above upper bound" + assert not _ManifestEvalVisitor(schema, EqualTo(Reference("id"), INT_MAX_VALUE + 6), case_sensitive=True).eval(manifest), ( + "Should not read: id above upper bound" + ) def test_integer_not_eq(schema: Schema, manifest: ManifestFile) -> None: - assert _ManifestEvalVisitor(schema, NotEqualTo(Reference("id"), INT_MIN_VALUE - 25), case_sensitive=True).eval( - manifest - ), "Should read: id below lower bound" + assert _ManifestEvalVisitor(schema, NotEqualTo(Reference("id"), INT_MIN_VALUE - 25), case_sensitive=True).eval(manifest), ( + "Should read: id below lower bound" + ) - assert _ManifestEvalVisitor(schema, NotEqualTo(Reference("id"), INT_MIN_VALUE - 1), case_sensitive=True).eval( - manifest - ), "Should read: id below lower bound" + assert _ManifestEvalVisitor(schema, NotEqualTo(Reference("id"), INT_MIN_VALUE - 1), case_sensitive=True).eval(manifest), ( + "Should read: id below lower bound" + ) - assert _ManifestEvalVisitor(schema, NotEqualTo(Reference("id"), INT_MIN_VALUE), case_sensitive=True).eval( - manifest - ), "Should read: id equal to lower bound" + assert _ManifestEvalVisitor(schema, NotEqualTo(Reference("id"), INT_MIN_VALUE), case_sensitive=True).eval(manifest), ( + "Should read: id equal to lower bound" + ) - assert _ManifestEvalVisitor(schema, NotEqualTo(Reference("id"), INT_MAX_VALUE - 4), case_sensitive=True).eval( - manifest - ), "Should read: id between lower and upper bounds" + assert _ManifestEvalVisitor(schema, NotEqualTo(Reference("id"), INT_MAX_VALUE - 4), case_sensitive=True).eval(manifest), ( + "Should read: id between lower and upper bounds" + ) - assert _ManifestEvalVisitor(schema, NotEqualTo(Reference("id"), INT_MAX_VALUE), case_sensitive=True).eval( - manifest - ), "Should read: id equal to upper bound" + assert _ManifestEvalVisitor(schema, NotEqualTo(Reference("id"), INT_MAX_VALUE), case_sensitive=True).eval(manifest), ( + "Should read: id equal to upper bound" + ) - assert _ManifestEvalVisitor(schema, NotEqualTo(Reference("id"), INT_MAX_VALUE + 1), case_sensitive=True).eval( - manifest - ), "Should read: id above upper bound" + assert _ManifestEvalVisitor(schema, NotEqualTo(Reference("id"), INT_MAX_VALUE + 1), case_sensitive=True).eval(manifest), ( + "Should read: id above upper bound" + ) - assert _ManifestEvalVisitor(schema, NotEqualTo(Reference("id"), INT_MAX_VALUE + 6), case_sensitive=True).eval( - manifest - ), "Should read: id above upper bound" + assert _ManifestEvalVisitor(schema, NotEqualTo(Reference("id"), INT_MAX_VALUE + 6), case_sensitive=True).eval(manifest), ( + "Should read: id above upper bound" + ) def test_integer_not_eq_rewritten(schema: Schema, manifest: ManifestFile) -> None: - assert _ManifestEvalVisitor(schema, Not(EqualTo(Reference("id"), INT_MIN_VALUE - 25)), case_sensitive=True).eval( - manifest - ), "Should read: id below lower bound" + assert _ManifestEvalVisitor(schema, Not(EqualTo(Reference("id"), INT_MIN_VALUE - 25)), case_sensitive=True).eval(manifest), ( + "Should read: id below lower bound" + ) - assert _ManifestEvalVisitor(schema, Not(EqualTo(Reference("id"), INT_MIN_VALUE - 1)), case_sensitive=True).eval( - manifest - ), "Should read: id below lower bound" + assert _ManifestEvalVisitor(schema, Not(EqualTo(Reference("id"), INT_MIN_VALUE - 1)), case_sensitive=True).eval(manifest), ( + "Should read: id below lower bound" + ) - assert _ManifestEvalVisitor(schema, Not(EqualTo(Reference("id"), INT_MIN_VALUE)), case_sensitive=True).eval( - manifest - ), "Should read: id equal to lower bound" + assert _ManifestEvalVisitor(schema, Not(EqualTo(Reference("id"), INT_MIN_VALUE)), case_sensitive=True).eval(manifest), ( + "Should read: id equal to lower bound" + ) - assert _ManifestEvalVisitor(schema, Not(EqualTo(Reference("id"), INT_MAX_VALUE - 4)), case_sensitive=True).eval( - manifest - ), "Should read: id between lower and upper bounds" + assert _ManifestEvalVisitor(schema, Not(EqualTo(Reference("id"), INT_MAX_VALUE - 4)), case_sensitive=True).eval(manifest), ( + "Should read: id between lower and upper bounds" + ) - assert _ManifestEvalVisitor(schema, Not(EqualTo(Reference("id"), INT_MAX_VALUE)), case_sensitive=True).eval( - manifest - ), "Should read: id equal to upper bound" + assert _ManifestEvalVisitor(schema, Not(EqualTo(Reference("id"), INT_MAX_VALUE)), case_sensitive=True).eval(manifest), ( + "Should read: id equal to upper bound" + ) - assert _ManifestEvalVisitor(schema, Not(EqualTo(Reference("id"), INT_MAX_VALUE + 1)), case_sensitive=True).eval( - manifest - ), "Should read: id above upper bound" + assert _ManifestEvalVisitor(schema, Not(EqualTo(Reference("id"), INT_MAX_VALUE + 1)), case_sensitive=True).eval(manifest), ( + "Should read: id above upper bound" + ) - assert _ManifestEvalVisitor(schema, Not(EqualTo(Reference("id"), INT_MAX_VALUE + 6)), case_sensitive=True).eval( - manifest - ), "Should read: id above upper bound" + assert _ManifestEvalVisitor(schema, Not(EqualTo(Reference("id"), INT_MAX_VALUE + 6)), case_sensitive=True).eval(manifest), ( + "Should read: id above upper bound" + ) def test_integer_not_eq_rewritten_case_insensitive(schema: Schema, manifest: ManifestFile) -> None: - assert _ManifestEvalVisitor(schema, Not(EqualTo(Reference("ID"), INT_MIN_VALUE - 25)), case_sensitive=False).eval( - manifest - ), "Should read: id below lower bound" + assert _ManifestEvalVisitor(schema, Not(EqualTo(Reference("ID"), INT_MIN_VALUE - 25)), case_sensitive=False).eval(manifest), ( + "Should read: id below lower bound" + ) - assert _ManifestEvalVisitor(schema, Not(EqualTo(Reference("ID"), INT_MIN_VALUE - 1)), case_sensitive=False).eval( - manifest - ), "Should read: id below lower bound" + assert _ManifestEvalVisitor(schema, Not(EqualTo(Reference("ID"), INT_MIN_VALUE - 1)), case_sensitive=False).eval(manifest), ( + "Should read: id below lower bound" + ) - assert _ManifestEvalVisitor(schema, Not(EqualTo(Reference("ID"), INT_MIN_VALUE)), case_sensitive=False).eval( - manifest - ), "Should read: id equal to lower bound" + assert _ManifestEvalVisitor(schema, Not(EqualTo(Reference("ID"), INT_MIN_VALUE)), case_sensitive=False).eval(manifest), ( + "Should read: id equal to lower bound" + ) - assert _ManifestEvalVisitor(schema, Not(EqualTo(Reference("ID"), INT_MAX_VALUE - 4)), case_sensitive=False).eval( - manifest - ), "Should read: id between lower and upper bounds" + assert _ManifestEvalVisitor(schema, Not(EqualTo(Reference("ID"), INT_MAX_VALUE - 4)), case_sensitive=False).eval(manifest), ( + "Should read: id between lower and upper bounds" + ) - assert _ManifestEvalVisitor(schema, Not(EqualTo(Reference("ID"), INT_MAX_VALUE)), case_sensitive=False).eval( - manifest - ), "Should read: id equal to upper bound" + assert _ManifestEvalVisitor(schema, Not(EqualTo(Reference("ID"), INT_MAX_VALUE)), case_sensitive=False).eval(manifest), ( + "Should read: id equal to upper bound" + ) - assert _ManifestEvalVisitor(schema, Not(EqualTo(Reference("ID"), INT_MAX_VALUE + 1)), case_sensitive=False).eval( - manifest - ), "Should read: id above upper bound" + assert _ManifestEvalVisitor(schema, Not(EqualTo(Reference("ID"), INT_MAX_VALUE + 1)), case_sensitive=False).eval(manifest), ( + "Should read: id above upper bound" + ) - assert _ManifestEvalVisitor(schema, Not(EqualTo(Reference("ID"), INT_MAX_VALUE + 6)), case_sensitive=False).eval( - manifest - ), "Should read: id above upper bound" + assert _ManifestEvalVisitor(schema, Not(EqualTo(Reference("ID"), INT_MAX_VALUE + 6)), case_sensitive=False).eval(manifest), ( + "Should read: id above upper bound" + ) def test_integer_in(schema: Schema, manifest: ManifestFile) -> None: @@ -1342,13 +1342,13 @@ def test_integer_in(schema: Schema, manifest: ManifestFile) -> None: manifest ), "Should skip: in on all nulls column" - assert _ManifestEvalVisitor(schema, In(Reference("some_nulls"), ("abc", "def")), case_sensitive=True).eval( - manifest - ), "Should read: in on some nulls column" + assert _ManifestEvalVisitor(schema, In(Reference("some_nulls"), ("abc", "def")), case_sensitive=True).eval(manifest), ( + "Should read: in on some nulls column" + ) - assert _ManifestEvalVisitor(schema, In(Reference("no_nulls"), ("abc", "def")), case_sensitive=True).eval( - manifest - ), "Should read: in on no nulls column" + assert _ManifestEvalVisitor(schema, In(Reference("no_nulls"), ("abc", "def")), case_sensitive=True).eval(manifest), ( + "Should read: in on no nulls column" + ) def test_integer_not_in(schema: Schema, manifest: ManifestFile) -> None: @@ -1384,73 +1384,73 @@ def test_integer_not_in(schema: Schema, manifest: ManifestFile) -> None: manifest ), "Should read: notIn on no nulls column" - assert _ManifestEvalVisitor(schema, NotIn(Reference("some_nulls"), ("abc", "def")), case_sensitive=True).eval( - manifest - ), "Should read: in on some nulls column" + assert _ManifestEvalVisitor(schema, NotIn(Reference("some_nulls"), ("abc", "def")), case_sensitive=True).eval(manifest), ( + "Should read: in on some nulls column" + ) - assert _ManifestEvalVisitor(schema, NotIn(Reference("no_nulls"), ("abc", "def")), case_sensitive=True).eval( - manifest - ), "Should read: in on no nulls column" + assert _ManifestEvalVisitor(schema, NotIn(Reference("no_nulls"), ("abc", "def")), case_sensitive=True).eval(manifest), ( + "Should read: in on no nulls column" + ) def test_string_starts_with(schema: Schema, manifest: ManifestFile) -> None: - assert _ManifestEvalVisitor(schema, StartsWith(Reference("some_nulls"), "a"), case_sensitive=False).eval( - manifest - ), "Should read: range matches" + assert _ManifestEvalVisitor(schema, StartsWith(Reference("some_nulls"), "a"), case_sensitive=False).eval(manifest), ( + "Should read: range matches" + ) - assert _ManifestEvalVisitor(schema, StartsWith(Reference("some_nulls"), "aa"), case_sensitive=False).eval( - manifest - ), "Should read: range matches" + assert _ManifestEvalVisitor(schema, StartsWith(Reference("some_nulls"), "aa"), case_sensitive=False).eval(manifest), ( + "Should read: range matches" + ) - assert _ManifestEvalVisitor(schema, StartsWith(Reference("some_nulls"), "dddd"), case_sensitive=False).eval( - manifest - ), "Should read: range matches" + assert _ManifestEvalVisitor(schema, StartsWith(Reference("some_nulls"), "dddd"), case_sensitive=False).eval(manifest), ( + "Should read: range matches" + ) - assert _ManifestEvalVisitor(schema, StartsWith(Reference("some_nulls"), "z"), case_sensitive=False).eval( - manifest - ), "Should read: range matches" + assert _ManifestEvalVisitor(schema, StartsWith(Reference("some_nulls"), "z"), case_sensitive=False).eval(manifest), ( + "Should read: range matches" + ) - assert _ManifestEvalVisitor(schema, StartsWith(Reference("no_nulls"), "a"), case_sensitive=False).eval( - manifest - ), "Should read: range matches" + assert _ManifestEvalVisitor(schema, StartsWith(Reference("no_nulls"), "a"), case_sensitive=False).eval(manifest), ( + "Should read: range matches" + ) - assert not _ManifestEvalVisitor(schema, StartsWith(Reference("some_nulls"), "zzzz"), case_sensitive=False).eval( - manifest - ), "Should skip: range doesn't match" + assert not _ManifestEvalVisitor(schema, StartsWith(Reference("some_nulls"), "zzzz"), case_sensitive=False).eval(manifest), ( + "Should skip: range doesn't match" + ) - assert not _ManifestEvalVisitor(schema, StartsWith(Reference("some_nulls"), "1"), case_sensitive=False).eval( - manifest - ), "Should skip: range doesn't match" + assert not _ManifestEvalVisitor(schema, StartsWith(Reference("some_nulls"), "1"), case_sensitive=False).eval(manifest), ( + "Should skip: range doesn't match" + ) def test_string_not_starts_with(schema: Schema, manifest: ManifestFile) -> None: - assert _ManifestEvalVisitor(schema, NotStartsWith(Reference("some_nulls"), "a"), case_sensitive=False).eval( - manifest - ), "Should read: range matches" + assert _ManifestEvalVisitor(schema, NotStartsWith(Reference("some_nulls"), "a"), case_sensitive=False).eval(manifest), ( + "Should read: range matches" + ) - assert _ManifestEvalVisitor(schema, NotStartsWith(Reference("some_nulls"), "aa"), case_sensitive=False).eval( - manifest - ), "Should read: range matches" + assert _ManifestEvalVisitor(schema, NotStartsWith(Reference("some_nulls"), "aa"), case_sensitive=False).eval(manifest), ( + "Should read: range matches" + ) - assert _ManifestEvalVisitor(schema, NotStartsWith(Reference("some_nulls"), "dddd"), case_sensitive=False).eval( - manifest - ), "Should read: range matches" + assert _ManifestEvalVisitor(schema, NotStartsWith(Reference("some_nulls"), "dddd"), case_sensitive=False).eval(manifest), ( + "Should read: range matches" + ) - assert _ManifestEvalVisitor(schema, NotStartsWith(Reference("some_nulls"), "z"), case_sensitive=False).eval( - manifest - ), "Should read: range matches" + assert _ManifestEvalVisitor(schema, NotStartsWith(Reference("some_nulls"), "z"), case_sensitive=False).eval(manifest), ( + "Should read: range matches" + ) - assert _ManifestEvalVisitor(schema, NotStartsWith(Reference("no_nulls"), "a"), case_sensitive=False).eval( - manifest - ), "Should read: range matches" + assert _ManifestEvalVisitor(schema, NotStartsWith(Reference("no_nulls"), "a"), case_sensitive=False).eval(manifest), ( + "Should read: range matches" + ) - assert _ManifestEvalVisitor(schema, NotStartsWith(Reference("some_nulls"), "zzzz"), case_sensitive=False).eval( - manifest - ), "Should read: range matches" + assert _ManifestEvalVisitor(schema, NotStartsWith(Reference("some_nulls"), "zzzz"), case_sensitive=False).eval(manifest), ( + "Should read: range matches" + ) - assert _ManifestEvalVisitor(schema, NotStartsWith(Reference("some_nulls"), "1"), case_sensitive=False).eval( - manifest - ), "Should read: range matches" + assert _ManifestEvalVisitor(schema, NotStartsWith(Reference("some_nulls"), "1"), case_sensitive=False).eval(manifest), ( + "Should read: range matches" + ) assert _ManifestEvalVisitor(schema, NotStartsWith(Reference("all_same_value_or_null"), "a"), case_sensitive=False).eval( manifest diff --git a/tests/table/test_init.py b/tests/table/test_init.py index dbac84bd81..6165dadec4 100644 --- a/tests/table/test_init.py +++ b/tests/table/test_init.py @@ -511,15 +511,15 @@ def test_update_column(table_v1: Table, table_v2: Table) -> None: assert new_schema3.find_field("z").required is False, "failed to update existing field required" # assert the above two updates also works with union_by_name - assert ( - table.update_schema().union_by_name(new_schema)._apply() == new_schema - ), "failed to update existing field doc with union_by_name" - assert ( - table.update_schema().union_by_name(new_schema2)._apply() == new_schema2 - ), "failed to remove existing field doc with union_by_name" - assert ( - table.update_schema().union_by_name(new_schema3)._apply() == new_schema3 - ), "failed to update existing field required with union_by_name" + assert table.update_schema().union_by_name(new_schema)._apply() == new_schema, ( + "failed to update existing field doc with union_by_name" + ) + assert table.update_schema().union_by_name(new_schema2)._apply() == new_schema2, ( + "failed to remove existing field doc with union_by_name" + ) + assert table.update_schema().union_by_name(new_schema3)._apply() == new_schema3, ( + "failed to update existing field required with union_by_name" + ) def test_add_primitive_type_column(table_v2: Table) -> None: diff --git a/tests/table/test_upsert.py b/tests/table/test_upsert.py index 9fecbbb7bb..cc6e008b1e 100644 --- a/tests/table/test_upsert.py +++ b/tests/table/test_upsert.py @@ -83,7 +83,7 @@ def gen_source_dataset(start_row: int, end_row: int, composite_key: bool, add_du ) sql = f""" - with t as (SELECT unnest(range({start_row},{end_row+1})) as order_id) + with t as (SELECT unnest(range({start_row},{end_row + 1})) as order_id) SELECT t.order_id {additional_columns} , date '2021-01-01' as order_date, 'B' as order_type from t @@ -101,7 +101,7 @@ def gen_target_iceberg_table( additional_columns = ", t.order_id + 1000 as order_line_id" if composite_key else "" df = ctx.sql(f""" - with t as (SELECT unnest(range({start_row},{end_row+1})) as order_id) + with t as (SELECT unnest(range({start_row},{end_row + 1})) as order_id) SELECT t.order_id {additional_columns} , date '2021-01-01' as order_date, 'A' as order_type from t diff --git a/tests/test_types.py b/tests/test_types.py index 586022e5a4..2527f0e822 100644 --- a/tests/test_types.py +++ b/tests/test_types.py @@ -260,9 +260,9 @@ def test_nested_field_primitive_type_as_str() -> None: type_str, required=True, ) - assert isinstance( - field_var.field_type, type_class - ), f"Expected {type_class.__name__}, got {field_var.field_type.__class__.__name__}" + assert isinstance(field_var.field_type, type_class), ( + f"Expected {type_class.__name__}, got {field_var.field_type.__class__.__name__}" + ) # Test that passing 'bool' raises a ValueError, as it should be 'boolean' with pytest.raises(ValueError) as exc_info: diff --git a/tests/utils/test_manifest.py b/tests/utils/test_manifest.py index 5740587958..5e907a7c46 100644 --- a/tests/utils/test_manifest.py +++ b/tests/utils/test_manifest.py @@ -621,9 +621,9 @@ def test_write_manifest_list( def test_file_format_case_insensitive(raw_file_format: str, expected_file_format: FileFormat) -> None: if expected_file_format: parsed_file_format = FileFormat(raw_file_format) - assert ( - parsed_file_format == expected_file_format - ), f"File format {raw_file_format}: {parsed_file_format} != {expected_file_format}" + assert parsed_file_format == expected_file_format, ( + f"File format {raw_file_format}: {parsed_file_format} != {expected_file_format}" + ) else: with pytest.raises(ValueError): _ = FileFormat(raw_file_format)