sqlspec 0.3.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

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/_typing.py

@@ -5,20 +5,30 @@ This is used to ensure compatibility when one or more of the libraries are insta
 
 from __future__ import annotations
 
+from enum import Enum
 from typing import (
     Any,
     ClassVar,
+    Final,
     Protocol,
+    Union,
     cast,
     runtime_checkable,
 )
 
-from typing_extensions import TypeVar, dataclass_transform
+from typing_extensions import Literal, TypeVar, dataclass_transform
+
+
+@runtime_checkable
+class DataclassProtocol(Protocol):
+    """Protocol for instance checking dataclasses."""
+
+    __dataclass_fields__: ClassVar[dict[str, Any]]
+
 
 T = TypeVar("T")
 T_co = TypeVar("T_co", covariant=True)
 
-
 try:
     from pydantic import BaseModel, FailFast, TypeAdapter
 
@@ -99,11 +109,57 @@ 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."""
+
+    EMPTY = 0
+
+
+EmptyType = Union[Literal[EmptyEnum.EMPTY], UnsetType]
+Empty: Final = EmptyEnum.EMPTY
+
+
 __all__ = (
+    "LITESTAR_INSTALLED",
     "MSGSPEC_INSTALLED",
     "PYDANTIC_INSTALLED",
     "UNSET",
     "BaseModel",
+    "DTOData",
+    "DataclassProtocol",
+    "Empty",
+    "EmptyEnum",
+    "EmptyType",
     "FailFast",
     "Struct",
     "TypeAdapter",

sqlspec/adapters/adbc/config.py

@@ -2,33 +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.utils.empty import Empty
+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 sqlspec.utils.empty import EmptyType
+    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/adapters/aiosqlite/config.py

@@ -4,10 +4,9 @@ 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.utils.dataclass import simple_asdict
-from sqlspec.utils.empty import Empty, EmptyType
+from sqlspec.typing import Empty, EmptyType, dataclass_to_dict
 
 if TYPE_CHECKING:
     from collections.abc import AsyncGenerator
@@ -20,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
@@ -60,7 +59,7 @@ class AiosqliteConfig(GenericDatabaseConfig):
         Returns:
             A string keyed dict of config kwargs for the aiosqlite.connect() function.
         """
-        return simple_asdict(self, exclude_empty=True, convert_nested=False)
+        return dataclass_to_dict(self, exclude_empty=True, convert_nested=False)
 
     async def create_connection(self) -> Connection:
         """Create and return a new database connection.
@@ -79,22 +78,6 @@ class AiosqliteConfig(GenericDatabaseConfig):
             msg = f"Could not configure the Aiosqlite connection. Error: {e!s}"
             raise ImproperConfigurationError(msg) from e
 
-    @asynccontextmanager
-    async def lifespan(self, *args: Any, **kwargs: Any) -> AsyncGenerator[None, None]:
-        """Manage the lifecycle of a database connection.
-
-        Yields:
-            None
-
-        Raises:
-            ImproperConfigurationError: If the connection could not be established.
-        """
-        connection = await self.create_connection()
-        try:
-            yield
-        finally:
-            await connection.close()
-
     @asynccontextmanager
     async def provide_connection(self, *args: Any, **kwargs: Any) -> AsyncGenerator[Connection, None]:
         """Create and provide a database connection.

sqlspec/adapters/asyncmy/config.py

@@ -4,17 +4,18 @@ 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.utils.dataclass import simple_asdict
-from sqlspec.utils.empty import Empty, EmptyType
+from sqlspec.typing import Empty, EmptyType, dataclass_to_dict
 
 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",
@@ -26,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.
@@ -101,13 +102,16 @@ class AsyncmyPoolConfig:
         Returns:
             A string keyed dict of config kwargs for the Asyncmy create_pool function.
         """
-        return simple_asdict(self, exclude_empty=True, convert_nested=False)
+        return dataclass_to_dict(self, exclude_empty=True, convert_nested=False)
 
 
 @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"""
 
@@ -125,7 +129,7 @@ class AsyncMyConfig:
             A string keyed dict of config kwargs for the Asyncmy create_pool function.
         """
         if self.pool_config:
-            return simple_asdict(self.pool_config, exclude_empty=True, convert_nested=False)
+            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)
 
@@ -162,23 +166,6 @@ class AsyncMyConfig:
         """
         return await self.create_pool()
 
-    @asynccontextmanager
-    async def lifespan(self, *args: Any, **kwargs: Any) -> AsyncGenerator[None, None]:
-        """Manage the lifecycle of a database connection pool.
-
-        Yields:
-            None
-
-        Raises:
-            ImproperConfigurationError: If the pool could not be established.
-        """
-        pool = await self.create_pool()
-        try:
-            yield
-        finally:
-            pool.close()
-            await pool.wait_closed()
-
     @asynccontextmanager
     async def provide_connection(self, *args: Any, **kwargs: Any) -> AsyncGenerator[Connection, None]:
         """Create and provide a database connection.

sqlspec/adapters/asyncpg/config.py

@@ -2,24 +2,24 @@ 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.utils.dataclass import simple_asdict
-from sqlspec.utils.empty import Empty, EmptyType
+from sqlspec.typing import Empty, EmptyType, dataclass_to_dict
 
 if TYPE_CHECKING:
     from asyncio import AbstractEventLoop
     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",
@@ -29,6 +29,8 @@ __all__ = (
 
 T = TypeVar("T")
 
+PgConnection: TypeAlias = Union[Connection, PoolConnectionProxy]
+
 
 @dataclass
 class AsyncPgPoolConfig(GenericPoolConfig):
@@ -71,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
@@ -98,7 +103,7 @@ class AsyncPgConfig(GenericDatabaseConfig):
             function.
         """
         if self.pool_config:
-            return simple_asdict(self.pool_config, exclude_empty=True, convert_nested=False)
+            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)
 
@@ -124,16 +129,7 @@ class AsyncPgConfig(GenericDatabaseConfig):
             )
         return self.pool_instance
 
-    @asynccontextmanager
-    async def lifespan(self, *args: Any, **kwargs) -> AsyncGenerator[None, None]:
-        db_pool = await self.create_pool()
-        try:
-            yield
-        finally:
-            db_pool.terminate()
-            await db_pool.close()
-
-    def provide_pool(self, *args: Any, **kwargs) -> Awaitable[Pool]:
+    def provide_pool(self, *args: Any, **kwargs: Any) -> Awaitable[Pool]:
         """Create a pool instance.
 
         Returns:
@@ -142,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/adapters/duckdb/__init__.py

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

sqlspec/adapters/duckdb/config.py

@@ -2,23 +2,71 @@ from __future__ import annotations
 
 from contextlib import contextmanager
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any
+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.utils.dataclass import simple_asdict
-from sqlspec.utils.empty import Empty, EmptyType
+from sqlspec.typing import Empty, EmptyType, dataclass_to_dict
 
 if TYPE_CHECKING:
-    from collections.abc import Generator
+    from collections.abc import Generator, Sequence
 
-    from duckdb import DuckDBPyConnection
 
-__all__ = ("DuckDBConfig",)
+__all__ = ("DuckDBConfig", "ExtensionConfig")
 
 
 @dataclass
-class DuckDBConfig(GenericDatabaseConfig):
+class ExtensionConfig:
+    """Configuration for a DuckDB extension.
+
+    This class provides configuration options for DuckDB extensions, including installation
+    and post-install configuration settings.
+
+    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:
+        """Create an ExtensionConfig from a configuration dictionary.
+
+        Args:
+            name: The name of the extension
+            config: Configuration dictionary that may contain settings
+
+        Returns:
+            A new ExtensionConfig instance
+        """
+        if config is None:
+            return cls(name=name)
+
+        if not isinstance(config, dict):
+            config = {"force_install": bool(config)}
+
+        install_args = {
+            key: config.pop(key)
+            for key in ["force_install", "repository", "repository_url", "version", "config", "name"]
+            if key in config
+        }
+        return cls(name=name, **install_args)
+
+
+@dataclass
+class DuckDBConfig(NoPoolConfig[DuckDBPyConnection], GenericDatabaseConfig):
     """Configuration for DuckDB database connections.
 
     This class provides configuration options for DuckDB database connections, wrapping all parameters
@@ -39,6 +87,73 @@ class DuckDBConfig(GenericDatabaseConfig):
     For details see: https://duckdb.org/docs/api/python/overview#connection-options
     """
 
+    extensions: Sequence[ExtensionConfig] | EmptyType = Empty
+    """A sequence of extension configurations to install and configure upon connection creation."""
+
+    def __post_init__(self) -> None:
+        """Post-initialization validation and processing.
+
+        This method handles merging extension configurations from both the extensions field
+        and the config dictionary, if present. The config['extensions'] field can be either:
+        - A dictionary mapping extension names to their configurations
+        - A list of extension names (which will be installed with force_install=True)
+
+        Raises:
+            ImproperConfigurationError: If there are duplicate extension configurations.
+        """
+        if self.config is Empty:
+            self.config = {}
+
+        if self.extensions is Empty:
+            self.extensions = []
+        # this is purely for mypy
+        assert isinstance(self.config, dict)  # noqa: S101
+        assert isinstance(self.extensions, list)  # noqa: S101
+
+        _e = self.config.pop("extensions", {})
+        if not isinstance(_e, (dict, list, tuple)):
+            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}  # pyright: ignore[reportUnknownVariableType,reportUnknownArgumentType]
+
+        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()])  # pyright: ignore[reportUnknownArgumentType,reportUnknownVariableType]
+
+    def _configure_extensions(self, connection: DuckDBPyConnection) -> None:
+        """Configure extensions for the connection.
+
+        Args:
+            connection: The DuckDB connection to configure extensions for.
+
+        Raises:
+            ImproperConfigurationError: If extension installation or configuration fails.
+        """
+        if self.extensions is Empty:
+            return
+
+        for extension in cast("list[ExtensionConfig]", self.extensions):
+            try:
+                if extension.force_install:
+                    connection.install_extension(
+                        extension=extension.name,
+                        force_install=extension.force_install,
+                        repository=extension.repository,
+                        repository_url=extension.repository_url,
+                        version=extension.version,
+                    )
+                connection.load_extension(extension.name)
+
+                if extension.config:
+                    for key, value in extension.config.items():
+                        connection.execute(f"SET {key}={value}")
+            except Exception as e:
+                msg = f"Failed to configure extension {extension.name}. Error: {e!s}"
+                raise ImproperConfigurationError(msg) from e
+
     @property
     def connection_config_dict(self) -> dict[str, Any]:
         """Return the connection configuration as a dict.
@@ -46,44 +161,30 @@ class DuckDBConfig(GenericDatabaseConfig):
         Returns:
             A string keyed dict of config kwargs for the duckdb.connect() function.
         """
-        config = simple_asdict(self, exclude_empty=True, convert_nested=False)
+        config = dataclass_to_dict(self, exclude_empty=True, exclude={"extensions"}, convert_nested=False)
         if not config.get("database"):
             config["database"] = ":memory:"
         return config
 
     def create_connection(self) -> DuckDBPyConnection:
-        """Create and return a new database connection.
+        """Create and return a new database connection with configured extensions.
 
         Returns:
-            A new DuckDB connection instance.
+            A new DuckDB connection instance with extensions installed and configured.
 
         Raises:
-            ImproperConfigurationError: If the connection could not be established.
+            ImproperConfigurationError: If the connection could not be established or extensions could not be configured.
         """
         import duckdb
 
         try:
-            return 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:
             msg = f"Could not configure the DuckDB connection. Error: {e!s}"
             raise ImproperConfigurationError(msg) from e
 
-    @contextmanager
-    def lifespan(self, *args: Any, **kwargs: Any) -> Generator[None, None, None]:
-        """Manage the lifecycle of a database connection.
-
-        Yields:
-            None
-
-        Raises:
-            ImproperConfigurationError: If the connection could not be established.
-        """
-        connection = self.create_connection()
-        try:
-            yield
-        finally:
-            connection.close()
-
     @contextmanager
     def provide_connection(self, *args: Any, **kwargs: Any) -> Generator[DuckDBPyConnection, None, None]:
         """Create and provide a database connection.

sqlspec/adapters/oracledb/__init__.py

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

sqlspec/adapters/oracledb/config/_asyncio.py

@@ -13,7 +13,7 @@ from sqlspec.adapters.oracledb.config._common import (
     OracleGenericPoolConfig,
 )
 from sqlspec.exceptions import ImproperConfigurationError
-from sqlspec.utils.dataclass import simple_asdict
+from sqlspec.typing import dataclass_to_dict
 
 if TYPE_CHECKING:
     from collections.abc import AsyncGenerator, Awaitable
@@ -26,16 +26,24 @@ __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
+    """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]:
@@ -46,7 +54,7 @@ class OracleAsyncDatabaseConfig(OracleGenericDatabaseConfig[AsyncConnectionPool,
             function.
         """
         if self.pool_config is not None:
-            return simple_asdict(self.pool_config, exclude_empty=True, convert_nested=False)
+            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)
 
@@ -65,20 +73,12 @@ 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
 
-    @asynccontextmanager
-    async def lifespan(self, *args: Any, **kwargs) -> AsyncGenerator[None, None]:
-        db_pool = await self.create_pool()
-        try:
-            yield
-        finally:
-            await db_pool.close(force=True)
-
-    def provide_pool(self, *args: Any, **kwargs) -> Awaitable[AsyncConnectionPool]:
+    def provide_pool(self, *args: Any, **kwargs: Any) -> Awaitable[AsyncConnectionPool]:
         """Create a pool instance.
 
         Returns: