sqlspec 0.10.0__py3-none-any.whl → 0.11.0__py3-none-any.whl

sqlspec/typing.py

@@ -474,7 +474,7 @@ def dataclass_to_dict(
     return cast("dict[str, Any]", ret)
 
 
-def schema_dump(  # noqa: PLR0911
+def schema_dump(
     data: "Union[dict[str, Any],   DataclassProtocol, Struct, BaseModel]",
     exclude_unset: bool = True,
 ) -> "dict[str, Any]":
@@ -503,6 +503,18 @@ def schema_dump(  # noqa: PLR0911
     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)
+
+
 __all__ = (
     "LITESTAR_INSTALLED",
     "MSGSPEC_INSTALLED",
@@ -536,6 +548,7 @@ __all__ = (
     "is_dict",
     "is_dict_with_field",
     "is_dict_without_field",
+    "is_dto_data",
     "is_msgspec_struct",
     "is_msgspec_struct_with_field",
     "is_msgspec_struct_without_field",
@@ -566,3 +579,7 @@ if TYPE_CHECKING:
         from sqlspec._typing import ArrowTable
     else:
         from pyarrow import Table as ArrowTable  # noqa: TC004
+    if not LITESTAR_INSTALLED:
+        from sqlspec._typing import DTOData
+    else:
+        from litestar.dto import DTOData  # noqa: TC004

sqlspec/utils/__init__.py

@@ -1,3 +1,3 @@
-from sqlspec.utils import deprecation, fixtures, module_loader, sync_tools, text
+from sqlspec.utils import deprecation, fixtures, module_loader, singleton, sync_tools, text
 
-__all__ = ("deprecation", "fixtures", "module_loader", "sync_tools", "text")
+__all__ = ("deprecation", "fixtures", "module_loader", "singleton", "sync_tools", "text")

sqlspec/utils/singleton.py

@@ -0,0 +1,35 @@
+from typing import Any, TypeVar
+
+__all__ = ("SingletonMeta",)
+
+
+_T = TypeVar("_T")
+
+
+class SingletonMeta(type):
+    """Metaclass for singleton pattern."""
+
+    # We store instances keyed by the class type
+    _instances: dict[type, object] = {}
+
+    def __call__(cls: type[_T], *args: Any, **kwargs: Any) -> _T:
+        """Call method for the singleton metaclass.
+
+        Args:
+            cls: The class being instantiated.
+            *args: Positional arguments for the class constructor.
+            **kwargs: Keyword arguments for the class constructor.
+
+        Returns:
+            The singleton instance of the class.
+        """
+        # Use SingletonMeta._instances to access the class attribute
+        if cls not in SingletonMeta._instances:  # pyright: ignore[reportUnnecessaryContains]
+            # Create the instance using super().__call__ which calls the class's __new__ and __init__
+            instance = super().__call__(*args, **kwargs)  # type: ignore[misc]
+            SingletonMeta._instances[cls] = instance
+
+        # Return the cached instance. We cast here because the dictionary stores `object`,
+        # but we know it's of type _T for the given cls key.
+        # Mypy might need an ignore here depending on configuration, but pyright should handle it.
+        return SingletonMeta._instances[cls]  # type: ignore[return-value]

sqlspec/utils/sync_tools.py

@@ -30,139 +30,6 @@ ParamSpecT = ParamSpec("ParamSpecT")
 T = TypeVar("T")
 
 
-class PendingType:
-    def __repr__(self) -> str:
-        return "AsyncPending"
-
-
-Pending = PendingType()
-
-
-class PendingValueError(Exception):
-    """Exception raised when a value is accessed before it is ready."""
-
-
-class SoonValue(Generic[T]):
-    """Holds a value that will be available soon after an async operation."""
-
-    def __init__(self) -> None:
-        self._stored_value: Union[T, PendingType] = Pending
-
-    @property
-    def value(self) -> "T":
-        if isinstance(self._stored_value, PendingType):
-            msg = "The return value of this task is still pending."
-            raise PendingValueError(msg)
-        return self._stored_value
-
-    @property
-    def ready(self) -> bool:
-        return not isinstance(self._stored_value, PendingType)
-
-
-class TaskGroup:
-    """Manages a group of asyncio tasks, allowing them to be run concurrently."""
-
-    def __init__(self) -> None:
-        self._tasks: set[asyncio.Task[Any]] = set()
-        self._exceptions: list[BaseException] = []
-        self._closed = False
-
-    async def __aenter__(self) -> "TaskGroup":
-        if self._closed:
-            msg = "Cannot enter a task group that has already been closed."
-            raise RuntimeError(msg)
-        return self
-
-    async def __aexit__(
-        self,
-        exc_type: "Optional[type[BaseException]]",  # noqa: PYI036
-        exc_val: "Optional[BaseException]",  # noqa: PYI036
-        exc_tb: "Optional[TracebackType]",  # noqa: PYI036
-    ) -> None:
-        self._closed = True
-        if exc_val:
-            self._exceptions.append(exc_val)
-
-        if self._tasks:
-            await asyncio.wait(self._tasks)
-
-        if self._exceptions:
-            # Re-raise the first exception encountered.
-            raise self._exceptions[0]
-
-    def create_task(self, coro: "Coroutine[Any, Any, Any]") -> "asyncio.Task[Any]":
-        """Create and add a coroutine as a task to the task group.
-
-        Args:
-            coro (Coroutine): The coroutine to be added as a task.
-
-        Returns:
-            asyncio.Task: The created asyncio task.
-
-        Raises:
-            RuntimeError: If the task group has already been closed.
-        """
-        if self._closed:
-            msg = "Cannot create a task in a task group that has already been closed."
-            raise RuntimeError(msg)
-        task = asyncio.create_task(coro)
-        self._tasks.add(task)
-        task.add_done_callback(self._tasks.discard)
-        task.add_done_callback(self._check_result)
-        return task
-
-    def _check_result(self, task: "asyncio.Task[Any]") -> None:
-        """Check and store exceptions from a completed task.
-
-        Args:
-            task (asyncio.Task): The task to check for exceptions.
-        """
-        try:
-            task.result()  # This will raise the exception if one occurred.
-        except Exception as e:  # noqa: BLE001
-            self._exceptions.append(e)
-
-    def start_soon_(
-        self,
-        async_function: "Callable[ParamSpecT, Awaitable[T]]",
-        name: object = None,
-    ) -> "Callable[ParamSpecT, SoonValue[T]]":
-        """Create a function to start a new task in this task group.
-
-        Args:
-            async_function (Callable): An async function to call soon.
-            name (object, optional): Name of the task for introspection and debugging.
-
-        Returns:
-            Callable: A function that starts the task and returns a SoonValue object.
-        """
-
-        @functools.wraps(async_function)
-        def wrapper(*args: "ParamSpecT.args", **kwargs: "ParamSpecT.kwargs") -> "SoonValue[T]":
-            partial_f = functools.partial(async_function, *args, **kwargs)
-            soon_value: SoonValue[T] = SoonValue()
-
-            @functools.wraps(partial_f)
-            async def value_wrapper(*args: "Any") -> None:
-                value = await partial_f()
-                soon_value._stored_value = value  # pyright: ignore[reportPrivateUsage]  # noqa: SLF001
-
-            self.create_task(value_wrapper)  # type: ignore[arg-type]
-            return soon_value
-
-        return wrapper
-
-
-def create_task_group() -> "TaskGroup":
-    """Create a TaskGroup for managing multiple concurrent async tasks.
-
-    Returns:
-        TaskGroup: A new TaskGroup instance.
-    """
-    return TaskGroup()
-
-
 class CapacityLimiter:
     """Limits the number of concurrent operations using a semaphore."""
 
@@ -195,7 +62,7 @@ class CapacityLimiter:
         self.release()
 
 
-_default_limiter = CapacityLimiter(40)
+_default_limiter = CapacityLimiter(15)
 
 
 def run_(async_function: "Callable[ParamSpecT, Coroutine[Any, Any, ReturnT]]") -> "Callable[ParamSpecT, ReturnT]":
@@ -237,6 +104,7 @@ def await_(
     Args:
         async_function (Callable): The async function to convert.
         raise_sync_error (bool, optional): If False, runs in a new event loop if no loop is present.
+                                         If True (default), raises RuntimeError if no loop is running.
 
     Returns:
         Callable: A blocking function that runs the async function.
@@ -248,12 +116,39 @@ def await_(
         try:
             loop = asyncio.get_running_loop()
         except RuntimeError:
-            loop = None
-
-        if loop is None and raise_sync_error is False:
+            # No running event loop
+            if raise_sync_error:
+                msg = "await_ called without a running event loop and raise_sync_error=True"
+                raise RuntimeError(msg) from None
+            return asyncio.run(partial_f())
+        else:
+            # 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
+                    current_task = None
+
+                if current_task is not None:
+                    # Called from within the event loop's execution context (a task).
+                    # Blocking here would deadlock the loop.
+                    msg = "await_ cannot be called from within an async task running on the same event loop. Use 'await' instead."
+                    raise RuntimeError(msg)
+                # Called from a different thread than the loop's thread.
+                # It's safe to block this thread and wait for the loop.
+                future = asyncio.run_coroutine_threadsafe(partial_f(), loop)
+                # This blocks the *calling* thread, not the loop thread.
+                return future.result()
+            # This case should ideally not happen if get_running_loop() succeeded
+            # but the loop isn't running, but handle defensively.
+            # loop is not running
+            if raise_sync_error:
+                msg = "await_ found a non-running loop via get_running_loop()"
+                raise RuntimeError(msg)
+            # Fallback to running in a new loop
             return asyncio.run(partial_f())
-        # Running in an existing event loop
-        return asyncio.run(partial_f())
 
     return wrapper
 
@@ -286,9 +181,17 @@ def async_(
     return wrapper
 
 
-def maybe_async_(
+def ensure_async_(
     function: "Callable[ParamSpecT, Union[Awaitable[ReturnT], ReturnT]]",
 ) -> "Callable[ParamSpecT, Awaitable[ReturnT]]":
+    """Convert a function to an async one if it is not already.
+
+    Args:
+        function (Callable): The function to convert.
+
+    Returns:
+        Callable: An async function that runs the original function.
+    """
     if inspect.iscoroutinefunction(function):
         return function
 
@@ -301,16 +204,6 @@ def maybe_async_(
     return wrapper
 
 
-def wrap_sync(fn: "Callable[ParamSpecT, ReturnT]") -> "Callable[ParamSpecT, Awaitable[ReturnT]]":
-    if inspect.iscoroutinefunction(fn):
-        return fn
-
-    async def wrapped(*args: "ParamSpecT.args", **kwargs: "ParamSpecT.kwargs") -> ReturnT:
-        return await async_(functools.partial(fn, *args, **kwargs))()
-
-    return wrapped
-
-
 class _ContextManagerWrapper(Generic[T]):
     def __init__(self, cm: AbstractContextManager[T]) -> None:
         self._cm = cm
@@ -327,9 +220,55 @@ class _ContextManagerWrapper(Generic[T]):
         return self._cm.__exit__(exc_type, exc_val, exc_tb)
 
 
-def maybe_async_context(
+def with_ensure_async_(
     obj: "Union[AbstractContextManager[T], AbstractAsyncContextManager[T]]",
 ) -> "AbstractAsyncContextManager[T]":
+    """Convert a context manager to an async one if it is not already.
+
+    Args:
+        obj (AbstractContextManager[T] or AbstractAsyncContextManager[T]): The context manager to convert.
+
+    Returns:
+        AbstractAsyncContextManager[T]: An async context manager that runs the original context manager.
+    """
+
     if isinstance(obj, AbstractContextManager):
         return cast("AbstractAsyncContextManager[T]", _ContextManagerWrapper(obj))
     return obj
+
+
+class NoValue:
+    """A fake "Empty class"""
+
+
+async def get_next(iterable: Any, default: Any = NoValue, *args: Any) -> Any:  # pragma: no cover
+    """Return the next item from an async iterator.
+
+    In Python <3.10, `anext` is not available. This function is a drop-in replacement.
+
+    This function will return the next value form an async iterable. If the
+    iterable is empty the StopAsyncIteration will be propagated. However, if
+    a default value is given as a second argument the exception is silenced and
+    the default value is returned instead.
+
+    Args:
+        iterable: An async iterable.
+        default: An optional default value to return if the iterable is empty.
+        *args: The remaining args
+    Return:
+        The next value of the iterable.
+
+    Raises:
+        StopAsyncIteration: The iterable given is not async.
+
+
+    """
+    has_default = bool(not isinstance(default, NoValue))
+    try:
+        return await iterable.__anext__()
+
+    except StopAsyncIteration as exc:
+        if has_default:
+            return default
+
+        raise StopAsyncIteration from exc

sqlspec/utils/text.py

@@ -2,23 +2,52 @@
 
 import re
 import unicodedata
+from functools import lru_cache
 from typing import Optional
 
+# Compiled regex for slugify
+_SLUGIFY_REMOVE_INVALID_CHARS_RE = re.compile(r"[^\w\s-]")
+_SLUGIFY_COLLAPSE_SEPARATORS_RE = re.compile(r"[-\s]+")
+
+# Compiled regex for snake_case
+# Handles sequences like "HTTPRequest" -> "HTTP_Request" or "SSLError" -> "SSL_Error"
+_SNAKE_CASE_RE_ACRONYM_SEQUENCE = re.compile(r"([A-Z\d]+)([A-Z][a-z])")
+# Handles transitions like "camelCase" -> "camel_Case" or "PascalCase" -> "Pascal_Case" (partially)
+_SNAKE_CASE_RE_LOWER_UPPER_TRANSITION = re.compile(r"([a-z\d])([A-Z])")
+# Replaces hyphens, spaces, and dots with a single underscore
+_SNAKE_CASE_RE_REPLACE_SEP = re.compile(r"[-\s.]+")
+# Cleans up multiple consecutive underscores
+_SNAKE_CASE_RE_CLEAN_MULTIPLE_UNDERSCORE = re.compile(r"__+")
+
 __all__ = (
+    "camelize",
     "check_email",
     "slugify",
+    "snake_case",
 )
 
 
 def check_email(email: str) -> str:
-    """Validate an email."""
+    """Validate an email.
+
+    Very simple email validation.
+
+    Args:
+        email (str): The email to validate.
+
+    Raises:
+        ValueError: If the email is invalid.
+
+    Returns:
+        str: The validated email.
+    """
     if "@" not in email:
         msg = "Invalid email!"
         raise ValueError(msg)
     return email.lower()
 
 
-def slugify(value: str, allow_unicode: bool = False, separator: "Optional[str]" = None) -> str:
+def slugify(value: str, allow_unicode: bool = False, separator: Optional[str] = None) -> str:
     """Slugify.
 
     Convert to ASCII if ``allow_unicode`` is ``False``. Convert spaces or repeated
@@ -39,7 +68,41 @@ def slugify(value: str, allow_unicode: bool = False, separator: "Optional[str]"
         value = unicodedata.normalize("NFKC", value)
     else:
         value = unicodedata.normalize("NFKD", value).encode("ascii", "ignore").decode("ascii")
-    value = re.sub(r"[^\w\s-]", "", value.lower())
+    value = _SLUGIFY_REMOVE_INVALID_CHARS_RE.sub("", value.lower())
     if separator is not None:
-        return re.sub(r"[-\s]+", "-", value).strip("-_").replace("-", separator)
-    return re.sub(r"[-\s]+", "-", value).strip("-_")
+        return _SLUGIFY_COLLAPSE_SEPARATORS_RE.sub("-", value).strip("-_").replace("-", separator)
+    return _SLUGIFY_COLLAPSE_SEPARATORS_RE.sub("-", value).strip("-_")
+
+
+@lru_cache(maxsize=100)
+def camelize(string: str) -> str:
+    """Convert a string to camel case.
+
+    Args:
+        string (str): The string to convert.
+
+    Returns:
+        str: The converted string.
+    """
+    return "".join(word if index == 0 else word.capitalize() for index, word in enumerate(string.split("_")))
+
+
+@lru_cache(maxsize=100)
+def snake_case(string: str) -> str:
+    """Convert a string to snake_case.
+
+    Handles CamelCase, PascalCase, strings with spaces, hyphens, or dots
+    as separators, and ensures single underscores. It also correctly
+    handles acronyms (e.g., "HTTPRequest" becomes "http_request").
+
+    Args:
+        string: The string to convert.
+
+    Returns:
+        The snake_case version of the string.
+    """
+    s = _SNAKE_CASE_RE_ACRONYM_SEQUENCE.sub(r"\1_\2", string)
+    s = _SNAKE_CASE_RE_LOWER_UPPER_TRANSITION.sub(r"\1_\2", s)
+    s = _SNAKE_CASE_RE_REPLACE_SEP.sub("_", s).lower()
+    s = _SNAKE_CASE_RE_CLEAN_MULTIPLE_UNDERSCORE.sub("_", s)
+    return s.strip("_")

{sqlspec-0.10.0.dist-info → sqlspec-0.11.0.dist-info}/METADATA

@@ -1,7 +1,10 @@
 Metadata-Version: 2.4
 Name: sqlspec
-Version: 0.10.0
+Version: 0.11.0
 Summary: SQL Experiments in Python
+Project-URL: Discord, https://discord.gg/litestar
+Project-URL: Issue, https://github.com/litestar-org/sqlspec/issues/
+Project-URL: Source, https://github.com/litestar-org/sqlspec
 Author-email: Cody Fincher <cody@litestar.dev>
 Maintainer-email: Litestar Developers <hello@litestar.dev>
 License-Expression: MIT
@@ -258,6 +261,7 @@ This list is not final. If you have a driver you'd like to see added, please ope
 | [`spanner`](https://googleapis.dev/python/spanner/latest/index.html)                                         | Spanner    | Sync    | 🗓️  |
 | [`sqlserver`](https://docs.microsoft.com/en-us/sql/connect/python/pyodbc/python-sql-driver-for-pyodbc?view=sql-server-ver16) | SQL Server | Sync    | 🗓️  |
 | [`mysql`](https://dev.mysql.com/doc/connector-python/en/connector-python-api-mysql-connector-python.html)     | MySQL      | Sync    | 🗓️  |
+| [`asyncmy`](https://github.com/long2ice/asyncmy)                                                           | MySQL      | Async   | ✅         |
 | [`snowflake`](https://docs.snowflake.com)                                                                    | Snowflake  | Sync    | 🗓️  |
 
 ## Proposed Project Structure

{sqlspec-0.10.0.dist-info → sqlspec-0.11.0.dist-info}/RECORD

@@ -1,67 +1,69 @@
 sqlspec/__init__.py,sha256=Dl1QOZAK21--ORQcRn15n4YPFklFMe2-Lb7TWWq_WQE,338
 sqlspec/__metadata__.py,sha256=hNP3wXvtk8fQVPKGjRLpZ9mP-gaPJqzrmgm3UqpDIXQ,460
 sqlspec/_serialization.py,sha256=tSwWwFImlYviC6ARdXRz0Bp4QXbCdc8cKGgZr33OglY,2657
-sqlspec/_typing.py,sha256=6ukndnNu_XWKf2OW-HP1x1L7YmqohMwjg2HF4Hq3xdU,7111
-sqlspec/base.py,sha256=SQDE27igKL6OVQ-D9lz3oNrEZz4vWggRSuE4SDXJSbs,32789
+sqlspec/_typing.py,sha256=a8QTy3oqdUfjrA6Iu4PxfQcUf9DuG9pZcalcevM_xIU,7037
+sqlspec/base.py,sha256=Q6fIHtOqYXAcNt8fFe6zeqP34MLWm72do-l2Xc8pjLA,34140
 sqlspec/exceptions.py,sha256=WnA56CdDSSdOjA5UE4jnfXXtrfClgwjCRxT-id0eVAo,4302
-sqlspec/filters.py,sha256=Gqwt4VQ7e8ffphkuR-jBfqW4m0OWGGUPiYWyEQ0Xn7M,3620
-sqlspec/mixins.py,sha256=JWniOJfjviNBpAj3AnTnd2ZA79C0Vcu-bVHPS3Lbxcg,4751
+sqlspec/filters.py,sha256=Up8lDFbAcObwhxHApxlqh84Zco57wPLIeMxdxiyUih4,11999
+sqlspec/mixins.py,sha256=TkXGJg8eR54_LRGgzAKz0v6BT98XPNEwXUoMq02nckY,10416
 sqlspec/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sqlspec/statement.py,sha256=lbnF_flv4sWPPiZtHX-53d72eCFcceBYB4BgQQYjnCU,17451
-sqlspec/typing.py,sha256=eMLeqi-j28PNLs8jBb4oxeMjOe95jjV1DW8FIp0uCJY,15932
+sqlspec/statement.py,sha256=LNagGHKt-ixjom5WW5VLRzT9YIJC0lOfvwnn41Zz-fw,16433
+sqlspec/typing.py,sha256=XAQpyOPAcHzlGScY3DCxIfiaQpfbFP4PntIgvYdcLwk,16313
 sqlspec/adapters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sqlspec/adapters/adbc/__init__.py,sha256=Ih0mdciGyhmOlqmz4uiByj7mEaqvP4upRjYhlUNopAQ,193
-sqlspec/adapters/adbc/config.py,sha256=uCY-PD06QFJW0v7XpA9vruYgq1eoVwQ63juZe9imMu4,9663
-sqlspec/adapters/adbc/driver.py,sha256=Q619R8nFdSk-lPab2jk0F5xkzhXZPEDqbxw-67_1NBM,20100
+sqlspec/adapters/adbc/config.py,sha256=yayt62Mx789_B7Xo8DrlWCyeXclFchL4OxUxZIFnh9I,9646
+sqlspec/adapters/adbc/driver.py,sha256=qOvZ1g-S02GRPX35AywciwB_S9d7ffXkaE_obd8EP-w,28871
 sqlspec/adapters/aiosqlite/__init__.py,sha256=CndH49GREnHuIB-jY1XAxVlLwZTvKNuk8XJu9jiiM7A,233
 sqlspec/adapters/aiosqlite/config.py,sha256=tE-DnjKbdy5FaqqRyA1q3s06rMSAglt0HkhO2oWQT2w,4603
-sqlspec/adapters/aiosqlite/driver.py,sha256=319ixRaD03L465xa5ZsK2pXXaZ7wIxuWDm7ZXr-OMcg,15552
+sqlspec/adapters/aiosqlite/driver.py,sha256=d9Gz4bQmmqPhkJ0GrGNRVKwzPrUOEeHjWrj-Rr-7GA4,16802
 sqlspec/adapters/asyncmy/__init__.py,sha256=7jQFc0WOgc58XPeIiDgX9a95scMa6PuFgGXQaxG33nI,291
 sqlspec/adapters/asyncmy/config.py,sha256=5ILV46FWjc9Cy46aMuhinpfc70b_708h9ubHj9HRCmE,9412
-sqlspec/adapters/asyncmy/driver.py,sha256=yFgSNtInWshm994eiKd8c_rNJtM1mToAHfQ039egci0,12376
+sqlspec/adapters/asyncmy/driver.py,sha256=jbaO3O3heNVF016FmlbHt0tCR2yczS2dlbttx9A2oUU,17207
 sqlspec/adapters/asyncpg/__init__.py,sha256=iR-vJYxImcw5hLaDgMqPLLRxW_vOYylEpemSg5G4dP4,261
-sqlspec/adapters/asyncpg/config.py,sha256=yhLcZyJksx9eKUGVlcKSsR7FQmj8F2caryeTdh1CNvQ,9966
-sqlspec/adapters/asyncpg/driver.py,sha256=93f7ePb91GSrmJhAaMC7PwgZLvwr3RC5zq8xk8OEQPw,22431
+sqlspec/adapters/asyncpg/config.py,sha256=cuQ_cCQ6xtqluaNO5Ax9vqZ-4JZoaUR31-QE6xAVbns,10011
+sqlspec/adapters/asyncpg/driver.py,sha256=cmyxzieTcXSOnvNHdPORg5qHTGqYJyIi-ogNMBbL6hg,20495
 sqlspec/adapters/bigquery/__init__.py,sha256=8kcl0_tnvnk8omVKnAljIY9n2XVnzkPRCfhfedGO0m4,264
-sqlspec/adapters/bigquery/driver.py,sha256=8Y9Iq3d9U11wLOrd7_QlmAXMF3VAg7Werp0i5v0WStg,28402
+sqlspec/adapters/bigquery/driver.py,sha256=IcYWbP61-z2xLs7f5Df6mWidpWnDXbD9ONn7bFSOvo4,27601
 sqlspec/adapters/bigquery/config/__init__.py,sha256=4ij4LAS-kIt-vOK8KetewVoYN90i1RV_BjtowKWDIs0,150
 sqlspec/adapters/bigquery/config/_common.py,sha256=LSbBC302-Ewx8XHTRzYR-tInMYywVW9I6UcL8cO7-HQ,1901
 sqlspec/adapters/bigquery/config/_sync.py,sha256=oglaEErXuce1TnE2wj5KrfFLkScRGFYAoOTCVV5BFcw,3323
 sqlspec/adapters/duckdb/__init__.py,sha256=GMSHigyHgtaJKu751kE_Sxl5Ry4hnQOnFUSIeLSg1qs,209
 sqlspec/adapters/duckdb/config.py,sha256=b-Ev7UnpguC12CJSxK9DDqcPw0R2dZUZXaVIePf_EEg,15700
-sqlspec/adapters/duckdb/driver.py,sha256=rpBIGuAQlHtUp3oVInjdMdCQSgyx_oiOP39sjGlrdOA,13960
+sqlspec/adapters/duckdb/driver.py,sha256=OZX9bx8qAK5N19KeM1OunZbHXfduSk_0CScQWH68SdA,16117
 sqlspec/adapters/oracledb/__init__.py,sha256=vVe8cXZJLFvBA6LPx4NzGRLdOeRugzRjz92UYjb0lC0,521
-sqlspec/adapters/oracledb/driver.py,sha256=nLsSggAN4Zs1uo6J3Cd_3f0e54EzjLAoTlgaatb5ll8,31053
+sqlspec/adapters/oracledb/driver.py,sha256=6KH-GNpHIjKKIV2uzD1SGo4QBUPBN2plyRHKnTst7vo,37603
 sqlspec/adapters/oracledb/config/__init__.py,sha256=emx5jWXqw3ifoW-m_tNI7sTz_duq2vRkubc0J2QqEQ4,306
 sqlspec/adapters/oracledb/config/_asyncio.py,sha256=k0wGr4FflFR03jUSgrw-4LC4mYtRlyH9gnbbBXNcMRM,7310
 sqlspec/adapters/oracledb/config/_common.py,sha256=UJZL2DQQZM3uOn1E1A_gnsB8nX3-yCDXGd66PDI29_s,5691
 sqlspec/adapters/oracledb/config/_sync.py,sha256=nm5FnrRG1ScrNviw3MR_40Vq8WJCXX5mJGtHhhRTPb0,7055
 sqlspec/adapters/psqlpy/__init__.py,sha256=K8UlQrKfbCZmxGAaT4CHzQvdwGPxPLB9TDOHJgkESFc,251
 sqlspec/adapters/psqlpy/config.py,sha256=qssXcu_Nd6o_X8QU1i61sAXwi9FiTApWxiTRU0gyBhk,10205
-sqlspec/adapters/psqlpy/driver.py,sha256=dDLH6OyCIEtCjPktBcZEmRqBEB3FUaczpQrPDVNfAtc,17165
+sqlspec/adapters/psqlpy/driver.py,sha256=AzoD-Gfm7VGoBXZYPORlzn_6ZE5A6blg2uV4COQF4aI,21156
 sqlspec/adapters/psycopg/__init__.py,sha256=xmFWHSB6hwPNQS1wpBmAczJThABmhRv2PDNKqaMFX3E,535
-sqlspec/adapters/psycopg/driver.py,sha256=LelXlEWMn9gcuMPYz9WsRfEds3y08A-XmXzVIgA5zio,28746
+sqlspec/adapters/psycopg/driver.py,sha256=1YiIz_HX6tNj7LhU6gKxW4sr-5iza_eBPJ4VZPygy9w,27529
 sqlspec/adapters/psycopg/config/__init__.py,sha256=hUmtNkSma4M-Y66B-l1gh601Lx7FVYVhU0BWo9ssdJo,570
 sqlspec/adapters/psycopg/config/_async.py,sha256=oKitbfpsJVLhMnbMUmICQub3rBzVZ5n9lwsU_ZvB45s,6661
 sqlspec/adapters/psycopg/config/_common.py,sha256=UqqvqPE9zlSO9G_Gh6fI190cHfCDG98S0GaznGAHpdU,2181
 sqlspec/adapters/psycopg/config/_sync.py,sha256=GYPgE7jfb15gbVdTWRoGGS3B7hauN8wk61CW6Bdrjcs,6512
 sqlspec/adapters/sqlite/__init__.py,sha256=N8VL4Y850OOt63qz-Yvu6rIaCXiziASmn_qDY5tsRuA,209
 sqlspec/adapters/sqlite/config.py,sha256=lGz0G-JFd7dZLhbUrITn9V-ipbhlekwNUr0bXEzM-8k,4498
-sqlspec/adapters/sqlite/driver.py,sha256=S7__m5AJst86tKaDCYyyeBixbeyiPxqECkeNX_a4sgs,14057
+sqlspec/adapters/sqlite/driver.py,sha256=QBy0Rfhw_9ozTM5yyWETdzqAzOXjtsoGWVjURbDGQec,14669
 sqlspec/extensions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sqlspec/extensions/litestar/__init__.py,sha256=vJf0co-AUM75c7ZLil_TUCYilVNDtmVsdeVLbm9_xn8,512
+sqlspec/extensions/litestar/__init__.py,sha256=ifiR2AXv3m4iDncA2XsVsgk8NnEjcEKxjK2jhFe6A-8,262
 sqlspec/extensions/litestar/_utils.py,sha256=UgwFxqLnjDw9S8G0H24DP2GsbMGas81W1lfhfTY68m8,1969
-sqlspec/extensions/litestar/config.py,sha256=M91ClAl15twFYcsQyJ-w-CdW5dMAxHztRlTDqg2hw_M,4368
-sqlspec/extensions/litestar/handlers.py,sha256=eO5rmj3LcomaPerZ6Mpsur3J0QmucutjByQlID0XZtM,7962
-sqlspec/extensions/litestar/plugin.py,sha256=kQgKnBIXnSm87SAngfSfYWAAN3BNZ6fPLxm2MefnD8Q,5216
-sqlspec/utils/__init__.py,sha256=nVIUuMaHhhC1vXydoSBvnc-xTArqwWJaAtpjHhiM84Q,159
+sqlspec/extensions/litestar/config.py,sha256=Lz5_NqZ-XDXvaLh7fsPqxvuSDJ1JLJg1XUqbC-PdZPU,4666
+sqlspec/extensions/litestar/handlers.py,sha256=3RJJ5rCEQCbmrhDhkz9Tp03UxqPYhyL8PYR7WKyvuP8,10372
+sqlspec/extensions/litestar/plugin.py,sha256=0isCQ_VFC33_xyRf1Zcb2oWYbZpjFTg-OOZ2EGwTV5M,5175
+sqlspec/extensions/litestar/providers.py,sha256=dwdw7o0jfhDGNbwgabx41dROQ3HCgA0cdXNhWsJPVuw,21805
+sqlspec/utils/__init__.py,sha256=_Ya8IZuc2cZIstXr_xjgnSfxICXHXvu5mfWsi2USDrw,183
 sqlspec/utils/deprecation.py,sha256=4pwGxoQYI3dAc3L1lh4tszZG6e2jp5m4e0ICk8SJx5M,3886
 sqlspec/utils/fixtures.py,sha256=ni51rAuen6S1wuSi1kUwn6Qh25B-XrewPEsjV8G4gQ0,2029
 sqlspec/utils/module_loader.py,sha256=tmMy9JcTTQETcwT8Wt8adCIuqr4zinQnPbCiBJ6JTSQ,2703
-sqlspec/utils/sync_tools.py,sha256=xxHZ-5rnTrPEUNr7gxQUVvJd0NGJeO_MgisR8X7sI3c,10425
-sqlspec/utils/text.py,sha256=Ya-fWBcfkQRhguNs7MNFIYtAUiArBo62w8sRPHavMWM,1476
-sqlspec-0.10.0.dist-info/METADATA,sha256=kVW_aG4aRxpkvbCQGlPfEhZRq8iSGk4rFd1bWmhAhFA,14034
-sqlspec-0.10.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-sqlspec-0.10.0.dist-info/licenses/LICENSE,sha256=MdujfZ6l5HuLz4mElxlu049itenOR3gnhN1_Nd3nVcM,1078
-sqlspec-0.10.0.dist-info/licenses/NOTICE,sha256=Lyir8ozXWov7CyYS4huVaOCNrtgL17P-bNV-5daLntQ,1634
-sqlspec-0.10.0.dist-info/RECORD,,
+sqlspec/utils/singleton.py,sha256=YsHuo8_blPRQJRvXnjWXa8-Y-TO5V7jFGRwql-rNpO0,1363
+sqlspec/utils/sync_tools.py,sha256=IRzgLMvdkYIwPGUG_EBYGwoOiBBmQSaphwaGachkV4M,9146
+sqlspec/utils/text.py,sha256=-RlwmGjXtfD_ZkqIesZTHAPi46xg-uqlpVKDMcNwFrU,3539
+sqlspec-0.11.0.dist-info/METADATA,sha256=a-INDP1gbHtG1KmqYdfxG4wcVN0zqzkYxca-m7hjaWU,14361
+sqlspec-0.11.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+sqlspec-0.11.0.dist-info/licenses/LICENSE,sha256=MdujfZ6l5HuLz4mElxlu049itenOR3gnhN1_Nd3nVcM,1078
+sqlspec-0.11.0.dist-info/licenses/NOTICE,sha256=Lyir8ozXWov7CyYS4huVaOCNrtgL17P-bNV-5daLntQ,1634
+sqlspec-0.11.0.dist-info/RECORD,,