duckdb 1.4.1.dev135__cp312-cp312-macosx_10_13_universal2.whl → 1.5.0.dev44__cp312-cp312-macosx_10_13_universal2.whl

_duckdb-stubs/_func.pyi

@@ -1,46 +0,0 @@
-import typing as pytyping
-
-__all__: list[str] = ["ARROW", "DEFAULT", "NATIVE", "SPECIAL", "FunctionNullHandling", "PythonUDFType"]
-
-class FunctionNullHandling:
-    DEFAULT: pytyping.ClassVar[FunctionNullHandling]  # value = <FunctionNullHandling.DEFAULT: 0>
-    SPECIAL: pytyping.ClassVar[FunctionNullHandling]  # value = <FunctionNullHandling.SPECIAL: 1>
-    __members__: pytyping.ClassVar[
-        dict[str, FunctionNullHandling]
-    ]  # value = {'DEFAULT': <FunctionNullHandling.DEFAULT: 0>, 'SPECIAL': <FunctionNullHandling.SPECIAL: 1>}
-    def __eq__(self, other: object) -> bool: ...
-    def __getstate__(self) -> int: ...
-    def __hash__(self) -> int: ...
-    def __index__(self) -> int: ...
-    def __init__(self, value: pytyping.SupportsInt) -> None: ...
-    def __int__(self) -> int: ...
-    def __ne__(self, other: object) -> bool: ...
-    def __setstate__(self, state: pytyping.SupportsInt) -> None: ...
-    @property
-    def name(self) -> str: ...
-    @property
-    def value(self) -> int: ...
-
-class PythonUDFType:
-    ARROW: pytyping.ClassVar[PythonUDFType]  # value = <PythonUDFType.ARROW: 1>
-    NATIVE: pytyping.ClassVar[PythonUDFType]  # value = <PythonUDFType.NATIVE: 0>
-    __members__: pytyping.ClassVar[
-        dict[str, PythonUDFType]
-    ]  # value = {'NATIVE': <PythonUDFType.NATIVE: 0>, 'ARROW': <PythonUDFType.ARROW: 1>}
-    def __eq__(self, other: object) -> bool: ...
-    def __getstate__(self) -> int: ...
-    def __hash__(self) -> int: ...
-    def __index__(self) -> int: ...
-    def __init__(self, value: pytyping.SupportsInt) -> None: ...
-    def __int__(self) -> int: ...
-    def __ne__(self, other: object) -> bool: ...
-    def __setstate__(self, state: pytyping.SupportsInt) -> None: ...
-    @property
-    def name(self) -> str: ...
-    @property
-    def value(self) -> int: ...
-
-ARROW: PythonUDFType  # value = <PythonUDFType.ARROW: 1>
-DEFAULT: FunctionNullHandling  # value = <FunctionNullHandling.DEFAULT: 0>
-NATIVE: PythonUDFType  # value = <PythonUDFType.NATIVE: 0>
-SPECIAL: FunctionNullHandling  # value = <FunctionNullHandling.SPECIAL: 1>

_duckdb-stubs/_sqltypes.pyi

@@ -1,75 +0,0 @@
-import duckdb
-import typing as pytyping
-
-__all__: list[str] = [
-    "BIGINT",
-    "BIT",
-    "BLOB",
-    "BOOLEAN",
-    "DATE",
-    "DOUBLE",
-    "FLOAT",
-    "HUGEINT",
-    "INTEGER",
-    "INTERVAL",
-    "SMALLINT",
-    "SQLNULL",
-    "TIME",
-    "TIMESTAMP",
-    "TIMESTAMP_MS",
-    "TIMESTAMP_NS",
-    "TIMESTAMP_S",
-    "TIMESTAMP_TZ",
-    "TIME_TZ",
-    "TINYINT",
-    "UBIGINT",
-    "UHUGEINT",
-    "UINTEGER",
-    "USMALLINT",
-    "UTINYINT",
-    "UUID",
-    "VARCHAR",
-    "DuckDBPyType",
-]
-
-class DuckDBPyType:
-    def __eq__(self, other: object) -> bool: ...
-    def __getattr__(self, name: str) -> DuckDBPyType: ...
-    def __getitem__(self, name: str) -> DuckDBPyType: ...
-    def __hash__(self) -> int: ...
-    @pytyping.overload
-    def __init__(self, type_str: str, connection: duckdb.DuckDBPyConnection) -> None: ...
-    @pytyping.overload
-    def __init__(self, obj: object) -> None: ...
-    @property
-    def children(self) -> list[tuple[str, object]]: ...
-    @property
-    def id(self) -> str: ...
-
-BIGINT: DuckDBPyType  # value = BIGINT
-BIT: DuckDBPyType  # value = BIT
-BLOB: DuckDBPyType  # value = BLOB
-BOOLEAN: DuckDBPyType  # value = BOOLEAN
-DATE: DuckDBPyType  # value = DATE
-DOUBLE: DuckDBPyType  # value = DOUBLE
-FLOAT: DuckDBPyType  # value = FLOAT
-HUGEINT: DuckDBPyType  # value = HUGEINT
-INTEGER: DuckDBPyType  # value = INTEGER
-INTERVAL: DuckDBPyType  # value = INTERVAL
-SMALLINT: DuckDBPyType  # value = SMALLINT
-SQLNULL: DuckDBPyType  # value = "NULL"
-TIME: DuckDBPyType  # value = TIME
-TIMESTAMP: DuckDBPyType  # value = TIMESTAMP
-TIMESTAMP_MS: DuckDBPyType  # value = TIMESTAMP_MS
-TIMESTAMP_NS: DuckDBPyType  # value = TIMESTAMP_NS
-TIMESTAMP_S: DuckDBPyType  # value = TIMESTAMP_S
-TIMESTAMP_TZ: DuckDBPyType  # value = TIMESTAMP WITH TIME ZONE
-TIME_TZ: DuckDBPyType  # value = TIME WITH TIME ZONE
-TINYINT: DuckDBPyType  # value = TINYINT
-UBIGINT: DuckDBPyType  # value = UBIGINT
-UHUGEINT: DuckDBPyType  # value = UHUGEINT
-UINTEGER: DuckDBPyType  # value = UINTEGER
-USMALLINT: DuckDBPyType  # value = USMALLINT
-UTINYINT: DuckDBPyType  # value = UTINYINT
-UUID: DuckDBPyType  # value = UUID
-VARCHAR: DuckDBPyType  # value = VARCHAR

adbc_driver_duckdb/__init__.py

@@ -1,50 +0,0 @@
-# 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.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-
-"""Low-level ADBC bindings for the DuckDB driver."""
-
-import enum
-import functools
-import importlib
-import typing
-
-import adbc_driver_manager
-
-
-class StatementOptions(enum.Enum):
-    """Statement options specific to the DuckDB driver."""
-
-    #: The number of rows per batch. Defaults to 2048.
-    BATCH_ROWS = "adbc.duckdb.query.batch_rows"
-
-
-def connect(path: typing.Optional[str] = None) -> adbc_driver_manager.AdbcDatabase:
-    """Create a low level ADBC connection to DuckDB."""
-    if path is None:
-        return adbc_driver_manager.AdbcDatabase(driver=driver_path(), entrypoint="duckdb_adbc_init")
-    return adbc_driver_manager.AdbcDatabase(driver=driver_path(), entrypoint="duckdb_adbc_init", path=path)
-
-
-@functools.cache
-def driver_path() -> str:
-    """Get the path to the DuckDB ADBC driver."""
-    duckdb_module_spec = importlib.util.find_spec("_duckdb")
-    if duckdb_module_spec is None:
-        msg = "Could not find duckdb shared library. Did you pip install duckdb?"
-        raise ImportError(msg)
-    print(f"Found duckdb shared library at {duckdb_module_spec.origin}")
-    return duckdb_module_spec.origin

adbc_driver_duckdb/dbapi.py

@@ -1,115 +0,0 @@
-# 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.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-
-"""DBAPI 2.0-compatible facade for the ADBC DuckDB driver."""
-
-import typing
-
-import adbc_driver_manager
-import adbc_driver_manager.dbapi
-
-import adbc_driver_duckdb
-
-__all__ = [
-    "BINARY",
-    "DATETIME",
-    "NUMBER",
-    "ROWID",
-    "STRING",
-    "Connection",
-    "Cursor",
-    "DataError",
-    "DatabaseError",
-    "Date",
-    "DateFromTicks",
-    "Error",
-    "IntegrityError",
-    "InterfaceError",
-    "InternalError",
-    "NotSupportedError",
-    "OperationalError",
-    "ProgrammingError",
-    "Time",
-    "TimeFromTicks",
-    "Timestamp",
-    "TimestampFromTicks",
-    "Warning",
-    "apilevel",
-    "connect",
-    "paramstyle",
-    "threadsafety",
-]
-
-# ----------------------------------------------------------
-# Globals
-
-apilevel = adbc_driver_manager.dbapi.apilevel
-threadsafety = adbc_driver_manager.dbapi.threadsafety
-paramstyle = "qmark"
-
-Warning = adbc_driver_manager.dbapi.Warning
-Error = adbc_driver_manager.dbapi.Error
-InterfaceError = adbc_driver_manager.dbapi.InterfaceError
-DatabaseError = adbc_driver_manager.dbapi.DatabaseError
-DataError = adbc_driver_manager.dbapi.DataError
-OperationalError = adbc_driver_manager.dbapi.OperationalError
-IntegrityError = adbc_driver_manager.dbapi.IntegrityError
-InternalError = adbc_driver_manager.dbapi.InternalError
-ProgrammingError = adbc_driver_manager.dbapi.ProgrammingError
-NotSupportedError = adbc_driver_manager.dbapi.NotSupportedError
-
-# ----------------------------------------------------------
-# Types
-
-Date = adbc_driver_manager.dbapi.Date
-Time = adbc_driver_manager.dbapi.Time
-Timestamp = adbc_driver_manager.dbapi.Timestamp
-DateFromTicks = adbc_driver_manager.dbapi.DateFromTicks
-TimeFromTicks = adbc_driver_manager.dbapi.TimeFromTicks
-TimestampFromTicks = adbc_driver_manager.dbapi.TimestampFromTicks
-STRING = adbc_driver_manager.dbapi.STRING
-BINARY = adbc_driver_manager.dbapi.BINARY
-NUMBER = adbc_driver_manager.dbapi.NUMBER
-DATETIME = adbc_driver_manager.dbapi.DATETIME
-ROWID = adbc_driver_manager.dbapi.ROWID
-
-# ----------------------------------------------------------
-# Functions
-
-
-def connect(path: typing.Optional[str] = None, **kwargs) -> "Connection":
-    """Connect to DuckDB via ADBC."""
-    db = None
-    conn = None
-
-    try:
-        db = adbc_driver_duckdb.connect(path)
-        conn = adbc_driver_manager.AdbcConnection(db)
-        return adbc_driver_manager.dbapi.Connection(db, conn, **kwargs)
-    except Exception:
-        if conn:
-            conn.close()
-        if db:
-            db.close()
-        raise
-
-
-# ----------------------------------------------------------
-# Classes
-
-Connection = adbc_driver_manager.dbapi.Connection
-Cursor = adbc_driver_manager.dbapi.Cursor

duckdb/_dbapi_type_object.py

@@ -1,231 +0,0 @@
-"""DuckDB DB API 2.0 Type Objects Module.
-
-This module provides DB API 2.0 compliant type objects for DuckDB, allowing applications
-to check column types returned by queries against standard database API categories.
-
-Example:
-    >>> import duckdb
-    >>>
-    >>> conn = duckdb.connect()
-    >>> cursor = conn.cursor()
-    >>> cursor.execute("SELECT 'hello' as text_col, 42 as num_col, CURRENT_DATE as date_col")
-    >>>
-    >>> # Check column types using DB API type objects
-    >>> for i, desc in enumerate(cursor.description):
-    >>>     col_name, col_type = desc[0], desc[1]
-    >>>     if col_type == duckdb.STRING:
-    >>>         print(f"{col_name} is a string type")
-    >>>     elif col_type == duckdb.NUMBER:
-    >>>         print(f"{col_name} is a numeric type")
-    >>>     elif col_type == duckdb.DATETIME:
-    >>>         print(f"{col_name} is a date/time type")
-
-See Also:
-    - PEP 249: https://peps.python.org/pep-0249/
-    - DuckDB Type System: https://duckdb.org/docs/sql/data_types/overview
-"""
-
-from duckdb import sqltypes
-
-
-class DBAPITypeObject:
-    """DB API 2.0 type object for categorizing database column types.
-
-    This class implements the type objects defined in PEP 249 (DB API 2.0).
-    It allows checking whether a specific DuckDB type belongs to a broader
-    category like STRING, NUMBER, DATETIME, etc.
-
-    The type object supports equality comparison with DuckDBPyType instances,
-    returning True if the type belongs to this category.
-
-    Args:
-        types: A list of DuckDBPyType instances that belong to this type category.
-
-    Example:
-        >>> string_types = DBAPITypeObject([sqltypes.VARCHAR, sqltypes.CHAR])
-        >>> result = sqltypes.VARCHAR == string_types  # True
-        >>> result = sqltypes.INTEGER == string_types  # False
-
-    Note:
-        This follows the DB API 2.0 specification where type objects are compared
-        using equality operators rather than isinstance() checks.
-    """
-
-    def __init__(self, types: list[sqltypes.DuckDBPyType]) -> None:
-        """Initialize a DB API type object.
-
-        Args:
-            types: List of DuckDB types that belong to this category.
-        """
-        self.types = types
-
-    def __eq__(self, other: object) -> bool:
-        """Check if a DuckDB type belongs to this type category.
-
-        This method implements the DB API 2.0 type checking mechanism.
-        It returns True if the other object is a DuckDBPyType that
-        is contained in this type category.
-
-        Args:
-            other: The object to compare, typically a DuckDBPyType instance.
-
-        Returns:
-            True if other is a DuckDBPyType in this category, False otherwise.
-
-        Example:
-            >>> NUMBER == sqltypes.INTEGER  # True
-            >>> NUMBER == sqltypes.VARCHAR  # False
-        """
-        if isinstance(other, sqltypes.DuckDBPyType):
-            return other in self.types
-        return False
-
-    def __repr__(self) -> str:
-        """Return a string representation of this type object.
-
-        Returns:
-            A string showing the type object and its contained DuckDB types.
-
-        Example:
-            >>> repr(STRING)
-            '<DBAPITypeObject [VARCHAR]>'
-        """
-        return f"<DBAPITypeObject [{','.join(str(x) for x in self.types)}]>"
-
-
-# Define the standard DB API 2.0 type objects for DuckDB
-
-STRING = DBAPITypeObject([sqltypes.VARCHAR])
-"""
-STRING type object for text-based database columns.
-
-This type object represents all string/text types in DuckDB. Currently includes:
-- VARCHAR: Variable-length character strings
-
-Use this to check if a column contains textual data that should be handled
-as Python strings.
-
-DB API 2.0 Reference:
-    https://peps.python.org/pep-0249/#string
-
-Example:
-    >>> cursor.description[0][1] == STRING  # Check if first column is text
-"""
-
-NUMBER = DBAPITypeObject(
-    [
-        sqltypes.TINYINT,
-        sqltypes.UTINYINT,
-        sqltypes.SMALLINT,
-        sqltypes.USMALLINT,
-        sqltypes.INTEGER,
-        sqltypes.UINTEGER,
-        sqltypes.BIGINT,
-        sqltypes.UBIGINT,
-        sqltypes.HUGEINT,
-        sqltypes.UHUGEINT,
-        sqltypes.DuckDBPyType("BIGNUM"),
-        sqltypes.DuckDBPyType("DECIMAL"),
-        sqltypes.FLOAT,
-        sqltypes.DOUBLE,
-    ]
-)
-"""
-NUMBER type object for numeric database columns.
-
-This type object represents all numeric types in DuckDB, including:
-
-Integer Types:
-- TINYINT, UTINYINT: 8-bit signed/unsigned integers
-- SMALLINT, USMALLINT: 16-bit signed/unsigned integers
-- INTEGER, UINTEGER: 32-bit signed/unsigned integers
-- BIGINT, UBIGINT: 64-bit signed/unsigned integers
-- HUGEINT, UHUGEINT: 128-bit signed/unsigned integers
-
-Decimal Types:
-- BIGNUM: Arbitrary precision integers
-- DECIMAL: Fixed-point decimal numbers
-
-Floating Point Types:
-- FLOAT: 32-bit floating point
-- DOUBLE: 64-bit floating point
-
-Use this to check if a column contains numeric data that should be handled
-as Python int, float, or Decimal objects.
-
-DB API 2.0 Reference:
-    https://peps.python.org/pep-0249/#number
-
-Example:
-    >>> cursor.description[1][1] == NUMBER  # Check if second column is numeric
-"""
-
-DATETIME = DBAPITypeObject(
-    [
-        sqltypes.DATE,
-        sqltypes.TIME,
-        sqltypes.TIME_TZ,
-        sqltypes.TIMESTAMP,
-        sqltypes.TIMESTAMP_TZ,
-        sqltypes.TIMESTAMP_NS,
-        sqltypes.TIMESTAMP_MS,
-        sqltypes.TIMESTAMP_S,
-    ]
-)
-"""
-DATETIME type object for date and time database columns.
-
-This type object represents all date/time types in DuckDB, including:
-
-Date Types:
-- DATE: Calendar dates (year, month, day)
-
-Time Types:
-- TIME: Time of day without timezone
-- TIME_TZ: Time of day with timezone
-
-Timestamp Types:
-- TIMESTAMP: Date and time without timezone (microsecond precision)
-- TIMESTAMP_TZ: Date and time with timezone
-- TIMESTAMP_NS: Nanosecond precision timestamps
-- TIMESTAMP_MS: Millisecond precision timestamps
-- TIMESTAMP_S: Second precision timestamps
-
-Use this to check if a column contains temporal data that should be handled
-as Python datetime, date, or time objects.
-
-DB API 2.0 Reference:
-    https://peps.python.org/pep-0249/#datetime
-
-Example:
-    >>> cursor.description[2][1] == DATETIME  # Check if third column is date/time
-"""
-
-BINARY = DBAPITypeObject([sqltypes.BLOB])
-"""
-BINARY type object for binary data database columns.
-
-This type object represents binary data types in DuckDB:
-- BLOB: Binary Large Objects for storing arbitrary binary data
-
-Use this to check if a column contains binary data that should be handled
-as Python bytes objects.
-
-DB API 2.0 Reference:
-    https://peps.python.org/pep-0249/#binary
-
-Example:
-    >>> cursor.description[3][1] == BINARY  # Check if fourth column is binary
-"""
-
-ROWID = None
-"""
-ROWID type object for row identifier columns.
-
-DB API 2.0 Reference:
-    https://peps.python.org/pep-0249/#rowid
-
-Note:
-    This will always be None for DuckDB connections. Applications should not
-    rely on ROWID functionality when using DuckDB.
-"""

duckdb/_version.py

@@ -1,22 +0,0 @@
-# ----------------------------------------------------------------------
-# Version API
-#
-# We provide three symbols:
-# - duckdb.__version__: The version of this package
-# - duckdb.__duckdb_version__: The version of duckdb that is bundled
-# - duckdb.version(): A human-readable version string containing both of the above
-# ----------------------------------------------------------------------
-from importlib.metadata import version as _dist_version
-
-import _duckdb
-
-__version__: str = _dist_version("duckdb")
-"""Version of the DuckDB Python Package."""
-
-__duckdb_version__: str = _duckdb.__version__
-"""Version of DuckDB that is bundled."""
-
-
-def version() -> str:
-    """Human-friendly formatted version string of both the distribution package and the bundled DuckDB engine."""
-    return f"{__version__} (with duckdb {_duckdb.__version__})"

duckdb/func/__init__.py

@@ -1,3 +0,0 @@
-from _duckdb._func import ARROW, DEFAULT, NATIVE, SPECIAL, FunctionNullHandling, PythonUDFType  # noqa: D104
-
-__all__ = ["ARROW", "DEFAULT", "NATIVE", "SPECIAL", "FunctionNullHandling", "PythonUDFType"]

duckdb/sqltypes/__init__.py

@@ -1,63 +0,0 @@
-"""DuckDB's SQL types."""
-
-from _duckdb._sqltypes import (
-    BIGINT,
-    BIT,
-    BLOB,
-    BOOLEAN,
-    DATE,
-    DOUBLE,
-    FLOAT,
-    HUGEINT,
-    INTEGER,
-    INTERVAL,
-    SMALLINT,
-    SQLNULL,
-    TIME,
-    TIME_TZ,
-    TIMESTAMP,
-    TIMESTAMP_MS,
-    TIMESTAMP_NS,
-    TIMESTAMP_S,
-    TIMESTAMP_TZ,
-    TINYINT,
-    UBIGINT,
-    UHUGEINT,
-    UINTEGER,
-    USMALLINT,
-    UTINYINT,
-    UUID,
-    VARCHAR,
-    DuckDBPyType,
-)
-
-__all__ = [
-    "BIGINT",
-    "BIT",
-    "BLOB",
-    "BOOLEAN",
-    "DATE",
-    "DOUBLE",
-    "FLOAT",
-    "HUGEINT",
-    "INTEGER",
-    "INTERVAL",
-    "SMALLINT",
-    "SQLNULL",
-    "TIME",
-    "TIMESTAMP",
-    "TIMESTAMP_MS",
-    "TIMESTAMP_NS",
-    "TIMESTAMP_S",
-    "TIMESTAMP_TZ",
-    "TIME_TZ",
-    "TINYINT",
-    "UBIGINT",
-    "UHUGEINT",
-    "UINTEGER",
-    "USMALLINT",
-    "UTINYINT",
-    "UUID",
-    "VARCHAR",
-    "DuckDBPyType",
-]