duckdb 1.4.1.dev125__cp310-cp310-macosx_11_0_arm64.whl → 1.5.0.dev37__cp310-cp310-macosx_11_0_arm64.whl

duckdb/experimental/spark/errors/exceptions/base.py

@@ -1,19 +1,20 @@
-from typing import Optional, cast  # noqa: D100
+from typing import Dict, Optional, cast
 
 from ..utils import ErrorClassesReader
 
-
 class PySparkException(Exception):
-    """Base Exception for handling errors generated from PySpark."""
+    """
+    Base Exception for handling errors generated from PySpark.
+    """
 
-    def __init__(  # noqa: D107
+    def __init__(
         self,
         message: Optional[str] = None,
         # The error class, decides the message format, must be one of the valid options listed in 'error_classes.py'
         error_class: Optional[str] = None,
         # The dictionary listing the arguments specified in the message (or the error_class)
-        message_parameters: Optional[dict[str, str]] = None,
-    ) -> None:
+        message_parameters: Optional[Dict[str, str]] = None,
+    ):
         # `message` vs `error_class` & `message_parameters` are mutually exclusive.
         assert (message is not None and (error_class is None and message_parameters is None)) or (
             message is None and (error_class is not None and message_parameters is not None)
@@ -23,7 +24,7 @@ class PySparkException(Exception):
 
         if message is None:
             self.message = self.error_reader.get_error_message(
-                cast("str", error_class), cast("dict[str, str]", message_parameters)
+                cast(str, error_class), cast(Dict[str, str], message_parameters)
             )
         else:
             self.message = message
@@ -32,23 +33,25 @@ class PySparkException(Exception):
         self.message_parameters = message_parameters
 
     def getErrorClass(self) -> Optional[str]:
-        """Returns an error class as a string.
+        """
+        Returns an error class as a string.
 
         .. versionadded:: 3.4.0
 
-        See Also:
+        See Also
         --------
         :meth:`PySparkException.getMessageParameters`
         :meth:`PySparkException.getSqlState`
         """
         return self.error_class
 
-    def getMessageParameters(self) -> Optional[dict[str, str]]:
-        """Returns a message parameters as a dictionary.
+    def getMessageParameters(self) -> Optional[Dict[str, str]]:
+        """
+        Returns a message parameters as a dictionary.
 
         .. versionadded:: 3.4.0
 
-        See Also:
+        See Also
         --------
         :meth:`PySparkException.getErrorClass`
         :meth:`PySparkException.getSqlState`
@@ -56,113 +59,159 @@ class PySparkException(Exception):
         return self.message_parameters
 
     def getSqlState(self) -> None:
-        """Returns an SQLSTATE as a string.
+        """
+        Returns an SQLSTATE as a string.
 
         Errors generated in Python have no SQLSTATE, so it always returns None.
 
         .. versionadded:: 3.4.0
 
-        See Also:
+        See Also
         --------
         :meth:`PySparkException.getErrorClass`
         :meth:`PySparkException.getMessageParameters`
         """
         return None
 
-    def __str__(self) -> str:  # noqa: D105
+    def __str__(self) -> str:
         if self.getErrorClass() is not None:
             return f"[{self.getErrorClass()}] {self.message}"
         else:
             return self.message
 
-
 class AnalysisException(PySparkException):
-    """Failed to analyze a SQL query plan."""
+    """
+    Failed to analyze a SQL query plan.
+    """
 
 
 class SessionNotSameException(PySparkException):
-    """Performed the same operation on different SparkSession."""
+    """
+    Performed the same operation on different SparkSession.
+    """
 
 
 class TempTableAlreadyExistsException(AnalysisException):
-    """Failed to create temp view since it is already exists."""
+    """
+    Failed to create temp view since it is already exists.
+    """
 
 
 class ParseException(AnalysisException):
-    """Failed to parse a SQL command."""
+    """
+    Failed to parse a SQL command.
+    """
 
 
 class IllegalArgumentException(PySparkException):
-    """Passed an illegal or inappropriate argument."""
+    """
+    Passed an illegal or inappropriate argument.
+    """
 
 
 class ArithmeticException(PySparkException):
-    """Arithmetic exception thrown from Spark with an error class."""
+    """
+    Arithmetic exception thrown from Spark with an error class.
+    """
 
 
 class UnsupportedOperationException(PySparkException):
-    """Unsupported operation exception thrown from Spark with an error class."""
+    """
+    Unsupported operation exception thrown from Spark with an error class.
+    """
 
 
 class ArrayIndexOutOfBoundsException(PySparkException):
-    """Array index out of bounds exception thrown from Spark with an error class."""
+    """
+    Array index out of bounds exception thrown from Spark with an error class.
+    """
 
 
 class DateTimeException(PySparkException):
-    """Datetime exception thrown from Spark with an error class."""
+    """
+    Datetime exception thrown from Spark with an error class.
+    """
 
 
 class NumberFormatException(IllegalArgumentException):
-    """Number format exception thrown from Spark with an error class."""
+    """
+    Number format exception thrown from Spark with an error class.
+    """
 
 
 class StreamingQueryException(PySparkException):
-    """Exception that stopped a :class:`StreamingQuery`."""
+    """
+    Exception that stopped a :class:`StreamingQuery`.
+    """
 
 
 class QueryExecutionException(PySparkException):
-    """Failed to execute a query."""
+    """
+    Failed to execute a query.
+    """
 
 
 class PythonException(PySparkException):
-    """Exceptions thrown from Python workers."""
+    """
+    Exceptions thrown from Python workers.
+    """
 
 
 class SparkRuntimeException(PySparkException):
-    """Runtime exception thrown from Spark with an error class."""
+    """
+    Runtime exception thrown from Spark with an error class.
+    """
 
 
 class SparkUpgradeException(PySparkException):
-    """Exception thrown because of Spark upgrade."""
+    """
+    Exception thrown because of Spark upgrade.
+    """
 
 
 class UnknownException(PySparkException):
-    """None of the above exceptions."""
+    """
+    None of the above exceptions.
+    """
 
 
 class PySparkValueError(PySparkException, ValueError):
-    """Wrapper class for ValueError to support error classes."""
+    """
+    Wrapper class for ValueError to support error classes.
+    """
 
 
 class PySparkIndexError(PySparkException, IndexError):
-    """Wrapper class for IndexError to support error classes."""
+    """
+    Wrapper class for IndexError to support error classes.
+    """
 
 
 class PySparkTypeError(PySparkException, TypeError):
-    """Wrapper class for TypeError to support error classes."""
+    """
+    Wrapper class for TypeError to support error classes.
+    """
 
 
 class PySparkAttributeError(PySparkException, AttributeError):
-    """Wrapper class for AttributeError to support error classes."""
+    """
+    Wrapper class for AttributeError to support error classes.
+    """
 
 
 class PySparkRuntimeError(PySparkException, RuntimeError):
-    """Wrapper class for RuntimeError to support error classes."""
+    """
+    Wrapper class for RuntimeError to support error classes.
+    """
 
 
 class PySparkAssertionError(PySparkException, AssertionError):
-    """Wrapper class for AssertionError to support error classes."""
+    """
+    Wrapper class for AssertionError to support error classes.
+    """
 
 
 class PySparkNotImplementedError(PySparkException, NotImplementedError):
-    """Wrapper class for NotImplementedError to support error classes."""
+    """
+    Wrapper class for NotImplementedError to support error classes.
+    """

duckdb/experimental/spark/errors/utils.py

@@ -1,4 +1,4 @@
-#  # noqa: D100
+#
 # Licensed to the Apache Software Foundation (ASF) under one or more
 # contributor license agreements.  See the NOTICE file distributed with
 # this work for additional information regarding copyright ownership.
@@ -16,30 +16,37 @@
 #
 
 import re
+from typing import Dict
 
 from .error_classes import ERROR_CLASSES_MAP
 
 
 class ErrorClassesReader:
-    """A reader to load error information from error_classes.py."""
+    """
+    A reader to load error information from error_classes.py.
+    """
 
-    def __init__(self) -> None:  # noqa: D107
+    def __init__(self) -> None:
         self.error_info_map = ERROR_CLASSES_MAP
 
-    def get_error_message(self, error_class: str, message_parameters: dict[str, str]) -> str:
-        """Returns the completed error message by applying message parameters to the message template."""
+    def get_error_message(self, error_class: str, message_parameters: Dict[str, str]) -> str:
+        """
+        Returns the completed error message by applying message parameters to the message template.
+        """
         message_template = self.get_message_template(error_class)
         # Verify message parameters.
         message_parameters_from_template = re.findall("<([a-zA-Z0-9_-]+)>", message_template)
         assert set(message_parameters_from_template) == set(message_parameters), (
-            f"Undefined error message parameter for error class: {error_class}. Parameters: {message_parameters}"
+            f"Undefined error message parameter for error class: {error_class}. "
+            f"Parameters: {message_parameters}"
         )
         table = str.maketrans("<>", "{}")
 
         return message_template.translate(table).format(**message_parameters)
 
     def get_message_template(self, error_class: str) -> str:
-        """Returns the message template for corresponding error class from error_classes.py.
+        """
+        Returns the message template for corresponding error class from error_classes.py.
 
         For example,
         when given `error_class` is "EXAMPLE_ERROR_CLASS",
@@ -86,8 +93,7 @@ class ErrorClassesReader:
         if main_error_class in self.error_info_map:
             main_error_class_info_map = self.error_info_map[main_error_class]
         else:
-            msg = f"Cannot find main error class '{main_error_class}'"
-            raise ValueError(msg)
+            raise ValueError(f"Cannot find main error class '{main_error_class}'")
 
         main_message_template = "\n".join(main_error_class_info_map["message"])
 
@@ -102,8 +108,7 @@ class ErrorClassesReader:
             if sub_error_class in main_error_class_subclass_info_map:
                 sub_error_class_info_map = main_error_class_subclass_info_map[sub_error_class]
             else:
-                msg = f"Cannot find sub error class '{sub_error_class}'"
-                raise ValueError(msg)
+                raise ValueError(f"Cannot find sub error class '{sub_error_class}'")
 
             sub_message_template = "\n".join(sub_error_class_info_map["message"])
             message_template = main_message_template + " " + sub_message_template

duckdb/experimental/spark/exception.py

@@ -1,17 +1,14 @@
-# ruff: noqa: D100
-from typing import Optional
-
-
 class ContributionsAcceptedError(NotImplementedError):
-    """This method is not planned to be implemented, if you would like to implement this method
+    """
+    This method is not planned to be implemented, if you would like to implement this method
     or show your interest in this method to other members of the community,
-    feel free to open up a PR or a Discussion over on https://github.com/duckdb/duckdb.
-    """  # noqa: D205
+    feel free to open up a PR or a Discussion over on https://github.com/duckdb/duckdb
+    """
 
-    def __init__(self, message: Optional[str] = None) -> None:  # noqa: D107
+    def __init__(self, message=None):
         doc = self.__class__.__doc__
         if message:
-            doc = message + "\n" + doc
+            doc = message + '\n' + doc
         super().__init__(doc)
 
 

duckdb/experimental/spark/sql/__init__.py

@@ -1,7 +1,7 @@
-from .catalog import Catalog  # noqa: D104
-from .conf import RuntimeConfig
-from .dataframe import DataFrame
-from .readwriter import DataFrameWriter
 from .session import SparkSession
+from .readwriter import DataFrameWriter
+from .dataframe import DataFrame
+from .conf import RuntimeConfig
+from .catalog import Catalog
 
-__all__ = ["Catalog", "DataFrame", "DataFrameWriter", "RuntimeConfig", "SparkSession"]
+__all__ = ["SparkSession", "DataFrame", "RuntimeConfig", "DataFrameWriter", "Catalog"]

duckdb/experimental/spark/sql/_typing.py

@@ -19,11 +19,12 @@
 from typing import (
     Any,
     Callable,
+    List,
     Optional,
+    Tuple,
     TypeVar,
     Union,
 )
-
 try:
     from typing import Literal, Protocol
 except ImportError:
@@ -56,21 +57,24 @@ AtomicValue = TypeVar(
     float,
 )
 
-RowLike = TypeVar("RowLike", list[Any], tuple[Any, ...], types.Row)
+RowLike = TypeVar("RowLike", List[Any], Tuple[Any, ...], types.Row)
 
 SQLBatchedUDFType = Literal[100]
 
 
 class SupportsOpen(Protocol):
-    def open(self, partition_id: int, epoch_id: int) -> bool: ...
+    def open(self, partition_id: int, epoch_id: int) -> bool:
+        ...
 
 
 class SupportsProcess(Protocol):
-    def process(self, row: types.Row) -> None: ...
+    def process(self, row: types.Row) -> None:
+        ...
 
 
 class SupportsClose(Protocol):
-    def close(self, error: Exception) -> None: ...
+    def close(self, error: Exception) -> None:
+        ...
 
 
 class UserDefinedFunctionLike(Protocol):
@@ -79,8 +83,11 @@ class UserDefinedFunctionLike(Protocol):
     deterministic: bool
 
     @property
-    def returnType(self) -> types.DataType: ...
+    def returnType(self) -> types.DataType:
+        ...
 
-    def __call__(self, *args: ColumnOrName) -> Column: ...
+    def __call__(self, *args: ColumnOrName) -> Column:
+        ...
 
-    def asNondeterministic(self) -> "UserDefinedFunctionLike": ...
+    def asNondeterministic(self) -> "UserDefinedFunctionLike":
+        ...

duckdb/experimental/spark/sql/catalog.py

@@ -1,15 +1,14 @@
-from typing import NamedTuple, Optional, Union  # noqa: D100
-
+from typing import List, NamedTuple, Optional
 from .session import SparkSession
 
 
-class Database(NamedTuple):  # noqa: D101
+class Database(NamedTuple):
     name: str
     description: Optional[str]
     locationUri: str
 
 
-class Table(NamedTuple):  # noqa: D101
+class Table(NamedTuple):
     name: str
     database: Optional[str]
     description: Optional[str]
@@ -17,7 +16,7 @@ class Table(NamedTuple):  # noqa: D101
     isTemporary: bool
 
 
-class Column(NamedTuple):  # noqa: D101
+class Column(NamedTuple):
     name: str
     description: Optional[str]
     dataType: str
@@ -26,36 +25,36 @@ class Column(NamedTuple):  # noqa: D101
     isBucket: bool
 
 
-class Function(NamedTuple):  # noqa: D101
+class Function(NamedTuple):
     name: str
     description: Optional[str]
     className: str
     isTemporary: bool
 
 
-class Catalog:  # noqa: D101
-    def __init__(self, session: SparkSession) -> None:  # noqa: D107
+class Catalog:
+    def __init__(self, session: SparkSession):
         self._session = session
 
-    def listDatabases(self) -> list[Database]:  # noqa: D102
-        res = self._session.conn.sql("select database_name from duckdb_databases()").fetchall()
+    def listDatabases(self) -> List[Database]:
+        res = self._session.conn.sql('select database_name from duckdb_databases()').fetchall()
 
-        def transform_to_database(x: list[str]) -> Database:
-            return Database(name=x[0], description=None, locationUri="")
+        def transform_to_database(x) -> Database:
+            return Database(name=x[0], description=None, locationUri='')
 
         databases = [transform_to_database(x) for x in res]
         return databases
 
-    def listTables(self) -> list[Table]:  # noqa: D102
-        res = self._session.conn.sql("select table_name, database_name, sql, temporary from duckdb_tables()").fetchall()
+    def listTables(self) -> List[Table]:
+        res = self._session.conn.sql('select table_name, database_name, sql, temporary from duckdb_tables()').fetchall()
 
-        def transform_to_table(x: list[str]) -> Table:
-            return Table(name=x[0], database=x[1], description=x[2], tableType="", isTemporary=x[3])
+        def transform_to_table(x) -> Table:
+            return Table(name=x[0], database=x[1], description=x[2], tableType='', isTemporary=x[3])
 
         tables = [transform_to_table(x) for x in res]
         return tables
 
-    def listColumns(self, tableName: str, dbName: Optional[str] = None) -> list[Column]:  # noqa: D102
+    def listColumns(self, tableName: str, dbName: Optional[str] = None) -> List[Column]:
         query = f"""
 			select column_name, data_type, is_nullable from duckdb_columns() where table_name = '{tableName}'
 		"""
@@ -63,17 +62,17 @@ class Catalog:  # noqa: D101
             query += f" and database_name = '{dbName}'"
         res = self._session.conn.sql(query).fetchall()
 
-        def transform_to_column(x: list[Union[str, bool]]) -> Column:
+        def transform_to_column(x) -> Column:
             return Column(name=x[0], description=None, dataType=x[1], nullable=x[2], isPartition=False, isBucket=False)
 
         columns = [transform_to_column(x) for x in res]
         return columns
 
-    def listFunctions(self, dbName: Optional[str] = None) -> list[Function]:  # noqa: D102
+    def listFunctions(self, dbName: Optional[str] = None) -> List[Function]:
         raise NotImplementedError
 
-    def setCurrentDatabase(self, dbName: str) -> None:  # noqa: D102
+    def setCurrentDatabase(self, dbName: str) -> None:
         raise NotImplementedError
 
 
-__all__ = ["Catalog", "Column", "Database", "Function", "Table"]
+__all__ = ["Catalog", "Table", "Column", "Function", "Database"]