duckdb 1.4.1.dev113__cp310-cp310-win_amd64.whl → 1.5.0.dev32__cp310-cp310-win_amd64.whl

duckdb/experimental/spark/sql/column.py

@@ -1,19 +1,19 @@
-from collections.abc import Iterable  # noqa: D100
-from typing import TYPE_CHECKING, Any, Callable, Union, cast
-
+from typing import Union, TYPE_CHECKING, Any, cast, Callable, Tuple
 from ..exception import ContributionsAcceptedError
+
 from .types import DataType
 
 if TYPE_CHECKING:
-    from ._typing import DateTimeLiteral, DecimalLiteral, LiteralType
+    from ._typing import ColumnOrName, LiteralType, DecimalLiteral, DateTimeLiteral
+
+from duckdb import ConstantExpression, ColumnExpression, FunctionExpression, Expression
 
-from duckdb import ColumnExpression, ConstantExpression, Expression, FunctionExpression
 from duckdb.typing import DuckDBPyType
 
 __all__ = ["Column"]
 
 
-def _get_expr(x: Union["Column", str]) -> Expression:
+def _get_expr(x) -> Expression:
     return x.expr if isinstance(x, Column) else ConstantExpression(x)
 
 
@@ -30,7 +30,7 @@ def _unary_op(
     name: str,
     doc: str = "unary operator",
 ) -> Callable[["Column"], "Column"]:
-    """Create a method for given unary operator."""
+    """Create a method for given unary operator"""
 
     def _(self: "Column") -> "Column":
         # Call the function identified by 'name' on the internal Expression object
@@ -45,7 +45,7 @@ def _bin_op(
     name: str,
     doc: str = "binary operator",
 ) -> Callable[["Column", Union["Column", "LiteralType", "DecimalLiteral", "DateTimeLiteral"]], "Column"]:
-    """Create a method for given binary operator."""
+    """Create a method for given binary operator"""
 
     def _(
         self: "Column",
@@ -63,7 +63,7 @@ def _bin_func(
     name: str,
     doc: str = "binary function",
 ) -> Callable[["Column", Union["Column", "LiteralType", "DecimalLiteral", "DateTimeLiteral"]], "Column"]:
-    """Create a function expression for the given binary function."""
+    """Create a function expression for the given binary function"""
 
     def _(
         self: "Column",
@@ -78,7 +78,8 @@ def _bin_func(
 
 
 class Column:
-    """A column in a DataFrame.
+    """
+    A column in a DataFrame.
 
     :class:`Column` instances can be created by::
 
@@ -94,11 +95,11 @@ class Column:
     .. versionadded:: 1.3.0
     """
 
-    def __init__(self, expr: Expression) -> None:  # noqa: D107
+    def __init__(self, expr: Expression):
         self.expr = expr
 
     # arithmetic operators
-    def __neg__(self) -> "Column":  # noqa: D105
+    def __neg__(self):
         return Column(-self.expr)
 
     # `and`, `or`, `not` cannot be overloaded in Python,
@@ -137,8 +138,9 @@ class Column:
 
     __rpow__ = _bin_op("__rpow__")
 
-    def __getitem__(self, k: Any) -> "Column":  # noqa: ANN401
-        """An expression that gets an item at position ``ordinal`` out of a list,
+    def __getitem__(self, k: Any) -> "Column":
+        """
+        An expression that gets an item at position ``ordinal`` out of a list,
         or gets an item by key out of a dict.
 
         .. versionadded:: 1.3.0
@@ -151,34 +153,35 @@ class Column:
         k
             a literal value, or a slice object without step.
 
-        Returns:
+        Returns
         -------
         :class:`Column`
             Column representing the item got by key out of a dict, or substrings sliced by
             the given slice object.
 
-        Examples:
+        Examples
         --------
-        >>> df = spark.createDataFrame([("abcedfg", {"key": "value"})], ["l", "d"])
-        >>> df.select(df.l[slice(1, 3)], df.d["key"]).show()
+        >>> df = spark.createDataFrame([('abcedfg', {"key": "value"})], ["l", "d"])
+        >>> df.select(df.l[slice(1, 3)], df.d['key']).show()
         +------------------+------+
         |substring(l, 1, 3)|d[key]|
         +------------------+------+
         |               abc| value|
         +------------------+------+
-        """  # noqa: D205
+        """
         if isinstance(k, slice):
             raise ContributionsAcceptedError
             # if k.step is not None:
             #    raise ValueError("Using a slice with a step value is not supported")
             # return self.substr(k.start, k.stop)
         else:
-            # TODO: this is super hacky  # noqa: TD002, TD003
+            # FIXME: this is super hacky
             expr_str = str(self.expr) + "." + str(k)
             return Column(ColumnExpression(expr_str))
 
-    def __getattr__(self, item: Any) -> "Column":  # noqa: ANN401
-        """An expression that gets an item at position ``ordinal`` out of a list,
+    def __getattr__(self, item: Any) -> "Column":
+        """
+        An expression that gets an item at position ``ordinal`` out of a list,
         or gets an item by key out of a dict.
 
         Parameters
@@ -186,53 +189,55 @@ class Column:
         item
             a literal value.
 
-        Returns:
+        Returns
         -------
         :class:`Column`
             Column representing the item got by key out of a dict.
 
-        Examples:
+        Examples
         --------
-        >>> df = spark.createDataFrame([("abcedfg", {"key": "value"})], ["l", "d"])
+        >>> df = spark.createDataFrame([('abcedfg', {"key": "value"})], ["l", "d"])
         >>> df.select(df.d.key).show()
         +------+
         |d[key]|
         +------+
         | value|
         +------+
-        """  # noqa: D205
+        """
         if item.startswith("__"):
-            msg = "Can not access __ (dunder) method"
-            raise AttributeError(msg)
+            raise AttributeError("Can not access __ (dunder) method")
         return self[item]
 
-    def alias(self, alias: str) -> "Column":  # noqa: D102
+    def alias(self, alias: str):
         return Column(self.expr.alias(alias))
 
-    def when(self, condition: "Column", value: Union["Column", str]) -> "Column":  # noqa: D102
+    def when(self, condition: "Column", value: Any):
         if not isinstance(condition, Column):
-            msg = "condition should be a Column"
-            raise TypeError(msg)
+            raise TypeError("condition should be a Column")
         v = _get_expr(value)
         expr = self.expr.when(condition.expr, v)
         return Column(expr)
 
-    def otherwise(self, value: Union["Column", str]) -> "Column":  # noqa: D102
+    def otherwise(self, value: Any):
         v = _get_expr(value)
         expr = self.expr.otherwise(v)
         return Column(expr)
 
-    def cast(self, dataType: Union[DataType, str]) -> "Column":  # noqa: D102
-        internal_type = DuckDBPyType(dataType) if isinstance(dataType, str) else dataType.duckdb_type
+    def cast(self, dataType: Union[DataType, str]) -> "Column":
+        if isinstance(dataType, str):
+            # Try to construct a default DuckDBPyType from it
+            internal_type = DuckDBPyType(dataType)
+        else:
+            internal_type = dataType.duckdb_type
         return Column(self.expr.cast(internal_type))
 
-    def isin(self, *cols: Union[Iterable[Union["Column", str]], Union["Column", str]]) -> "Column":  # noqa: D102
+    def isin(self, *cols: Any) -> "Column":
         if len(cols) == 1 and isinstance(cols[0], (list, set)):
             # Only one argument supplied, it's a list
-            cols = cast("tuple", cols[0])
+            cols = cast(Tuple, cols[0])
 
         cols = cast(
-            "tuple",
+            Tuple,
             [_get_expr(c) for c in cols],
         )
         return Column(self.expr.isin(*cols))
@@ -242,14 +247,14 @@ class Column:
         self,
         other: Union["Column", "LiteralType", "DecimalLiteral", "DateTimeLiteral"],
     ) -> "Column":
-        """Binary function."""
+        """binary function"""
         return Column(self.expr == (_get_expr(other)))
 
     def __ne__(  # type: ignore[override]
         self,
-        other: object,
+        other: Any,
     ) -> "Column":
-        """Binary function."""
+        """binary function"""
         return Column(self.expr != (_get_expr(other)))
 
     __lt__ = _bin_op("__lt__")
@@ -342,20 +347,22 @@ class Column:
     nulls_first = _unary_op("nulls_first")
     nulls_last = _unary_op("nulls_last")
 
-    def asc_nulls_first(self) -> "Column":  # noqa: D102
+
+    def asc_nulls_first(self) -> "Column":
         return self.asc().nulls_first()
 
-    def asc_nulls_last(self) -> "Column":  # noqa: D102
+    def asc_nulls_last(self) -> "Column":
         return self.asc().nulls_last()
 
-    def desc_nulls_first(self) -> "Column":  # noqa: D102
+    def desc_nulls_first(self) -> "Column":
         return self.desc().nulls_first()
 
-    def desc_nulls_last(self) -> "Column":  # noqa: D102
+    def desc_nulls_last(self) -> "Column":
         return self.desc().nulls_last()
 
-    def isNull(self) -> "Column":  # noqa: D102
+    def isNull(self) -> "Column":
         return Column(self.expr.isnull())
 
-    def isNotNull(self) -> "Column":  # noqa: D102
+    def isNotNull(self) -> "Column":
         return Column(self.expr.isnotnull())
+

duckdb/experimental/spark/sql/conf.py

@@ -1,23 +1,22 @@
-from typing import Optional, Union  # noqa: D100
-
+from typing import Optional, Union
+from duckdb.experimental.spark._globals import _NoValueType, _NoValue
 from duckdb import DuckDBPyConnection
-from duckdb.experimental.spark._globals import _NoValue, _NoValueType
 
 
-class RuntimeConfig:  # noqa: D101
-    def __init__(self, connection: DuckDBPyConnection) -> None:  # noqa: D107
+class RuntimeConfig:
+    def __init__(self, connection: DuckDBPyConnection):
         self._connection = connection
 
-    def set(self, key: str, value: str) -> None:  # noqa: D102
+    def set(self, key: str, value: str) -> None:
         raise NotImplementedError
 
-    def isModifiable(self, key: str) -> bool:  # noqa: D102
+    def isModifiable(self, key: str) -> bool:
         raise NotImplementedError
 
-    def unset(self, key: str) -> None:  # noqa: D102
+    def unset(self, key: str) -> None:
         raise NotImplementedError
 
-    def get(self, key: str, default: Union[Optional[str], _NoValueType] = _NoValue) -> str:  # noqa: D102
+    def get(self, key: str, default: Union[Optional[str], _NoValueType] = _NoValue) -> str:
         raise NotImplementedError