PyAthena 3.30.0__tar.gz → 3.30.1__tar.gz

{pyathena-3.30.0 → pyathena-3.30.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyAthena
-Version: 3.30.0
+Version: 3.30.1
 Summary: Python DB API 2.0 (PEP 249) client for Amazon Athena
 Project-URL: homepage, https://github.com/pyathena-dev/PyAthena/
 Project-URL: repository, https://github.com/pyathena-dev/PyAthena/

pyathena-3.30.1/pyathena/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '3.30.1'
+__version_tuple__ = version_tuple = (3, 30, 1)
+
+__commit_id__ = commit_id = None

{pyathena-3.30.0 → pyathena-3.30.1}/pyathena/arrow/converter.py

@@ -115,4 +115,5 @@ class DefaultArrowUnloadTypeConverter(Converter):
         )
 
     def convert(self, type_: str, value: str | None, type_hint: str | None = None) -> Any | None:
-        pass
+        converter = self.get(type_)
+        return converter(value)

{pyathena-3.30.0 → pyathena-3.30.1}/pyathena/converter.py

@@ -3,12 +3,13 @@ from __future__ import annotations
 import binascii
 import json
 import logging
+import re
 from abc import ABCMeta, abstractmethod
 from collections.abc import Callable
 from copy import deepcopy
 from datetime import date, datetime, time
 from decimal import Decimal
-from typing import Any
+from typing import Any, ClassVar
 
 from dateutil.tz import gettz
 
@@ -16,7 +17,6 @@ from pyathena.parser import (
     TypedValueConverter,
     TypeNode,
     TypeSignatureParser,
-    _normalize_hive_syntax,
     _split_array_items,
 )
 from pyathena.util import strtobool
@@ -551,6 +551,9 @@ class DefaultTypeConverter(Converter):
         ['1', '2', '3']
     """
 
+    _HIVE_SYNTAX_RE: ClassVar[re.Pattern[str]] = re.compile(r"[<>:]")
+    _HIVE_REPLACEMENTS: ClassVar[dict[str, str]] = {"<": "(", ">": ")", ":": " "}
+
     def __init__(self) -> None:
         super().__init__(mappings=deepcopy(_DEFAULT_CONVERTERS), default=_to_default)
         self._parser = TypeSignatureParser()
@@ -561,6 +564,25 @@ class DefaultTypeConverter(Converter):
         )
         self._parsed_hints: dict[str, TypeNode] = {}
 
+    @staticmethod
+    def _normalize_hive_syntax(type_str: str) -> str:
+        """Normalize Hive-style DDL syntax to Trino-style.
+
+        Converts angle-bracket notation (``array<struct<a:int>>``) to
+        parenthesized notation (``array(struct(a int))``).
+
+        Args:
+            type_str: Type signature string, possibly using Hive syntax.
+
+        Returns:
+            Normalized type signature using Trino-style parenthesized notation.
+        """
+        if "<" not in type_str:
+            return type_str
+        return DefaultTypeConverter._HIVE_SYNTAX_RE.sub(
+            lambda m: DefaultTypeConverter._HIVE_REPLACEMENTS[m.group()], type_str
+        )
+
     def convert(self, type_: str, value: str | None, type_hint: str | None = None) -> Any | None:
         """Convert a string value to the appropriate Python type.
 
@@ -605,7 +627,7 @@ class DefaultTypeConverter(Converter):
         Returns:
             Parsed TypeNode.
         """
-        normalized = _normalize_hive_syntax(type_hint)
+        normalized = self._normalize_hive_syntax(type_hint)
         if normalized not in self._parsed_hints:
             self._parsed_hints[normalized] = self._parser.parse(normalized)
         return self._parsed_hints[normalized]

{pyathena-3.30.0 → pyathena-3.30.1}/pyathena/pandas/converter.py

@@ -81,7 +81,8 @@ class DefaultPandasTypeConverter(Converter):
         return self.__dtypes
 
     def convert(self, type_: str, value: str | None, type_hint: str | None = None) -> Any | None:
-        pass
+        converter = self.get(type_)
+        return converter(value)
 
 
 class DefaultPandasUnloadTypeConverter(Converter):
@@ -104,4 +105,5 @@ class DefaultPandasUnloadTypeConverter(Converter):
         )
 
     def convert(self, type_: str, value: str | None, type_hint: str | None = None) -> Any | None:
-        pass
+        converter = self.get(type_)
+        return converter(value)

{pyathena-3.30.0 → pyathena-3.30.1}/pyathena/pandas/result_set.py

@@ -320,38 +320,33 @@ class AthenaPandasResultSet(AthenaResultSet):
         """Determine the appropriate CSV engine based on configuration and compatibility.
 
         Args:
-            file_size_bytes: Size of the CSV file in bytes.
+            file_size_bytes: Size of the CSV file in bytes. Only used for PyArrow
+                compatibility checks (minimum file size threshold).
             chunksize: Chunksize parameter (overrides self._chunksize if provided).
 
         Returns:
             CSV engine name ('pyarrow', 'c', or 'python').
         """
-        effective_chunksize = chunksize if chunksize is not None else self._chunksize
+        if self._engine == "python":
+            return "python"
 
+        # Use PyArrow only when explicitly requested and all compatibility
+        # checks pass; otherwise fall through to the C engine default.
         if self._engine == "pyarrow":
-            return self._get_pyarrow_engine(file_size_bytes, effective_chunksize)
-
-        if self._engine in ("c", "python"):
-            return self._engine
-
-        # Auto-selection for "auto" or unknown engine values
-        return self._get_optimal_csv_engine(file_size_bytes)
-
-    def _get_pyarrow_engine(self, file_size_bytes: int | None, chunksize: int | None) -> str:
-        """Get PyArrow engine if compatible, otherwise return optimal engine."""
-        # Check parameter compatibility
-        if chunksize is not None or self._quoting != 1 or self.converters:
-            return self._get_optimal_csv_engine(file_size_bytes)
-
-        # Check file size compatibility
-        if file_size_bytes is not None and file_size_bytes < self.PYARROW_MIN_FILE_SIZE_BYTES:
-            return self._get_optimal_csv_engine(file_size_bytes)
+            effective_chunksize = chunksize if chunksize is not None else self._chunksize
+            is_compatible = (
+                effective_chunksize is None
+                and self._quoting == 1
+                and not self.converters
+                and (file_size_bytes is None or file_size_bytes >= self.PYARROW_MIN_FILE_SIZE_BYTES)
+            )
+            if is_compatible:
+                try:
+                    return self._get_available_engine(["pyarrow"])
+                except ImportError:
+                    pass
 
-        # Check availability
-        try:
-            return self._get_available_engine(["pyarrow"])
-        except ImportError:
-            return self._get_optimal_csv_engine(file_size_bytes)
+        return "c"
 
     def _get_available_engine(self, engine_candidates: list[str]) -> str:
         """Get the first available engine from a list of candidates.
@@ -382,19 +377,6 @@ class AthenaPandasResultSet(AthenaResultSet):
             f"{error_msgs}"
         )
 
-    def _get_optimal_csv_engine(self, file_size_bytes: int | None = None) -> str:
-        """Get the optimal CSV engine based on file size.
-
-        Args:
-            file_size_bytes: Size of the CSV file in bytes.
-
-        Returns:
-            'python' for large files (>50MB) to avoid C parser limits, otherwise 'c'.
-        """
-        if file_size_bytes and file_size_bytes > self.LARGE_FILE_THRESHOLD_BYTES:
-            return "python"
-        return "c"
-
     def _auto_determine_chunksize(self, file_size_bytes: int) -> int | None:
         """Determine appropriate chunksize for large files based on file size.
 
@@ -594,26 +576,6 @@ class AthenaPandasResultSet(AthenaResultSet):
 
         except Exception as e:
             _logger.exception("Failed to read %s.", self.output_location)
-            error_msg = str(e).lower()
-            if any(
-                phrase in error_msg
-                for phrase in ["signed integer", "maximum", "overflow", "int32", "c parser"]
-            ):
-                # Enhanced error message with specific recommendations
-                file_mb = (length or 0) // (1024 * 1024)
-                detailed_msg = (
-                    f"Large dataset processing error ({file_mb}MB file): {e}. "
-                    "This is likely due to pandas C parser limitations. "
-                    "Recommended solutions:\n"
-                    "1. Set chunksize: cursor = connection.cursor(PandasCursor, chunksize=50000)\n"
-                    "2. Enable auto-optimization: "
-                    "cursor = connection.cursor(PandasCursor, auto_optimize_chunksize=True)\n"
-                    "3. Use PyArrow engine: "
-                    "cursor = connection.cursor(PandasCursor, engine='pyarrow')\n"
-                    "4. Use Python engine: "
-                    "cursor = connection.cursor(PandasCursor, engine='python')"
-                )
-                raise OperationalError(detailed_msg) from e
             raise OperationalError(*e.args) from e
 
     def _read_parquet(self, engine) -> DataFrame:

{pyathena-3.30.0 → pyathena-3.30.1}/pyathena/parser.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import json
-import re
 from collections.abc import Callable
 from dataclasses import dataclass, field
 from typing import Any
@@ -11,28 +10,6 @@ _TYPE_ALIASES: dict[str, str] = {
     "int": "integer",
 }
 
-# Pattern for normalizing Hive-style type signatures to Trino-style.
-# Matches angle brackets and colons used in Hive DDL (e.g., array<struct<a:int>>).
-_HIVE_SYNTAX_RE: re.Pattern[str] = re.compile(r"[<>:]")
-_HIVE_REPLACEMENTS: dict[str, str] = {"<": "(", ">": ")", ":": " "}
-
-
-def _normalize_hive_syntax(type_str: str) -> str:
-    """Normalize Hive-style DDL syntax to Trino-style.
-
-    Converts angle-bracket notation (``array<struct<a:int>>``) to
-    parenthesized notation (``array(struct(a int))``).
-
-    Args:
-        type_str: Type signature string, possibly using Hive syntax.
-
-    Returns:
-        Normalized type signature using Trino-style parenthesized notation.
-    """
-    if "<" not in type_str:
-        return type_str
-    return _HIVE_SYNTAX_RE.sub(lambda m: _HIVE_REPLACEMENTS[m.group()], type_str)
-
 
 def _split_array_items(inner: str) -> list[str]:
     """Split array items by comma, respecting brace and bracket groupings.

{pyathena-3.30.0 → pyathena-3.30.1}/pyathena/polars/converter.py

@@ -128,4 +128,5 @@ class DefaultPolarsUnloadTypeConverter(Converter):
         )
 
     def convert(self, type_: str, value: str | None, type_hint: str | None = None) -> Any | None:
-        pass
+        converter = self.get(type_)
+        return converter(value)

pyathena-3.30.0/pyathena/_version.py

@@ -1,34 +0,0 @@
-# file generated by setuptools-scm
-# don't change, don't track in version control
-
-__all__ = [
-    "__version__",
-    "__version_tuple__",
-    "version",
-    "version_tuple",
-    "__commit_id__",
-    "commit_id",
-]
-
-TYPE_CHECKING = False
-if TYPE_CHECKING:
-    from typing import Tuple
-    from typing import Union
-
-    VERSION_TUPLE = Tuple[Union[int, str], ...]
-    COMMIT_ID = Union[str, None]
-else:
-    VERSION_TUPLE = object
-    COMMIT_ID = object
-
-version: str
-__version__: str
-__version_tuple__: VERSION_TUPLE
-version_tuple: VERSION_TUPLE
-commit_id: COMMIT_ID
-__commit_id__: COMMIT_ID
-
-__version__ = version = '3.30.0'
-__version_tuple__ = version_tuple = (3, 30, 0)
-
-__commit_id__ = commit_id = None