Rename DataFrameIterator to PandasDataFrameIterator and PolarsDataFrameIterator

Rename the DataFrameIterator classes to include their respective module
prefix for clarity and to avoid confusion when importing from both modules.

- pyathena.pandas.result_set.DataFrameIterator → PandasDataFrameIterator
- pyathena.polars.result_set.DataFrameIterator → PolarsDataFrameIterator

Also updates all documentation and test references.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: laughingman7743

docs/api/pandas.rst

@@ -23,7 +23,7 @@ Pandas Result Set
    :members:
    :inherited-members:
 
-.. autoclass:: pyathena.pandas.result_set.DataFrameIterator
+.. autoclass:: pyathena.pandas.result_set.PandasDataFrameIterator
    :members:
 
 Pandas Data Converters

docs/api/polars.rst

@@ -23,6 +23,9 @@ Polars Result Set
    :members:
    :inherited-members:
 
+.. autoclass:: pyathena.polars.result_set.PolarsDataFrameIterator
+   :members:
+
 Polars Data Converters
 ----------------------
 

docs/pandas.rst

@@ -381,7 +381,7 @@ SQLAlchemy allows this option to be specified in the connection string.
 
     awsathena+pandas://:@athena.{region_name}.amazonaws.com:443/{schema_name}?s3_staging_dir={s3_staging_dir}&chunksize=1000000...
 
-When this option is used, the object returned by the as_pandas method is a ``DataFrameIterator`` object.
+When this option is used, the object returned by the as_pandas method is a ``PandasDataFrameIterator`` object.
 This object has exactly the same interface as the ``TextFileReader`` object and can be handled in the same way.
 
 .. code:: python
@@ -418,7 +418,7 @@ PandasCursor provides an ``iter_chunks()`` method for convenient chunked process
         # Memory can be freed after each chunk
         del chunk
 
-The ``DataFrameIterator`` also has an ``as_pandas()`` method that collects all chunks into a single DataFrame:
+The ``PandasDataFrameIterator`` also has an ``as_pandas()`` method that collects all chunks into a single DataFrame:
 
 .. code:: python
 

pyathena/pandas/cursor.py

@@ -25,7 +25,7 @@
     DefaultPandasTypeConverter,
     DefaultPandasUnloadTypeConverter,
 )
-from pyathena.pandas.result_set import AthenaPandasResultSet, DataFrameIterator
+from pyathena.pandas.result_set import AthenaPandasResultSet, PandasDataFrameIterator
 from pyathena.result_set import WithResultSet
 
 if TYPE_CHECKING:
@@ -331,11 +331,11 @@ def fetchall(
         result_set = cast(AthenaPandasResultSet, self.result_set)
         return result_set.fetchall()
 
-    def as_pandas(self) -> Union["DataFrame", DataFrameIterator]:
-        """Return DataFrame or DataFrameIterator based on chunksize setting.
+    def as_pandas(self) -> Union["DataFrame", PandasDataFrameIterator]:
+        """Return DataFrame or PandasDataFrameIterator based on chunksize setting.
 
         Returns:
-            DataFrame when chunksize is None, DataFrameIterator when chunksize is set.
+            DataFrame when chunksize is None, PandasDataFrameIterator when chunksize is set.
         """
         if not self.has_result_set:
             raise ProgrammingError("No result set.")

pyathena/pandas/result_set.py

@@ -38,7 +38,7 @@ def _no_trunc_date(df: "DataFrame") -> "DataFrame":
     return df
 
 
-class DataFrameIterator(abc.Iterator):  # type: ignore
+class PandasDataFrameIterator(abc.Iterator):  # type: ignore
     """Iterator for chunked DataFrame results from Athena queries.
 
     This class wraps either a pandas TextFileReader (for chunked reading) or
@@ -98,11 +98,11 @@ def __next__(self) -> "DataFrame":
             self.close()
             raise
 
-    def __iter__(self) -> "DataFrameIterator":
+    def __iter__(self) -> "PandasDataFrameIterator":
         """Return self as iterator."""
         return self
 
-    def __enter__(self) -> "DataFrameIterator":
+    def __enter__(self) -> "PandasDataFrameIterator":
         """Context manager entry."""
         return self
 
@@ -285,11 +285,11 @@ def __init__(
         if self.state == AthenaQueryExecution.STATE_SUCCEEDED and self.output_location:
             df = self._as_pandas()
             trunc_date = _no_trunc_date if self.is_unload else self._trunc_date
-            self._df_iter = DataFrameIterator(df, trunc_date)
+            self._df_iter = PandasDataFrameIterator(df, trunc_date)
         else:
             import pandas as pd
 
-            self._df_iter = DataFrameIterator(pd.DataFrame(), _no_trunc_date)
+            self._df_iter = PandasDataFrameIterator(pd.DataFrame(), _no_trunc_date)
         self._iterrows = self._df_iter.iterrows()
 
     def _get_parquet_engine(self) -> str:
@@ -670,12 +670,12 @@ def _as_pandas(self) -> Union["TextFileReader", "DataFrame"]:
             df = self._read_csv()
         return df
 
-    def as_pandas(self) -> Union[DataFrameIterator, "DataFrame"]:
+    def as_pandas(self) -> Union[PandasDataFrameIterator, "DataFrame"]:
         if self._chunksize is None:
             return next(self._df_iter)
         return self._df_iter
 
-    def iter_chunks(self) -> DataFrameIterator:
+    def iter_chunks(self) -> PandasDataFrameIterator:
         """Iterate over result chunks as pandas DataFrames.
 
         This method provides an iterator interface for processing large result sets.
@@ -684,7 +684,7 @@ def iter_chunks(self) -> DataFrameIterator:
         single DataFrame.
 
         Returns:
-            DataFrameIterator that yields pandas DataFrames for each chunk
+            PandasDataFrameIterator that yields pandas DataFrames for each chunk
             of rows, or the entire DataFrame if chunksize was not specified.
 
         Example:
@@ -706,6 +706,6 @@ def close(self) -> None:
         import pandas as pd
 
         super().close()
-        self._df_iter = DataFrameIterator(pd.DataFrame(), _no_trunc_date)
+        self._df_iter = PandasDataFrameIterator(pd.DataFrame(), _no_trunc_date)
         self._iterrows = enumerate([])
         self._data_manifest = []

pyathena/polars/result_set.py

@@ -34,7 +34,7 @@
 _logger = logging.getLogger(__name__)
 
 
-class DataFrameIterator(abc.Iterator):  # type: ignore
+class PolarsDataFrameIterator(abc.Iterator):  # type: ignore
     """Iterator for chunked DataFrame results from Athena queries.
 
     This class wraps either a Polars DataFrame iterator (for chunked reading) or
@@ -99,11 +99,11 @@ def __next__(self) -> "pl.DataFrame":
             self.close()
             raise
 
-    def __iter__(self) -> "DataFrameIterator":
+    def __iter__(self) -> "PolarsDataFrameIterator":
         """Return self as iterator."""
         return self
 
-    def __enter__(self) -> "DataFrameIterator":
+    def __enter__(self) -> "PolarsDataFrameIterator":
         """Context manager entry."""
         return self
 
@@ -247,7 +247,7 @@ def __init__(
         else:
             import polars as pl
 
-            self._df_iter = DataFrameIterator(
+            self._df_iter = PolarsDataFrameIterator(
                 pl.DataFrame(), self.converters, self._get_column_names()
             )
         self._iterrows = self._df_iter.iterrows()
@@ -320,11 +320,11 @@ def _get_column_names(self) -> List[str]:
         description = self.description if self.description else []
         return [d[0] for d in description]
 
-    def _create_dataframe_iterator(self) -> DataFrameIterator:
+    def _create_dataframe_iterator(self) -> PolarsDataFrameIterator:
         """Create a DataFrame iterator for the result set.
 
         Returns:
-            DataFrameIterator that handles both chunked and non-chunked cases.
+            PolarsDataFrameIterator that handles both chunked and non-chunked cases.
         """
         if self._chunksize is not None:
             # Chunked mode: create lazy iterator
@@ -335,7 +335,7 @@ def _create_dataframe_iterator(self) -> DataFrameIterator:
             # Non-chunked mode: load entire DataFrame
             reader = self._as_polars()
 
-        return DataFrameIterator(reader, self.converters, self._get_column_names())
+        return PolarsDataFrameIterator(reader, self.converters, self._get_column_names())
 
     def fetchone(
         self,
@@ -661,7 +661,7 @@ def _iter_parquet_chunks(self) -> Iterator["pl.DataFrame"]:
             _logger.exception(f"Failed to read {self._unload_location}.")
             raise OperationalError(*e.args) from e
 
-    def iter_chunks(self) -> DataFrameIterator:
+    def iter_chunks(self) -> PolarsDataFrameIterator:
         """Iterate over result chunks as Polars DataFrames.
 
         This method provides an iterator interface for processing large result sets.
@@ -670,7 +670,7 @@ def iter_chunks(self) -> DataFrameIterator:
         it yields the entire result as a single DataFrame.
 
         Returns:
-            DataFrameIterator that yields Polars DataFrames for each chunk
+            PolarsDataFrameIterator that yields Polars DataFrames for each chunk
             of rows, or the entire DataFrame if chunksize was not specified.
 
         Example:
@@ -693,5 +693,5 @@ def close(self) -> None:
         import polars as pl
 
         super().close()
-        self._df_iter = DataFrameIterator(pl.DataFrame(), {}, [])
+        self._df_iter = PolarsDataFrameIterator(pl.DataFrame(), {}, [])
         self._iterrows = iter([])

tests/pyathena/pandas/test_cursor.py

@@ -15,7 +15,7 @@
 
 from pyathena.error import DatabaseError, ProgrammingError
 from pyathena.pandas.cursor import PandasCursor
-from pyathena.pandas.result_set import AthenaPandasResultSet, DataFrameIterator
+from pyathena.pandas.result_set import AthenaPandasResultSet, PandasDataFrameIterator
 from tests import ENV
 from tests.pyathena.conftest import connect
 
@@ -1207,7 +1207,7 @@ def test_pandas_cursor_auto_optimize_chunksize_enabled(self, pandas_cursor):
         # Should work without error (auto-optimization for small files may not trigger chunking)
         result = cursor.as_pandas()
         # Small test data likely won't trigger chunking, so expect DataFrame
-        assert isinstance(result, (pd.DataFrame, DataFrameIterator))
+        assert isinstance(result, (pd.DataFrame, PandasDataFrameIterator))
 
     def test_pandas_cursor_auto_optimize_chunksize_disabled(self, pandas_cursor):
         """Test PandasCursor with auto_optimize_chunksize disabled (default)."""
@@ -1229,7 +1229,7 @@ def test_pandas_cursor_explicit_chunksize_overrides_auto_optimize(self, pandas_c
 
         # Should return iterator due to explicit chunksize
         result = cursor.as_pandas()
-        assert isinstance(result, DataFrameIterator)
+        assert isinstance(result, PandasDataFrameIterator)
 
     def test_pandas_cursor_iter_chunks_without_chunksize(self, pandas_cursor):
         """Test PandasCursor iter_chunks method without chunksize (single DataFrame)."""
@@ -1283,7 +1283,7 @@ def test_pandas_cursor_actual_chunking_behavior(self, pandas_cursor):
         cursor.execute("SELECT * FROM many_rows LIMIT 50")
 
         result = cursor.as_pandas()
-        assert isinstance(result, DataFrameIterator)
+        assert isinstance(result, PandasDataFrameIterator)
 
         chunk_sizes = []
         total_rows = 0