sqlspec 0.13.1__py3-none-any.whl → 0.16.2__py3-none-any.whl

sqlspec/driver/mixins/_type_coercion.py

@@ -1,130 +0,0 @@
-"""Type coercion mixin for database drivers.
-
-This module provides a mixin that all database drivers use to handle
-TypedParameter objects and perform appropriate type conversions.
-"""
-
-from decimal import Decimal
-from typing import TYPE_CHECKING, Any, Optional, Union
-
-from sqlspec.utils.type_guards import has_parameter_value
-
-if TYPE_CHECKING:
-    from sqlspec.typing import SQLParameterType
-
-__all__ = ("TypeCoercionMixin",)
-
-
-class TypeCoercionMixin:
-    """Mixin providing type coercion for database drivers.
-
-    This mixin is used by all database drivers to handle TypedParameter objects
-    and convert values to database-specific types.
-    """
-
-    __slots__ = ()
-
-    def _process_parameters(self, parameters: "SQLParameterType") -> "SQLParameterType":
-        """Process parameters, extracting values from TypedParameter objects.
-
-        This method is called by drivers before executing SQL to handle
-        TypedParameter objects and perform necessary type conversions.
-
-        Args:
-            parameters: Raw parameters that may contain TypedParameter objects
-
-        Returns:
-            Processed parameters with TypedParameter values extracted and converted
-        """
-        if parameters is None:
-            return None
-
-        if isinstance(parameters, dict):
-            return self._process_dict_parameters(parameters)
-        if isinstance(parameters, (list, tuple)):
-            return self._process_sequence_parameters(parameters)
-        # Single scalar parameter
-        return self._coerce_parameter_type(parameters)
-
-    def _process_dict_parameters(self, params: dict[str, Any]) -> dict[str, Any]:
-        """Process dictionary parameters."""
-        result = {}
-        for key, value in params.items():
-            result[key] = self._coerce_parameter_type(value)
-        return result
-
-    def _process_sequence_parameters(self, params: Union[list, tuple]) -> Union[list, tuple]:
-        """Process list/tuple parameters."""
-        result = [self._coerce_parameter_type(p) for p in params]
-        return tuple(result) if isinstance(params, tuple) else result
-
-    def _coerce_parameter_type(self, param: Any) -> Any:
-        """Coerce a single parameter to the appropriate database type.
-
-        This method checks if the parameter is a TypedParameter and extracts
-        its value, then applies driver-specific type conversions.
-
-        Args:
-            param: Parameter value or TypedParameter object
-
-        Returns:
-            Coerced parameter value suitable for the database
-        """
-        if has_parameter_value(param):
-            value = param.value
-            type_hint = param.type_hint
-
-            return self._apply_type_coercion(value, type_hint)
-        # Regular parameter - apply default coercion
-        return self._apply_type_coercion(param, None)
-
-    def _apply_type_coercion(self, value: Any, type_hint: Optional[str]) -> Any:
-        """Apply driver-specific type coercion.
-
-        This method should be overridden by each driver to implement
-        database-specific type conversions.
-
-        Args:
-            value: The value to coerce
-            type_hint: Optional type hint from TypedParameter
-
-        Returns:
-            Coerced value
-        """
-        # Default implementation - override in specific drivers
-        # This base implementation handles common cases
-
-        if value is None:
-            return None
-
-        # Use type hint if available
-        if type_hint:
-            if type_hint == "boolean":
-                return self._coerce_boolean(value)
-            if type_hint == "decimal":
-                return self._coerce_decimal(value)
-            if type_hint == "json":
-                return self._coerce_json(value)
-            if type_hint.startswith("array"):
-                return self._coerce_array(value)
-
-        # Default: return value as-is
-        return value
-
-    def _coerce_boolean(self, value: Any) -> Any:
-        """Coerce boolean values. Override in drivers without native boolean support."""
-        return value
-
-    def _coerce_decimal(self, value: Any) -> Any:
-        """Coerce decimal values. Override for specific decimal handling."""
-        if isinstance(value, str):
-            return Decimal(value)
-        return value
-
-    def _coerce_json(self, value: Any) -> Any:
-        """Coerce JSON values. Override for databases needing JSON strings."""
-        return value
-
-    def _coerce_array(self, value: Any) -> Any:
-        """Coerce array values. Override for databases without native array support."""
-        return value

sqlspec/driver/parameters.py

@@ -1,138 +0,0 @@
-"""Consolidated parameter processing utilities for database drivers.
-
-This module provides centralized parameter handling logic to avoid duplication
-across sync and async driver implementations.
-"""
-
-from typing import TYPE_CHECKING, Any, Optional, Union
-
-from sqlspec.statement.filters import StatementFilter
-from sqlspec.utils.type_guards import is_sync_transaction_capable
-
-if TYPE_CHECKING:
-    from sqlspec.typing import StatementParameters
-
-__all__ = (
-    "convert_parameters_to_positional",
-    "normalize_parameter_sequence",
-    "process_execute_many_parameters",
-    "separate_filters_and_parameters",
-    "should_use_transaction",
-)
-
-
-def separate_filters_and_parameters(
-    parameters: "tuple[Union[StatementParameters, StatementFilter], ...]",
-) -> "tuple[list[StatementFilter], list[Any]]":
-    """Separate filters from parameters in a mixed parameter tuple.
-
-    Args:
-        parameters: Mixed tuple of parameters and filters
-
-    Returns:
-        Tuple of (filters, parameters) lists
-    """
-
-    filters: list[StatementFilter] = []
-    param_values: list[Any] = []
-
-    for param in parameters:
-        if isinstance(param, StatementFilter):
-            filters.append(param)
-        else:
-            param_values.append(param)
-
-    return filters, param_values
-
-
-def process_execute_many_parameters(
-    parameters: "tuple[Union[StatementParameters, StatementFilter], ...]",
-) -> "tuple[list[StatementFilter], Optional[list[Any]]]":
-    """Process parameters for execute_many operations.
-
-    Args:
-        parameters: Mixed tuple of parameters and filters
-
-    Returns:
-        Tuple of (filters, parameter_sequence)
-    """
-    filters, param_values = separate_filters_and_parameters(parameters)
-
-    # Use first parameter as the sequence for execute_many
-    param_sequence = param_values[0] if param_values else None
-
-    # Normalize the parameter sequence
-    param_sequence = normalize_parameter_sequence(param_sequence)
-
-    return filters, param_sequence
-
-
-def normalize_parameter_sequence(params: Any) -> Optional[list[Any]]:
-    """Normalize a parameter sequence to a list format.
-
-    Args:
-        params: Parameter sequence in various formats
-
-    Returns:
-        Normalized list of parameters or None
-    """
-    if params is None:
-        return None
-
-    if isinstance(params, list):
-        return params
-
-    if isinstance(params, tuple):
-        return list(params)
-
-    # Check if it's iterable (but not string or dict)
-    # Use duck typing to check for iterable protocol
-    try:
-        iter(params)
-        if not isinstance(params, (str, dict)):
-            return list(params)
-    except TypeError:
-        pass
-
-    # Single parameter, wrap in list
-    return [params]
-
-
-def convert_parameters_to_positional(params: "dict[str, Any]", parameter_info: "list[Any]") -> list[Any]:
-    """Convert named parameters to positional based on SQL order.
-
-    Args:
-        params: Dictionary of named parameters
-        parameter_info: List of parameter info from SQL parsing
-
-    Returns:
-        List of positional parameters
-    """
-    if not params:
-        return []
-
-    # Handle param_0, param_1, etc. pattern
-    if all(key.startswith("param_") for key in params):
-        return [params[f"param_{i}"] for i in range(len(params))]
-
-    # Convert based on parameter info order
-    # Check for name attribute using getattr with default
-    result = []
-    for info in parameter_info:
-        param_name = getattr(info, "name", None)
-        if param_name is not None:
-            result.append(params.get(param_name, None))
-    return result
-
-
-def should_use_transaction(connection: Any, auto_commit: bool = True) -> bool:
-    """Determine if a transaction should be used.
-
-    Args:
-        connection: Database connection object
-        auto_commit: Whether auto-commit is enabled
-
-    Returns:
-        True if transaction capabilities are available and should be used
-    """
-    return False if auto_commit else is_sync_transaction_capable(connection)

sqlspec/service/__init__.py

@@ -1,4 +0,0 @@
-from sqlspec.service.base import SQLSpecAsyncService, SQLSpecSyncService
-from sqlspec.service.pagination import OffsetPagination
-
-__all__ = ("OffsetPagination", "SQLSpecAsyncService", "SQLSpecSyncService")

sqlspec/service/_util.py

@@ -1,147 +0,0 @@
-from collections.abc import Sequence
-from functools import partial
-from typing import Any, Optional, TypeVar, Union, cast, overload
-
-from sqlspec.driver.mixins._result_utils import _DEFAULT_TYPE_DECODERS, _default_msgspec_deserializer
-from sqlspec.exceptions import SQLSpecError
-from sqlspec.service.pagination import OffsetPagination
-from sqlspec.statement.filters import FilterTypeT, LimitOffsetFilter, StatementFilter
-from sqlspec.typing import BaseModel, DataclassProtocol, ModelDTOT, ModelT, Struct, convert, get_type_adapter
-from sqlspec.utils.type_guards import is_dataclass, is_msgspec_struct, is_pydantic_model
-
-__all__ = ("ResultConverter", "find_filter")
-
-
-T = TypeVar("T")
-
-
-def find_filter(
-    filter_type: "type[FilterTypeT]", filters: "Optional[Sequence[StatementFilter]]" = None
-) -> "Optional[FilterTypeT]":
-    """Get the filter specified by filter type from the filters.
-
-    Args:
-        filter_type: The type of filter to find.
-        filters: filter types to apply to the query
-
-    Returns:
-        The match filter instance or None
-    """
-    if filters is None:
-        return None
-    return next(
-        (cast("Optional[FilterTypeT]", filter_) for filter_ in filters if isinstance(filter_, filter_type)), None
-    )
-
-
-# TODO: add overloads for each type of pagination in the future
-class ResultConverter:
-    """Simple mixin to help convert to dictionary or list of dictionaries to specified schema type.
-
-    Single objects are transformed to the supplied schema type, and lists of objects are transformed into a list of the supplied schema type.
-
-    Args:
-        data: A database model instance or row mapping.
-              Type: :class:`~sqlspec.typing.ModelDictT`
-
-    Returns:
-        The converted schema object.
-    """
-
-    @overload
-    def to_schema(
-        self,
-        data: "ModelT",
-        total: "int | None" = None,
-        filters: "Sequence[StatementFilter] | None" = None,
-        *,
-        schema_type: None = None,
-    ) -> "ModelT": ...
-    @overload
-    def to_schema(
-        self,
-        data: "dict[str, Any] | Struct | BaseModel | DataclassProtocol",
-        total: "int | None" = None,
-        filters: "Sequence[StatementFilter] | None" = None,
-        *,
-        schema_type: "type[ModelDTOT]",
-    ) -> "ModelDTOT": ...
-    @overload
-    def to_schema(
-        self,
-        data: "Sequence[ModelT]",
-        total: "int | None" = None,
-        filters: "Sequence[StatementFilter] | None" = None,
-        *,
-        schema_type: None = None,
-    ) -> "OffsetPagination[ModelT]": ...
-    @overload
-    def to_schema(
-        self,
-        data: "Sequence[dict[str, Any] | Struct | BaseModel | DataclassProtocol]",
-        total: "int | None" = None,
-        filters: "Sequence[StatementFilter] | None" = None,
-        *,
-        schema_type: "type[ModelDTOT]",
-    ) -> "OffsetPagination[ModelDTOT]": ...
-    def to_schema(
-        self,
-        data: "ModelT | Sequence[ModelT] | dict[str, Any] | Struct | BaseModel | DataclassProtocol | Sequence[dict[str, Any] | Struct | BaseModel | DataclassProtocol]",
-        total: "int | None" = None,
-        filters: "Sequence[StatementFilter] | None" = None,
-        *,
-        schema_type: "type[ModelDTOT] | None" = None,
-    ) -> "Union[ModelT,   ModelDTOT ,  OffsetPagination[ModelT] , OffsetPagination[ModelDTOT]]":
-        if not isinstance(data, Sequence):
-            if schema_type is None:
-                return cast("ModelT", data)
-            if is_dataclass(schema_type):
-                return cast("ModelDTOT", schema_type(**data))  # type: ignore[operator]
-            if is_msgspec_struct(schema_type):
-                return cast(
-                    "ModelDTOT",
-                    convert(
-                        obj=data,
-                        type=schema_type,
-                        from_attributes=True,
-                        dec_hook=partial(_default_msgspec_deserializer, type_decoders=_DEFAULT_TYPE_DECODERS),
-                    ),
-                )
-            if is_pydantic_model(schema_type):  # pyright: ignore
-                return cast(
-                    "ModelDTOT",
-                    get_type_adapter(schema_type).validate_python(data, from_attributes=True),  # pyright: ignore
-                )
-        assert isinstance(data, Sequence)
-        limit_offset = find_filter(LimitOffsetFilter, filters=filters)
-        if schema_type is None:
-            return OffsetPagination[ModelT](
-                items=cast("list[ModelT]", data),
-                limit=limit_offset.limit if limit_offset else len(data),
-                offset=limit_offset.offset if limit_offset else 0,
-                total=total if total is not None else len(data),
-            )
-        converted_items: Sequence[ModelDTOT]
-        if is_dataclass(schema_type):
-            converted_items = [schema_type(**item) for item in data]  # type: ignore[operator]
-        elif is_msgspec_struct(schema_type):
-            converted_items = convert(
-                obj=data,
-                type=list[schema_type],  # type: ignore[valid-type]
-                from_attributes=True,
-                dec_hook=partial(_default_msgspec_deserializer, type_decoders=_DEFAULT_TYPE_DECODERS),
-            )
-        elif is_pydantic_model(schema_type):  # pyright: ignore
-            converted_items = get_type_adapter(list[schema_type]).validate_python(data, from_attributes=True)  # type: ignore[valid-type] # pyright: ignore[reportUnknownArgumentType]
-        else:
-            # This will also catch the case where a single item had an unrecognized schema_type
-            # if it somehow bypassed the initial single-item checks.
-            msg = "`schema_type` should be a valid Dataclass, Pydantic model or Msgspec struct"
-            raise SQLSpecError(msg)
-
-        return OffsetPagination[ModelDTOT](
-            items=cast("list[ModelDTOT]", converted_items),
-            limit=limit_offset.limit if limit_offset else len(data),
-            offset=limit_offset.offset if limit_offset else 0,
-            total=total if total is not None else len(data),
-        )