sqlspec 0.14.1__py3-none-any.whl → 0.15.0__py3-none-any.whl

sqlspec/_typing.py

@@ -1,10 +1,9 @@
-# ruff: noqa: RUF100, PLR0913, A002, DOC201, PLR6301, PLR0917, ARG004
-"""This is a simple wrapper around a few important classes in each library.
-
-This is used to ensure compatibility when one or more of the libraries are installed.
-"""
+# ruff: noqa: RUF100, PLR0913, A002, DOC201, PLR6301, PLR0917, ARG004, ARG002, ARG001
+"""Wrapper around library classes for compatibility when libraries are installed."""
 
+import enum
 from collections.abc import Iterable, Mapping
+from dataclasses import dataclass
 from enum import Enum
 from importlib.util import find_spec
 from typing import Any, ClassVar, Final, Optional, Protocol, Union, cast, runtime_checkable
@@ -14,11 +13,7 @@ from typing_extensions import Literal, TypeVar, dataclass_transform
 
 @runtime_checkable
 class DataclassProtocol(Protocol):
-    """Protocol for instance checking dataclasses.
-
-    This protocol only requires the presence of `__dataclass_fields__`, which is the
-    standard attribute that Python's dataclasses module adds to all dataclass instances.
-    """
+    """Protocol for instance checking dataclasses."""
 
     __dataclass_fields__: "ClassVar[dict[str, Any]]"
 
@@ -26,160 +21,277 @@ class DataclassProtocol(Protocol):
 T = TypeVar("T")
 T_co = TypeVar("T_co", covariant=True)
 
-try:
-    from pydantic import (
-        BaseModel,  # pyright: ignore[reportAssignmentType]
-        FailFast,  # pyright: ignore[reportGeneralTypeIssues,reportAssignmentType]
-        TypeAdapter,
-    )
+# Always define stub types for type checking
 
-    PYDANTIC_INSTALLED = True
-except ImportError:
-    from dataclasses import dataclass
 
-    class BaseModel(Protocol):  # type: ignore[no-redef]
-        """Placeholder Implementation"""
+class BaseModelStub:
+    """Placeholder implementation."""
 
-        model_fields: "ClassVar[dict[str, Any]]"
+    model_fields: ClassVar[dict[str, Any]] = {}
+    __slots__ = ("__dict__", "__pydantic_extra__", "__pydantic_fields_set__", "__pydantic_private__")
 
-        def model_dump(
-            self,
-            /,
-            *,
-            include: "Optional[Any]" = None,
-            exclude: "Optional[Any]" = None,
-            context: "Optional[Any]" = None,
-            by_alias: bool = False,
-            exclude_unset: bool = False,
-            exclude_defaults: bool = False,
-            exclude_none: bool = False,
-            round_trip: bool = False,
-            warnings: "Union[bool, Literal['none', 'warn', 'error']]" = True,
-            serialize_as_any: bool = False,
-        ) -> "dict[str, Any]":
-            """Placeholder"""
-            return {}
-
-        def model_dump_json(
-            self,
-            /,
-            *,
-            include: "Optional[Any]" = None,
-            exclude: "Optional[Any]" = None,
-            context: "Optional[Any]" = None,
-            by_alias: bool = False,
-            exclude_unset: bool = False,
-            exclude_defaults: bool = False,
-            exclude_none: bool = False,
-            round_trip: bool = False,
-            warnings: "Union[bool, Literal['none', 'warn', 'error']]" = True,
-            serialize_as_any: bool = False,
-        ) -> str:
-            """Placeholder"""
-            return ""
+    def __init__(self, **data: Any) -> None:
+        for key, value in data.items():
+            setattr(self, key, value)
 
-    @runtime_checkable
-    class TypeAdapter(Protocol[T_co]):  # type: ignore[no-redef]
-        """Placeholder Implementation"""
+    def model_dump(  # noqa: PLR0913
+        self,
+        /,
+        *,
+        include: "Optional[Any]" = None,  # noqa: ARG002
+        exclude: "Optional[Any]" = None,  # noqa: ARG002
+        context: "Optional[Any]" = None,  # noqa: ARG002
+        by_alias: bool = False,  # noqa: ARG002
+        exclude_unset: bool = False,  # noqa: ARG002
+        exclude_defaults: bool = False,  # noqa: ARG002
+        exclude_none: bool = False,  # noqa: ARG002
+        round_trip: bool = False,  # noqa: ARG002
+        warnings: "Union[bool, Literal['none', 'warn', 'error']]" = True,  # noqa: ARG002
+        serialize_as_any: bool = False,  # noqa: ARG002
+    ) -> "dict[str, Any]":
+        """Placeholder implementation."""
+        return {k: v for k, v in self.__dict__.items() if not k.startswith("_")}
+
+    def model_dump_json(  # noqa: PLR0913
+        self,
+        /,
+        *,
+        include: "Optional[Any]" = None,  # noqa: ARG002
+        exclude: "Optional[Any]" = None,  # noqa: ARG002
+        context: "Optional[Any]" = None,  # noqa: ARG002
+        by_alias: bool = False,  # noqa: ARG002
+        exclude_unset: bool = False,  # noqa: ARG002
+        exclude_defaults: bool = False,  # noqa: ARG002
+        exclude_none: bool = False,  # noqa: ARG002
+        round_trip: bool = False,  # noqa: ARG002
+        warnings: "Union[bool, Literal['none', 'warn', 'error']]" = True,  # noqa: ARG002
+        serialize_as_any: bool = False,  # noqa: ARG002
+    ) -> str:
+        """Placeholder implementation."""
+        return "{}"
+
+
+class TypeAdapterStub:
+    """Placeholder implementation."""
+
+    def __init__(
+        self,
+        type: Any,  # noqa: A002
+        *,
+        config: "Optional[Any]" = None,  # noqa: ARG002
+        _parent_depth: int = 2,  # noqa: ARG002
+        module: "Optional[str]" = None,  # noqa: ARG002
+    ) -> None:
+        """Initialize."""
+        self._type = type
+
+    def validate_python(  # noqa: PLR0913
+        self,
+        object: Any,
+        /,
+        *,
+        strict: "Optional[bool]" = None,  # noqa: ARG002
+        from_attributes: "Optional[bool]" = None,  # noqa: ARG002
+        context: "Optional[dict[str, Any]]" = None,  # noqa: ARG002
+        experimental_allow_partial: "Union[bool, Literal['off', 'on', 'trailing-strings']]" = False,  # noqa: ARG002
+    ) -> Any:
+        """Validate Python object."""
+        return object
 
-        def __init__(
-            self,
-            type: Any,  # noqa: A002
-            *,
-            config: "Optional[Any]" = None,
-            _parent_depth: int = 2,
-            module: "Optional[str]" = None,
-        ) -> None:
-            """Init"""
 
-        def validate_python(
-            self,
-            object: Any,
-            /,
-            *,
-            strict: "Optional[bool]" = None,
-            from_attributes: "Optional[bool]" = None,
-            context: "Optional[dict[str, Any]]" = None,
-            experimental_allow_partial: "Union[bool, Literal['off', 'on', 'trailing-strings']]" = False,
-        ) -> "T_co":
-            """Stub"""
-            return cast("T_co", object)
-
-    @dataclass
-    class FailFast:  # type: ignore[no-redef]
-        """Placeholder Implementation for FailFast"""
-
-        fail_fast: bool = True
+@dataclass
+class FailFastStub:
+    """Placeholder implementation for FailFast."""
 
-    PYDANTIC_INSTALLED = False  # pyright: ignore[reportConstantRedefinition]
+    fail_fast: bool = True
 
-try:
-    from msgspec import (
-        UNSET,
-        Struct,
-        UnsetType,  # pyright: ignore[reportAssignmentType,reportGeneralTypeIssues]
-        convert,
-    )
 
-    MSGSPEC_INSTALLED: bool = True
+# Try to import real implementations at runtime
+try:
+    from pydantic import BaseModel as _RealBaseModel
+    from pydantic import FailFast as _RealFailFast
+    from pydantic import TypeAdapter as _RealTypeAdapter
+
+    BaseModel = _RealBaseModel
+    TypeAdapter = _RealTypeAdapter
+    FailFast = _RealFailFast
+    PYDANTIC_INSTALLED = True  # pyright: ignore[reportConstantRedefinition]
 except ImportError:
-    import enum
-    from collections.abc import Iterable
-    from typing import Callable, Optional, Union
+    BaseModel = BaseModelStub  # type: ignore[assignment,misc]
+    TypeAdapter = TypeAdapterStub  # type: ignore[assignment,misc]
+    FailFast = FailFastStub  # type: ignore[assignment,misc]
+    PYDANTIC_INSTALLED = False  # pyright: ignore[reportConstantRedefinition]
 
-    @dataclass_transform()
-    @runtime_checkable
-    class Struct(Protocol):  # type: ignore[no-redef]
-        """Placeholder Implementation"""
+# Always define stub types for msgspec
 
-        __struct_fields__: "ClassVar[tuple[str, ...]]"
 
-    def convert(  # type: ignore[no-redef]
-        obj: Any,
-        type: "Union[Any, type[T]]",  # noqa: A002
-        *,
-        strict: bool = True,
-        from_attributes: bool = False,
-        dec_hook: "Optional[Callable[[type, Any], Any]]" = None,
-        builtin_types: "Optional[Iterable[type]]" = None,
-        str_keys: bool = False,
-    ) -> "Union[T, Any]":
-        """Placeholder implementation"""
-        return {}
+@dataclass_transform()
+class StructStub:
+    """Placeholder implementation."""
+
+    __struct_fields__: ClassVar[tuple[str, ...]] = ()
+    __slots__ = ()
+
+    def __init__(self, **kwargs: Any) -> None:
+        for key, value in kwargs.items():
+            setattr(self, key, value)
+
+
+def convert_stub(  # noqa: PLR0913
+    obj: Any,  # noqa: ARG001
+    type: Any,  # noqa: A002,ARG001
+    *,
+    strict: bool = True,  # noqa: ARG001
+    from_attributes: bool = False,  # noqa: ARG001
+    dec_hook: "Optional[Any]" = None,  # noqa: ARG001
+    builtin_types: "Optional[Any]" = None,  # noqa: ARG001
+    str_keys: bool = False,  # noqa: ARG001
+) -> Any:
+    """Placeholder implementation."""
+    return {}
 
-    class UnsetType(enum.Enum):  # type: ignore[no-redef]
-        UNSET = "UNSET"
 
-    UNSET = UnsetType.UNSET  # pyright: ignore[reportConstantRedefinition]
+class UnsetTypeStub(enum.Enum):
+    UNSET = "UNSET"
+
+
+UNSET_STUB = UnsetTypeStub.UNSET
+
+# Try to import real implementations at runtime
+try:
+    from msgspec import UNSET as _REAL_UNSET
+    from msgspec import Struct as _RealStruct
+    from msgspec import UnsetType as _RealUnsetType
+    from msgspec import convert as _real_convert
+
+    Struct = _RealStruct
+    UnsetType = _RealUnsetType
+    UNSET = _REAL_UNSET
+    convert = _real_convert
+    MSGSPEC_INSTALLED = True  # pyright: ignore[reportConstantRedefinition]
+except ImportError:
+    Struct = StructStub  # type: ignore[assignment,misc]
+    UnsetType = UnsetTypeStub  # type: ignore[assignment,misc]
+    UNSET = UNSET_STUB  # type: ignore[assignment] # pyright: ignore[reportConstantRedefinition]
+    convert = convert_stub
     MSGSPEC_INSTALLED = False  # pyright: ignore[reportConstantRedefinition]
 
+
+# Always define stub type for DTOData
+@runtime_checkable
+class DTODataStub(Protocol[T]):
+    """Placeholder implementation."""
+
+    __slots__ = ("_backend", "_data_as_builtins")
+
+    def __init__(self, backend: Any, data_as_builtins: Any) -> None:
+        """Initialize."""
+
+    def create_instance(self, **kwargs: Any) -> T:
+        return cast("T", kwargs)
+
+    def update_instance(self, instance: T, **kwargs: Any) -> T:
+        """Update instance."""
+        return cast("T", kwargs)
+
+    def as_builtins(self) -> Any:
+        """Convert to builtins."""
+        return {}
+
+
+# Try to import real implementation at runtime
 try:
-    from litestar.dto.data_structures import DTOData  # pyright: ignore[reportUnknownVariableType]
+    from litestar.dto.data_structures import DTOData as _RealDTOData  # pyright: ignore[reportUnknownVariableType]
 
-    LITESTAR_INSTALLED = True
+    DTOData = _RealDTOData
+    LITESTAR_INSTALLED = True  # pyright: ignore[reportConstantRedefinition]
 except ImportError:
+    DTOData = DTODataStub  # type: ignore[assignment,misc]
+    LITESTAR_INSTALLED = False  # pyright: ignore[reportConstantRedefinition]
 
-    @runtime_checkable
-    class DTOData(Protocol[T]):  # type: ignore[no-redef]
-        """Placeholder implementation"""
 
-        __slots__ = ("_backend", "_data_as_builtins")
+# Always define stub types for attrs
+@dataclass_transform()
+class AttrsInstanceStub:
+    """Placeholder Implementation for attrs classes"""
 
-        def __init__(self, backend: Any, data_as_builtins: Any) -> None:
-            """Placeholder init"""
+    __attrs_attrs__: ClassVar[tuple[Any, ...]] = ()
+    __slots__ = ()
 
-        def create_instance(self, **kwargs: Any) -> T:
-            return cast("T", kwargs)
+    def __init__(self, **kwargs: Any) -> None:
+        for key, value in kwargs.items():
+            setattr(self, key, value)
 
-        def update_instance(self, instance: T, **kwargs: Any) -> T:
-            """Placeholder implementation"""
-            return cast("T", kwargs)
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}()"
 
-        def as_builtins(self) -> Any:
-            """Placeholder implementation"""
-            return {}
 
-    LITESTAR_INSTALLED = False  # pyright: ignore[reportConstantRedefinition]
+def attrs_asdict_stub(*args: Any, **kwargs: Any) -> "dict[str, Any]":  # noqa: ARG001
+    """Placeholder implementation"""
+    return {}
+
+
+def attrs_define_stub(*args: Any, **kwargs: Any) -> Any:  # noqa: ARG001
+    """Placeholder implementation"""
+    return lambda cls: cls  # pyright: ignore[reportUnknownVariableType,reportUnknownLambdaType]
+
+
+def attrs_field_stub(*args: Any, **kwargs: Any) -> Any:  # noqa: ARG001
+    """Placeholder implementation"""
+    return None
+
+
+def attrs_fields_stub(*args: Any, **kwargs: Any) -> "tuple[Any, ...]":  # noqa: ARG001
+    """Placeholder implementation"""
+    return ()
+
+
+def attrs_has_stub(*args: Any, **kwargs: Any) -> bool:  # noqa: ARG001
+    """Placeholder implementation"""
+    return False
+
+
+# Try to import real implementations at runtime
+try:
+    from attrs import AttrsInstance as _RealAttrsInstance  # pyright: ignore
+    from attrs import asdict as _real_attrs_asdict
+    from attrs import define as _real_attrs_define
+    from attrs import field as _real_attrs_field
+    from attrs import fields as _real_attrs_fields
+    from attrs import has as _real_attrs_has
+
+    AttrsInstance = _RealAttrsInstance
+    attrs_asdict = _real_attrs_asdict
+    attrs_define = _real_attrs_define
+    attrs_field = _real_attrs_field
+    attrs_fields = _real_attrs_fields
+    attrs_has = _real_attrs_has
+    ATTRS_INSTALLED = True  # pyright: ignore[reportConstantRedefinition]
+except ImportError:
+    AttrsInstance = AttrsInstanceStub  # type: ignore[misc]
+    attrs_asdict = attrs_asdict_stub
+    attrs_define = attrs_define_stub
+    attrs_field = attrs_field_stub
+    attrs_fields = attrs_fields_stub
+    attrs_has = attrs_has_stub  # type: ignore[assignment]
+    ATTRS_INSTALLED = False  # pyright: ignore[reportConstantRedefinition]
+
+try:
+    from cattrs import structure as cattrs_structure
+    from cattrs import unstructure as cattrs_unstructure
+
+    CATTRS_INSTALLED = True  # pyright: ignore[reportConstantRedefinition]
+except ImportError:
+
+    def cattrs_unstructure(*args: Any, **kwargs: Any) -> Any:  # noqa: ARG001
+        """Placeholder implementation"""
+        return {}
+
+    def cattrs_structure(*args: Any, **kwargs: Any) -> Any:  # noqa: ARG001
+        """Placeholder implementation"""
+        return {}
+
+    CATTRS_INSTALLED = False  # pyright: ignore[reportConstantRedefinition]  # pyright: ignore[reportConstantRedefinition]
 
 
 class EmptyEnum(Enum):
@@ -278,7 +390,7 @@ try:
         Tracer,  # pyright: ignore[reportMissingImports, reportAssignmentType]
     )
 
-    OPENTELEMETRY_INSTALLED = True
+    OPENTELEMETRY_INSTALLED = True  # pyright: ignore[reportConstantRedefinition]
 except ImportError:
     # Define shims for when opentelemetry is not installed
 
@@ -338,7 +450,7 @@ except ImportError:
     trace = _TraceModule()  # type: ignore[assignment]
     StatusCode = trace.StatusCode  # type: ignore[misc]
     Status = trace.Status  # type: ignore[misc]
-    OPENTELEMETRY_INSTALLED = False  # pyright: ignore[reportConstantRedefinition]
+    OPENTELEMETRY_INSTALLED = False  # pyright: ignore[reportConstantRedefinition]  # pyright: ignore[reportConstantRedefinition]
 
 
 try:
@@ -348,7 +460,7 @@ try:
         Histogram,  # pyright: ignore[reportAssignmentType]
     )
 
-    PROMETHEUS_INSTALLED = True
+    PROMETHEUS_INSTALLED = True  # pyright: ignore[reportConstantRedefinition]
 except ImportError:
     # Define shims for when prometheus_client is not installed
 
@@ -394,7 +506,7 @@ except ImportError:
         def labels(self, *labelvalues: str, **labelkwargs: str) -> _MetricInstance:
             return _MetricInstance()  # pragma: no cover
 
-    PROMETHEUS_INSTALLED = False  # pyright: ignore[reportConstantRedefinition]
+    PROMETHEUS_INSTALLED = False  # pyright: ignore[reportConstantRedefinition]  # pyright: ignore[reportConstantRedefinition]
 
 
 try:
@@ -413,7 +525,7 @@ try:
         SyncDriverAdapterProtocol as AiosqlSyncProtocol,  # pyright: ignore[reportMissingImports, reportAssignmentType]
     )
 
-    AIOSQL_INSTALLED = True
+    AIOSQL_INSTALLED = True  # pyright: ignore[reportConstantRedefinition]
 except ImportError:
     # Define shims for when aiosql is not installed
 
@@ -490,7 +602,7 @@ except ImportError:
         async def insert_update_delete_many(self, conn: Any, query_name: str, sql: str, parameters: Any) -> None: ...
         async def insert_returning(self, conn: Any, query_name: str, sql: str, parameters: Any) -> "Optional[Any]": ...
 
-    AIOSQL_INSTALLED = False  # pyright: ignore[reportConstantRedefinition]
+    AIOSQL_INSTALLED = False  # pyright: ignore[reportConstantRedefinition]  # pyright: ignore[reportConstantRedefinition]
 
 
 FSSPEC_INSTALLED = bool(find_spec("fsspec"))
@@ -500,6 +612,8 @@ PGVECTOR_INSTALLED = bool(find_spec("pgvector"))
 
 __all__ = (
     "AIOSQL_INSTALLED",
+    "ATTRS_INSTALLED",
+    "CATTRS_INSTALLED",
     "FSSPEC_INSTALLED",
     "LITESTAR_INSTALLED",
     "MSGSPEC_INSTALLED",
@@ -510,6 +624,7 @@ __all__ = (
     "PYARROW_INSTALLED",
     "PYDANTIC_INSTALLED",
     "UNSET",
+    "UNSET_STUB",
     "AiosqlAsyncProtocol",
     "AiosqlParamType",
     "AiosqlProtocol",
@@ -519,26 +634,47 @@ __all__ = (
     "ArrowRecordBatchResult",
     "ArrowTable",
     "ArrowTableResult",
+    "AttrsInstance",
+    "AttrsInstanceStub",
     "BaseModel",
+    "BaseModelStub",
     "Counter",
     "DTOData",
+    "DTODataStub",
     "DataclassProtocol",
     "Empty",
     "EmptyEnum",
     "EmptyType",
     "FailFast",
+    "FailFastStub",
     "Gauge",
     "Histogram",
     "Span",
     "Status",
     "StatusCode",
     "Struct",
+    "StructStub",
     "T",
     "T_co",
     "Tracer",
     "TypeAdapter",
+    "TypeAdapterStub",
     "UnsetType",
+    "UnsetTypeStub",
     "aiosql",
+    "attrs_asdict",
+    "attrs_asdict_stub",
+    "attrs_define",
+    "attrs_define_stub",
+    "attrs_field",
+    "attrs_field_stub",
+    "attrs_fields",
+    "attrs_fields_stub",
+    "attrs_has",
+    "attrs_has_stub",
+    "cattrs_structure",
+    "cattrs_unstructure",
     "convert",
+    "convert_stub",
     "trace",
 )

sqlspec/adapters/adbc/__init__.py

@@ -1,4 +1,5 @@
-from sqlspec.adapters.adbc.config import CONNECTION_FIELDS, AdbcConfig
-from sqlspec.adapters.adbc.driver import AdbcConnection, AdbcDriver
+from sqlspec.adapters.adbc._types import AdbcConnection
+from sqlspec.adapters.adbc.config import AdbcConfig, AdbcConnectionParams
+from sqlspec.adapters.adbc.driver import AdbcCursor, AdbcDriver, AdbcExceptionHandler
 
-__all__ = ("CONNECTION_FIELDS", "AdbcConfig", "AdbcConnection", "AdbcDriver")
+__all__ = ("AdbcConfig", "AdbcConnection", "AdbcConnectionParams", "AdbcCursor", "AdbcDriver", "AdbcExceptionHandler")

sqlspec/adapters/adbc/_types.py

@@ -0,0 +1,12 @@
+# pyright: reportCallIssue=false, reportAttributeAccessIssue=false, reportArgumentType=false
+from typing import TYPE_CHECKING
+
+from adbc_driver_manager.dbapi import Connection
+
+if TYPE_CHECKING:
+    from typing_extensions import TypeAlias
+
+    AdbcConnection: TypeAlias = Connection
+else:
+    AdbcConnection = Connection
+__all__ = ("AdbcConnection",)