sqlspec 0.12.2__py3-none-any.whl → 0.13.0__py3-none-any.whl

sqlspec/typing.py

@@ -1,11 +1,9 @@
-from collections.abc import Iterable, Mapping
-from collections.abc import Set as AbstractSet
-from dataclasses import Field, fields
+# pyright: ignore[reportAttributeAccessIssue]
+from collections.abc import Mapping
 from functools import lru_cache
-from typing import TYPE_CHECKING, Annotated, Any, Optional, Union, cast
+from typing import TYPE_CHECKING, Annotated, Any, Union
 
-from sqlglot import exp
-from typing_extensions import TypeAlias, TypeGuard, TypeVar
+from typing_extensions import TypeAlias, TypeVar
 
 from sqlspec._typing import (
     AIOSQL_INSTALLED,
@@ -47,7 +45,7 @@ from sqlspec._typing import (
 )
 
 if TYPE_CHECKING:
-    from collections.abc import Iterable, Sequence
+    from collections.abc import Sequence
 
 
 PYDANTIC_USE_FAILFAST = False  # leave permanently disabled for now
@@ -132,20 +130,6 @@ Represents:
 """
 
 
-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.
-    """
-    # Ensure obj is an instance and not the class itself,
-    # and that its type is a dataclass.
-    return not isinstance(obj, type) and 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.
@@ -161,394 +145,6 @@ def get_type_adapter(f: "type[T]") -> "TypeAdapter[T]":
     return TypeAdapter(f)
 
 
-def is_pydantic_model(obj: Any) -> "TypeGuard[BaseModel]":
-    """Check if a value is a pydantic model.
-
-    Args:
-        obj: Value to check.
-
-    Returns:
-        bool
-    """
-    return PYDANTIC_INSTALLED and isinstance(obj, BaseModel)
-
-
-def is_pydantic_model_with_field(obj: "Any", field_name: str) -> "TypeGuard[BaseModel]":
-    """Check if a pydantic model has a specific field.
-
-    Args:
-        obj: Value to check.
-        field_name: Field name to check for.
-
-    Returns:
-        bool
-    """
-    return is_pydantic_model(obj) and hasattr(obj, field_name)
-
-
-def is_pydantic_model_without_field(obj: "Any", field_name: str) -> "TypeGuard[BaseModel]":
-    """Check if a pydantic model does not have a specific field.
-
-    Args:
-        obj: Value to check.
-        field_name: Field name to check for.
-
-    Returns:
-        bool
-    """
-    return is_pydantic_model(obj) and not hasattr(obj, field_name)
-
-
-def is_msgspec_struct(obj: "Any") -> "TypeGuard[Struct]":
-    """Check if a value is a msgspec struct.
-
-    Args:
-        obj: Value to check.
-
-    Returns:
-        bool
-    """
-    return MSGSPEC_INSTALLED and isinstance(obj, Struct)
-
-
-def is_msgspec_struct_with_field(obj: "Any", field_name: str) -> "TypeGuard[Struct]":
-    """Check if a msgspec struct has a specific field.
-
-    Args:
-        obj: Value to check.
-        field_name: Field name to check for.
-
-    Returns:
-        bool
-    """
-    return is_msgspec_struct(obj) and hasattr(obj, field_name)
-
-
-def is_msgspec_struct_without_field(obj: "Any", field_name: str) -> "TypeGuard[Struct]":
-    """Check if a msgspec struct does not have a specific field.
-
-    Args:
-        obj: Value to check.
-        field_name: Field name to check for.
-
-    Returns:
-        bool
-    """
-    return is_msgspec_struct(obj) and not hasattr(obj, field_name)
-
-
-def is_dict(obj: "Any") -> "TypeGuard[dict[str, Any]]":
-    """Check if a value is a dictionary.
-
-    Args:
-        obj: Value to check.
-
-    Returns:
-        bool
-    """
-    return isinstance(obj, dict)
-
-
-def is_dict_with_field(obj: "Any", field_name: str) -> "TypeGuard[dict[str, Any]]":
-    """Check if a dictionary has a specific field.
-
-    Args:
-        obj: Value to check.
-        field_name: Field name to check for.
-
-    Returns:
-        bool
-    """
-    return is_dict(obj) and field_name in obj
-
-
-def is_dict_without_field(obj: "Any", field_name: str) -> "TypeGuard[dict[str, Any]]":
-    """Check if a dictionary does not have a specific field.
-
-    Args:
-        obj: Value to check.
-        field_name: Field name to check for.
-
-    Returns:
-        bool
-    """
-    return is_dict(obj) and field_name not in obj
-
-
-def is_schema(obj: "Any") -> "TypeGuard[SupportedSchemaModel]":
-    """Check if a value is a msgspec Struct or Pydantic model.
-
-    Args:
-        obj: Value to check.
-
-    Returns:
-        bool
-    """
-    return is_msgspec_struct(obj) or is_pydantic_model(obj)
-
-
-def is_schema_or_dict(obj: "Any") -> "TypeGuard[Union[SupportedSchemaModel, dict[str, Any]]]":
-    """Check if a value is a msgspec Struct, Pydantic model, or dict.
-
-    Args:
-        obj: Value to check.
-
-    Returns:
-        bool
-    """
-    return is_schema(obj) or is_dict(obj)
-
-
-def is_schema_with_field(obj: "Any", field_name: str) -> "TypeGuard[SupportedSchemaModel]":
-    """Check if a value is a msgspec Struct or Pydantic model with a specific field.
-
-    Args:
-        obj: Value to check.
-        field_name: Field name to check for.
-
-    Returns:
-        bool
-    """
-    return is_msgspec_struct_with_field(obj, field_name) or is_pydantic_model_with_field(obj, field_name)
-
-
-def is_schema_without_field(obj: "Any", field_name: str) -> "TypeGuard[SupportedSchemaModel]":
-    """Check if a value is a msgspec Struct or Pydantic model without a specific field.
-
-    Args:
-        obj: Value to check.
-        field_name: Field name to check for.
-
-    Returns:
-        bool
-    """
-    return not is_schema_with_field(obj, field_name)
-
-
-def is_schema_or_dict_with_field(
-    obj: "Any", field_name: str
-) -> "TypeGuard[Union[SupportedSchemaModel, dict[str, Any]]]":
-    """Check if a value is a msgspec Struct, Pydantic model, or dict with a specific field.
-
-    Args:
-        obj: Value to check.
-        field_name: Field name to check for.
-
-    Returns:
-        bool
-    """
-    return is_schema_with_field(obj, field_name) or is_dict_with_field(obj, field_name)
-
-
-def is_schema_or_dict_without_field(
-    obj: "Any", field_name: str
-) -> "TypeGuard[Union[SupportedSchemaModel, dict[str, Any]]]":
-    """Check if a value is a msgspec Struct, Pydantic model, or dict without a specific field.
-
-    Args:
-        obj: Value to check.
-        field_name: Field name to check for.
-
-    Returns:
-        bool
-    """
-    return not is_schema_or_dict_with_field(obj, field_name)
-
-
-def is_dataclass(obj: "Any") -> "TypeGuard[DataclassProtocol]":
-    """Check if an object is a dataclass.
-
-    Args:
-        obj: Value to check.
-
-    Returns:
-        bool
-    """
-    if isinstance(obj, type) and hasattr(obj, "__dataclass_fields__"):
-        return True
-    return is_dataclass_instance(obj)
-
-
-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.
-
-    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.
-
-    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(
-    obj: "DataclassProtocol",
-    exclude_none: bool = False,
-    exclude_empty: bool = False,
-    include: "Optional[AbstractSet[str]]" = None,
-    exclude: "Optional[AbstractSet[str]]" = None,
-) -> "tuple[Field[Any], ...]":
-    """Extract dataclass fields.
-
-    Args:
-        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.
-    """
-    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(obj)
-    if exclude_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(obj, 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(
-    obj: "DataclassProtocol",
-    exclude_none: bool = False,
-    exclude_empty: bool = False,
-    include: "Optional[AbstractSet[str]]" = None,
-    exclude: "Optional[AbstractSet[str]]" = 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:
-        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.
-
-    Returns:
-        A tuple of key/value pairs.
-    """
-    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(
-    obj: "DataclassProtocol",
-    exclude_none: bool = False,
-    exclude_empty: bool = False,
-    convert_nested: bool = True,
-    exclude: "Optional[AbstractSet[str]]" = 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 cast("dict[str, Any]", ret)
-
-
-def schema_dump(
-    data: "Union[dict[str, Any],   DataclassProtocol, Struct, BaseModel]", exclude_unset: bool = True
-) -> "dict[str, Any]":
-    """Dump a data object to a dictionary.
-
-    Args:
-        data:  :type:`dict[str, Any]` | :class:`DataclassProtocol` | :class:`msgspec.Struct` | :class:`pydantic.BaseModel`
-        exclude_unset: :type:`bool` Whether to exclude unset values.
-
-    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_struct(data):
-        if exclude_unset:
-            return {f: val for f in data.__struct_fields__ if (val := getattr(data, f, None)) != UNSET}
-        return {f: getattr(data, f, None) for f in data.__struct_fields__}
-
-    if hasattr(data, "__dict__"):
-        return data.__dict__
-    return cast("dict[str, Any]", data)
-
-
-def is_dto_data(v: Any) -> TypeGuard[DTOData[Any]]:
-    """Check if a value is a Litestar DTOData object.
-
-    Args:
-        v: Value to check.
-
-    Returns:
-        bool
-    """
-    return LITESTAR_INSTALLED and isinstance(v, DTOData)
-
-
-def is_expression(obj: "Any") -> "TypeGuard[exp.Expression]":
-    """Check if a value is a sqlglot Expression.
-
-    Args:
-        obj: Value to check.
-
-    Returns:
-        bool
-    """
-    return isinstance(obj, exp.Expression)
-
-
 def MixinOf(base: type[T]) -> type[T]:  # noqa: N802
     """Useful function to make mixins with baseclass type hint
 
@@ -585,6 +181,7 @@ __all__ = (
     "BulkModelDict",
     "ConnectionT",
     "Counter",
+    "DTOData",
     "DataclassProtocol",
     "DictRow",
     "Empty",
@@ -617,32 +214,7 @@ __all__ = (
     "UnsetType",
     "aiosql",
     "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_dto_data",
-    "is_expression",
-    "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",
-    "is_schema",
-    "is_schema_or_dict",
-    "is_schema_or_dict_with_field",
-    "is_schema_or_dict_without_field",
-    "is_schema_with_field",
-    "is_schema_without_field",
-    "schema_dump",
     "trace",
 )
 

sqlspec/utils/cached_property.py

@@ -0,0 +1,25 @@
+"""A simple cached property decorator."""
+
+from typing import Any, Callable, Generic, TypeVar
+
+__all__ = ("CachedProperty",)
+
+
+T = TypeVar("T")
+Cls = TypeVar("Cls")
+
+
+class CachedProperty(Generic[T]):
+    """A property that is only computed once per instance and then replaces
+    itself with an ordinary attribute. Deleting the attribute resets the
+    property.
+    """
+
+    def __init__(self, func: Callable[[Any], T]) -> None:
+        self.func = func
+
+    def __get__(self, obj: Any, cls: type[Any]) -> Any:
+        if obj is None:
+            return self
+        value = obj.__dict__[self.func.__name__] = self.func(obj)
+        return value

sqlspec/utils/correlation.py

@@ -72,7 +72,6 @@ class CorrelationContext:
         previous_id = cls.get()
 
         try:
-            # Set the new correlation ID
             cls.set(correlation_id)
             yield correlation_id
         finally:
@@ -145,7 +144,6 @@ def get_correlation_adapter(logger: Any) -> LoggerAdapter:
             """
             extra = kwargs.get("extra", {})
 
-            # Add correlation ID if available
             if correlation_id := CorrelationContext.get():
                 extra["correlation_id"] = correlation_id
 

sqlspec/utils/logging.py

@@ -63,15 +63,12 @@ class StructuredFormatter(logging.Formatter):
             "line": record.lineno,
         }
 
-        # Add correlation ID if available
         if correlation_id := get_correlation_id():
             log_entry["correlation_id"] = correlation_id
 
-        # Add any extra fields from the record
         if hasattr(record, "extra_fields"):
             log_entry.update(record.extra_fields)  # pyright: ignore
 
-        # Add exception info if present
         if record.exc_info:
             log_entry["exception"] = self.formatException(record.exc_info)
 
@@ -107,13 +104,11 @@ def get_logger(name: str | None = None) -> logging.Logger:
     if name is None:
         return logging.getLogger("sqlspec")
 
-    # Ensure all loggers are under the sqlspec namespace
     if not name.startswith("sqlspec"):
         name = f"sqlspec.{name}"
 
     logger = logging.getLogger(name)
 
-    # Add correlation ID filter if not already present
     if not any(isinstance(f, CorrelationIDFilter) for f in logger.filters):
         logger.addFilter(CorrelationIDFilter())
 
@@ -129,7 +124,6 @@ def log_with_context(logger: logging.Logger, level: int, message: str, **extra_f
         message: Log message
         **extra_fields: Additional fields to include in structured logs
     """
-    # Create a LogRecord with extra fields
     record = logger.makeRecord(logger.name, level, "(unknown file)", 0, message, (), None)
     record.extra_fields = extra_fields
     logger.handle(record)

sqlspec/utils/sync_tools.py

@@ -79,7 +79,6 @@ def run_(async_function: "Callable[ParamSpecT, Coroutine[Any, Any, ReturnT]]") -
         if loop is not None:
             # Running in an existing event loop
             return asyncio.run(partial_f())
-        # Create a new event loop and run the function
         if uvloop and sys.platform != "win32":
             uvloop.install()  # pyright: ignore[reportUnknownMemberType]
         return asyncio.run(partial_f())
@@ -107,7 +106,6 @@ def await_(
         try:
             loop = asyncio.get_running_loop()
         except RuntimeError:
-            # No running event loop
             if raise_sync_error:
                 msg = "Cannot run async function"
                 raise RuntimeError(msg) from None
@@ -116,7 +114,6 @@ def await_(
             # Running in an existing event loop.
             if loop.is_running():
                 try:
-                    # Check if the current context is within a task managed by this loop
                     current_task = asyncio.current_task(loop=loop)
                 except RuntimeError:
                     # Not running inside a task managed by this loop
@@ -138,7 +135,6 @@ def await_(
             if raise_sync_error:
                 msg = "Cannot run async function"
                 raise RuntimeError(msg)
-            # Fallback to running in a new loop
             return asyncio.run(partial_f())
 
     return wrapper

sqlspec/utils/text.py

@@ -14,7 +14,6 @@ _SLUGIFY_HYPHEN_COLLAPSE = re.compile(r"-+")
 _SNAKE_CASE_LOWER_OR_DIGIT_TO_UPPER = re.compile(r"(?<=[a-z0-9])(?=[A-Z])", re.UNICODE)
 # Insert underscore between uppercase letter and uppercase followed by lowercase
 _SNAKE_CASE_UPPER_TO_UPPER_LOWER = re.compile(r"(?<=[A-Z])(?=[A-Z][a-z])", re.UNICODE)
-# Replace hyphens, spaces, dots, and @ symbols with underscores for snake_case
 _SNAKE_CASE_HYPHEN_SPACE = re.compile(r"[.\s@-]+", re.UNICODE)
 # Collapse multiple underscores
 _SNAKE_CASE_MULTIPLE_UNDERSCORES = re.compile(r"__+", re.UNICODE)
@@ -66,17 +65,13 @@ def slugify(value: str, allow_unicode: bool = False, separator: Optional[str] =
     value = value.lower().strip()
     sep = separator if separator is not None else "-"
     if not sep:
-        # Remove all non-alphanumeric characters and return
         return _SLUGIFY_REMOVE_NON_ALPHANUMERIC.sub("", value)
-    # Replace all runs of non-alphanumeric chars with the separator
     value = _SLUGIFY_REMOVE_NON_ALPHANUMERIC.sub(sep, value)
-    # Remove leading/trailing separators and collapse multiple separators
     # For dynamic separators, we need to use re.sub with escaped separator
     if sep == "-":
         # Use pre-compiled regex for common case
         value = value.strip("-")
         return _SLUGIFY_HYPHEN_COLLAPSE.sub("-", value)
-    # For other separators, use dynamic regex
     value = re.sub(rf"^{re.escape(sep)}+|{re.escape(sep)}+$", "", value)
     return re.sub(rf"{re.escape(sep)}+", sep, value)