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

sqlspec/extensions/litestar/config.py

@@ -0,0 +1,81 @@
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Callable, Literal, Optional, Union
+
+from sqlspec.base import (
+    ConnectionT,
+    PoolT,
+)
+from sqlspec.exceptions import ImproperConfigurationError
+from sqlspec.extensions.litestar.handlers import (
+    autocommit_handler_maker,
+    connection_provider_maker,
+    lifespan_handler_maker,
+    manual_handler_maker,
+    pool_provider_maker,
+)
+
+if TYPE_CHECKING:
+    from collections.abc import Awaitable
+    from contextlib import AbstractAsyncContextManager
+
+    from litestar import Litestar
+    from litestar.datastructures.state import State
+    from litestar.types import BeforeMessageSendHookHandler, Scope
+
+    from sqlspec.base import (
+        AsyncConfigT,
+        ConnectionT,
+        PoolT,
+        SyncConfigT,
+    )
+
+CommitMode = Literal["manual", "autocommit", "autocommit_include_redirect"]
+DEFAULT_COMMIT_MODE: CommitMode = "manual"
+DEFAULT_CONNECTION_KEY = "db_connection"
+DEFAULT_POOL_KEY = "db_pool"
+
+
+@dataclass
+class DatabaseConfig:
+    config: "Union[SyncConfigT, AsyncConfigT]" = field()  # type: ignore[valid-type]   # pyright: ignore[reportGeneralTypeIssues]
+    connection_key: str = field(default=DEFAULT_CONNECTION_KEY)
+    pool_key: str = field(default=DEFAULT_POOL_KEY)
+    commit_mode: "CommitMode" = field(default=DEFAULT_COMMIT_MODE)
+    extra_commit_statuses: "Optional[set[int]]" = field(default=None)
+    extra_rollback_statuses: "Optional[set[int]]" = field(default=None)
+    connection_provider: "Callable[[State,Scope], Awaitable[ConnectionT]]" = field(init=False, repr=False, hash=False)  # pyright: ignore[reportGeneralTypeIssues]
+    pool_provider: "Callable[[State,Scope], Awaitable[PoolT]]" = field(init=False, repr=False, hash=False)  # pyright: ignore[reportGeneralTypeIssues]
+    before_send_handler: "BeforeMessageSendHookHandler" = field(init=False, repr=False, hash=False)
+    lifespan_handler: "Callable[[Litestar], AbstractAsyncContextManager[None]]" = field(
+        init=False,
+        repr=False,
+        hash=False,
+    )
+    annotation: "type[Union[SyncConfigT, AsyncConfigT]]" = field(init=False, repr=False, hash=False)  # type: ignore[valid-type]   # pyright: ignore[reportGeneralTypeIssues]
+
+    def __post_init__(self) -> None:
+        if not self.config.support_connection_pooling and self.pool_key == DEFAULT_POOL_KEY:  # type: ignore[union-attr,unused-ignore]
+            """If the database configuration does not support connection pooling, the pool key must be unique.  We just automatically generate a unique identify so it won't conflict with other configs that may get added"""
+            self.pool_key = f"_{self.pool_key}_{id(self.config)}"
+        if self.commit_mode == "manual":
+            self.before_send_handler = manual_handler_maker(connection_scope_key=self.connection_key)
+        elif self.commit_mode == "autocommit":
+            self.before_send_handler = autocommit_handler_maker(
+                commit_on_redirect=False,
+                extra_commit_statuses=self.extra_commit_statuses,
+                extra_rollback_statuses=self.extra_rollback_statuses,
+                connection_scope_key=self.connection_key,
+            )
+        elif self.commit_mode == "autocommit_include_redirect":
+            self.before_send_handler = autocommit_handler_maker(
+                commit_on_redirect=True,
+                extra_commit_statuses=self.extra_commit_statuses,
+                extra_rollback_statuses=self.extra_rollback_statuses,
+                connection_scope_key=self.connection_key,
+            )
+        else:
+            msg = f"Invalid commit mode: {self.commit_mode}"  # type: ignore[unreachable]
+            raise ImproperConfigurationError(detail=msg)
+        self.lifespan_handler = lifespan_handler_maker(config=self.config, pool_key=self.pool_key)
+        self.connection_provider = connection_provider_maker(connection_key=self.connection_key, config=self.config)
+        self.pool_provider = pool_provider_maker(pool_key=self.pool_key, config=self.config)

sqlspec/extensions/litestar/handlers.py

@@ -0,0 +1,188 @@
+import contextlib
+from typing import TYPE_CHECKING, Any, Callable, Optional, cast
+
+from litestar.constants import HTTP_DISCONNECT, HTTP_RESPONSE_START, WEBSOCKET_CLOSE, WEBSOCKET_DISCONNECT
+
+from sqlspec.exceptions import ImproperConfigurationError
+from sqlspec.extensions.litestar._utils import (
+    delete_sqlspec_scope_state,
+    get_sqlspec_scope_state,
+    set_sqlspec_scope_state,
+)
+from sqlspec.utils.sync_tools import maybe_async_
+
+if TYPE_CHECKING:
+    from collections.abc import AsyncGenerator, Awaitable, Coroutine
+    from contextlib import AbstractAsyncContextManager
+
+    from litestar import Litestar
+    from litestar.datastructures.state import State
+    from litestar.types import Message, Scope
+
+    from sqlspec.base import ConnectionT, DatabaseConfigProtocol, DriverT, PoolT
+
+
+SESSION_TERMINUS_ASGI_EVENTS = {HTTP_RESPONSE_START, HTTP_DISCONNECT, WEBSOCKET_DISCONNECT, WEBSOCKET_CLOSE}
+"""ASGI events that terminate a session scope."""
+
+
+def manual_handler_maker(connection_scope_key: str) -> "Callable[[Message, Scope], Coroutine[Any, Any, None]]":
+    """Set up the handler to issue a transaction commit or rollback based on specified status codes
+    Args:
+        connection_scope_key: The key to use within the application state
+
+    Returns:
+        The handler callable
+    """
+
+    async def handler(message: "Message", scope: "Scope") -> None:
+        """Handle commit/rollback, closing and cleaning up sessions before sending.
+
+        Args:
+            message: ASGI-``Message``
+            scope: An ASGI-``Scope``
+
+        """
+        connection = get_sqlspec_scope_state(scope, connection_scope_key)
+        if connection and message["type"] in SESSION_TERMINUS_ASGI_EVENTS:
+            with contextlib.suppress(Exception):
+                await maybe_async_(connection.close)()
+            delete_sqlspec_scope_state(scope, connection_scope_key)
+
+    return handler
+
+
+def autocommit_handler_maker(
+    connection_scope_key: str,
+    commit_on_redirect: bool = False,
+    extra_commit_statuses: "Optional[set[int]]" = None,
+    extra_rollback_statuses: "Optional[set[int]]" = None,
+) -> "Callable[[Message, Scope], Coroutine[Any, Any, None]]":
+    """Set up the handler to issue a transaction commit or rollback based on specified status codes
+    Args:
+        commit_on_redirect: Issue a commit when the response status is a redirect (``3XX``)
+        extra_commit_statuses: A set of additional status codes that trigger a commit
+        extra_rollback_statuses: A set of additional status codes that trigger a rollback
+        connection_scope_key: The key to use within the application state
+
+    Raises:
+        ImproperConfigurationError: If extra_commit_statuses and extra_rollback_statuses share any status codes
+
+    Returns:
+        The handler callable
+    """
+    if extra_commit_statuses is None:
+        extra_commit_statuses = set()
+
+    if extra_rollback_statuses is None:
+        extra_rollback_statuses = set()
+
+    if len(extra_commit_statuses & extra_rollback_statuses) > 0:
+        msg = "Extra rollback statuses and commit statuses must not share any status codes"
+        raise ImproperConfigurationError(msg)
+
+    commit_range = range(200, 400 if commit_on_redirect else 300)
+
+    async def handler(message: "Message", scope: "Scope") -> None:
+        """Handle commit/rollback, closing and cleaning up sessions before sending.
+
+        Args:
+            message: ASGI-``litestar.types.Message``
+            scope: An ASGI-``litestar.types.Scope``
+
+        """
+        connection = get_sqlspec_scope_state(scope, connection_scope_key)
+        try:
+            if connection is not None and message["type"] == HTTP_RESPONSE_START:
+                if (message["status"] in commit_range or message["status"] in extra_commit_statuses) and message[
+                    "status"
+                ] not in extra_rollback_statuses:
+                    await maybe_async_(connection.commit)()
+                else:
+                    await maybe_async_(connection.rollback)()
+        finally:
+            if connection and message["type"] in SESSION_TERMINUS_ASGI_EVENTS:
+                with contextlib.suppress(Exception):
+                    await maybe_async_(connection.close)()
+                delete_sqlspec_scope_state(scope, connection_scope_key)
+
+    return handler
+
+
+def lifespan_handler_maker(
+    config: "DatabaseConfigProtocol[Any, Any, Any]",
+    pool_key: str,
+) -> "Callable[[Litestar], AbstractAsyncContextManager[None]]":
+    """Build the lifespan handler for the database configuration.
+
+    Args:
+        config: The database configuration.
+        pool_key: The key to use for the connection pool within Litestar.
+
+    Returns:
+        The generated lifespan handler for the connection.
+    """
+
+    @contextlib.asynccontextmanager
+    async def lifespan_handler(app: "Litestar") -> "AsyncGenerator[None, None]":
+        db_pool = await maybe_async_(config.create_pool)()
+        app.state.update({pool_key: db_pool})
+        try:
+            yield
+        finally:
+            app.state.pop(pool_key, None)
+            try:
+                await maybe_async_(config.close_pool)()
+            except Exception as e:  # noqa: BLE001
+                if app.logger:
+                    app.logger.warning("Error closing database pool for %s. Error: %s", pool_key, e)
+
+    return lifespan_handler
+
+
+def connection_provider_maker(
+    connection_key: str,
+    config: "DatabaseConfigProtocol[ConnectionT, PoolT, DriverT]",
+) -> "Callable[[State,Scope], Awaitable[ConnectionT]]":
+    """Build the connection provider for the database configuration.
+
+    Args:
+        connection_key: The dependency key to use for the session within Litestar.
+        config: The database configuration.
+
+    Returns:
+        The generated connection provider for the connection.
+    """
+
+    async def provide_connection(state: "State", scope: "Scope") -> "ConnectionT":
+        connection = get_sqlspec_scope_state(scope, connection_key)
+        if connection is None:
+            connection = await maybe_async_(config.create_connection)()
+            set_sqlspec_scope_state(scope, connection_key, connection)
+        return cast("ConnectionT", connection)
+
+    return provide_connection
+
+
+def pool_provider_maker(
+    pool_key: str,
+    config: "DatabaseConfigProtocol[ConnectionT, PoolT, DriverT]",
+) -> "Callable[[State,Scope], Awaitable[PoolT]]":
+    """Build the pool provider for the database configuration.
+
+    Args:
+        pool_key: The dependency key to use for the pool within Litestar.
+        config: The database configuration.
+
+    Returns:
+        The generated connection pool for the database.
+    """
+
+    async def provide_pool(state: "State", scope: "Scope") -> "PoolT":
+        pool = get_sqlspec_scope_state(scope, pool_key)
+        if pool is None:
+            pool = await maybe_async_(config.create_pool)()
+            set_sqlspec_scope_state(scope, pool_key, pool)
+        return cast("PoolT", pool)
+
+    return provide_pool

sqlspec/extensions/litestar/plugin.py

@@ -1,34 +1,63 @@
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, Literal, Union
 
+from litestar.di import Provide
 from litestar.plugins import InitPluginProtocol
 
+from sqlspec.base import (
+    AsyncConfigT,
+    ConnectionT,
+    DatabaseConfigProtocol,
+    PoolT,
+    SyncConfigT,
+)
+from sqlspec.base import SQLSpec as SQLSpecBase
+from sqlspec.exceptions import ImproperConfigurationError
+from sqlspec.extensions.litestar.config import DatabaseConfig
+
 if TYPE_CHECKING:
+    from click import Group
     from litestar.config.app import AppConfig
 
-    from sqlspec.base import ConfigManager
+
+CommitMode = Literal["manual", "autocommit", "autocommit_include_redirect"]
+DEFAULT_COMMIT_MODE: CommitMode = "manual"
+DEFAULT_CONNECTION_KEY = "db_connection"
+DEFAULT_POOL_KEY = "db_pool"
 
 
-class SQLSpecPlugin(InitPluginProtocol):
+class SQLSpec(InitPluginProtocol, SQLSpecBase):
     """SQLSpec plugin."""
 
-    __slots__ = ("_config",)
+    __slots__ = ("_config", "_plugin_configs")
 
-    def __init__(self, config: "ConfigManager") -> None:
+    def __init__(
+        self,
+        config: Union["SyncConfigT", "AsyncConfigT", "DatabaseConfig", list["DatabaseConfig"]],
+    ) -> None:
         """Initialize ``SQLSpecPlugin``.
 
         Args:
             config: configure SQLSpec plugin for use with Litestar.
         """
-        self._config = config
+        self._configs: dict[Any, DatabaseConfigProtocol[Any, Any, Any]] = {}
+        if isinstance(config, DatabaseConfigProtocol):
+            self._plugin_configs: list[DatabaseConfig] = [DatabaseConfig(config=config)]
+        elif isinstance(config, DatabaseConfig):
+            self._plugin_configs = [config]
+        else:
+            self._plugin_configs = config
 
     @property
-    def config(self) -> "ConfigManager":
+    def config(self) -> "list[DatabaseConfig]":  # pyright: ignore[reportInvalidTypeVarUse]
         """Return the plugin config.
 
         Returns:
             ConfigManager.
         """
-        return self._config
+        return self._plugin_configs
+
+    def on_cli_init(self, cli: "Group") -> None:
+        """Configure the CLI for use with SQLSpec."""
 
     def on_app_init(self, app_config: "AppConfig") -> "AppConfig":
         """Configure application for use with SQLSpec.
@@ -39,8 +68,68 @@ class SQLSpecPlugin(InitPluginProtocol):
         Returns:
             The updated :class:`AppConfig <.config.app.AppConfig>` instance.
         """
+        self._validate_dependency_keys()
+        app_config.signature_types.extend(
+            [
+                SQLSpec,
+                ConnectionT,
+                PoolT,
+                DatabaseConfig,
+                DatabaseConfigProtocol,
+                SyncConfigT,
+                AsyncConfigT,
+            ]
+        )
+        for c in self._plugin_configs:
+            c.annotation = self.add_config(c.config)
+            app_config.before_send.append(c.before_send_handler)
+            app_config.lifespan.append(c.lifespan_handler)  # pyright: ignore[reportUnknownMemberType]
+            app_config.dependencies.update(
+                {c.connection_key: Provide(c.connection_provider), c.pool_key: Provide(c.pool_provider)},
+            )
 
-        from sqlspec.base import ConfigManager
-
-        app_config.signature_types.append(ConfigManager)
         return app_config
+
+    def get_annotations(self) -> "list[type[Union[SyncConfigT, AsyncConfigT]]]":  # pyright: ignore[reportInvalidTypeVarUse]
+        """Return the list of annotations.
+
+        Returns:
+            List of annotations.
+        """
+        return [c.annotation for c in self.config]
+
+    def get_annotation(
+        self,
+        key: "Union[str, SyncConfigT, AsyncConfigT, type[Union[SyncConfigT, AsyncConfigT]]]",
+    ) -> "type[Union[SyncConfigT, AsyncConfigT]]":
+        """Return the annotation for the given configuration.
+
+        Args:
+            key: The configuration instance or key to lookup
+
+        Raises:
+            KeyError: If no configuration is found for the given key.
+
+        Returns:
+            The annotation for the configuration.
+        """
+        for c in self.config:
+            if key == c.config or key in {c.annotation, c.connection_key, c.pool_key}:
+                return c.annotation
+        msg = f"No configuration found for {key}"
+        raise KeyError(msg)
+
+    def _validate_dependency_keys(self) -> None:
+        """Verify uniqueness of ``connection_key`` and ``pool_key``.
+
+        Raises:
+            ImproperConfigurationError: If session keys or pool keys are not unique.
+        """
+        connection_keys = [c.connection_key for c in self.config]
+        pool_keys = [c.pool_key for c in self.config]
+        if len(set(connection_keys)) != len(connection_keys):
+            msg = "When using multiple database configuration, each configuration must have a unique `connection_key`."
+            raise ImproperConfigurationError(detail=msg)
+        if len(set(pool_keys)) != len(pool_keys):
+            msg = "When using multiple database configuration, each configuration must have a unique `pool_key`."
+            raise ImproperConfigurationError(detail=msg)

sqlspec/typing.py

@@ -11,6 +11,7 @@ from sqlspec._typing import (
     UNSET,
     BaseModel,
     DataclassProtocol,
+    DTOData,
     Empty,
     EmptyType,
     Struct,
@@ -38,26 +39,53 @@ FilterTypeT = TypeVar("FilterTypeT", bound="StatementFilter")
 
 :class:`~advanced_alchemy.filters.StatementFilter`
 """
+SupportedSchemaModel: TypeAlias = "Union[Struct, BaseModel, DataclassProtocol]"
+"""Type alias for pydantic or msgspec models.
 
+:class:`msgspec.Struct` | :class:`pydantic.BaseModel` | :class:`DataclassProtocol`
+"""
+ModelDTOT = TypeVar("ModelDTOT", bound="SupportedSchemaModel")
+"""Type variable for model DTOs.
 
-SupportedSchemaModel: TypeAlias = Union[Struct, BaseModel]
+:class:`msgspec.Struct`|:class:`pydantic.BaseModel`
+"""
+PydanticOrMsgspecT = SupportedSchemaModel
 """Type alias for pydantic or msgspec models.
 
 :class:`msgspec.Struct` or :class:`pydantic.BaseModel`
 """
-ModelDictT: TypeAlias = "Union[dict[str, Any], ModelT ]"
+ModelDict: TypeAlias = "Union[dict[str, Any], SupportedSchemaModel, DTOData[SupportedSchemaModel]]"
 """Type alias for model dictionaries.
 
 Represents:
 - :type:`dict[str, Any]` | :class:`DataclassProtocol` | :class:`msgspec.Struct` |  :class:`pydantic.BaseModel`
 """
-ModelDictListT: TypeAlias = "Sequence[Union[dict[str, Any], ModelT ]]"
+ModelDictList: TypeAlias = "Sequence[Union[dict[str, Any], SupportedSchemaModel]]"
 """Type alias for model dictionary lists.
 
 A list or sequence of any of the following:
 - :type:`Sequence`[:type:`dict[str, Any]` | :class:`DataclassProtocol` | :class:`msgspec.Struct` | :class:`pydantic.BaseModel`]
 
 """
+BulkModelDict: TypeAlias = (
+    "Union[Sequence[Union[dict[str, Any], SupportedSchemaModel]], DTOData[list[SupportedSchemaModel]]]"
+)
+"""Type alias for bulk model dictionaries.
+
+Represents:
+- :type:`Sequence`[:type:`dict[str, Any]` | :class:`DataclassProtocol` | :class:`msgspec.Struct` | :class:`pydantic.BaseModel`]
+- :class:`DTOData`[:type:`list[ModelT]`]
+"""
+
+StatementParameterType: TypeAlias = "Union[dict[str, Any], list[Any], tuple[Any, ...], None]"
+"""Type alias for parameter types.
+
+Represents:
+- :type:`dict[str, Any]`
+- :type:`list[Any]`
+- :type:`tuple[Any, ...]`
+- :type:`None`
+"""
 
 
 def is_dataclass_instance(obj: Any) -> "TypeGuard[DataclassProtocol]":
@@ -286,7 +314,14 @@ def is_schema_or_dict_without_field(
 
 
 def is_dataclass(obj: "Any") -> "TypeGuard[DataclassProtocol]":
-    """Check if an object is a dataclass."""
+    """Check if an object is a dataclass.
+
+    Args:
+        obj: Value to check.
+
+    Returns:
+        bool
+    """
     return is_dataclass_instance(obj)
 
 
@@ -294,17 +329,33 @@ def is_dataclass_with_field(
     obj: "Any",
     field_name: str,
 ) -> "TypeGuard[object]":  # Can't specify dataclass type directly
-    """Check if an object is a dataclass and has a specific field."""
+    """Check if an object is a dataclass and has a specific field.
+
+    Args:
+        obj: Value to check.
+        field_name: Field name to check for.
+
+    Returns:
+        bool
+    """
     return is_dataclass(obj) and hasattr(obj, field_name)
 
 
 def is_dataclass_without_field(obj: "Any", field_name: str) -> "TypeGuard[object]":
-    """Check if an object is a dataclass and does not have a specific field."""
+    """Check if an object is a dataclass and does not have a specific field.
+
+    Args:
+        obj: Value to check.
+        field_name: Field name to check for.
+
+    Returns:
+        bool
+    """
     return is_dataclass(obj) and not hasattr(obj, field_name)
 
 
 def extract_dataclass_fields(
-    dt: "DataclassProtocol",
+    obj: "DataclassProtocol",
     exclude_none: bool = False,
     exclude_empty: bool = False,
     include: "Optional[AbstractSet[str]]" = None,
@@ -313,12 +364,14 @@ def extract_dataclass_fields(
     """Extract dataclass fields.
 
     Args:
-        dt: A dataclass instance.
+        obj: A dataclass instance.
         exclude_none: Whether to exclude None values.
         exclude_empty: Whether to exclude Empty values.
         include: An iterable of fields to include.
         exclude: An iterable of fields to exclude.
 
+    Raises:
+        ValueError: If there are fields that are both included and excluded.
 
     Returns:
         A tuple of dataclass fields.
@@ -330,11 +383,11 @@ def extract_dataclass_fields(
         msg = f"Fields {common} are both included and excluded."
         raise ValueError(msg)
 
-    dataclass_fields: Iterable[Field[Any]] = fields(dt)
+    dataclass_fields: Iterable[Field[Any]] = fields(obj)
     if exclude_none:
-        dataclass_fields = (field for field in dataclass_fields if getattr(dt, field.name) is not None)
+        dataclass_fields = (field for field in dataclass_fields if getattr(obj, field.name) is not None)
     if exclude_empty:
-        dataclass_fields = (field for field in dataclass_fields if getattr(dt, field.name) is not Empty)
+        dataclass_fields = (field for field in dataclass_fields if getattr(obj, field.name) is not Empty)
     if include:
         dataclass_fields = (field for field in dataclass_fields if field.name in include)
     if exclude:
@@ -344,7 +397,7 @@ def extract_dataclass_fields(
 
 
 def extract_dataclass_items(
-    dt: "DataclassProtocol",
+    obj: "DataclassProtocol",
     exclude_none: bool = False,
     exclude_empty: bool = False,
     include: "Optional[AbstractSet[str]]" = None,
@@ -355,7 +408,7 @@ def extract_dataclass_items(
     Unlike the 'asdict' method exports by the stdlib, this function does not pickle values.
 
     Args:
-        dt: A dataclass instance.
+        obj: A dataclass instance.
         exclude_none: Whether to exclude None values.
         exclude_empty: Whether to exclude Empty values.
         include: An iterable of fields to include.
@@ -364,8 +417,8 @@ def extract_dataclass_items(
     Returns:
         A tuple of key/value pairs.
     """
-    dataclass_fields = extract_dataclass_fields(dt, exclude_none, exclude_empty, include, exclude)
-    return tuple((field.name, getattr(dt, field.name)) for field in dataclass_fields)
+    dataclass_fields = extract_dataclass_fields(obj, exclude_none, exclude_empty, include, exclude)
+    return tuple((field.name, getattr(obj, field.name)) for field in dataclass_fields)
 
 
 def dataclass_to_dict(
@@ -442,9 +495,11 @@ __all__ = (
     "EmptyType",
     "FailFast",
     "FilterTypeT",
-    "ModelDictListT",
-    "ModelDictT",
+    "ModelDict",
+    "ModelDictList",
+    "StatementParameterType",
     "Struct",
+    "SupportedSchemaModel",
     "TypeAdapter",
     "UnsetType",
     "convert",

sqlspec/utils/__init__.py

@@ -0,0 +1,3 @@
+from sqlspec.utils import deprecation, fixtures, module_loader, sync_tools, text
+
+__all__ = ("deprecation", "fixtures", "module_loader", "sync_tools", "text")

sqlspec/utils/fixtures.py

@@ -19,7 +19,7 @@ def open_fixture(fixtures_path: "Union[Path, AsyncPath]", fixture_name: str) ->
         fixture_name (str): The fixture name to load.
 
     Raises:
-        :class:`FileNotFoundError`: Fixtures not found.
+        FileNotFoundError: Fixtures not found.
 
     Returns:
         Any: The parsed JSON data
@@ -43,8 +43,8 @@ async def open_fixture_async(fixtures_path: "Union[Path, AsyncPath]", fixture_na
         fixture_name (str): The fixture name to load.
 
     Raises:
-        :class:`~advanced_alchemy.exceptions.MissingDependencyError`: The `anyio` library is required to use this function.
-        :class:`FileNotFoundError`: Fixtures not found.
+        FileNotFoundError: Fixtures not found.
+        MissingDependencyError: The `anyio` library is required to use this function.
 
     Returns:
         Any: The parsed JSON data
@@ -52,8 +52,7 @@ async def open_fixture_async(fixtures_path: "Union[Path, AsyncPath]", fixture_na
     try:
         from anyio import Path as AsyncPath
     except ImportError as exc:
-        msg = "The `anyio` library is required to use this function. Please install it with `pip install anyio`."
-        raise MissingDependencyError(msg) from exc
+        raise MissingDependencyError(package="anyio") from exc
 
     fixture = AsyncPath(fixtures_path / f"{fixture_name}.json")
     if await fixture.exists():