sqlspec 0.1.0__py3-none-any.whl

sqlspec/__init__.py

@@ -0,0 +1 @@
+from __future__ import annotations

sqlspec/__metadata__.py

@@ -0,0 +1,18 @@
+"""Metadata for the Project."""
+
+from __future__ import annotations
+
+from importlib.metadata import PackageNotFoundError, metadata, version
+
+__all__ = ["__version__", "__project__"]
+
+try:
+    __version__ = version("sqlspec")
+    """Version of the project."""
+    __project__ = metadata("sqlspec")["Name"]
+    """Name of the project."""
+except PackageNotFoundError:  # pragma: no cover
+    __version__ = "0.0.1"
+    __project__ = "SQLSpec"
+finally:
+    del version, PackageNotFoundError, metadata

sqlspec/_serialization.py

@@ -0,0 +1,24 @@
+from typing import Any
+
+__all__ = ("decode_json", "encode_json")
+
+try:
+    from msgspec.json import Decoder, Encoder  # pyright: ignore[reportMissingImports]
+
+    encoder, decoder = Encoder(), Decoder()
+    decode_json = decoder.decode
+
+    def encode_json(data: Any) -> str:
+        return encoder.encode(data).decode("utf-8")
+
+except ImportError:
+    try:
+        from orjson import dumps as _encode_json  # pyright: ignore[reportMissingImports]
+        from orjson import loads as decode_json  # type: ignore[no-redef,assignment]
+
+        def encode_json(data: Any) -> str:
+            return _encode_json(data).decode("utf-8")  # type: ignore[no-any-return]
+
+    except ImportError:
+        from json import dumps as encode_json  # type: ignore[assignment]
+        from json import loads as decode_json  # type: ignore[assignment]

sqlspec/exceptions.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+from typing import Any
+
+
+class SQLSpecError(Exception):
+    """Base exception class from which all Advanced Alchemy exceptions inherit."""
+
+    detail: str
+
+    def __init__(self, *args: Any, detail: str = "") -> None:
+        """Initialize ``AdvancedAlchemyException``.
+
+        Args:
+            *args: args are converted to :class:`str` before passing to :class:`Exception`
+            detail: detail of the exception.
+        """
+        str_args = [str(arg) for arg in args if arg]
+        if not detail:
+            if str_args:
+                detail, *str_args = str_args
+            elif hasattr(self, "detail"):
+                detail = self.detail
+        self.detail = detail
+        super().__init__(*str_args)
+
+    def __repr__(self) -> str:
+        if self.detail:
+            return f"{self.__class__.__name__} - {self.detail}"
+        return self.__class__.__name__
+
+    def __str__(self) -> str:
+        return " ".join((*self.args, self.detail)).strip()
+
+
+class MissingDependencyError(SQLSpecError, ImportError):
+    """Missing optional dependency.
+
+    This exception is raised only when a module depends on a dependency that has not been installed.
+    """
+
+    def __init__(self, package: str, install_package: str | None = None) -> None:
+        super().__init__(
+            f"Package {package!r} is not installed but required. You can install it by running "
+            f"'pip install sqlspec[{install_package or package}]' to install sqlspec with the required extra "
+            f"or 'pip install {install_package or package}' to install the package separately",
+        )
+
+
+class ImproperConfigurationError(SQLSpecError):
+    """Improper Configuration error.
+
+    This exception is raised only when a module depends on a dependency that has not been installed.
+    """
+
+
+class SerializationError(SQLSpecError):
+    """Encoding or decoding of an object failed."""
+
+
+class RepositoryError(SQLSpecError):
+    """Base repository exception type."""
+
+
+class IntegrityError(RepositoryError):
+    """Data integrity error."""
+
+
+class NotFoundError(RepositoryError):
+    """An identity does not exist."""
+
+
+class MultipleResultsFoundError(RepositoryError):
+    """A single database result was required but more than one were found."""

sqlspec/filters.py

@@ -0,0 +1,121 @@
+"""Collection filter datastructures."""
+
+from __future__ import annotations
+
+from collections import abc  # noqa: TCH003
+from dataclasses import dataclass
+from datetime import datetime  # noqa: TCH003
+from typing import TYPE_CHECKING, Any, Generic, Literal, TypeVar
+
+if TYPE_CHECKING:
+    from typing_extensions import TypeAlias
+
+T = TypeVar("T")
+
+__all__ = (
+    "BeforeAfter",
+    "CollectionFilter",
+    "FilterTypes",
+    "LimitOffset",
+    "NotInCollectionFilter",
+    "NotInSearchFilter",
+    "OnBeforeAfter",
+    "OrderBy",
+    "SearchFilter",
+)
+
+
+FilterTypes: TypeAlias = "BeforeAfter | OnBeforeAfter | CollectionFilter[Any] | LimitOffset | OrderBy | SearchFilter | NotInCollectionFilter[Any] | NotInSearchFilter"
+"""Aggregate type alias of the types supported for collection filtering."""
+
+
+@dataclass
+class BeforeAfter:
+    """Data required to filter a query on a ``datetime`` column."""
+
+    field_name: str
+    """Name of the model attribute to filter on."""
+    before: datetime | None
+    """Filter results where field earlier than this."""
+    after: datetime | None
+    """Filter results where field later than this."""
+
+
+@dataclass
+class OnBeforeAfter:
+    """Data required to filter a query on a ``datetime`` column."""
+
+    field_name: str
+    """Name of the model attribute to filter on."""
+    on_or_before: datetime | None
+    """Filter results where field is on or earlier than this."""
+    on_or_after: datetime | None
+    """Filter results where field on or later than this."""
+
+
+@dataclass
+class CollectionFilter(Generic[T]):
+    """Data required to construct a ``WHERE ... IN (...)`` clause."""
+
+    field_name: str
+    """Name of the model attribute to filter on."""
+    values: abc.Collection[T] | None
+    """Values for ``IN`` clause.
+
+    An empty list will return an empty result set, however, if ``None``, the filter is not applied to the query, and all rows are returned. """
+
+
+@dataclass
+class NotInCollectionFilter(Generic[T]):
+    """Data required to construct a ``WHERE ... NOT IN (...)`` clause."""
+
+    field_name: str
+    """Name of the model attribute to filter on."""
+    values: abc.Collection[T] | None
+    """Values for ``NOT IN`` clause.
+
+    An empty list or ``None`` will return all rows."""
+
+
+@dataclass
+class LimitOffset:
+    """Data required to add limit/offset filtering to a query."""
+
+    limit: int
+    """Value for ``LIMIT`` clause of query."""
+    offset: int
+    """Value for ``OFFSET`` clause of query."""
+
+
+@dataclass
+class OrderBy:
+    """Data required to construct a ``ORDER BY ...`` clause."""
+
+    field_name: str
+    """Name of the model attribute to sort on."""
+    sort_order: Literal["asc", "desc"] = "asc"
+    """Sort ascending or descending"""
+
+
+@dataclass
+class SearchFilter:
+    """Data required to construct a ``WHERE field_name LIKE '%' || :value || '%'`` clause."""
+
+    field_name: str
+    """Name of the model attribute to sort on."""
+    value: str
+    """Values for ``LIKE`` clause."""
+    ignore_case: bool | None = False
+    """Should the search be case insensitive."""
+
+
+@dataclass
+class NotInSearchFilter:
+    """Data required to construct a ``WHERE field_name NOT LIKE '%' || :value || '%'`` clause."""
+
+    field_name: str
+    """Name of the model attribute to search on."""
+    value: str
+    """Values for ``NOT LIKE`` clause."""
+    ignore_case: bool | None = False
+    """Should the search be case insensitive."""

sqlspec/types/empty.py

@@ -0,0 +1,18 @@
+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

sqlspec/types/protocols.py

@@ -0,0 +1,117 @@
+# SPDX-FileCopyrightText: 2023-present Cody Fincher <codyfincher@google.com>
+#
+# SPDX-License-Identifier: MIT
+from __future__ import annotations
+
+from collections.abc import Collection, Iterable
+from typing import Any, ClassVar, Protocol, TypeVar, runtime_checkable
+
+__all__ = (
+    "DataclassProtocol",
+    "InstantiableCollection",
+    "Logger",
+)
+
+
+class Logger(Protocol):
+    """Logger protocol."""
+
+    def debug(self, event: str, *args: Any, **kwargs: Any) -> Any:
+        """Output a log message at 'DEBUG' level.
+
+        Args:
+             event: Log message.
+             *args: Any args.
+             **kwargs: Any kwargs.
+        """
+
+    def info(self, event: str, *args: Any, **kwargs: Any) -> Any:
+        """Output a log message at 'INFO' level.
+
+        Args:
+             event: Log message.
+             *args: Any args.
+             **kwargs: Any kwargs.
+        """
+
+    def warning(self, event: str, *args: Any, **kwargs: Any) -> Any:
+        """Output a log message at 'WARNING' level.
+
+        Args:
+             event: Log message.
+             *args: Any args.
+             **kwargs: Any kwargs.
+        """
+
+    def warn(self, event: str, *args: Any, **kwargs: Any) -> Any:
+        """Output a log message at 'WARN' level.
+
+        Args:
+             event: Log message.
+             *args: Any args.
+             **kwargs: Any kwargs.
+        """
+
+    def error(self, event: str, *args: Any, **kwargs: Any) -> Any:
+        """Output a log message at 'ERROR' level.
+
+        Args:
+             event: Log message.
+             *args: Any args.
+             **kwargs: Any kwargs.
+        """
+
+    def fatal(self, event: str, *args: Any, **kwargs: Any) -> Any:
+        """Output a log message at 'FATAL' level.
+
+        Args:
+             event: Log message.
+             *args: Any args.
+             **kwargs: Any kwargs.
+        """
+
+    def exception(self, event: str, *args: Any, **kwargs: Any) -> Any:
+        """Log a message with level 'ERROR' on this logger. The arguments are interpreted as for debug(). Exception info
+        is added to the logging message.
+
+        Args:
+             event: Log message.
+             *args: Any args.
+             **kwargs: Any kwargs.
+        """
+
+    def critical(self, event: str, *args: Any, **kwargs: Any) -> Any:
+        """Output a log message at 'INFO' level.
+
+        Args:
+             event: Log message.
+             *args: Any args.
+             **kwargs: Any kwargs.
+        """
+
+    def setLevel(self, level: int) -> None:  # noqa: N802
+        """Set the log level
+
+        Args:
+            level: Log level to set as an integer
+
+        Returns:
+            None
+        """
+
+
+@runtime_checkable
+class DataclassProtocol(Protocol):
+    """Protocol for instance checking dataclasses"""
+
+    __dataclass_fields__: ClassVar[dict[str, Any]]
+
+
+T_co = TypeVar("T_co", covariant=True)
+
+
+@runtime_checkable
+class InstantiableCollection(Collection[T_co], Protocol[T_co]):  # pyright: ignore
+    """A protocol for instantiable collection types."""
+
+    def __init__(self, iterable: Iterable[T_co], /) -> None: ...

sqlspec/utils/dataclass.py

@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+from dataclasses import Field, fields
+from typing import TYPE_CHECKING, TypeGuard
+
+from sqlspec.types.empty import Empty
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+    from collections.abc import Set as AbstractSet
+    from typing import Any
+
+    from sqlspec.types.protocols import DataclassProtocol
+
+__all__ = (
+    "extract_dataclass_fields",
+    "extract_dataclass_items",
+    "is_dataclass_instance",
+    "simple_asdict",
+)
+
+
+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__")
+
+
+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 simple_asdict(
+    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] = simple_asdict(value, exclude_none, exclude_empty)
+        else:
+            ret[field.name] = getattr(obj, field.name)
+    return ret

sqlspec-0.1.0.dist-info/METADATA

@@ -0,0 +1,25 @@
+Metadata-Version: 2.3
+Name: sqlspec
+Version: 0.1.0
+Summary: SQL Expiriments in Python
+Author-email: Cody Fincher <cody@litestar.dev>
+Maintainer-email: Litestar Developers <hello@litestar.dev>
+Requires-Python: <4.0,>=3.9
+Requires-Dist: eval-type-backport; python_version <= '3.9'
+Requires-Dist: typing-extensions>=4.0.0
+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 Expiriments in Python

sqlspec-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+sqlspec/__init__.py,sha256=U4S_2y3zgLZVfMenHRaJFBW8yqh2mUBuI291LGQVOJ8,35
+sqlspec/__metadata__.py,sha256=IKK7ARcZFaxFXHrjAgeneCvbZDQi5a-6Es32B8nIkTc,496
+sqlspec/_serialization.py,sha256=p6CadqKxifALuKUQW_YCJQSzy4NIHj_NeKUTXY95r3s,835
+sqlspec/exceptions.py,sha256=wfOqLdCmOBpQEkDlMlIAUYItYgTwY5YDmWiHnrBDZBg,2290
+sqlspec/filters.py,sha256=1QeJkY8e4z6VPF0T9qn7xsiDKLKGWtZecg80iZZWdl0,3404
+sqlspec/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sqlspec/types/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sqlspec/types/empty.py,sha256=5iijfAjHHzAVwWlkfea8woUWilHA6nJK_GN1MVedmS0,383
+sqlspec/types/protocols.py,sha256=skczeIQzjvFbgdpnHdGJR_iTTDYJj0M5sef2vJby_es,3093
+sqlspec/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sqlspec/utils/dataclass.py,sha256=swzzYjDgIS0OkmGH5z33P1HFkzvspyamvWGyI25oNGE,4129
+sqlspec-0.1.0.dist-info/METADATA,sha256=INa6CEObNsnM3zXee5nKmiD7FzZ8uIdFUzp8UOpgPGk,1045
+sqlspec-0.1.0.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+sqlspec-0.1.0.dist-info/RECORD,,

sqlspec-0.1.0.dist-info/WHEEL

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