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

sqlspec/adapters/psycopg/config/_sync.py

@@ -7,10 +7,8 @@ from typing import TYPE_CHECKING
 from psycopg import Connection
 from psycopg_pool import ConnectionPool
 
-from sqlspec.adapters.psycopg.config._common import (
-    PsycoPgGenericDatabaseConfig,
-    PsycoPgGenericPoolConfig,
-)
+from sqlspec.adapters.psycopg.config._common import PsycoPgGenericPoolConfig
+from sqlspec.base import SyncDatabaseConfig
 from sqlspec.exceptions import ImproperConfigurationError
 from sqlspec.typing import dataclass_to_dict
 
@@ -26,13 +24,19 @@ __all__ = (
 
 
 @dataclass
-class PsycoPgSyncPoolConfig(PsycoPgGenericPoolConfig[ConnectionPool, Connection]):
+class PsycoPgSyncPoolConfig(PsycoPgGenericPoolConfig[Connection, ConnectionPool]):
     """Sync Psycopg Pool Config"""
 
 
 @dataclass
-class PsycoPgSyncDatabaseConfig(PsycoPgGenericDatabaseConfig[ConnectionPool, Connection]):
-    """Sync Psycopg database Configuration."""
+class PsycoPgSyncDatabaseConfig(SyncDatabaseConfig[Connection, ConnectionPool]):
+    """Sync Psycopg database Configuration.
+    This class provides the base configuration for Psycopg database connections, extending
+    the generic database configuration with Psycopg-specific settings.([1](https://www.psycopg.org/psycopg3/docs/api/connections.html))
+
+    The configuration supports all standard Psycopg connection parameters and can be used
+    with both synchronous and asynchronous connections.([2](https://www.psycopg.org/psycopg3/docs/api/connections.html))
+    """
 
     pool_config: PsycoPgSyncPoolConfig | None = None
     """Psycopg Pool configuration"""
@@ -58,7 +62,7 @@ class PsycoPgSyncDatabaseConfig(PsycoPgGenericDatabaseConfig[ConnectionPool, Con
 
         pool_config = self.pool_config_dict
         self.pool_instance = ConnectionPool(**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."  # type: ignore[unreachable]
             raise ImproperConfigurationError(msg)
         return self.pool_instance

sqlspec/adapters/sqlite/config.py

@@ -4,7 +4,7 @@ from contextlib import contextmanager
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, Literal
 
-from sqlspec.config import GenericDatabaseConfig
+from sqlspec.base import NoPoolSyncConfig
 from sqlspec.exceptions import ImproperConfigurationError
 from sqlspec.typing import Empty, EmptyType, dataclass_to_dict
 
@@ -16,7 +16,7 @@ __all__ = ("SqliteConfig",)
 
 
 @dataclass
-class SqliteConfig(GenericDatabaseConfig):
+class SqliteConfig(NoPoolSyncConfig["Connection"]):
     """Configuration for SQLite database connections.
 
     This class provides configuration options for SQLite database connections, wrapping all parameters
@@ -25,7 +25,7 @@ class SqliteConfig(GenericDatabaseConfig):
     For details see: https://docs.python.org/3/library/sqlite3.html#sqlite3.connect
     """
 
-    database: str
+    database: str = ":memory:"
     """The path to the database file to be opened. Pass ":memory:" to open a connection to a database that resides in RAM instead of on disk."""
 
     timeout: float | EmptyType = Empty

sqlspec/base.py

@@ -0,0 +1,221 @@
+from abc import ABC, abstractmethod
+from collections.abc import AsyncGenerator, Awaitable, Generator
+from contextlib import AbstractAsyncContextManager, AbstractContextManager
+from dataclasses import dataclass
+from typing import Annotated, Any, ClassVar, Generic, TypeVar, Union, cast, overload
+
+__all__ = (
+    "AsyncDatabaseConfig",
+    "DatabaseConfigProtocol",
+    "GenericPoolConfig",
+    "NoPoolAsyncConfig",
+    "NoPoolSyncConfig",
+    "SyncDatabaseConfig",
+)
+
+ConnectionT = TypeVar("ConnectionT")
+PoolT = TypeVar("PoolT")
+AsyncConfigT = TypeVar("AsyncConfigT", bound="Union[AsyncDatabaseConfig[Any, Any], NoPoolAsyncConfig[Any]]")
+SyncConfigT = TypeVar("SyncConfigT", bound="Union[SyncDatabaseConfig[Any, Any], NoPoolSyncConfig[Any]]")
+
+
+@dataclass
+class DatabaseConfigProtocol(Generic[ConnectionT, PoolT], ABC):
+    """Protocol defining the interface for database configurations."""
+
+    __is_async__: ClassVar[bool] = False
+    __supports_connection_pooling__: ClassVar[bool] = False
+
+    def __hash__(self) -> int:
+        return id(self)
+
+    @abstractmethod
+    def create_connection(self) -> Union[ConnectionT, Awaitable[ConnectionT]]:
+        """Create and return a new database connection."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def provide_connection(
+        self, *args: Any, **kwargs: Any
+    ) -> Union[
+        Generator[ConnectionT, None, None],
+        AsyncGenerator[ConnectionT, None],
+        AbstractContextManager[ConnectionT],
+        AbstractAsyncContextManager[ConnectionT],
+    ]:
+        """Provide a database connection context manager."""
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def connection_config_dict(self) -> dict[str, Any]:
+        """Return the connection configuration as a dict."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def create_pool(self) -> Union[PoolT, Awaitable[PoolT]]:
+        """Create and return connection pool."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def provide_pool(
+        self, *args: Any, **kwargs: Any
+    ) -> Union[PoolT, Awaitable[PoolT], AbstractContextManager[PoolT], AbstractAsyncContextManager[PoolT]]:
+        """Provide pool instance."""
+        raise NotImplementedError
+
+    @property
+    def is_async(self) -> bool:
+        """Return whether the configuration is for an async database."""
+        return self.__is_async__
+
+    @property
+    def support_connection_pooling(self) -> bool:
+        """Return whether the configuration supports connection pooling."""
+        return self.__supports_connection_pooling__
+
+
+class NoPoolSyncConfig(DatabaseConfigProtocol[ConnectionT, None]):
+    """Base class for a sync database configurations that do not implement a pool."""
+
+    __is_async__ = False
+    __supports_connection_pooling__ = False
+
+    def create_pool(self) -> None:
+        """This database backend has not implemented the pooling configurations."""
+        return
+
+    def provide_pool(self, *args: Any, **kwargs: Any) -> None:
+        """This database backend has not implemented the pooling configurations."""
+        return
+
+
+class NoPoolAsyncConfig(DatabaseConfigProtocol[ConnectionT, None]):
+    """Base class for an async database configurations that do not implement a pool."""
+
+    __is_async__ = True
+    __supports_connection_pooling__ = False
+
+    async def create_pool(self) -> None:
+        """This database backend has not implemented the pooling configurations."""
+        return
+
+    def provide_pool(self, *args: Any, **kwargs: Any) -> None:
+        """This database backend has not implemented the pooling configurations."""
+        return
+
+
+@dataclass
+class GenericPoolConfig:
+    """Generic Database Pool Configuration."""
+
+
+@dataclass
+class SyncDatabaseConfig(DatabaseConfigProtocol[ConnectionT, PoolT]):
+    """Generic Sync Database Configuration."""
+
+    __is_async__ = False
+    __supports_connection_pooling__ = True
+
+
+@dataclass
+class AsyncDatabaseConfig(DatabaseConfigProtocol[ConnectionT, PoolT]):
+    """Generic Async Database Configuration."""
+
+    __is_async__ = True
+    __supports_connection_pooling__ = True
+
+
+class ConfigManager:
+    """Type-safe configuration manager with literal inference."""
+
+    def __init__(self) -> None:
+        self._configs: dict[Any, DatabaseConfigProtocol[Any, Any]] = {}
+
+    @overload
+    def add_config(self, config: SyncConfigT) -> type[SyncConfigT]: ...
+
+    @overload
+    def add_config(self, config: AsyncConfigT) -> type[AsyncConfigT]: ...
+
+    def add_config(
+        self,
+        config: Union[
+            SyncConfigT,
+            AsyncConfigT,
+        ],
+    ) -> Union[Annotated[type[SyncConfigT], int], Annotated[type[AsyncConfigT], int]]:  # pyright: ignore[reportInvalidTypeVarUse]
+        """Add a new configuration to the manager."""
+        key = Annotated[type(config), id(config)]  # type: ignore[valid-type]
+        self._configs[key] = config
+        return key  # type: ignore[return-value]  # pyright: ignore[reportReturnType]
+
+    @overload
+    def get_config(self, name: type[SyncConfigT]) -> SyncConfigT: ...
+
+    @overload
+    def get_config(self, name: type[AsyncConfigT]) -> AsyncConfigT: ...
+
+    def get_config(
+        self, name: Union[type[DatabaseConfigProtocol[ConnectionT, PoolT]], Any]
+    ) -> DatabaseConfigProtocol[ConnectionT, PoolT]:
+        """Retrieve a configuration by its type."""
+        config = self._configs.get(name)
+        if not config:
+            raise KeyError(f"No configuration found for {name}")
+        return config
+
+    @overload
+    def get_connection(
+        self,
+        name: Union[
+            type[NoPoolSyncConfig[ConnectionT]],
+            type[SyncDatabaseConfig[ConnectionT, PoolT]],
+        ],
+    ) -> ConnectionT: ...  # pyright: ignore[reportInvalidTypeVarUse]
+
+    @overload
+    def get_connection(
+        self,
+        name: Union[
+            type[NoPoolAsyncConfig[ConnectionT]],
+            type[AsyncDatabaseConfig[ConnectionT, PoolT]],
+        ],
+    ) -> Awaitable[ConnectionT]: ...  # pyright: ignore[reportInvalidTypeVarUse]
+
+    def get_connection(
+        self,
+        name: Union[
+            type[NoPoolSyncConfig[ConnectionT]],
+            type[NoPoolAsyncConfig[ConnectionT]],
+            type[SyncDatabaseConfig[ConnectionT, PoolT]],
+            type[AsyncDatabaseConfig[ConnectionT, PoolT]],
+        ],
+    ) -> Union[ConnectionT, Awaitable[ConnectionT]]:
+        """Create and return a connection from the specified configuration."""
+        config = self.get_config(name)
+        return config.create_connection()
+
+    @overload
+    def get_pool(self, name: type[Union[NoPoolSyncConfig[ConnectionT], NoPoolAsyncConfig[ConnectionT]]]) -> None: ...  # pyright: ignore[reportInvalidTypeVarUse]
+
+    @overload
+    def get_pool(self, name: type[SyncDatabaseConfig[ConnectionT, PoolT]]) -> type[PoolT]: ...  # pyright: ignore[reportInvalidTypeVarUse]
+
+    @overload
+    def get_pool(self, name: type[AsyncDatabaseConfig[ConnectionT, PoolT]]) -> Awaitable[type[PoolT]]: ...  # pyright: ignore[reportInvalidTypeVarUse]
+
+    def get_pool(
+        self,
+        name: Union[
+            type[NoPoolSyncConfig[ConnectionT]],
+            type[NoPoolAsyncConfig[ConnectionT]],
+            type[SyncDatabaseConfig[ConnectionT, PoolT]],
+            type[AsyncDatabaseConfig[ConnectionT, PoolT]],
+        ],
+    ) -> Union[type[PoolT], Awaitable[type[PoolT]], None]:
+        """Create and return a connection pool from the specified configuration."""
+        config = self.get_config(name)
+        if isinstance(config, (NoPoolSyncConfig, NoPoolAsyncConfig)):
+            return None
+        return cast("Union[type[PoolT], Awaitable[type[PoolT]]]", config.create_pool())

sqlspec/extensions/litestar/plugin.py

@@ -1,34 +1,42 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, TypeVar
+from typing import TYPE_CHECKING
 
 from litestar.plugins import InitPluginProtocol
 
+from sqlspec.base import ConfigManager
+
 if TYPE_CHECKING:
     from litestar.config.app import AppConfig
 
 
-T = TypeVar("T")
-
-
 class SQLSpecPlugin(InitPluginProtocol):
-    """Aiosql plugin."""
+    """SQLSpec plugin."""
 
     __slots__ = ("_config",)
 
-    def __init__(self, config: Any) -> None:
-        """Initialize ``AiosqlPlugin``.
+    def __init__(self, config: ConfigManager) -> None:
+        """Initialize ``SQLSpecPlugin``.
 
         Args:
-            config: configure and start Aiosql.
+            config: configure SQLSpec plugin for use with Litestar.
         """
         self._config = config
 
+    @property
+    def config(self) -> ConfigManager:
+        """Return the plugin config.
+
+        Returns:
+            ConfigManager.
+        """
+        return self._config
+
     def on_app_init(self, app_config: AppConfig) -> AppConfig:
-        """Configure application for use with Aiosql.
+        """Configure application for use with SQLSpec.
 
         Args:
             app_config: The :class:`AppConfig <.config.app.AppConfig>` instance.
         """
-        app_config.signature_namespace.update(self._config.signature_namespace)
+        app_config.signature_types.append(ConfigManager)
         return app_config

sqlspec/filters.py

@@ -25,12 +25,13 @@ __all__ = (
 )
 
 T = TypeVar("T")
+StatementT = TypeVar("StatementT", bound="str")
 
 
 class StatementFilter(Protocol):
     """Protocol for filters that can be appended to a statement."""
 
-    def append_to_statement(self, statement: str) -> str:
+    def append_to_statement(self, statement: StatementT) -> StatementT:
         """Append the filter to the statement."""
         return statement
 

sqlspec/typing.py

@@ -1,4 +1,4 @@
-from __future__ import annotations
+from __future__ import annotations  # noqa: A005
 
 from collections.abc import Sequence
 from dataclasses import Field, fields
@@ -48,11 +48,21 @@ FilterTypeT = TypeVar("FilterTypeT", bound="StatementFilter")
 
 :class:`~advanced_alchemy.filters.StatementFilter`
 """
+ModelDTOT = TypeVar("ModelDTOT", bound="Struct | BaseModel")
+"""Type variable for model DTOs.
+
+:class:`msgspec.Struct`|:class:`pydantic.BaseModel`
+"""
+PydanticOrMsgspecT: TypeAlias = Union[Struct, BaseModel]
+"""Type alias for pydantic or msgspec models.
+
+:class:`msgspec.Struct` or :class:`pydantic.BaseModel`
+"""
 ModelDictT: TypeAlias = Union[dict[str, Any], ModelT, DataclassProtocol, Struct, BaseModel]
 """Type alias for model dictionaries.
 
 Represents:
-- :type:`dict[str, Any]` | :class:`~advanced_alchemy.base.ModelProtocol` | :class:`msgspec.Struct` |  :class:`pydantic.BaseModel` | :class:`litestar.dto.data_structures.DTOData` | :class:`~advanced_alchemy.base.ModelProtocol`
+- :type:`dict[str, Any]` |  :class:`msgspec.Struct` |  :class:`pydantic.BaseModel`
 """
 ModelDictListT: TypeAlias = Sequence[Union[dict[str, Any], ModelT, DataclassProtocol, Struct, BaseModel]]
 """Type alias for model dictionary lists.
@@ -72,7 +82,7 @@ def is_dataclass_instance(obj: Any) -> TypeGuard[DataclassProtocol]:
     Returns:
         True if the object is a dataclass instance.
     """
-    return hasattr(type(obj), "__dataclass_fields__")
+    return hasattr(type(obj), "__dataclass_fields__")  # pyright: ignore[reportUnknownArgumentType]
 
 
 @lru_cache(typed=True)
@@ -104,7 +114,33 @@ def is_pydantic_model(v: Any) -> TypeGuard[BaseModel]:
     return PYDANTIC_INSTALLED and isinstance(v, BaseModel)
 
 
-def is_msgspec_model(v: Any) -> TypeGuard[Struct]:
+def is_pydantic_model_with_field(v: Any, field_name: str) -> TypeGuard[BaseModel]:
+    """Check if a pydantic model has a specific field.
+
+    Args:
+        v: Value to check.
+        field_name: Field name to check for.
+
+    Returns:
+        bool
+    """
+    return is_pydantic_model(v) and field_name in v.model_fields
+
+
+def is_pydantic_model_without_field(v: Any, field_name: str) -> TypeGuard[BaseModel]:
+    """Check if a pydantic model does not have a specific field.
+
+    Args:
+        v: Value to check.
+        field_name: Field name to check for.
+
+    Returns:
+        bool
+    """
+    return not is_pydantic_model_with_field(v, field_name)
+
+
+def is_msgspec_struct(v: Any) -> TypeGuard[Struct]:
     """Check if a value is a msgspec model.
 
     Args:
@@ -116,6 +152,32 @@ def is_msgspec_model(v: Any) -> TypeGuard[Struct]:
     return MSGSPEC_INSTALLED and isinstance(v, Struct)
 
 
+def is_msgspec_struct_with_field(v: Any, field_name: str) -> TypeGuard[Struct]:
+    """Check if a msgspec model has a specific field.
+
+    Args:
+        v: Value to check.
+        field_name: Field name to check for.
+
+    Returns:
+        bool
+    """
+    return is_msgspec_struct(v) and field_name in v.__struct_fields__
+
+
+def is_msgspec_struct_without_field(v: Any, field_name: str) -> TypeGuard[Struct]:
+    """Check if a msgspec model does not have a specific field.
+
+    Args:
+        v: Value to check.
+        field_name: Field name to check for.
+
+    Returns:
+        bool
+    """
+    return not is_msgspec_struct_with_field(v, field_name)
+
+
 def is_dict(v: Any) -> TypeGuard[dict[str, Any]]:
     """Check if a value is a dictionary.
 
@@ -154,8 +216,8 @@ def is_dict_without_field(v: Any, field_name: str) -> TypeGuard[dict[str, Any]]:
     return is_dict(v) and field_name not in v
 
 
-def is_dataclass(v: Any) -> TypeGuard[DataclassProtocol]:
-    """Check if a value is a dataclass.
+def is_schema(v: Any) -> TypeGuard[Struct | BaseModel]:
+    """Check if a value is a msgspec Struct or Pydantic model.
 
     Args:
         v: Value to check.
@@ -163,11 +225,23 @@ def is_dataclass(v: Any) -> TypeGuard[DataclassProtocol]:
     Returns:
         bool
     """
-    return is_dataclass_instance(v)
+    return is_msgspec_struct(v) or is_pydantic_model(v)
 
 
-def is_dataclass_with_field(v: Any, field_name: str) -> TypeGuard[DataclassProtocol]:
-    """Check if a dataclass has a specific field.
+def is_schema_or_dict(v: Any) -> TypeGuard[Struct | BaseModel | dict[str, Any]]:
+    """Check if a value is a msgspec Struct, Pydantic model, or dict.
+
+    Args:
+        v: Value to check.
+
+    Returns:
+        bool
+    """
+    return is_schema(v) or is_dict(v)
+
+
+def is_schema_with_field(v: Any, field_name: str) -> TypeGuard[Struct | BaseModel]:
+    """Check if a value is a msgspec Struct or Pydantic model with a specific field.
 
     Args:
         v: Value to check.
@@ -176,11 +250,11 @@ def is_dataclass_with_field(v: Any, field_name: str) -> TypeGuard[DataclassProto
     Returns:
         bool
     """
-    return is_dataclass(v) and field_name in v.__dataclass_fields__
+    return is_msgspec_struct_with_field(v, field_name) or is_pydantic_model_with_field(v, field_name)
 
 
-def is_dataclass_without_field(v: Any, field_name: str) -> TypeGuard[DataclassProtocol]:
-    """Check if a dataclass does not have a specific field.
+def is_schema_without_field(v: Any, field_name: str) -> TypeGuard[Struct | BaseModel]:
+    """Check if a value is a msgspec Struct or Pydantic model without a specific field.
 
     Args:
         v: Value to check.
@@ -189,11 +263,11 @@ def is_dataclass_without_field(v: Any, field_name: str) -> TypeGuard[DataclassPr
     Returns:
         bool
     """
-    return is_dataclass(v) and field_name not in v.__dataclass_fields__
+    return not is_schema_with_field(v, field_name)
 
 
-def is_pydantic_model_with_field(v: Any, field_name: str) -> TypeGuard[BaseModel]:
-    """Check if a pydantic model has a specific field.
+def is_schema_or_dict_with_field(v: Any, field_name: str) -> TypeGuard[Struct | BaseModel | dict[str, Any]]:
+    """Check if a value is a msgspec Struct, Pydantic model, or dict with a specific field.
 
     Args:
         v: Value to check.
@@ -202,11 +276,11 @@ def is_pydantic_model_with_field(v: Any, field_name: str) -> TypeGuard[BaseModel
     Returns:
         bool
     """
-    return is_pydantic_model(v) and field_name in v.model_fields
+    return is_schema_with_field(v, field_name) or is_dict_with_field(v, field_name)
 
 
-def is_pydantic_model_without_field(v: Any, field_name: str) -> TypeGuard[BaseModel]:
-    """Check if a pydantic model does not have a specific field.
+def is_schema_or_dict_without_field(v: Any, field_name: str) -> TypeGuard[Struct | BaseModel | dict[str, Any]]:
+    """Check if a value is a msgspec Struct, Pydantic model, or dict without a specific field.
 
     Args:
         v: Value to check.
@@ -215,11 +289,23 @@ def is_pydantic_model_without_field(v: Any, field_name: str) -> TypeGuard[BaseMo
     Returns:
         bool
     """
-    return not is_pydantic_model_with_field(v, field_name)
+    return not is_schema_or_dict_with_field(v, field_name)
 
 
-def is_msgspec_model_with_field(v: Any, field_name: str) -> TypeGuard[Struct]:
-    """Check if a msgspec model has a specific field.
+def is_dataclass(v: Any) -> TypeGuard[DataclassProtocol]:
+    """Check if a value is a dataclass.
+
+    Args:
+        v: Value to check.
+
+    Returns:
+        bool
+    """
+    return is_dataclass_instance(v)
+
+
+def is_dataclass_with_field(v: Any, field_name: str) -> TypeGuard[DataclassProtocol]:
+    """Check if a dataclass has a specific field.
 
     Args:
         v: Value to check.
@@ -228,11 +314,11 @@ def is_msgspec_model_with_field(v: Any, field_name: str) -> TypeGuard[Struct]:
     Returns:
         bool
     """
-    return is_msgspec_model(v) and field_name in v.__struct_fields__
+    return is_dataclass(v) and field_name in v.__dataclass_fields__
 
 
-def is_msgspec_model_without_field(v: Any, field_name: str) -> TypeGuard[Struct]:
-    """Check if a msgspec model does not have a specific field.
+def is_dataclass_without_field(v: Any, field_name: str) -> TypeGuard[DataclassProtocol]:
+    """Check if a dataclass does not have a specific field.
 
     Args:
         v: Value to check.
@@ -241,7 +327,7 @@ def is_msgspec_model_without_field(v: Any, field_name: str) -> TypeGuard[Struct]
     Returns:
         bool
     """
-    return not is_msgspec_model_with_field(v, field_name)
+    return is_dataclass(v) and field_name not in v.__dataclass_fields__
 
 
 def extract_dataclass_fields(
@@ -339,7 +425,7 @@ def dataclass_to_dict(
             ret[field.name] = dataclass_to_dict(value, exclude_none, exclude_empty)
         else:
             ret[field.name] = getattr(obj, field.name)
-    return ret
+    return cast("dict[str, Any]", ret)
 
 
 def schema_dump(
@@ -355,13 +441,15 @@ def schema_dump(
     Returns:
         :type: dict[str, Any]
     """
+    if is_dict(data):
+        return data
     if is_dataclass(data):
         return dataclass_to_dict(data, exclude_empty=exclude_unset)
     if is_pydantic_model(data):
         return data.model_dump(exclude_unset=exclude_unset)
-    if is_msgspec_model(data) and exclude_unset:
+    if is_msgspec_struct(data) and exclude_unset:
         return {f: val for f in data.__struct_fields__ if (val := getattr(data, f, None)) != UNSET}
-    if is_msgspec_model(data) and not exclude_unset:
+    if is_msgspec_struct(data) and not exclude_unset:
         return {f: getattr(data, f, None) for f in data.__struct_fields__}
     return cast("dict[str,Any]", data)
 
@@ -394,9 +482,9 @@ __all__ = (
     "is_dict",
     "is_dict_with_field",
     "is_dict_without_field",
-    "is_msgspec_model",
-    "is_msgspec_model_with_field",
-    "is_msgspec_model_without_field",
+    "is_msgspec_struct",
+    "is_msgspec_struct_with_field",
+    "is_msgspec_struct_without_field",
     "is_pydantic_model",
     "is_pydantic_model_with_field",
     "is_pydantic_model_without_field",