sqlspec 0.4.0__tar.gz → 0.5.0__tar.gz

{sqlspec-0.4.0 → sqlspec-0.5.0}/.pre-commit-config.yaml

@@ -2,7 +2,7 @@ default_language_version:
   python: "3"
 repos:
   - repo: https://github.com/compilerla/conventional-pre-commit
-    rev: v3.6.0
+    rev: v4.0.0
     hooks:
       - id: conventional-pre-commit
         stages: [commit-msg]
@@ -17,7 +17,7 @@ repos:
       - id: mixed-line-ending
       - id: trailing-whitespace
   - repo: https://github.com/charliermarsh/ruff-pre-commit
-    rev: "v0.8.3"
+    rev: "v0.9.1"
     hooks:
       - id: ruff
         args: ["--fix"]

{sqlspec-0.4.0 → sqlspec-0.5.0}/Makefile

@@ -121,45 +121,36 @@ test:                                               ## Run the tests
 	@uv run pytest tests
 	@echo "${OK} Tests complete ✨"
 
-.PHONY: test-examples
-test-examples:                                      ## Run the examples tests
-	@echo "${INFO} Running example tests... 🧪"
-	@uv run pytest docs/examples
-	@echo "${OK} Example tests complete ✨"
-
 .PHONY: test-all
-test-all: test test-examples                        ## Run all tests
+test-all: tests				                        ## Run all tests
 	@echo "${INFO} All tests executed successfully ✨"
 
 .PHONY: coverage
-coverage:                                          ## Run tests with coverage report
+coverage:                                           ## Run tests with coverage report
 	@echo "${INFO} Running tests with coverage... 📊"
-	@uv run pytest tests --cov -n auto --quiet
+	@uv run pytest --cov -n auto --quiet
 	@uv run coverage html >/dev/null 2>&1
 	@uv run coverage xml >/dev/null 2>&1
 	@echo "${OK} Coverage report generated ✨"
 
+# -----------------------------------------------------------------------------
+# Type Checking
+# -----------------------------------------------------------------------------
+
 .PHONY: mypy
 mypy:                                               ## Run mypy
 	@echo "${INFO} Running mypy... 🔍"
 	@uv run dmypy run
-	@echo "${OK} mypy complete ✨"
-
-.PHONY: mypy-nocache
-mypy-nocache:                                       ## Run Mypy without cache
-	@echo "${INFO} Running mypy without cache... 🔍"
-	@uv run mypy
-	@echo "${OK} mypy complete ✨"
+	@echo "${OK} Mypy checks passed ✨"
 
 .PHONY: pyright
 pyright:                                            ## Run pyright
 	@echo "${INFO} Running pyright... 🔍"
 	@uv run pyright
-	@echo "${OK} pyright complete ✨"
+	@echo "${OK} Pyright checks passed ✨"
 
 .PHONY: type-check
 type-check: mypy pyright                            ## Run all type checking
-	@echo "${OK} All type checks passed ✨"
 
 # -----------------------------------------------------------------------------
 # Linting and Formatting

sqlspec-0.5.0/PKG-INFO

@@ -0,0 +1,126 @@
+Metadata-Version: 2.4
+Name: sqlspec
+Version: 0.5.0
+Summary: SQL Experiments in Python
+Author-email: Cody Fincher <cody@litestar.dev>
+Maintainer-email: Litestar Developers <hello@litestar.dev>
+License-File: NOTICE
+Requires-Python: <4.0,>=3.9
+Requires-Dist: eval-type-backport; python_version < '3.10'
+Requires-Dist: sqlglot
+Requires-Dist: typing-extensions
+Provides-Extra: adbc
+Requires-Dist: adbc-driver-manager; extra == 'adbc'
+Requires-Dist: pyarrow; extra == 'adbc'
+Provides-Extra: aioodbc
+Requires-Dist: aioodbc; extra == 'aioodbc'
+Provides-Extra: aiosqlite
+Requires-Dist: aiosqlite; extra == 'aiosqlite'
+Provides-Extra: asyncmy
+Requires-Dist: asyncmy; extra == 'asyncmy'
+Provides-Extra: asyncpg
+Requires-Dist: asyncpg; extra == 'asyncpg'
+Provides-Extra: bigquery
+Requires-Dist: google-cloud-bigquery; extra == 'bigquery'
+Provides-Extra: duckdb
+Requires-Dist: duckdb; extra == 'duckdb'
+Provides-Extra: fastapi
+Requires-Dist: fastapi; extra == 'fastapi'
+Provides-Extra: flask
+Requires-Dist: flask; extra == 'flask'
+Provides-Extra: litestar
+Requires-Dist: litestar; extra == 'litestar'
+Provides-Extra: msgspec
+Requires-Dist: msgspec; extra == 'msgspec'
+Provides-Extra: oracledb
+Requires-Dist: oracledb; extra == 'oracledb'
+Provides-Extra: performance
+Requires-Dist: google-re2; (sys_platform == 'linux') and extra == 'performance'
+Requires-Dist: sqlglot[rs]; extra == 'performance'
+Provides-Extra: psycopg
+Requires-Dist: psycopg[binary,pool]; extra == 'psycopg'
+Provides-Extra: pydantic
+Requires-Dist: pydantic; extra == 'pydantic'
+Provides-Extra: pymssql
+Requires-Dist: pymssql; extra == 'pymssql'
+Provides-Extra: pymysql
+Requires-Dist: pymysql; extra == 'pymysql'
+Provides-Extra: spanner
+Requires-Dist: google-cloud-spanner; extra == 'spanner'
+Description-Content-Type: text/markdown
+
+# SQLSpec
+
+## A Query Mapper for Python
+
+SQLSpec is an experimental Python library designed to streamline and modernize your SQL interactions across a variety of database systems. While still in its early stages, SQLSpec aims to provide a flexible, typed, and extensible interface for working with SQL in Python.
+
+**Note**: SQLSpec is currently under active development and the API is subject to change.  It is not yet ready for production use.  Contributions are welcome!
+
+### Core Features (Planned but subject to change, removal or redesign)
+
+- **Consistent Database Session Interface**: Provides a consistent connectivity interface for interacting with one or more database systems, including SQLite, Postgres, DuckDB, MySQL, Oracle, SQL Server, Spanner, BigQuery, and more.
+- **Emphasis on RAW SQL and Minimal Abstractions and Performance**: SQLSpec is a library for working with SQL in Python.  It's goals are to offer minimal abstractions between the user and the database.  It does not aim to be an ORM library.
+- **Type-Safe Queries**: Quickly map SQL queries to typed objects using libraries such as Pydantic, Msqgspec, Attrs, etc.
+- **Extensible Design**: Easily add support for new database dialects or extend existing functionality to meet your specific needs.  Easily add support for async and sync database drivers.
+- **Minimal Dependencies**: SQLSpec is designed to be lightweight and can run on it's own or with other libraries such as `litestar`, `fastapi`, `flask` and more.  (Contributions welcome!)
+- **Dynamic Query Manipulation**: Easily apply filters to pre-defined queries with a fluent, Pythonic API. Safely manipulate queries without the risk of SQL injection.
+- **Dialect Validation and Conversion**: Use `sqlglot` to validate your SQL against specific dialects and seamlessly convert between them.
+- **Support for Async and Sync Database Drivers**: SQLSpec supports both async and sync database drivers, allowing you to choose the style that best fits your application.
+
+### What SQLSpec Is Not (Yet)
+
+SQLSpec is a work in progress. While it offers a solid foundation for modern SQL interactions, it does not yet include every feature you might find in a mature ORM or database toolkit. The focus is on building a robust, flexible core that can be extended over time.
+
+### Inspiration and Future Direction
+
+SQLSpec originally drew inspiration from features found in the `aiosql` library.  This is a great library for working with and executed SQL stored in files.  It's unclear how much of an overlap there will be between the two libraries, but it's possible that some features will be contributed back to `aiosql` where appropriate.
+
+### Current Focus: Universal Connectivity
+
+The primary goal at this stage is to establish a **native connectivity interface** that works seamlessly across all supported database environments. This means you can connect to any of the supported databases using a consistent API, regardless of the underlying driver or dialect.
+
+### Adapters: Completed, In Progress, and Planned
+
+This list is not final. If you have a driver you'd like to see added, please open an issue or submit a PR!
+
+| Driver                                                                                                       | Database   | Mode    | Status     |
+| :----------------------------------------------------------------------------------------------------------- | :--------- | :------ | :--------- |
+| [`adbc`](https://arrow.apache.org/adbc/)                                                                     | Postgres   | Sync    | ✅         |
+| [`adbc`](https://arrow.apache.org/adbc/)                                                                     | SQLite     | Sync    | ✅         |
+| [`adbc`](https://arrow.apache.org/adbc/)                                                                     | Snowflake  | Sync    | ✅         |
+| [`adbc`](https://arrow.apache.org/adbc/)                                                                     | DuckDB     | Sync    | ✅         |
+| [`asyncpg`](https://magicstack.github.io/asyncpg/current/)                                                    | PostgreSQL | Async   | ✅         |
+| [`psycopg`](https://www.psycopg.org/)                                                                         | PostgreSQL | Sync    | ✅         |
+| [`psycopg`](https://www.psycopg.org/)                                                                         | PostgreSQL | Async   | ✅         |
+| [`aiosqlite`](https://github.com/omnilib/aiosqlite)                                                           | SQLite     | Async   | ✅         |
+| `sqlite3`                                                                                                    | SQLite     | Sync    | ✅         |
+| [`oracledb`](https://oracle.github.io/python-oracledb/)                                                      | Oracle     | Async   | ✅         |
+| [`oracledb`](https://oracle.github.io/python-oracledb/)                                                      | Oracle     | Sync    | ✅         |
+| [`duckdb`](https://duckdb.org/)                                                                               | DuckDB     | Sync    | ✅         |
+| [`bigquery`](https://googleapis.dev/python/bigquery/latest/index.html)                                        | BigQuery   | Sync    | 🗓️ Planned |
+| [`spanner`](https://googleapis.dev/python/spanner/latest/index.html)                                         | Spanner    | Sync    | 🗓️ Planned |
+| [`sqlserver`](https://docs.microsoft.com/en-us/sql/connect/python/pyodbc/python-sql-driver-for-pyodbc?view=sql-server-ver16) | SQL Server | Sync    | 🗓️ Planned |
+| [`mysql`](https://dev.mysql.com/doc/connector-python/en/connector-python-api-mysql-connector-python.html)     | MySQL      | Sync    | 🗓️ Planned |
+| [`snowflake`](https://docs.snowflake.com)
+
+### Proposed Project Structure
+
+- `sqlspec/`:
+    - `adapters/`: Contains all database drivers and associated configuration.
+    - `extensions/`:
+        - `litestar/`: Future home of `litestar` integration.
+        - `fastapi/`: Future home of `fastapi` integration.
+        - `flask/`: Future home of `flask` integration.
+        - `*/`: Future home of your favorite framework integration 🔌 ✨
+    - `base.py`: Contains base protocols for database configurations.
+    - `filters.py`: Contains the `Filter` class which is used to apply filters to pre-defined SQL queries.
+    - `utils/`: Contains utility functions used throughout the project.
+    - `exceptions.py`: Contains custom exceptions for SQLSpec.
+    - `typing.py`: Contains type hints, type guards and several facades for optional libraries that are not required for the core functionality of SQLSpec.
+
+### Get Involved
+
+SQLSpec is an open-source project, and contributions are welcome! Whether you're interested in adding support for new databases, improving the query interface, or simply providing feedback, your input is valuable.
+
+**Disclaimer**: SQLSpec is under active development. Expect changes and improvements as the project evolves.

sqlspec-0.5.0/README.md

@@ -0,0 +1,75 @@
+# SQLSpec
+
+## A Query Mapper for Python
+
+SQLSpec is an experimental Python library designed to streamline and modernize your SQL interactions across a variety of database systems. While still in its early stages, SQLSpec aims to provide a flexible, typed, and extensible interface for working with SQL in Python.
+
+**Note**: SQLSpec is currently under active development and the API is subject to change.  It is not yet ready for production use.  Contributions are welcome!
+
+### Core Features (Planned but subject to change, removal or redesign)
+
+- **Consistent Database Session Interface**: Provides a consistent connectivity interface for interacting with one or more database systems, including SQLite, Postgres, DuckDB, MySQL, Oracle, SQL Server, Spanner, BigQuery, and more.
+- **Emphasis on RAW SQL and Minimal Abstractions and Performance**: SQLSpec is a library for working with SQL in Python.  It's goals are to offer minimal abstractions between the user and the database.  It does not aim to be an ORM library.
+- **Type-Safe Queries**: Quickly map SQL queries to typed objects using libraries such as Pydantic, Msqgspec, Attrs, etc.
+- **Extensible Design**: Easily add support for new database dialects or extend existing functionality to meet your specific needs.  Easily add support for async and sync database drivers.
+- **Minimal Dependencies**: SQLSpec is designed to be lightweight and can run on it's own or with other libraries such as `litestar`, `fastapi`, `flask` and more.  (Contributions welcome!)
+- **Dynamic Query Manipulation**: Easily apply filters to pre-defined queries with a fluent, Pythonic API. Safely manipulate queries without the risk of SQL injection.
+- **Dialect Validation and Conversion**: Use `sqlglot` to validate your SQL against specific dialects and seamlessly convert between them.
+- **Support for Async and Sync Database Drivers**: SQLSpec supports both async and sync database drivers, allowing you to choose the style that best fits your application.
+
+### What SQLSpec Is Not (Yet)
+
+SQLSpec is a work in progress. While it offers a solid foundation for modern SQL interactions, it does not yet include every feature you might find in a mature ORM or database toolkit. The focus is on building a robust, flexible core that can be extended over time.
+
+### Inspiration and Future Direction
+
+SQLSpec originally drew inspiration from features found in the `aiosql` library.  This is a great library for working with and executed SQL stored in files.  It's unclear how much of an overlap there will be between the two libraries, but it's possible that some features will be contributed back to `aiosql` where appropriate.
+
+### Current Focus: Universal Connectivity
+
+The primary goal at this stage is to establish a **native connectivity interface** that works seamlessly across all supported database environments. This means you can connect to any of the supported databases using a consistent API, regardless of the underlying driver or dialect.
+
+### Adapters: Completed, In Progress, and Planned
+
+This list is not final. If you have a driver you'd like to see added, please open an issue or submit a PR!
+
+| Driver                                                                                                       | Database   | Mode    | Status     |
+| :----------------------------------------------------------------------------------------------------------- | :--------- | :------ | :--------- |
+| [`adbc`](https://arrow.apache.org/adbc/)                                                                     | Postgres   | Sync    | ✅         |
+| [`adbc`](https://arrow.apache.org/adbc/)                                                                     | SQLite     | Sync    | ✅         |
+| [`adbc`](https://arrow.apache.org/adbc/)                                                                     | Snowflake  | Sync    | ✅         |
+| [`adbc`](https://arrow.apache.org/adbc/)                                                                     | DuckDB     | Sync    | ✅         |
+| [`asyncpg`](https://magicstack.github.io/asyncpg/current/)                                                    | PostgreSQL | Async   | ✅         |
+| [`psycopg`](https://www.psycopg.org/)                                                                         | PostgreSQL | Sync    | ✅         |
+| [`psycopg`](https://www.psycopg.org/)                                                                         | PostgreSQL | Async   | ✅         |
+| [`aiosqlite`](https://github.com/omnilib/aiosqlite)                                                           | SQLite     | Async   | ✅         |
+| `sqlite3`                                                                                                    | SQLite     | Sync    | ✅         |
+| [`oracledb`](https://oracle.github.io/python-oracledb/)                                                      | Oracle     | Async   | ✅         |
+| [`oracledb`](https://oracle.github.io/python-oracledb/)                                                      | Oracle     | Sync    | ✅         |
+| [`duckdb`](https://duckdb.org/)                                                                               | DuckDB     | Sync    | ✅         |
+| [`bigquery`](https://googleapis.dev/python/bigquery/latest/index.html)                                        | BigQuery   | Sync    | 🗓️ Planned |
+| [`spanner`](https://googleapis.dev/python/spanner/latest/index.html)                                         | Spanner    | Sync    | 🗓️ Planned |
+| [`sqlserver`](https://docs.microsoft.com/en-us/sql/connect/python/pyodbc/python-sql-driver-for-pyodbc?view=sql-server-ver16) | SQL Server | Sync    | 🗓️ Planned |
+| [`mysql`](https://dev.mysql.com/doc/connector-python/en/connector-python-api-mysql-connector-python.html)     | MySQL      | Sync    | 🗓️ Planned |
+| [`snowflake`](https://docs.snowflake.com)
+
+### Proposed Project Structure
+
+- `sqlspec/`:
+    - `adapters/`: Contains all database drivers and associated configuration.
+    - `extensions/`:
+        - `litestar/`: Future home of `litestar` integration.
+        - `fastapi/`: Future home of `fastapi` integration.
+        - `flask/`: Future home of `flask` integration.
+        - `*/`: Future home of your favorite framework integration 🔌 ✨
+    - `base.py`: Contains base protocols for database configurations.
+    - `filters.py`: Contains the `Filter` class which is used to apply filters to pre-defined SQL queries.
+    - `utils/`: Contains utility functions used throughout the project.
+    - `exceptions.py`: Contains custom exceptions for SQLSpec.
+    - `typing.py`: Contains type hints, type guards and several facades for optional libraries that are not required for the core functionality of SQLSpec.
+
+### Get Involved
+
+SQLSpec is an open-source project, and contributions are welcome! Whether you're interested in adding support for new databases, improving the query interface, or simply providing feedback, your input is valuable.
+
+**Disclaimer**: SQLSpec is under active development. Expect changes and improvements as the project evolves.

{sqlspec-0.4.0 → sqlspec-0.5.0}/pyproject.toml

@@ -1,12 +1,12 @@
 [project]
 authors = [{ name = "Cody Fincher", email = "cody@litestar.dev" }]
-dependencies = ["typing-extensions>=4.0.0", "eval_type_backport; python_version <= \"3.9\"", "sqlglot"]
+dependencies = ["typing-extensions", "sqlglot", "eval_type_backport; python_version < \"3.10\""]
 description = "SQL Experiments in Python"
 maintainers = [{ name = "Litestar Developers", email = "hello@litestar.dev" }]
 name = "sqlspec"
 readme = "README.md"
 requires-python = ">=3.9, <4.0"
-version = "0.4.0"
+version = "0.5.0"
 
 [project.optional-dependencies]
 adbc = ["adbc-driver-manager", "pyarrow"]

{sqlspec-0.4.0 → sqlspec-0.5.0}/sqlspec/_serialization.py

@@ -13,7 +13,7 @@ try:
 
 except ImportError:
     try:
-        from orjson import dumps as _encode_json  # pyright: ignore[reportMissingImports]
+        from orjson import dumps as _encode_json  # pyright: ignore[reportMissingImports,reportUnknownVariableType]
         from orjson import loads as decode_json  # type: ignore[no-redef]
 
         def encode_json(data: Any) -> str:

{sqlspec-0.4.0 → sqlspec-0.5.0}/sqlspec/_typing.py

@@ -29,7 +29,6 @@ class DataclassProtocol(Protocol):
 T = TypeVar("T")
 T_co = TypeVar("T_co", covariant=True)
 
-
 try:
     from pydantic import BaseModel, FailFast, TypeAdapter
 
@@ -110,6 +109,35 @@ except ImportError:
     UNSET = UnsetType.UNSET  # pyright: ignore[reportConstantRedefinition]
     MSGSPEC_INSTALLED = False  # pyright: ignore[reportConstantRedefinition]
 
+try:
+    from litestar.dto.data_structures import DTOData  # pyright: ignore[reportUnknownVariableType]
+
+    LITESTAR_INSTALLED = True
+except ImportError:
+
+    @runtime_checkable
+    class DTOData(Protocol[T]):  # type: ignore[no-redef]
+        """Placeholder implementation"""
+
+        __slots__ = ("_backend", "_data_as_builtins")
+
+        def __init__(self, backend: Any, data_as_builtins: Any) -> None:
+            """Placeholder init"""
+
+        def create_instance(self, **kwargs: Any) -> T:
+            """Placeholder implementation"""
+            return cast("T", kwargs)
+
+        def update_instance(self, instance: T, **kwargs: Any) -> T:
+            """Placeholder implementation"""
+            return cast("T", kwargs)
+
+        def as_builtins(self) -> Any:
+            """Placeholder implementation"""
+            return {}
+
+    LITESTAR_INSTALLED = False  # pyright: ignore[reportConstantRedefinition]
+
 
 class EmptyEnum(Enum):
     """A sentinel enum used as placeholder."""
@@ -122,10 +150,12 @@ Empty: Final = EmptyEnum.EMPTY
 
 
 __all__ = (
+    "LITESTAR_INSTALLED",
     "MSGSPEC_INSTALLED",
     "PYDANTIC_INSTALLED",
     "UNSET",
     "BaseModel",
+    "DTOData",
     "DataclassProtocol",
     "Empty",
     "EmptyEnum",

{sqlspec-0.4.0 → sqlspec-0.5.0}/sqlspec/adapters/adbc/config.py

@@ -2,31 +2,31 @@ from __future__ import annotations
 
 from contextlib import contextmanager
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, TypeVar
+from typing import TYPE_CHECKING
 
-from sqlspec.config import GenericDatabaseConfig
+from sqlspec.base import GenericDatabaseConfig, NoPoolConfig
 from sqlspec.typing import Empty, EmptyType
 
 if TYPE_CHECKING:
     from collections.abc import Generator
     from typing import Any
 
-    from adbc_driver_manager.dbapi import Connection, Cursor
+    from adbc_driver_manager.dbapi import Connection
 
 __all__ = ("AdbcDatabaseConfig",)
 
-ConnectionT = TypeVar("ConnectionT", bound="Connection")
-CursorT = TypeVar("CursorT", bound="Cursor")
-
 
 @dataclass
-class AdbcDatabaseConfig(GenericDatabaseConfig):
+class AdbcDatabaseConfig(NoPoolConfig["Connection"], GenericDatabaseConfig):
     """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))
     """
 
+    __supports_connection_pooling = False
+    __is_async = False
+
     uri: str | EmptyType = Empty
     """Database URI"""
     driver_name: str | EmptyType = Empty

{sqlspec-0.4.0 → sqlspec-0.5.0}/sqlspec/adapters/aiosqlite/config.py

@@ -4,7 +4,7 @@ from contextlib import asynccontextmanager
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any
 
-from sqlspec.config import GenericDatabaseConfig
+from sqlspec.base import GenericDatabaseConfig, NoPoolConfig
 from sqlspec.exceptions import ImproperConfigurationError
 from sqlspec.typing import Empty, EmptyType, dataclass_to_dict
 
@@ -19,7 +19,7 @@ __all__ = ("AiosqliteConfig",)
 
 
 @dataclass
-class AiosqliteConfig(GenericDatabaseConfig):
+class AiosqliteConfig(NoPoolConfig["Connection"], GenericDatabaseConfig):
     """Configuration for Aiosqlite database connections.
 
     This class provides configuration options for Aiosqlite database connections, wrapping all parameters

{sqlspec-0.4.0 → sqlspec-0.5.0}/sqlspec/adapters/asyncmy/config.py

@@ -4,6 +4,10 @@ from contextlib import asynccontextmanager
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, TypeVar
 
+from asyncmy.connection import Connection
+from asyncmy.pool import Pool
+
+from sqlspec.base import DatabaseConfigProtocol, GenericDatabaseConfig, GenericPoolConfig
 from sqlspec.exceptions import ImproperConfigurationError
 from sqlspec.typing import Empty, EmptyType, dataclass_to_dict
 
@@ -11,9 +15,7 @@ if TYPE_CHECKING:
     from collections.abc import AsyncGenerator
     from typing import Any
 
-    from asyncmy.connection import Connection
     from asyncmy.cursors import Cursor, DictCursor
-    from asyncmy.pool import Pool
 
 __all__ = (
     "AsyncMyConfig",
@@ -25,7 +27,7 @@ T = TypeVar("T")
 
 
 @dataclass
-class AsyncmyPoolConfig:
+class AsyncmyPoolConfig(GenericPoolConfig):
     """Configuration for Asyncmy's connection pool.
 
     This class provides configuration options for Asyncmy database connection pools.
@@ -104,9 +106,12 @@ class AsyncmyPoolConfig:
 
 
 @dataclass
-class AsyncMyConfig:
+class AsyncMyConfig(DatabaseConfigProtocol[Connection, Pool], GenericDatabaseConfig):
     """Asyncmy Configuration."""
 
+    __is_async__ = True
+    __supports_connection_pooling__ = True
+
     pool_config: AsyncmyPoolConfig | None = None
     """Asyncmy Pool configuration"""
 

{sqlspec-0.4.0 → sqlspec-0.5.0}/sqlspec/adapters/asyncpg/config.py

@@ -2,13 +2,16 @@ from __future__ import annotations
 
 from contextlib import asynccontextmanager
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, TypeVar
+from typing import TYPE_CHECKING, TypeVar, Union
 
 from asyncpg import Record
 from asyncpg import create_pool as asyncpg_create_pool
+from asyncpg.connection import Connection
+from asyncpg.pool import Pool, PoolConnectionProxy
+from typing_extensions import TypeAlias
 
 from sqlspec._serialization import decode_json, encode_json
-from sqlspec.config import GenericDatabaseConfig, GenericPoolConfig
+from sqlspec.base import DatabaseConfigProtocol, GenericDatabaseConfig, GenericPoolConfig
 from sqlspec.exceptions import ImproperConfigurationError
 from sqlspec.typing import Empty, EmptyType, dataclass_to_dict
 
@@ -17,8 +20,6 @@ if TYPE_CHECKING:
     from collections.abc import AsyncGenerator, Awaitable, Callable, Coroutine
     from typing import Any
 
-    from asyncpg.connection import Connection
-    from asyncpg.pool import Pool, PoolConnectionProxy
 
 __all__ = (
     "AsyncPgConfig",
@@ -28,6 +29,8 @@ __all__ = (
 
 T = TypeVar("T")
 
+PgConnection: TypeAlias = Union[Connection, PoolConnectionProxy]
+
 
 @dataclass
 class AsyncPgPoolConfig(GenericPoolConfig):
@@ -70,9 +73,12 @@ class AsyncPgPoolConfig(GenericPoolConfig):
 
 
 @dataclass
-class AsyncPgConfig(GenericDatabaseConfig):
+class AsyncPgConfig(DatabaseConfigProtocol[PgConnection, Pool], GenericDatabaseConfig):
     """Asyncpg Configuration."""
 
+    __is_async__ = True
+    __supports_connection_pooling__ = True
+
     pool_config: AsyncPgPoolConfig | None = None
     """Asyncpg Pool configuration"""
     json_deserializer: Callable[[str], Any] = decode_json
@@ -132,9 +138,7 @@ class AsyncPgConfig(GenericDatabaseConfig):
         return self.create_pool()
 
     @asynccontextmanager
-    async def provide_connection(
-        self, *args: Any, **kwargs: Any
-    ) -> AsyncGenerator[Connection | PoolConnectionProxy, None]:
+    async def provide_connection(self, *args: Any, **kwargs: Any) -> AsyncGenerator[PoolConnectionProxy, None]:
         """Create a connection instance.
 
         Returns:

sqlspec-0.5.0/sqlspec/adapters/duckdb/__init__.py

@@ -0,0 +1,3 @@
+from sqlspec.adapters.duckdb.config import DuckDBConfig
+
+__all__ = ("DuckDBConfig",)

{sqlspec-0.4.0 → sqlspec-0.5.0}/sqlspec/adapters/duckdb/config.py

@@ -4,14 +4,15 @@ from contextlib import contextmanager
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, cast
 
-from sqlspec.config import GenericDatabaseConfig
+from duckdb import DuckDBPyConnection
+
+from sqlspec.base import GenericDatabaseConfig, NoPoolConfig
 from sqlspec.exceptions import ImproperConfigurationError
 from sqlspec.typing import Empty, EmptyType, dataclass_to_dict
 
 if TYPE_CHECKING:
     from collections.abc import Generator, Sequence
 
-    from duckdb import DuckDBPyConnection
 
 __all__ = ("DuckDBConfig", "ExtensionConfig")
 
@@ -23,21 +24,21 @@ class ExtensionConfig:
     This class provides configuration options for DuckDB extensions, including installation
     and post-install configuration settings.
 
-    Args:
-        name: The name of the extension to install
-        config: Optional configuration settings to apply after installation
-        force_install: Whether to force reinstall if already present
-        repository: Optional repository name to install from
-        repository_url: Optional repository URL to install from
-        version: Optional version of the extension to install
+    For details see: https://duckdb.org/docs/extensions/overview
     """
 
     name: str
+    """The name of the extension to install"""
     config: dict[str, Any] | None = None
+    """Optional configuration settings to apply after installation"""
     force_install: bool = False
+    """Whether to force reinstall if already present"""
     repository: str | None = None
+    """Optional repository name to install from"""
     repository_url: str | None = None
+    """Optional repository URL to install from"""
     version: str | None = None
+    """Optional version of the extension to install"""
 
     @classmethod
     def from_dict(cls, name: str, config: dict[str, Any] | bool | None = None) -> ExtensionConfig:
@@ -65,7 +66,7 @@ class ExtensionConfig:
 
 
 @dataclass
-class DuckDBConfig(GenericDatabaseConfig):
+class DuckDBConfig(NoPoolConfig[DuckDBPyConnection], GenericDatabaseConfig):
     """Configuration for DuckDB database connections.
 
     This class provides configuration options for DuckDB database connections, wrapping all parameters
@@ -114,13 +115,13 @@ class DuckDBConfig(GenericDatabaseConfig):
             msg = "When configuring extensions in the 'config' dictionary, the value must be a dictionary or sequence of extension names"
             raise ImproperConfigurationError(msg)
         if not isinstance(_e, dict):
-            _e = {str(ext): {"force_install": False} for ext in _e}
+            _e = {str(ext): {"force_install": False} for ext in _e}  # pyright: ignore[reportUnknownVariableType,reportUnknownArgumentType]
 
-        if len(set(_e.keys()).intersection({ext.name for ext in self.extensions})) > 0:
+        if len(set(_e.keys()).intersection({ext.name for ext in self.extensions})) > 0:  # pyright: ignore[ reportUnknownArgumentType]
             msg = "Configuring the same extension in both 'extensions' and as a key in 'config['extensions']' is not allowed"
             raise ImproperConfigurationError(msg)
 
-        self.extensions.extend([ExtensionConfig.from_dict(name, ext_config) for name, ext_config in _e.items()])
+        self.extensions.extend([ExtensionConfig.from_dict(name, ext_config) for name, ext_config in _e.items()])  # pyright: ignore[reportUnknownArgumentType,reportUnknownVariableType]
 
     def _configure_extensions(self, connection: DuckDBPyConnection) -> None:
         """Configure extensions for the connection.
@@ -177,7 +178,7 @@ class DuckDBConfig(GenericDatabaseConfig):
         import duckdb
 
         try:
-            connection = duckdb.connect(**self.connection_config_dict)
+            connection = duckdb.connect(**self.connection_config_dict)  # pyright: ignore[reportUnknownMemberType]
             self._configure_extensions(connection)
             return connection
         except Exception as e:

{sqlspec-0.4.0 → sqlspec-0.5.0}/sqlspec/adapters/oracledb/__init__.py

@@ -1,4 +1,4 @@
-from .config import (
+from sqlspec.adapters.oracledb.config import (
     OracleAsyncDatabaseConfig,
     OracleAsyncPoolConfig,
     OracleSyncDatabaseConfig,

{sqlspec-0.4.0 → sqlspec-0.5.0}/sqlspec/adapters/oracledb/config/_asyncio.py

@@ -26,14 +26,17 @@ __all__ = (
 
 
 @dataclass
-class OracleAsyncPoolConfig(OracleGenericPoolConfig[AsyncConnectionPool, AsyncConnection]):
+class OracleAsyncPoolConfig(OracleGenericPoolConfig[AsyncConnection, AsyncConnectionPool]):
     """Async Oracle Pool Config"""
 
 
 @dataclass
-class OracleAsyncDatabaseConfig(OracleGenericDatabaseConfig[AsyncConnectionPool, AsyncConnection]):
+class OracleAsyncDatabaseConfig(OracleGenericDatabaseConfig[AsyncConnection, AsyncConnectionPool]):
     """Async Oracle database Configuration."""
 
+    __is_async__ = True
+    __supports_connection_pooling__ = True
+
     pool_config: OracleAsyncPoolConfig | None = None
     """Oracle Pool configuration"""
     pool_instance: AsyncConnectionPool | None = None
@@ -70,7 +73,7 @@ class OracleAsyncDatabaseConfig(OracleGenericDatabaseConfig[AsyncConnectionPool,
 
         pool_config = self.pool_config_dict
         self.pool_instance = oracledb_create_pool(**pool_config)
-        if self.pool_instance is None:
+        if self.pool_instance is None:  # pyright: ignore[reportUnnecessaryComparison]
             msg = "Could not configure the 'pool_instance'. Please check your configuration."
             raise ImproperConfigurationError(msg)
         return self.pool_instance