Fix Ruff errors

Author: kosiew

python/datafusion/catalog.py

@@ -19,11 +19,10 @@
 
 from __future__ import annotations
 
+import warnings
 from abc import ABC, abstractmethod
 from typing import TYPE_CHECKING, Any, Protocol
 
-import warnings
-
 import datafusion._internal as df_internal
 from datafusion._internal import EXPECTED_PROVIDER_MSG
 from datafusion.utils import _normalize_table_provider
@@ -170,7 +169,6 @@ def __init__(
         table: _InternalRawTable | _InternalTableProvider | Table,
     ) -> None:
         """Wrap a low level table or table provider."""
-
         if isinstance(table, Table):
             table = table.table
 
@@ -181,7 +179,6 @@ def __init__(
 
     def __getattribute__(self, name: str) -> Any:
         """Restrict provider-specific helpers to compatible tables."""
-
         if name == "__datafusion_table_provider__":
             table = object.__getattribute__(self, "_table")
             if not hasattr(table, "__datafusion_table_provider__"):
@@ -200,20 +197,17 @@ def table(self) -> _InternalRawTable | _InternalTableProvider:
     @classmethod
     def from_dataset(cls, dataset: pa.dataset.Dataset) -> Table:
         """Turn a :mod:`pyarrow.dataset` ``Dataset`` into a :class:`Table`."""
-
         return cls(_InternalRawTable.from_dataset(dataset))
 
     @classmethod
     def from_capsule(cls, capsule: Any) -> Table:
         """Create a :class:`Table` from a PyCapsule exported provider."""
-
         provider = _InternalTableProvider.from_capsule(capsule)
         return cls(provider)
 
     @classmethod
     def from_dataframe(cls, df: Any) -> Table:
         """Create a :class:`Table` from tabular data."""
-
         from datafusion.dataframe import DataFrame as DataFrameWrapper
 
         dataframe = df if isinstance(df, DataFrameWrapper) else DataFrameWrapper(df)
@@ -222,7 +216,6 @@ def from_dataframe(cls, df: Any) -> Table:
     @classmethod
     def from_view(cls, df: Any) -> Table:
         """Deprecated helper for constructing tables from views."""
-
         from datafusion.dataframe import DataFrame as DataFrameWrapper
 
         if isinstance(df, DataFrameWrapper):
@@ -249,7 +242,6 @@ def kind(self) -> str:
 
     def __datafusion_table_provider__(self) -> Any:
         """Expose the wrapped provider for FFI integrations."""
-
         exporter = getattr(self._table, "__datafusion_table_provider__", None)
         if exporter is None:
             msg = "Underlying object does not export __datafusion_table_provider__()"

python/datafusion/dataframe.py

@@ -319,7 +319,8 @@ def into_view(self) -> Table:
         """Convert ``DataFrame`` into a :class:`~datafusion.Table` for registration.
 
         This is the preferred way to obtain a view for
-        :py:meth:`~datafusion.context.SessionContext.register_table` for several reasons:
+        :py:meth:`~datafusion.context.SessionContext.register_table` for several
+        reasons:
 
         1. **Direct API**: Most efficient path - directly calls the underlying Rust
            ``DataFrame.into_view()`` method without intermediate delegations.
@@ -330,8 +331,8 @@ def into_view(self) -> Table:
         4. **Deprecated alternatives**: The older ``Table.from_view`` helper
            is deprecated and issues warnings when used.
 
-        ``datafusion.Table.from_dataframe`` calls this method under the hood, and the
-        older ``Table.from_view`` helper is deprecated.
+        ``datafusion.Table.from_dataframe`` calls this method under the hood,
+        and the older ``Table.from_view`` helper is deprecated.
 
         The ``DataFrame`` remains valid after conversion, so it can still be used for
         additional queries alongside the returned view.

python/tests/test_context.py

@@ -369,6 +369,7 @@ def test_table_from_dataframe_internal(ctx):
     result = ctx.sql("SELECT * FROM from_internal_dataframe_tbl").collect()
     assert [b.to_pydict() for b in result] == [{"a": [1, 2]}]
 
+
 def test_register_table_capsule_direct(ctx):
     df = ctx.from_pydict({"a": [1, 2]})
     provider = df.into_view()

python/tests/test_wrapper_coverage.py

@@ -21,7 +21,6 @@
 import datafusion.substrait
 import pytest
 
-
 IGNORED_EXPORTS = {"TableProvider"}
 
 # EnumType introduced in 3.11. 3.10 and prior it was called EnumMeta.
@@ -31,7 +30,29 @@
     from enum import EnumMeta as EnumType
 
 
-def missing_exports(internal_obj, wrapped_obj) -> None:  # noqa: C901
+def _check_enum_exports(internal_obj, wrapped_obj) -> None:
+    """Check that all enum values are present in wrapped object."""
+    expected_values = [v for v in dir(internal_obj) if not v.startswith("__")]
+    for value in expected_values:
+        assert value in dir(wrapped_obj)
+
+
+def _check_list_attribute(internal_attr, wrapped_attr) -> None:
+    """Check that list attributes match between internal and wrapped objects."""
+    assert isinstance(wrapped_attr, list)
+
+    # We have cases like __all__ that are a list and we want to be certain that
+    # every value in the list in the internal object is also in the wrapper list
+    for val in internal_attr:
+        if isinstance(val, str) and val in IGNORED_EXPORTS:
+            continue
+        if isinstance(val, str) and val.startswith("Raw"):
+            assert val[3:] in wrapped_attr
+        else:
+            assert val in wrapped_attr
+
+
+def missing_exports(internal_obj, wrapped_obj) -> None:
     """
     Identify if any of the rust exposted structs or functions do not have wrappers.
 
@@ -44,9 +65,7 @@ def missing_exports(internal_obj, wrapped_obj) -> None:  # noqa: C901
     # Special case enums - EnumType overrides a some of the internal functions,
     # so check all of the values exist and move on
     if isinstance(wrapped_obj, EnumType):
-        expected_values = [v for v in dir(internal_obj) if not v.startswith("__")]
-        for value in expected_values:
-            assert value in dir(wrapped_obj)
+        _check_enum_exports(internal_obj, wrapped_obj)
         return
 
     if "__repr__" in internal_obj.__dict__ and "__repr__" not in wrapped_obj.__dict__:
@@ -74,17 +93,7 @@ def missing_exports(internal_obj, wrapped_obj) -> None:  # noqa: C901
             continue
 
         if isinstance(internal_attr, list):
-            assert isinstance(wrapped_attr, list)
-
-            # We have cases like __all__ that are a list and we want to be certain that
-            # every value in the list in the internal object is also in the wrapper list
-            for val in internal_attr:
-                if isinstance(val, str) and val in IGNORED_EXPORTS:
-                    continue
-                if isinstance(val, str) and val.startswith("Raw"):
-                    assert val[3:] in wrapped_attr
-                else:
-                    assert val in wrapped_attr
+            _check_list_attribute(internal_attr, wrapped_attr)
         elif hasattr(internal_attr, "__dict__"):
             # Check all submodules recursively
             missing_exports(internal_attr, wrapped_attr)