sqlspec 0.6.0__py3-none-any.whl → 0.7.1__py3-none-any.whl

sqlspec/__init__.py

@@ -1 +0,0 @@
-from __future__ import annotations

sqlspec/__metadata__.py

@@ -1,7 +1,5 @@
 """Metadata for the Project."""
 
-from __future__ import annotations
-
 from importlib.metadata import PackageNotFoundError, metadata, version
 
 __all__ = ("__project__", "__version__")

sqlspec/_serialization.py

@@ -1,24 +1,71 @@
+import datetime
+import enum
 from typing import Any
 
-__all__ = ("decode_json", "encode_json")
+from sqlspec._typing import PYDANTIC_INSTALLED, BaseModel
+
+
+def _type_to_string(value: Any) -> str:  # pragma: no cover
+    if isinstance(value, datetime.datetime):
+        return convert_datetime_to_gmt_iso(value)
+    if isinstance(value, datetime.date):
+        return convert_date_to_iso(value)
+    if isinstance(value, enum.Enum):
+        return str(value.value)
+    if PYDANTIC_INSTALLED and isinstance(value, BaseModel):
+        return value.model_dump_json()
+    try:
+        val = str(value)
+    except Exception as exc:
+        raise TypeError from exc
+    return val
+
 
 try:
-    from msgspec.json import Decoder, Encoder  # pyright: ignore[reportMissingImports]
+    from msgspec.json import Decoder, Encoder
 
-    encoder, decoder = Encoder(), Decoder()
+    encoder, decoder = Encoder(enc_hook=_type_to_string), Decoder()
     decode_json = decoder.decode
 
-    def encode_json(data: Any) -> str:
+    def encode_json(data: Any) -> str:  # pragma: no cover
         return encoder.encode(data).decode("utf-8")
 
 except ImportError:
     try:
-        from orjson import dumps as _encode_json  # pyright: ignore[reportMissingImports,reportUnknownVariableType]
-        from orjson import loads as decode_json  # type: ignore[no-redef]
+        from orjson import (  # pyright: ignore[reportMissingImports]
+            OPT_NAIVE_UTC,  # pyright: ignore[reportUnknownVariableType]
+            OPT_SERIALIZE_NUMPY,  # pyright: ignore[reportUnknownVariableType]
+            OPT_SERIALIZE_UUID,  # pyright: ignore[reportUnknownVariableType]
+        )
+        from orjson import dumps as _encode_json  # pyright: ignore[reportUnknownVariableType,reportMissingImports]
+        from orjson import loads as decode_json  # type: ignore[no-redef,assignment,unused-ignore]
 
-        def encode_json(data: Any) -> str:
-            return _encode_json(data).decode("utf-8")  # type: ignore[no-any-return]
+        def encode_json(data: Any) -> str:  # pragma: no cover
+            return _encode_json(
+                data,
+                default=_type_to_string,
+                option=OPT_SERIALIZE_NUMPY | OPT_NAIVE_UTC | OPT_SERIALIZE_UUID,
+            ).decode("utf-8")
 
     except ImportError:
         from json import dumps as encode_json  # type: ignore[assignment]
         from json import loads as decode_json  # type: ignore[assignment]
+
+__all__ = (
+    "convert_date_to_iso",
+    "convert_datetime_to_gmt_iso",
+    "decode_json",
+    "encode_json",
+)
+
+
+def convert_datetime_to_gmt_iso(dt: datetime.datetime) -> str:  # pragma: no cover
+    """Handle datetime serialization for nested timestamps."""
+    if not dt.tzinfo:
+        dt = dt.replace(tzinfo=datetime.timezone.utc)
+    return dt.isoformat().replace("+00:00", "Z")
+
+
+def convert_date_to_iso(dt: datetime.date) -> str:  # pragma: no cover
+    """Handle datetime serialization for nested timestamps."""
+    return dt.isoformat()

sqlspec/_typing.py

@@ -3,8 +3,6 @@
 This is used to ensure compatibility when one or more of the libraries are installed.
 """
 
-from __future__ import annotations
-
 from enum import Enum
 from typing import (
     Any,
@@ -30,10 +28,15 @@ T = TypeVar("T")
 T_co = TypeVar("T_co", covariant=True)
 
 try:
-    from pydantic import BaseModel, FailFast, TypeAdapter
+    from pydantic import (
+        BaseModel,
+        FailFast,  # pyright: ignore[reportGeneralTypeIssues,reportAssignmentType]
+        TypeAdapter,
+    )
 
     PYDANTIC_INSTALLED = True
 except ImportError:
+    from dataclasses import dataclass
 
     @runtime_checkable
     class BaseModel(Protocol):  # type: ignore[no-redef]
@@ -41,10 +44,42 @@ except ImportError:
 
         model_fields: ClassVar[dict[str, Any]]
 
-        def model_dump(self, *args: Any, **kwargs: Any) -> dict[str, Any]:
+        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 ""
+
     @runtime_checkable
     class TypeAdapter(Protocol[T_co]):  # type: ignore[no-redef]
         """Placeholder Implementation"""
@@ -53,9 +88,9 @@ except ImportError:
             self,
             type: Any,  # noqa: A002
             *,
-            config: Any | None = None,
+            config: "Optional[Any]" = None,
             _parent_depth: int = 2,
-            module: str | None = None,
+            module: "Optional[str]" = None,
         ) -> None:
             """Init"""
 
@@ -64,19 +99,19 @@ except ImportError:
             object: Any,  # noqa: A002
             /,
             *,
-            strict: bool | None = None,
-            from_attributes: bool | None = None,
-            context: dict[str, Any] | None = None,
-        ) -> T_co:
+            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)
 
-    @runtime_checkable
-    class FailFast(Protocol):  # type: ignore[no-redef]
+    @dataclass
+    class FailFast:  # type: ignore[no-redef]
         """Placeholder Implementation for FailFast"""
 
-        def __init__(self, *args: Any, **kwargs: Any) -> None:
-            """Init"""
+        fail_fast: bool = True
 
     PYDANTIC_INSTALLED = False  # pyright: ignore[reportConstantRedefinition]
 
@@ -84,22 +119,36 @@ try:
     from msgspec import (
         UNSET,
         Struct,
-        UnsetType,  # pyright: ignore[reportAssignmentType]
+        UnsetType,  # pyright: ignore[reportAssignmentType,reportGeneralTypeIssues]
         convert,
     )
 
     MSGSPEC_INSTALLED: bool = True
 except ImportError:
     import enum
+    from collections.abc import Iterable
+    from typing import TYPE_CHECKING, Callable, Optional, Union
+
+    if TYPE_CHECKING:
+        from collections.abc import Iterable
 
     @dataclass_transform()
     @runtime_checkable
     class Struct(Protocol):  # type: ignore[no-redef]
         """Placeholder Implementation"""
 
-        __struct_fields__: ClassVar[tuple[str, ...]]
-
-    def convert(*args: Any, **kwargs: Any) -> Any:  # type: ignore[no-redef]
+        __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: "Union[Iterable[type], None]" = None,
+        str_keys: bool = False,
+    ) -> "Union[T, Any]":
         """Placeholder implementation"""
         return {}
 
@@ -124,11 +173,11 @@ except ImportError:
         def __init__(self, backend: Any, data_as_builtins: Any) -> None:
             """Placeholder init"""
 
-        def create_instance(self, **kwargs: Any) -> T:
+        def create_instance(self, **kwargs: Any) -> "T":
             """Placeholder implementation"""
             return cast("T", kwargs)
 
-        def update_instance(self, instance: T, **kwargs: Any) -> T:
+        def update_instance(self, instance: "T", **kwargs: Any) -> "T":
             """Placeholder implementation"""
             return cast("T", kwargs)
 

sqlspec/adapters/adbc/config.py

@@ -1,8 +1,6 @@
-from __future__ import annotations
-
 from contextlib import contextmanager
 from dataclasses import dataclass
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, Optional, Union
 
 from sqlspec.base import NoPoolSyncConfig
 from sqlspec.typing import Empty, EmptyType
@@ -24,18 +22,15 @@ class AdbcDatabaseConfig(NoPoolSyncConfig["Connection"]):
     ADBC Driver Manager.([1](https://arrow.apache.org/adbc/current/python/api/adbc_driver_manager.html))
     """
 
-    __supports_connection_pooling = False
-    __is_async = False
-
-    uri: str | EmptyType = Empty
+    uri: "Union[str, EmptyType]" = Empty
     """Database URI"""
-    driver_name: str | EmptyType = Empty
+    driver_name: "Union[str, EmptyType]" = Empty
     """Name of the ADBC driver to use"""
-    db_kwargs: dict[str, Any] | None = None
+    db_kwargs: "Optional[dict[str, Any]]" = None
     """Additional database-specific connection parameters"""
 
     @property
-    def connection_params(self) -> dict[str, Any]:
+    def connection_params(self) -> "dict[str, Any]":
         """Return the connection parameters as a dict."""
         return {
             k: v
@@ -44,7 +39,7 @@ class AdbcDatabaseConfig(NoPoolSyncConfig["Connection"]):
         }
 
     @contextmanager
-    def provide_connection(self, *args: Any, **kwargs: Any) -> Generator[Connection, None, None]:
+    def provide_connection(self, *args: "Any", **kwargs: "Any") -> "Generator[Connection, None, None]":
         """Create and provide a database connection."""
         from adbc_driver_manager.dbapi import connect
 

sqlspec/adapters/aiosqlite/__init__.py

@@ -1,3 +1,3 @@
-from .config import AiosqliteConfig
+from sqlspec.adapters.aiosqlite.config import AiosqliteConfig
 
 __all__ = ("AiosqliteConfig",)

sqlspec/adapters/aiosqlite/config.py

@@ -1,8 +1,6 @@
-from __future__ import annotations
-
 from contextlib import asynccontextmanager
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, Optional, Union
 
 from sqlspec.base import NoPoolSyncConfig
 from sqlspec.exceptions import ImproperConfigurationError
@@ -28,25 +26,25 @@ class AiosqliteConfig(NoPoolSyncConfig["Connection"]):
     For details see: https://github.com/omnilib/aiosqlite/blob/main/aiosqlite/__init__.pyi
     """
 
-    database: str = field(default=":memory:")
+    database: "Union[str, EmptyType]" = field(default=":memory:")
     """The path to the database file to be opened. Pass ":memory:" to open a connection to a database that resides in RAM instead of on disk."""
-    timeout: float | EmptyType = field(default=Empty)
+    timeout: "Union[float, EmptyType]" = field(default=Empty)
     """How many seconds the connection should wait before raising an OperationalError when a table is locked. If another thread or process has acquired a shared lock, a wait for the specified timeout occurs."""
-    detect_types: int | EmptyType = field(default=Empty)
+    detect_types: "Union[int, EmptyType]" = field(default=Empty)
     """Control whether and how data types are detected. It can be 0 (default) or a combination of PARSE_DECLTYPES and PARSE_COLNAMES."""
-    isolation_level: Literal["DEFERRED", "IMMEDIATE", "EXCLUSIVE"] | None | EmptyType = field(default=Empty)
+    isolation_level: "Optional[Union[Literal['DEFERRED', 'IMMEDIATE', 'EXCLUSIVE'], EmptyType]]" = field(default=Empty)
     """The isolation_level of the connection. This can be None for autocommit mode or one of "DEFERRED", "IMMEDIATE" or "EXCLUSIVE"."""
-    check_same_thread: bool | EmptyType = field(default=Empty)
+    check_same_thread: "Union[bool, EmptyType]" = field(default=Empty)
     """If True (default), ProgrammingError is raised if the database connection is used by a thread other than the one that created it. If False, the connection may be shared across multiple threads."""
-    factory: type[SQLite3Connection] | EmptyType = field(default=Empty)
+    factory: "Union[type[SQLite3Connection], EmptyType]" = field(default=Empty)
     """A custom Connection class factory. If given, must be a callable that returns a Connection instance."""
-    cached_statements: int | EmptyType = field(default=Empty)
+    cached_statements: "Union[int, EmptyType]" = field(default=Empty)
     """The number of statements that SQLite will cache for this connection. The default is 128."""
-    uri: bool | EmptyType = field(default=Empty)
+    uri: "Union[bool, EmptyType]" = field(default=Empty)
     """If set to True, database is interpreted as a URI with supported options."""
 
     @property
-    def connection_config_dict(self) -> dict[str, Any]:
+    def connection_config_dict(self) -> "dict[str, Any]":
         """Return the connection configuration as a dict.
 
         Returns:
@@ -54,7 +52,7 @@ class AiosqliteConfig(NoPoolSyncConfig["Connection"]):
         """
         return dataclass_to_dict(self, exclude_empty=True, convert_nested=False)
 
-    async def create_connection(self) -> Connection:
+    async def create_connection(self) -> "Connection":
         """Create and return a new database connection.
 
         Returns:
@@ -72,7 +70,7 @@ class AiosqliteConfig(NoPoolSyncConfig["Connection"]):
             raise ImproperConfigurationError(msg) from e
 
     @asynccontextmanager
-    async def provide_connection(self, *args: Any, **kwargs: Any) -> AsyncGenerator[Connection, None]:
+    async def provide_connection(self, *args: "Any", **kwargs: "Any") -> "AsyncGenerator[Connection, None]":
         """Create and provide a database connection.
 
         Yields:

sqlspec/adapters/asyncmy/__init__.py

@@ -1,3 +1,3 @@
-from .config import AsyncMyConfig, AsyncmyPoolConfig
+from sqlspec.adapters.asyncmy.config import AsyncMyConfig, AsyncmyPoolConfig
 
 __all__ = ("AsyncMyConfig", "AsyncmyPoolConfig")

sqlspec/adapters/asyncmy/config.py

@@ -1,11 +1,9 @@
-from __future__ import annotations
-
 from contextlib import asynccontextmanager
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, TypeVar
+from typing import TYPE_CHECKING, Optional, TypeVar, Union
 
-from asyncmy.connection import Connection
-from asyncmy.pool import Pool
+from asyncmy.connection import Connection  # pyright: ignore[reportUnknownVariableType]
+from asyncmy.pool import Pool  # pyright: ignore[reportUnknownVariableType]
 
 from sqlspec.base import AsyncDatabaseConfig, GenericPoolConfig
 from sqlspec.exceptions import ImproperConfigurationError
@@ -15,7 +13,7 @@ if TYPE_CHECKING:
     from collections.abc import AsyncGenerator
     from typing import Any
 
-    from asyncmy.cursors import Cursor, DictCursor
+    from asyncmy.cursors import Cursor, DictCursor  # pyright: ignore[reportUnknownVariableType]
 
 __all__ = (
     "AsyncMyConfig",
@@ -35,68 +33,68 @@ class AsyncmyPoolConfig(GenericPoolConfig):
     For details see: https://github.com/long2ice/asyncmy
     """
 
-    host: str | EmptyType = Empty
+    host: "Union[str, EmptyType]" = Empty
     """Host where the database server is located."""
 
-    user: str | EmptyType = Empty
+    user: "Union[str, EmptyType]" = Empty
     """The username used to authenticate with the database."""
 
-    password: str | EmptyType = Empty
+    password: "Union[str, EmptyType]" = Empty
     """The password used to authenticate with the database."""
 
-    database: str | EmptyType = Empty
+    database: "Union[str, EmptyType]" = Empty
     """The database name to use."""
 
-    port: int | EmptyType = Empty
+    port: "Union[int, EmptyType]" = Empty
     """The TCP/IP port of the MySQL server. Must be an integer."""
 
-    unix_socket: str | EmptyType = Empty
+    unix_socket: "Union[str, EmptyType]" = Empty
     """The location of the Unix socket file."""
 
-    charset: str | EmptyType = Empty
+    charset: "Union[str, EmptyType]" = Empty
     """The character set to use for the connection."""
 
-    connect_timeout: float | EmptyType = Empty
+    connect_timeout: "Union[float, EmptyType]" = Empty
     """Timeout before throwing an error when connecting."""
 
-    read_default_file: str | EmptyType = Empty
+    read_default_file: "Union[str, EmptyType]" = Empty
     """MySQL configuration file to read."""
 
-    read_default_group: str | EmptyType = Empty
+    read_default_group: "Union[str, EmptyType]" = Empty
     """Group to read from the configuration file."""
 
-    autocommit: bool | EmptyType = Empty
+    autocommit: "Union[bool, EmptyType]" = Empty
     """If True, autocommit mode will be enabled."""
 
-    local_infile: bool | EmptyType = Empty
+    local_infile: "Union[bool, EmptyType]" = Empty
     """If True, enables LOAD LOCAL INFILE."""
 
-    ssl: dict[str, Any] | bool | EmptyType = Empty
+    ssl: "Union[dict[str, Any], bool, EmptyType]" = Empty
     """If present, a dictionary of SSL connection parameters, or just True."""
 
-    sql_mode: str | EmptyType = Empty
+    sql_mode: "Union[str, EmptyType]" = Empty
     """Default SQL_MODE to use."""
 
-    init_command: str | EmptyType = Empty
+    init_command: "Union[str, EmptyType]" = Empty
     """Initial SQL statement to execute once connected."""
 
-    cursor_class: type[Cursor] | type[DictCursor] | EmptyType = Empty
+    cursor_class: "Union[type[Union[Cursor, DictCursor]], EmptyType]" = Empty
     """Custom cursor class to use."""
 
-    minsize: int | EmptyType = Empty
+    minsize: "Union[int, EmptyType]" = Empty
     """Minimum number of connections to keep in the pool."""
 
-    maxsize: int | EmptyType = Empty
+    maxsize: "Union[int, EmptyType]" = Empty
     """Maximum number of connections allowed in the pool."""
 
-    echo: bool | EmptyType = Empty
+    echo: "Union[bool, EmptyType]" = Empty
     """If True, logging will be enabled for all SQL statements."""
 
-    pool_recycle: int | EmptyType = Empty
+    pool_recycle: "Union[int, EmptyType]" = Empty
     """Number of seconds after which a connection is recycled."""
 
     @property
-    def pool_config_dict(self) -> dict[str, Any]:
+    def pool_config_dict(self) -> "dict[str, Any]":
         """Return the pool configuration as a dict.
 
         Returns:
@@ -112,28 +110,31 @@ class AsyncMyConfig(AsyncDatabaseConfig[Connection, Pool]):
     __is_async__ = True
     __supports_connection_pooling__ = True
 
-    pool_config: AsyncmyPoolConfig | None = None
+    pool_config: "Optional[AsyncmyPoolConfig]" = None
     """Asyncmy Pool configuration"""
 
-    pool_instance: Pool | None = None
+    pool_instance: "Optional[Pool]" = None  # pyright: ignore[reportUnknownVariableType]
     """Optional pool to use.
 
     If set, the plugin will use the provided pool rather than instantiate one.
     """
 
     @property
-    def pool_config_dict(self) -> dict[str, Any]:
+    def pool_config_dict(self) -> "dict[str, Any]":
         """Return the pool configuration as a dict.
 
         Returns:
             A string keyed dict of config kwargs for the Asyncmy create_pool function.
+
+        Raises:
+            ImproperConfigurationError: If the pool configuration is not provided.
         """
         if self.pool_config:
             return dataclass_to_dict(self.pool_config, exclude_empty=True, convert_nested=False)
         msg = "'pool_config' methods can not be used when a 'pool_instance' is provided."
         raise ImproperConfigurationError(msg)
 
-    async def create_pool(self) -> Pool:
+    async def create_pool(self) -> "Pool":  # pyright: ignore[reportUnknownParameterType]
         """Return a pool. If none exists yet, create one.
 
         Returns:
@@ -142,40 +143,39 @@ class AsyncMyConfig(AsyncDatabaseConfig[Connection, Pool]):
         Raises:
             ImproperConfigurationError: If the pool could not be created.
         """
-        if self.pool_instance is not None:
-            return self.pool_instance
+        if self.pool_instance is not None:  # pyright: ignore[reportUnknownMemberType]
+            return self.pool_instance  # pyright: ignore[reportUnknownVariableType,reportUnknownMemberType]
 
         if self.pool_config is None:
             msg = "One of 'pool_config' or 'pool_instance' must be provided."
             raise ImproperConfigurationError(msg)
 
         try:
-            import asyncmy
+            import asyncmy  # pyright: ignore[reportMissingTypeStubs]
 
-            self.pool_instance = await asyncmy.create_pool(**self.pool_config_dict)
-            return self.pool_instance
+            self.pool_instance = await asyncmy.create_pool(**self.pool_config_dict)  # pyright: ignore[reportUnknownMemberType]
         except Exception as e:
             msg = f"Could not configure the Asyncmy pool. Error: {e!s}"
             raise ImproperConfigurationError(msg) from e
+        else:
+            return self.pool_instance  # pyright: ignore[reportUnknownVariableType,reportUnknownMemberType]
 
-    async def provide_pool(self, *args: Any, **kwargs: Any) -> Pool:
+    async def provide_pool(self, *args: "Any", **kwargs: "Any") -> "Pool":  # pyright: ignore[reportUnknownParameterType]
         """Create a pool instance.
 
         Returns:
             A Pool instance.
         """
-        return await self.create_pool()
+        return await self.create_pool()  # pyright: ignore[reportUnknownMemberType,reportUnknownVariableType]
 
     @asynccontextmanager
-    async def provide_connection(self, *args: Any, **kwargs: Any) -> AsyncGenerator[Connection, None]:
+    async def provide_connection(self, *args: "Any", **kwargs: "Any") -> "AsyncGenerator[Connection, None]":  # pyright: ignore[reportUnknownParameterType]
         """Create and provide a database connection.
 
         Yields:
             An Asyncmy connection instance.
 
-        Raises:
-            ImproperConfigurationError: If the connection could not be established.
         """
-        pool = await self.provide_pool(*args, **kwargs)
-        async with pool.acquire() as connection:
-            yield connection
+        pool = await self.provide_pool(*args, **kwargs)  # pyright: ignore[reportUnknownVariableType,reportUnknownMemberType]
+        async with pool.acquire() as connection:  # pyright: ignore[reportUnknownMemberType,reportUnknownVariableType]
+            yield connection  # pyright: ignore[reportUnknownMemberType]