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

sqlspec/typing.py

@@ -0,0 +1,415 @@
+from __future__ import annotations
+
+from collections.abc import Sequence
+from dataclasses import Field, fields
+from functools import lru_cache
+from typing import (
+    TYPE_CHECKING,
+    Annotated,
+    Any,
+    TypeVar,
+    Union,
+    cast,
+)
+
+from typing_extensions import TypeAlias, TypeGuard
+
+from sqlspec._typing import (
+    MSGSPEC_INSTALLED,
+    PYDANTIC_INSTALLED,
+    UNSET,
+    BaseModel,
+    DataclassProtocol,
+    Empty,
+    EmptyType,
+    FailFast,
+    Struct,
+    TypeAdapter,
+    UnsetType,
+    convert,
+)
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+    from collections.abc import Set as AbstractSet
+
+    from sqlspec.filters import StatementFilter
+
+
+PYDANTIC_USE_FAILFAST = False  # leave permanently disabled for now
+
+
+T = TypeVar("T")
+
+ModelT = TypeVar("ModelT", bound="Struct | BaseModel | DataclassProtocol")
+
+FilterTypeT = TypeVar("FilterTypeT", bound="StatementFilter")
+"""Type variable for filter types.
+
+:class:`~advanced_alchemy.filters.StatementFilter`
+"""
+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`
+"""
+ModelDictListT: TypeAlias = Sequence[Union[dict[str, Any], ModelT, DataclassProtocol, Struct, BaseModel]]
+"""Type alias for model dictionary lists.
+
+A list or sequence of any of the following:
+- :type:`Sequence`[:type:`dict[str, Any]` | :class:`~advanced_alchemy.base.ModelProtocol` | :class:`msgspec.Struct` | :class:`pydantic.BaseModel`]
+
+"""
+
+
+def is_dataclass_instance(obj: Any) -> TypeGuard[DataclassProtocol]:
+    """Check if an object is a dataclass instance.
+
+    Args:
+        obj: An object to check.
+
+    Returns:
+        True if the object is a dataclass instance.
+    """
+    return hasattr(type(obj), "__dataclass_fields__")
+
+
+@lru_cache(typed=True)
+def get_type_adapter(f: type[T]) -> TypeAdapter[T]:
+    """Caches and returns a pydantic type adapter.
+
+    Args:
+        f: Type to create a type adapter for.
+
+    Returns:
+        :class:`pydantic.TypeAdapter`[:class:`typing.TypeVar`[T]]
+    """
+    if PYDANTIC_USE_FAILFAST:
+        return TypeAdapter(
+            Annotated[f, FailFast()],
+        )
+    return TypeAdapter(f)
+
+
+def is_pydantic_model(v: Any) -> TypeGuard[BaseModel]:
+    """Check if a value is a pydantic model.
+
+    Args:
+        v: Value to check.
+
+    Returns:
+        bool
+    """
+    return PYDANTIC_INSTALLED and isinstance(v, BaseModel)
+
+
+def is_msgspec_model(v: Any) -> TypeGuard[Struct]:
+    """Check if a value is a msgspec model.
+
+    Args:
+        v: Value to check.
+
+    Returns:
+        bool
+    """
+    return MSGSPEC_INSTALLED and isinstance(v, Struct)
+
+
+def is_dict(v: Any) -> TypeGuard[dict[str, Any]]:
+    """Check if a value is a dictionary.
+
+    Args:
+        v: Value to check.
+
+    Returns:
+        bool
+    """
+    return isinstance(v, dict)
+
+
+def is_dict_with_field(v: Any, field_name: str) -> TypeGuard[dict[str, Any]]:
+    """Check if a dictionary has a specific field.
+
+    Args:
+        v: Value to check.
+        field_name: Field name to check for.
+
+    Returns:
+        bool
+    """
+    return is_dict(v) and field_name in v
+
+
+def is_dict_without_field(v: Any, field_name: str) -> TypeGuard[dict[str, Any]]:
+    """Check if a dictionary does not have a specific field.
+
+    Args:
+        v: Value to check.
+        field_name: Field name to check for.
+
+    Returns:
+        bool
+    """
+    return is_dict(v) and field_name not in v
+
+
+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.
+        field_name: Field name to check for.
+
+    Returns:
+        bool
+    """
+    return is_dataclass(v) and field_name in v.__dataclass_fields__
+
+
+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.
+        field_name: Field name to check for.
+
+    Returns:
+        bool
+    """
+    return is_dataclass(v) and field_name not in v.__dataclass_fields__
+
+
+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_model_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_model(v) and field_name in v.__struct_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.
+
+    Args:
+        v: Value to check.
+        field_name: Field name to check for.
+
+    Returns:
+        bool
+    """
+    return not is_msgspec_model_with_field(v, field_name)
+
+
+def extract_dataclass_fields(
+    dt: DataclassProtocol,
+    exclude_none: bool = False,
+    exclude_empty: bool = False,
+    include: AbstractSet[str] | None = None,
+    exclude: AbstractSet[str] | None = None,
+) -> tuple[Field[Any], ...]:
+    """Extract dataclass fields.
+
+    Args:
+        dt: 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.
+
+
+    Returns:
+        A tuple of dataclass fields.
+    """
+    include = include or set()
+    exclude = exclude or set()
+
+    if common := (include & exclude):
+        msg = f"Fields {common} are both included and excluded."
+        raise ValueError(msg)
+
+    dataclass_fields: Iterable[Field[Any]] = fields(dt)
+    if exclude_none:
+        dataclass_fields = (field for field in dataclass_fields if getattr(dt, field.name) is not None)
+    if exclude_empty:
+        dataclass_fields = (field for field in dataclass_fields if getattr(dt, field.name) is not Empty)
+    if include:
+        dataclass_fields = (field for field in dataclass_fields if field.name in include)
+    if exclude:
+        dataclass_fields = (field for field in dataclass_fields if field.name not in exclude)
+
+    return tuple(dataclass_fields)
+
+
+def extract_dataclass_items(
+    dt: DataclassProtocol,
+    exclude_none: bool = False,
+    exclude_empty: bool = False,
+    include: AbstractSet[str] | None = None,
+    exclude: AbstractSet[str] | None = None,
+) -> tuple[tuple[str, Any], ...]:
+    """Extract dataclass name, value pairs.
+
+    Unlike the 'asdict' method exports by the stdlib, this function does not pickle values.
+
+    Args:
+        dt: 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.
+
+    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)
+
+
+def dataclass_to_dict(
+    obj: DataclassProtocol,
+    exclude_none: bool = False,
+    exclude_empty: bool = False,
+    convert_nested: bool = True,
+    exclude: set[str] | None = None,
+) -> dict[str, Any]:
+    """Convert a dataclass to a dictionary.
+
+    This method has important differences to the standard library version:
+    - it does not deepcopy values
+    - it does not recurse into collections
+
+    Args:
+        obj: A dataclass instance.
+        exclude_none: Whether to exclude None values.
+        exclude_empty: Whether to exclude Empty values.
+        convert_nested: Whether to recursively convert nested dataclasses.
+        exclude: An iterable of fields to exclude.
+
+    Returns:
+        A dictionary of key/value pairs.
+    """
+    ret = {}
+    for field in extract_dataclass_fields(obj, exclude_none, exclude_empty, exclude=exclude):
+        value = getattr(obj, field.name)
+        if is_dataclass_instance(value) and convert_nested:
+            ret[field.name] = dataclass_to_dict(value, exclude_none, exclude_empty)
+        else:
+            ret[field.name] = getattr(obj, field.name)
+    return ret
+
+
+def schema_dump(
+    data: dict[str, Any] | Struct | BaseModel | DataclassProtocol,
+    exclude_unset: bool = True,
+) -> dict[str, Any]:
+    """Dump a data object to a dictionary.
+
+    Args:
+        data:  dict[str, Any] | ModelT | Struct | BaseModel | DataclassProtocol
+        exclude_unset: :type:`bool` Whether to exclude unset values.
+
+    Returns:
+        :type: dict[str, Any]
+    """
+    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:
+        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:
+        return {f: getattr(data, f, None) for f in data.__struct_fields__}
+    return cast("dict[str,Any]", data)
+
+
+__all__ = (
+    "MSGSPEC_INSTALLED",
+    "PYDANTIC_INSTALLED",
+    "PYDANTIC_USE_FAILFAST",
+    "UNSET",
+    "BaseModel",
+    "DataclassProtocol",
+    "Empty",
+    "EmptyType",
+    "FailFast",
+    "FilterTypeT",
+    "ModelDictListT",
+    "ModelDictT",
+    "Struct",
+    "TypeAdapter",
+    "UnsetType",
+    "convert",
+    "dataclass_to_dict",
+    "extract_dataclass_fields",
+    "extract_dataclass_items",
+    "get_type_adapter",
+    "is_dataclass",
+    "is_dataclass_instance",
+    "is_dataclass_with_field",
+    "is_dataclass_without_field",
+    "is_dict",
+    "is_dict_with_field",
+    "is_dict_without_field",
+    "is_msgspec_model",
+    "is_msgspec_model_with_field",
+    "is_msgspec_model_without_field",
+    "is_pydantic_model",
+    "is_pydantic_model_with_field",
+    "is_pydantic_model_without_field",
+    "schema_dump",
+)
+
+if TYPE_CHECKING:
+    if not PYDANTIC_INSTALLED:
+        from ._typing import BaseModel, FailFast, TypeAdapter
+    else:
+        from pydantic import BaseModel, FailFast, TypeAdapter  # noqa: TC004
+
+    if not MSGSPEC_INSTALLED:
+        from ._typing import UNSET, Struct, UnsetType, convert
+    else:
+        from msgspec import UNSET, Struct, UnsetType, convert  # noqa: TC004

sqlspec-0.4.0.dist-info/METADATA

@@ -0,0 +1,84 @@
+Metadata-Version: 2.4
+Name: sqlspec
+Version: 0.4.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.9'
+Requires-Dist: sqlglot
+Requires-Dist: typing-extensions>=4.0.0
+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
+
+<!-- markdownlint-disable -->
+<p align="center">
+  <!-- github-banner-start -->
+  <img src="https://raw.githubusercontent.com/litestar-org/branding/main/assets/Branding%20-%20SVG%20-%20Transparent/Logo%20-%20Banner%20-%20Inline%20-%20Light.svg#gh-light-mode-only" alt="Litestar Logo - Light" width="100%" height="auto" />
+  <img src="https://raw.githubusercontent.com/litestar-org/branding/main/assets/Branding%20-%20SVG%20-%20Transparent/Logo%20-%20Banner%20-%20Inline%20-%20Dark.svg#gh-dark-mode-only" alt="Litestar Logo - Dark" width="100%" height="auto" />
+  <!-- github-banner-end -->
+
+</p>
+<div align="center">
+<!-- markdownlint-restore -->
+
+# SQLSpec
+
+SQL Experiments in Python
+
+
+## Minimal SQL Abstractions for Python.
+
+- Modern: Typed and Extensible
+- Multi-database: SQLite, Postgres, DuckDB, MySQL, Oracle, SQL Server, Spanner, Big Query, and more...
+- Easy ability to manipulate and add filters to queries
+- Validate and Convert between dialects with `sqlglot`
+- and more...
+
+## Can it do `X`?
+
+- Probably not currently; but, if it makes sense we can add enhancements.
+
+## Inspiration
+
+`aiosql` is the primary influence for this library.  However, I wanted to be able to use the query interface from `aiosql` a bit more flexibly.
+
+Why not add it to `aiosql`?  Where it makes sense, many of these changes will likely get submitted to aiosql as a PR (`spanner` and `bigquery` drivers are likely the starting point.)

sqlspec-0.4.0.dist-info/RECORD

@@ -0,0 +1,39 @@
+sqlspec/__init__.py,sha256=U4S_2y3zgLZVfMenHRaJFBW8yqh2mUBuI291LGQVOJ8,35
+sqlspec/__metadata__.py,sha256=Vw99abV_UQNVH2jB0IBa9-8emyZQcXm1J9eMtLxFX2Y,496
+sqlspec/_serialization.py,sha256=OL4x0Rz5UjF7RgAKqhYChi5qSS_ImtaVrIlA4DhIKUE,824
+sqlspec/_typing.py,sha256=Za41GlNdEKAGTy66GTofOiGYROE7ccFMvxZdh_vxIFk,3278
+sqlspec/config.py,sha256=BOX_V_q2MOP33tK0ISpYaiQJt3zrvK4D_JIBD9FOixY,272
+sqlspec/exceptions.py,sha256=fhCOILBj0J7HJP67BNSC0d9YUbW8QpZPXM55xJJzE8A,3039
+sqlspec/filters.py,sha256=H5UAn1HKm598QqDujQHwvytKHjw4QoQ2zPpgXMcYpSU,3552
+sqlspec/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sqlspec/typing.py,sha256=t5fpzxUCWkKJIpFDKmUeq77RkdmNNFqMj4azgJpRS7k,11316
+sqlspec/adapters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sqlspec/adapters/adbc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sqlspec/adapters/adbc/config.py,sha256=BeiZdqoBQXuht0GXWleqVKL_LOFI3Ygna1XWDmb-dBw,1704
+sqlspec/adapters/aiosqlite/__init__.py,sha256=PLqWg24l3TooJvqA0Xf1WErrxtqwo8DEoL_Zp2iSCzs,68
+sqlspec/adapters/aiosqlite/config.py,sha256=5DOKaYT_lBFTimrITJwIqTHoweZ2aZlQ07kti1VJtxk,3821
+sqlspec/adapters/asyncmy/__init__.py,sha256=o0R_Azae3FHiSZ1TQ5ZjyCneDOuvnEeMjmSkhuiKoWo,103
+sqlspec/adapters/asyncmy/config.py,sha256=7VsNEokhBtBgXDj2gakdwplOYPaV3ADIwWX-o22vwNk,5461
+sqlspec/adapters/asyncpg/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sqlspec/adapters/asyncpg/config.py,sha256=NyVvsT2x3IIZBZF6dTaSv1w6lCPEvmUprYXyTSJ9Ixk,6014
+sqlspec/adapters/duckdb/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sqlspec/adapters/duckdb/config.py,sha256=BgGGkk0Y3CQboQeI1aB81_ABVGmgOL1cbk_cZKzeggQ,7927
+sqlspec/adapters/oracledb/__init__.py,sha256=fFQ2xOxFcgpr-ug4AVv430irnJgBRUINvt4sL3qzyBw,275
+sqlspec/adapters/oracledb/config/__init__.py,sha256=XoHgInT4IbXjDg5ax3ncuUoVvnYB5qQjI-Ib7gwSycU,338
+sqlspec/adapters/oracledb/config/_asyncio.py,sha256=Z87V7t-5blS6NkMhvFjoBgUrJtKgOrTyKSl8xy2uD_M,3211
+sqlspec/adapters/oracledb/config/_common.py,sha256=k8ou3aWR1En1jl5uo4fORMG3CoF-XQ96qdwULtteHLo,6173
+sqlspec/adapters/oracledb/config/_sync.py,sha256=guCrotTdNJajcbG5xwVCLoza7wLPQxZkQaw99s4ibNE,3071
+sqlspec/adapters/psycopg/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sqlspec/adapters/psycopg/config/__init__.py,sha256=pXI9Pa2VYESTchPgM3tt5kFF8tsmgq-ksZRGR6pgiUQ,280
+sqlspec/adapters/psycopg/config/_async.py,sha256=sNQU3dzencGgOToHZuMfxoqhR9EvRyrxdWqtPDC2gUY,2712
+sqlspec/adapters/psycopg/config/_common.py,sha256=gC-QQDy9DNjp0DGZAT3wu7MKW8ejHe5fuHU-318Vgr0,2757
+sqlspec/adapters/psycopg/config/_sync.py,sha256=lwzaeO6I-nYuC7vif-bjn2jLugPwbPjTW226_hcweqo,2590
+sqlspec/adapters/sqlite/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sqlspec/adapters/sqlite/config.py,sha256=rCv6XWWWi1dzpmAVnwHxg-ahmAif78yfFhA548fNaT8,3697
+sqlspec/extensions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sqlspec/extensions/litestar/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sqlspec/extensions/litestar/plugin.py,sha256=oiBFfRffNvy_vnGptREd6JYZGB6Yd98KbtVct_VcW0A,837
+sqlspec-0.4.0.dist-info/METADATA,sha256=OnTkY_OG3IeqaJQBkzHjsKuQwkfmhQO4WnhXKbEoDLc,3222
+sqlspec-0.4.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+sqlspec-0.4.0.dist-info/licenses/NOTICE,sha256=Lyir8ozXWov7CyYS4huVaOCNrtgL17P-bNV-5daLntQ,1634
+sqlspec-0.4.0.dist-info/RECORD,,

{sqlspec-0.1.1.dist-info → sqlspec-0.4.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.25.0
+Generator: hatchling 1.27.0
 Root-Is-Purelib: true
 Tag: py3-none-any

sqlspec-0.4.0.dist-info/licenses/NOTICE

@@ -0,0 +1,29 @@
+# Early versions of this utility adapt code from `aoisql`.
+# BSD 2-Clause License
+Copyright (c) 2014-2017, Honza Pokorny
+Copyright (c) 2018, William Vaughn
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+The views and conclusions contained in the software and documentation are those
+of the authors and should not be interpreted as representing official policies,
+either expressed or implied, of the aiosql Project.

sqlspec/types/empty.py

@@ -1,18 +0,0 @@
-from __future__ import annotations
-
-from enum import Enum
-from typing import Final, Literal, Union
-
-from msgspec import UnsetType  # pyright: ignore[reportMissingImports]
-
-__all__ = ("Empty", "EmptyType")
-
-
-class _EmptyEnum(Enum):
-    """A sentinel enum used as placeholder."""
-
-    EMPTY = 0
-
-
-EmptyType = Union[Literal[_EmptyEnum.EMPTY], UnsetType]
-Empty: Final = _EmptyEnum.EMPTY