sqlspec 0.7.0__tar.gz → 0.8.0__tar.gz

{sqlspec-0.7.0 → sqlspec-0.8.0}/.pre-commit-config.yaml

@@ -17,7 +17,7 @@ repos:
       - id: mixed-line-ending
       - id: trailing-whitespace
   - repo: https://github.com/charliermarsh/ruff-pre-commit
-    rev: "v0.9.10"
+    rev: "v0.11.6"
     hooks:
       - id: ruff
         args: ["--fix"]

{sqlspec-0.7.0 → sqlspec-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlspec
-Version: 0.7.0
+Version: 0.8.0
 Summary: SQL Experiments in Python
 Author-email: Cody Fincher <cody@litestar.dev>
 Maintainer-email: Litestar Developers <hello@litestar.dev>

{sqlspec-0.7.0 → sqlspec-0.8.0}/pyproject.toml

@@ -7,10 +7,10 @@ maintainers = [{ name = "Litestar Developers", email = "hello@litestar.dev" }]
 name = "sqlspec"
 readme = "README.md"
 requires-python = ">=3.9, <4.0"
-version = "0.7.0"
+version = "0.8.0"
 
 [project.optional-dependencies]
-adbc = ["adbc-driver-manager", "pyarrow"]
+adbc = ["adbc_driver_manager", "pyarrow"]
 aioodbc = ["aioodbc"]
 aiosqlite = ["aiosqlite"]
 asyncmy = ["asyncmy"]
@@ -35,9 +35,7 @@ uuid = ["uuid-utils>=0.6.1"]
 [dependency-groups]
 build = ["bump-my-version"]
 dev = [
-  "adbc-driver-sqlite",
-  "adbc-driver-postgresql",
-  "adbc-driver-flightsql",
+  { include-group = "extras" },
   { include-group = "lint" },
   { include-group = "doc" },
   { include-group = "test" },
@@ -59,6 +57,15 @@ doc = [
   "myst-parser",
   "sphinx-autodoc-typehints",
 ]
+extras = [
+  "adbc_driver_manager",
+  "pyarrow",
+  "polars",
+  "adbc_driver_sqlite",
+  "adbc_driver_postgresql",
+  "adbc_driver_flightsql",
+  "adbc_driver_bigquery",
+]
 lint = [
   "mypy>=1.13.0",
   "pre-commit>=3.5.0",
@@ -75,7 +82,7 @@ test = [
   "pytest>=8.0.0",
   "pytest-asyncio>=0.23.8",
   "pytest-cov>=5.0.0",
-  "pytest-databases>=0.10.0",
+  "pytest-databases[postgres,oracle,mysql,bigquery,spanner]>=0.12.2",
   "pytest-mock>=3.14.0",
   "pytest-sugar>=1.0.0",
   "pytest-xdist>=3.6.1",
@@ -101,7 +108,7 @@ packages = ["sqlspec"]
 allow_dirty = true
 commit = false
 commit_args = "--no-verify"
-current_version = "0.33.1"
+current_version = "0.8.0"
 ignore_missing_files = false
 ignore_missing_version = false
 message = "chore(release): bump to v{new_version}"
@@ -123,11 +130,11 @@ search = 'version = "{current_version}"'
 [[tool.bumpversion.files]]
 filename = "uv.lock"
 replace = """
-name = "advanced-alchemy"
+name = "sqlspec"
 version = "{new_version}"
 """
 search = """
-name = "advanced-alchemy"
+name = "sqlspec"
 version = "{current_version}"
 """
 
@@ -217,10 +224,17 @@ module = [
 
 [tool.pyright]
 disableBytesTypePromotions = true
-exclude = ["tools", "docs"]
+exclude = ["**/node_modules", "**/__pycache__", ".venv", "tools", "docs"]
 include = ["sqlspec", "tests"]
 pythonVersion = "3.9"
+reportMissingTypeStubs = false
+reportPrivateImportUsage = false
+reportPrivateUsage = false
+reportUnknownArgumentType = false
+reportUnknownMemberType = false
+reportUnknownVariableType = false
 reportUnnecessaryTypeIgnoreComments = true
+root = "."
 
 
 [tool.slotscheck]
@@ -267,6 +281,9 @@ ignore = [
   "ARG002",  # Unused method argument
   "ARG001",  # Unused function argument
   "CPY001",  # pycodestyle - Missing Copywrite notice at the top of the file
+  "RUF029",  # Ruff - function is declared as async but has no awaitable calls
+  "COM812",  # flake8-comma - Missing trailing comma
+  "PGH003",  # Use Specific ignore for pyright
 ]
 select = ["ALL"]
 
@@ -310,6 +327,8 @@ known-first-party = ["sqlspec", "tests"]
   "TRY",
   "PT012",
   "INP001",
+  "DOC",
+  "PLC",
 ]
 "tools/**/*.*" = ["D", "ARG", "EM", "TRY", "G", "FBT", "S603", "F811", "PLW0127", "PLR0911"]
 "tools/prepare_release.py" = ["S603", "S607"]

sqlspec-0.8.0/sqlspec/__init__.py

@@ -0,0 +1,15 @@
+from sqlspec import adapters, base, exceptions, extensions, filters, typing, utils
+from sqlspec.__metadata__ import __version__
+from sqlspec.base import SQLSpec
+
+__all__ = (
+    "SQLSpec",
+    "__version__",
+    "adapters",
+    "base",
+    "exceptions",
+    "extensions",
+    "filters",
+    "typing",
+    "utils",
+)

{sqlspec-0.7.0 → sqlspec-0.8.0}/sqlspec/_serialization.py

@@ -60,12 +60,26 @@ __all__ = (
 
 
 def convert_datetime_to_gmt_iso(dt: datetime.datetime) -> str:  # pragma: no cover
-    """Handle datetime serialization for nested timestamps."""
+    """Handle datetime serialization for nested timestamps.
+
+    Args:
+        dt: The datetime to convert.
+
+    Returns:
+        The ISO formatted datetime string.
+    """
     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."""
+    """Handle datetime serialization for nested timestamps.
+
+    Args:
+        dt: The date to convert.
+
+    Returns:
+        The ISO formatted date string.
+    """
     return dt.isoformat()

{sqlspec-0.7.0 → sqlspec-0.8.0}/sqlspec/_typing.py

@@ -29,7 +29,7 @@ T_co = TypeVar("T_co", covariant=True)
 
 try:
     from pydantic import (
-        BaseModel,
+        BaseModel,  # pyright: ignore[reportAssignmentType]
         FailFast,  # pyright: ignore[reportGeneralTypeIssues,reportAssignmentType]
         TypeAdapter,
     )

sqlspec-0.8.0/sqlspec/adapters/adbc/__init__.py

@@ -0,0 +1,7 @@
+from sqlspec.adapters.adbc.config import Adbc
+from sqlspec.adapters.adbc.driver import AdbcDriver
+
+__all__ = (
+    "Adbc",
+    "AdbcDriver",
+)

sqlspec-0.8.0/sqlspec/adapters/adbc/config.py

@@ -0,0 +1,190 @@
+from contextlib import contextmanager
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any, Callable, Optional, Union, cast
+
+from adbc_driver_manager.dbapi import Connection
+
+from sqlspec.adapters.adbc.driver import AdbcDriver
+from sqlspec.base import NoPoolSyncConfig
+from sqlspec.exceptions import ImproperConfigurationError
+from sqlspec.typing import Empty, EmptyType
+from sqlspec.utils.module_loader import import_string
+
+if TYPE_CHECKING:
+    from collections.abc import Generator
+
+
+__all__ = ("Adbc",)
+
+
+@dataclass
+class Adbc(NoPoolSyncConfig["Connection", "AdbcDriver"]):
+    """Configuration for ADBC connections.
+
+    This class provides configuration options for ADBC database connections using the
+    ADBC Driver Manager.([1](https://arrow.apache.org/adbc/current/python/api/adbc_driver_manager.html))
+    """
+
+    uri: "Union[str, EmptyType]" = Empty
+    """Database URI"""
+    driver_name: "Union[str, EmptyType]" = Empty
+    """Full dotted path to the ADBC driver's connect function (e.g., 'adbc_driver_sqlite.dbapi.connect')"""
+    db_kwargs: "Optional[dict[str, Any]]" = None
+    """Additional database-specific connection parameters"""
+    conn_kwargs: "Optional[dict[str, Any]]" = None
+    """Additional database-specific connection parameters"""
+    connection_type: "type[Connection]" = field(init=False, default_factory=lambda: Connection)
+    """Type of the connection object"""
+    driver_type: "type[AdbcDriver]" = field(init=False, default_factory=lambda: AdbcDriver)  # type: ignore[type-abstract,unused-ignore]
+    """Type of the driver object"""
+    pool_instance: None = field(init=False, default=None)
+    """No connection pool is used for ADBC connections"""
+    _is_in_memory: bool = field(init=False, default=False)
+    """Flag indicating if the connection is for an in-memory database"""
+
+    def _set_adbc(self) -> str:  # noqa: PLR0912
+        """Identify the driver type based on the URI (if provided) or preset driver name.
+
+        Also sets the `_is_in_memory` flag for specific in-memory URIs.
+
+        Raises:
+            ImproperConfigurationError: If the driver name is not recognized or supported.
+
+        Returns:
+            str: The driver name to be used for the connection.
+        """
+
+        if isinstance(self.driver_name, str):
+            if self.driver_name != "adbc_driver_sqlite.dbapi.connect" and "sqlite" in self.driver_name:
+                self.driver_name = "adbc_driver_sqlite.dbapi.connect"
+            elif self.driver_name != "adbc_driver_duckdb.dbapi.connect" and "duckdb" in self.driver_name:
+                self.driver_name = "adbc_driver_duckdb.dbapi.connect"
+            elif self.driver_name != "adbc_driver_postgresql.dbapi.connect" and "postgres" in self.driver_name:
+                self.driver_name = "adbc_driver_postgresql.dbapi.connect"
+            elif self.driver_name != "adbc_driver_snowflake.dbapi.connect" and "snowflake" in self.driver_name:
+                self.driver_name = "adbc_driver_snowflake.dbapi.connect"
+            elif self.driver_name != "adbc_driver_bigquery.dbapi.connect" and "bigquery" in self.driver_name:
+                self.driver_name = "adbc_driver_bigquery.dbapi.connect"
+            elif self.driver_name != "adbc_driver_flightsql.dbapi.connect" and "flightsql" in self.driver_name:
+                self.driver_name = "adbc_driver_flightsql.dbapi.connect"
+            return self.driver_name
+
+        # If driver_name wasn't explicit, try to determine from URI
+        if isinstance(self.uri, str) and self.uri.startswith("postgresql://"):
+            self.driver_name = "adbc_driver_postgresql.dbapi.connect"
+        elif isinstance(self.uri, str) and self.uri.startswith("sqlite://"):
+            self.driver_name = "adbc_driver_sqlite.dbapi.connect"
+        elif isinstance(self.uri, str) and self.uri.startswith("grpc://"):
+            self.driver_name = "adbc_driver_flightsql.dbapi.connect"
+        elif isinstance(self.uri, str) and self.uri.startswith("snowflake://"):
+            self.driver_name = "adbc_driver_snowflake.dbapi.connect"
+        elif isinstance(self.uri, str) and self.uri.startswith("bigquery://"):
+            self.driver_name = "adbc_driver_bigquery.dbapi.connect"
+        elif isinstance(self.uri, str) and self.uri.startswith("duckdb://"):
+            self.driver_name = "adbc_driver_duckdb.dbapi.connect"
+
+        # Check if we successfully determined a driver name
+        if self.driver_name is Empty or not isinstance(self.driver_name, str):
+            msg = (
+                "Could not determine ADBC driver connect path. Please specify 'driver_name' "
+                "(e.g., 'adbc_driver_sqlite.dbapi.connect') or provide a supported 'uri'. "
+                f"URI: {self.uri}, Driver Name: {self.driver_name}"
+            )
+            raise ImproperConfigurationError(msg)
+        return self.driver_name
+
+    @property
+    def connection_config_dict(self) -> "dict[str, Any]":
+        """Return the connection configuration as a dict.
+
+        Omits the 'uri' key for known in-memory database types.
+
+        Returns:
+            A string keyed dict of config kwargs for the adbc_driver_manager.dbapi.connect function.
+        """
+        config = {}
+        db_kwargs = self.db_kwargs or {}
+        conn_kwargs = self.conn_kwargs or {}
+        if isinstance(self.uri, str) and self.uri.startswith("sqlite://"):
+            db_kwargs["uri"] = self.uri.replace("sqlite://", "")
+        elif isinstance(self.uri, str) and self.uri.startswith("duckdb://"):
+            db_kwargs["path"] = self.uri.replace("duckdb://", "")
+        elif isinstance(self.uri, str):
+            db_kwargs["uri"] = self.uri
+        if isinstance(self.driver_name, str) and self.driver_name.startswith("adbc_driver_bigquery"):
+            config["db_kwargs"] = db_kwargs
+        else:
+            config = db_kwargs
+        if conn_kwargs:
+            config["conn_kwargs"] = conn_kwargs
+        return config
+
+    def _get_connect_func(self) -> "Callable[..., Connection]":
+        self._set_adbc()
+        driver_path = cast("str", self.driver_name)
+        try:
+            connect_func = import_string(driver_path)
+        except ImportError as e:
+            # Check if the error is likely due to missing suffix and try again
+            if ".dbapi.connect" not in driver_path:
+                try:
+                    driver_path += ".dbapi.connect"
+                    connect_func = import_string(driver_path)
+                except ImportError as e2:
+                    msg = f"Failed to import ADBC connect function from '{self.driver_name}' or '{driver_path}'. Is the driver installed and the path correct? Original error: {e} / {e2}"
+                    raise ImproperConfigurationError(msg) from e2
+            else:
+                # Original import failed, and suffix was already present or added
+                msg = f"Failed to import ADBC connect function from '{driver_path}'. Is the driver installed and the path correct? Original error: {e}"
+                raise ImproperConfigurationError(msg) from e
+        if not callable(connect_func):
+            msg = f"The path '{driver_path}' did not resolve to a callable function."
+            raise ImproperConfigurationError(msg)
+        return connect_func  # type: ignore[no-any-return]
+
+    def create_connection(self) -> "Connection":
+        """Create and return a new database connection using the specific driver.
+
+        Returns:
+            A new ADBC connection instance.
+
+        Raises:
+            ImproperConfigurationError: If the connection could not be established.
+        """
+        try:
+            connect_func = self._get_connect_func()
+            _config = self.connection_config_dict
+            return connect_func(**_config)
+        except Exception as e:
+            # Include driver name in error message for better context
+            driver_name = self.driver_name if isinstance(self.driver_name, str) else "Unknown/Derived"
+            # Use the potentially modified driver_path from _get_connect_func if available,
+            # otherwise fallback to self.driver_name for the error message.
+            # This requires _get_connect_func to potentially return the used path or store it.
+            # For simplicity now, we stick to self.driver_name in the message.
+            msg = f"Could not configure the ADBC connection using driver path '{driver_name}'. Error: {e!s}"
+            raise ImproperConfigurationError(msg) from e
+
+    @contextmanager
+    def provide_connection(self, *args: "Any", **kwargs: "Any") -> "Generator[Connection, None, None]":
+        """Create and provide a database connection using the specific driver.
+
+        Yields:
+            Connection: A database connection instance.
+        """
+
+        connection = self.create_connection()
+        try:
+            yield connection
+        finally:
+            connection.close()
+
+    @contextmanager
+    def provide_session(self, *args: Any, **kwargs: Any) -> "Generator[AdbcDriver, None, None]":
+        """Create and provide a database session.
+
+        Yields:
+            An ADBC driver instance with an active connection.
+        """
+        with self.provide_connection(*args, **kwargs) as connection:
+            yield self.driver_type(connection)