no venv

34 files changed, 0 insertions, 1925 deletions

diff --git a/venv/lib/python3.11/site-packages/litestar/utils/__init__.py b/venv/lib/python3.11/site-packages/litestar/utils/__init__.py
deleted file mode 100644
index 3f62792..0000000
--- a/venv/lib/python3.11/site-packages/litestar/utils/__init__.py
+++ /dev/null
@@ -1,86 +0,0 @@
-from typing import Any
-
-from litestar.utils.deprecation import deprecated, warn_deprecation
-
-from .helpers import get_enum_string_value, get_name, unique_name_for_scope, url_quote
-from .path import join_paths, normalize_path
-from .predicates import (
-    _is_sync_or_async_generator,
-    is_annotated_type,
-    is_any,
-    is_async_callable,
-    is_attrs_class,
-    is_class_and_subclass,
-    is_class_var,
-    is_dataclass_class,
-    is_dataclass_instance,
-    is_generic,
-    is_mapping,
-    is_non_string_iterable,
-    is_non_string_sequence,
-    is_optional_union,
-    is_undefined_sentinel,
-    is_union,
-)
-from .scope import (  # type: ignore[attr-defined]
-    _delete_litestar_scope_state,
-    _get_litestar_scope_state,
-    _set_litestar_scope_state,
-    get_serializer_from_scope,
-)
-from .sequence import find_index, unique
-from .sync import AsyncIteratorWrapper, ensure_async_callable
-from .typing import get_origin_or_inner_type, make_non_optional_union
-
-__all__ = (
-    "ensure_async_callable",
-    "AsyncIteratorWrapper",
-    "deprecated",
-    "find_index",
-    "get_enum_string_value",
-    "get_name",
-    "get_origin_or_inner_type",
-    "get_serializer_from_scope",
-    "is_annotated_type",
-    "is_any",
-    "is_async_callable",
-    "is_attrs_class",
-    "is_class_and_subclass",
-    "is_class_var",
-    "is_dataclass_class",
-    "is_dataclass_instance",
-    "is_generic",
-    "is_mapping",
-    "is_non_string_iterable",
-    "is_non_string_sequence",
-    "is_optional_union",
-    "is_undefined_sentinel",
-    "is_union",
-    "join_paths",
-    "make_non_optional_union",
-    "normalize_path",
-    "unique",
-    "unique_name_for_scope",
-    "url_quote",
-    "warn_deprecation",
-)
-
-_deprecated_names = {
-    "get_litestar_scope_state": _get_litestar_scope_state,
-    "set_litestar_scope_state": _set_litestar_scope_state,
-    "delete_litestar_scope_state": _delete_litestar_scope_state,
-    "is_sync_or_async_generator": _is_sync_or_async_generator,
-}
-
-
-def __getattr__(name: str) -> Any:
-    if name in _deprecated_names:
-        warn_deprecation(
-            deprecated_name=f"litestar.utils.{name}",
-            version="2.4",
-            kind="import",
-            removal_in="3.0",
-            info=f"'litestar.utils.{name}' is deprecated.",
-        )
-        return globals()["_deprecated_names"][name]
-    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")  # pragma: no cover
diff --git a/venv/lib/python3.11/site-packages/litestar/utils/__pycache__/__init__.cpython-311.pyc b/venv/lib/python3.11/site-packages/litestar/utils/__pycache__/__init__.cpython-311.pyc
deleted file mode 100644
index da9ad02..0000000
--- a/venv/lib/python3.11/site-packages/litestar/utils/__pycache__/__init__.cpython-311.pyc
+++ /dev/null
diff --git a/venv/lib/python3.11/site-packages/litestar/utils/__pycache__/compat.cpython-311.pyc b/venv/lib/python3.11/site-packages/litestar/utils/__pycache__/compat.cpython-311.pyc
deleted file mode 100644
index 39d39d6..0000000
--- a/venv/lib/python3.11/site-packages/litestar/utils/__pycache__/compat.cpython-311.pyc
+++ /dev/null
diff --git a/venv/lib/python3.11/site-packages/litestar/utils/__pycache__/dataclass.cpython-311.pyc b/venv/lib/python3.11/site-packages/litestar/utils/__pycache__/dataclass.cpython-311.pyc
deleted file mode 100644
index addf140..0000000
--- a/venv/lib/python3.11/site-packages/litestar/utils/__pycache__/dataclass.cpython-311.pyc
+++ /dev/null
diff --git a/venv/lib/python3.11/site-packages/litestar/utils/__pycache__/deprecation.cpython-311.pyc b/venv/lib/python3.11/site-packages/litestar/utils/__pycache__/deprecation.cpython-311.pyc
deleted file mode 100644
index ddf3b7c..0000000
--- a/venv/lib/python3.11/site-packages/litestar/utils/__pycache__/deprecation.cpython-311.pyc
+++ /dev/null
diff --git a/venv/lib/python3.11/site-packages/litestar/utils/__pycache__/empty.cpython-311.pyc b/venv/lib/python3.11/site-packages/litestar/utils/__pycache__/empty.cpython-311.pyc
deleted file mode 100644
index 2b358ad..0000000
--- a/venv/lib/python3.11/site-packages/litestar/utils/__pycache__/empty.cpython-311.pyc
+++ /dev/null
diff --git a/venv/lib/python3.11/site-packages/litestar/utils/__pycache__/helpers.cpython-311.pyc b/venv/lib/python3.11/site-packages/litestar/utils/__pycache__/helpers.cpython-311.pyc
deleted file mode 100644
index 9db59c4..0000000
--- a/venv/lib/python3.11/site-packages/litestar/utils/__pycache__/helpers.cpython-311.pyc
+++ /dev/null
diff --git a/venv/lib/python3.11/site-packages/litestar/utils/__pycache__/module_loader.cpython-311.pyc b/venv/lib/python3.11/site-packages/litestar/utils/__pycache__/module_loader.cpython-311.pyc
deleted file mode 100644
index f32ca7e..0000000
--- a/venv/lib/python3.11/site-packages/litestar/utils/__pycache__/module_loader.cpython-311.pyc
+++ /dev/null
diff --git a/venv/lib/python3.11/site-packages/litestar/utils/__pycache__/path.cpython-311.pyc b/venv/lib/python3.11/site-packages/litestar/utils/__pycache__/path.cpython-311.pyc
deleted file mode 100644
index 6602b02..0000000
--- a/venv/lib/python3.11/site-packages/litestar/utils/__pycache__/path.cpython-311.pyc
+++ /dev/null
diff --git a/venv/lib/python3.11/site-packages/litestar/utils/__pycache__/predicates.cpython-311.pyc b/venv/lib/python3.11/site-packages/litestar/utils/__pycache__/predicates.cpython-311.pyc
deleted file mode 100644
index 983250b..0000000
--- a/venv/lib/python3.11/site-packages/litestar/utils/__pycache__/predicates.cpython-311.pyc
+++ /dev/null
diff --git a/venv/lib/python3.11/site-packages/litestar/utils/__pycache__/sequence.cpython-311.pyc b/venv/lib/python3.11/site-packages/litestar/utils/__pycache__/sequence.cpython-311.pyc
deleted file mode 100644
index b2f8c1a..0000000
--- a/venv/lib/python3.11/site-packages/litestar/utils/__pycache__/sequence.cpython-311.pyc
+++ /dev/null
diff --git a/venv/lib/python3.11/site-packages/litestar/utils/__pycache__/signature.cpython-311.pyc b/venv/lib/python3.11/site-packages/litestar/utils/__pycache__/signature.cpython-311.pyc
deleted file mode 100644
index d81050f..0000000
--- a/venv/lib/python3.11/site-packages/litestar/utils/__pycache__/signature.cpython-311.pyc
+++ /dev/null
diff --git a/venv/lib/python3.11/site-packages/litestar/utils/__pycache__/sync.cpython-311.pyc b/venv/lib/python3.11/site-packages/litestar/utils/__pycache__/sync.cpython-311.pyc
deleted file mode 100644
index 8a18dfb..0000000
--- a/venv/lib/python3.11/site-packages/litestar/utils/__pycache__/sync.cpython-311.pyc
+++ /dev/null
diff --git a/venv/lib/python3.11/site-packages/litestar/utils/__pycache__/typing.cpython-311.pyc b/venv/lib/python3.11/site-packages/litestar/utils/__pycache__/typing.cpython-311.pyc
deleted file mode 100644
index 53db129..0000000
--- a/venv/lib/python3.11/site-packages/litestar/utils/__pycache__/typing.cpython-311.pyc
+++ /dev/null
diff --git a/venv/lib/python3.11/site-packages/litestar/utils/__pycache__/version.cpython-311.pyc b/venv/lib/python3.11/site-packages/litestar/utils/__pycache__/version.cpython-311.pyc
deleted file mode 100644
index f656ef4..0000000
--- a/venv/lib/python3.11/site-packages/litestar/utils/__pycache__/version.cpython-311.pyc
+++ /dev/null
diff --git a/venv/lib/python3.11/site-packages/litestar/utils/__pycache__/warnings.cpython-311.pyc b/venv/lib/python3.11/site-packages/litestar/utils/__pycache__/warnings.cpython-311.pyc
deleted file mode 100644
index 3fa1cf1..0000000
--- a/venv/lib/python3.11/site-packages/litestar/utils/__pycache__/warnings.cpython-311.pyc
+++ /dev/null
diff --git a/venv/lib/python3.11/site-packages/litestar/utils/compat.py b/venv/lib/python3.11/site-packages/litestar/utils/compat.py
deleted file mode 100644
index 384db76..0000000
--- a/venv/lib/python3.11/site-packages/litestar/utils/compat.py
+++ /dev/null
@@ -1,27 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, TypeVar
-
-from litestar.types import Empty, EmptyType
-
-__all__ = ("async_next",)
-
-
-if TYPE_CHECKING:
-    from typing import Any, AsyncGenerator
-
-T = TypeVar("T")
-D = TypeVar("D")
-
-try:
-    async_next = anext  # type: ignore[name-defined]
-except NameError:
-
-    async def async_next(gen: AsyncGenerator[T, Any], default: D | EmptyType = Empty) -> T | D:
-        """Backwards compatibility shim for Python<3.10."""
-        try:
-            return await gen.__anext__()
-        except StopAsyncIteration as exc:
-            if default is not Empty:
-                return default
-            raise exc
diff --git a/venv/lib/python3.11/site-packages/litestar/utils/dataclass.py b/venv/lib/python3.11/site-packages/litestar/utils/dataclass.py
deleted file mode 100644
index 597465d..0000000
--- a/venv/lib/python3.11/site-packages/litestar/utils/dataclass.py
+++ /dev/null
@@ -1,115 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import Field, fields
-from typing import TYPE_CHECKING
-
-from litestar.types import Empty
-from litestar.utils.predicates import is_dataclass_instance
-
-if TYPE_CHECKING:
-    from typing import AbstractSet, Any, Iterable
-
-    from litestar.types.protocols import DataclassProtocol
-
-__all__ = (
-    "extract_dataclass_fields",
-    "extract_dataclass_items",
-    "simple_asdict",
-)
-
-
-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):
-        raise ValueError(f"Fields {common} are both included and excluded.")
-
-    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 stlib, 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
diff --git a/venv/lib/python3.11/site-packages/litestar/utils/deprecation.py b/venv/lib/python3.11/site-packages/litestar/utils/deprecation.py
deleted file mode 100644
index b1b8725..0000000
--- a/venv/lib/python3.11/site-packages/litestar/utils/deprecation.py
+++ /dev/null
@@ -1,111 +0,0 @@
-from __future__ import annotations
-
-import inspect
-from functools import wraps
-from typing import Callable, Literal, TypeVar
-from warnings import warn
-
-from typing_extensions import ParamSpec
-
-__all__ = ("deprecated", "warn_deprecation")
-
-
-T = TypeVar("T")
-P = ParamSpec("P")
-DeprecatedKind = Literal["function", "method", "classmethod", "attribute", "property", "class", "parameter", "import"]
-
-
-def warn_deprecation(
-    version: str,
-    deprecated_name: str,
-    kind: DeprecatedKind,
-    *,
-    removal_in: str | None = None,
-    alternative: str | None = None,
-    info: str | None = None,
-    pending: bool = False,
-) -> None:
-    """Warn about a call to a (soon to be) deprecated function.
-
-    Args:
-        version: Litestar version where the deprecation will occur
-        deprecated_name: Name of the deprecated function
-        removal_in: Litestar version where the deprecated function will be removed
-        alternative: Name of a function that should be used instead
-        info: Additional information
-        pending: Use ``PendingDeprecationWarning`` instead of ``DeprecationWarning``
-        kind: Type of the deprecated thing
-    """
-    parts = []
-
-    if kind == "import":
-        access_type = "Import of"
-    elif kind in {"function", "method"}:
-        access_type = "Call to"
-    else:
-        access_type = "Use of"
-
-    if pending:
-        parts.append(f"{access_type} {kind} awaiting deprecation {deprecated_name!r}")
-    else:
-        parts.append(f"{access_type} deprecated {kind} {deprecated_name!r}")
-
-    parts.extend(
-        (
-            f"Deprecated in litestar {version}",
-            f"This {kind} will be removed in {removal_in or 'the next major version'}",
-        )
-    )
-    if alternative:
-        parts.append(f"Use {alternative!r} instead")
-
-    if info:
-        parts.append(info)
-
-    text = ". ".join(parts)
-    warning_class = PendingDeprecationWarning if pending else DeprecationWarning
-
-    warn(text, warning_class, stacklevel=2)
-
-
-def deprecated(
-    version: str,
-    *,
-    removal_in: str | None = None,
-    alternative: str | None = None,
-    info: str | None = None,
-    pending: bool = False,
-    kind: Literal["function", "method", "classmethod", "property"] | None = None,
-) -> Callable[[Callable[P, T]], Callable[P, T]]:
-    """Create a decorator wrapping a function, method or property with a warning call about a (pending) deprecation.
-
-    Args:
-        version: Litestar version where the deprecation will occur
-        removal_in: Litestar version where the deprecated function will be removed
-        alternative: Name of a function that should be used instead
-        info: Additional information
-        pending: Use ``PendingDeprecationWarning`` instead of ``DeprecationWarning``
-        kind: Type of the deprecated callable. If ``None``, will use ``inspect`` to figure
-            out if it's a function or method
-
-    Returns:
-        A decorator wrapping the function call with a warning
-    """
-
-    def decorator(func: Callable[P, T]) -> Callable[P, T]:
-        @wraps(func)
-        def wrapped(*args: P.args, **kwargs: P.kwargs) -> T:
-            warn_deprecation(
-                version=version,
-                deprecated_name=func.__name__,
-                info=info,
-                alternative=alternative,
-                pending=pending,
-                removal_in=removal_in,
-                kind=kind or ("method" if inspect.ismethod(func) else "function"),
-            )
-            return func(*args, **kwargs)
-
-        return wrapped
-
-    return decorator
diff --git a/venv/lib/python3.11/site-packages/litestar/utils/empty.py b/venv/lib/python3.11/site-packages/litestar/utils/empty.py
deleted file mode 100644
index cdde871..0000000
--- a/venv/lib/python3.11/site-packages/litestar/utils/empty.py
+++ /dev/null
@@ -1,26 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, TypeVar
-
-from litestar.types.empty import Empty
-
-if TYPE_CHECKING:
-    from litestar.types.empty import EmptyType
-
-ValueT = TypeVar("ValueT")
-DefaultT = TypeVar("DefaultT")
-
-
-def value_or_default(value: ValueT | EmptyType, default: DefaultT) -> ValueT | DefaultT:
-    """Return `value` handling the case where it is empty.
-
-    If `value` is `Empty`, `default` is returned.
-
-    Args:
-        value: The value to check.
-        default: The default value to return if `value` is `Empty`.
-
-    Returns:
-        The value or default value.
-    """
-    return default if value is Empty else value
diff --git a/venv/lib/python3.11/site-packages/litestar/utils/helpers.py b/venv/lib/python3.11/site-packages/litestar/utils/helpers.py
deleted file mode 100644
index c25fe35..0000000
--- a/venv/lib/python3.11/site-packages/litestar/utils/helpers.py
+++ /dev/null
@@ -1,103 +0,0 @@
-from __future__ import annotations
-
-from enum import Enum
-from functools import partial
-from typing import TYPE_CHECKING, TypeVar, cast
-from urllib.parse import quote
-
-from litestar.utils.typing import get_origin_or_inner_type
-
-if TYPE_CHECKING:
-    from collections.abc import Container
-
-    from litestar.types import MaybePartial
-
-__all__ = (
-    "get_enum_string_value",
-    "get_name",
-    "unwrap_partial",
-    "url_quote",
-    "unique_name_for_scope",
-)
-
-T = TypeVar("T")
-
-
-def get_name(value: object) -> str:
-    """Get the ``__name__`` of an object.
-
-    Args:
-        value: An arbitrary object.
-
-    Returns:
-        A name string.
-    """
-
-    name = getattr(value, "__name__", None)
-    if name is not None:
-        return cast("str", name)
-
-    # On Python 3.8 and 3.9, Foo[int] does not have the __name__ attribute.
-    if origin := get_origin_or_inner_type(value):
-        return cast("str", origin.__name__)
-
-    return type(value).__name__
-
-
-def get_enum_string_value(value: Enum | str) -> str:
-    """Return the string value of a string enum.
-
-    See: https://github.com/litestar-org/litestar/pull/633#issuecomment-1286519267
-
-    Args:
-        value: An enum or string.
-
-    Returns:
-        A string.
-    """
-    return value.value if isinstance(value, Enum) else value  # type: ignore[no-any-return]
-
-
-def unwrap_partial(value: MaybePartial[T]) -> T:
-    """Unwraps a partial, returning the underlying callable.
-
-    Args:
-        value: A partial function.
-
-    Returns:
-        Callable
-    """
-    from litestar.utils.sync import AsyncCallable
-
-    return cast("T", value.func if isinstance(value, (partial, AsyncCallable)) else value)
-
-
-def url_quote(value: str | bytes) -> str:
-    """Quote a URL.
-
-    Args:
-        value: A URL.
-
-    Returns:
-        A quoted URL.
-    """
-    return quote(value, safe="/#%[]=:;$&()+,!?*@'~")
-
-
-def unique_name_for_scope(base_name: str, scope: Container[str]) -> str:
-    """Create a name derived from ``base_name`` that's unique within ``scope``"""
-    i = 0
-    while True:
-        if (unique_name := f"{base_name}_{i}") not in scope:
-            return unique_name
-        i += 1
-
-
-def get_exception_group() -> type[BaseException]:
-    """Get the exception group class with version compatibility."""
-    try:
-        return cast("type[BaseException]", ExceptionGroup)  # type:ignore[name-defined]
-    except NameError:
-        from exceptiongroup import ExceptionGroup as _ExceptionGroup  # pyright: ignore
-
-        return cast("type[BaseException]", _ExceptionGroup)
diff --git a/venv/lib/python3.11/site-packages/litestar/utils/module_loader.py b/venv/lib/python3.11/site-packages/litestar/utils/module_loader.py
deleted file mode 100644
index 09dbf9f..0000000
--- a/venv/lib/python3.11/site-packages/litestar/utils/module_loader.py
+++ /dev/null
@@ -1,92 +0,0 @@
-"""General utility functions."""
-
-from __future__ import annotations
-
-import os.path
-import sys
-from importlib import import_module
-from importlib.util import find_spec
-from pathlib import Path
-from typing import TYPE_CHECKING, Any
-
-if TYPE_CHECKING:
-    from types import ModuleType
-
-__all__ = (
-    "import_string",
-    "module_to_os_path",
-)
-
-
-def module_to_os_path(dotted_path: str = "app") -> Path:
-    """Find Module to OS Path.
-
-    Return a path to the base directory of the project or the module
-    specified by `dotted_path`.
-
-    Args:
-        dotted_path: The path to the module. Defaults to "app".
-
-    Raises:
-        TypeError: The module could not be found.
-
-    Returns:
-        Path: The path to the module.
-    """
-    try:
-        if (src := find_spec(dotted_path)) is None:  # pragma: no cover
-            raise TypeError(f"Couldn't find the path for {dotted_path}")
-    except ModuleNotFoundError as e:
-        raise TypeError(f"Couldn't find the path for {dotted_path}") from e
-
-    return Path(str(src.origin).rsplit(os.path.sep + "__init__.py", maxsplit=1)[0])
-
-
-def import_string(dotted_path: str) -> Any:
-    """Dotted Path Import.
-
-    Import a dotted module path and return the attribute/class designated by the
-    last name in the path. Raise ImportError if the import failed.
-
-    Args:
-        dotted_path: The path of the module to import.
-
-    Raises:
-        ImportError: Could not import the module.
-
-    Returns:
-        object: The imported object.
-    """
-
-    def _is_loaded(module: ModuleType | None) -> bool:
-        spec = getattr(module, "__spec__", None)
-        initializing = getattr(spec, "_initializing", False)
-        return bool(module and spec and not initializing)
-
-    def _cached_import(module_path: str, class_name: str) -> Any:
-        """Import and cache a class from a module.
-
-        Args:
-            module_path: dotted path to module.
-            class_name: Class or function name.
-
-        Returns:
-            object: The imported class or function
-        """
-        # Check whether module is loaded and fully initialized.
-        module = sys.modules.get(module_path)
-        if not _is_loaded(module):
-            module = import_module(module_path)
-        return getattr(module, class_name)
-
-    try:
-        module_path, class_name = dotted_path.rsplit(".", 1)
-    except ValueError as e:
-        msg = "%s doesn't look like a module path"
-        raise ImportError(msg, dotted_path) from e
-
-    try:
-        return _cached_import(module_path, class_name)
-    except AttributeError as e:
-        msg = "Module '%s' does not define a '%s' attribute/class"
-        raise ImportError(msg, module_path, class_name) from e
diff --git a/venv/lib/python3.11/site-packages/litestar/utils/path.py b/venv/lib/python3.11/site-packages/litestar/utils/path.py
deleted file mode 100644
index 76b43af..0000000
--- a/venv/lib/python3.11/site-packages/litestar/utils/path.py
+++ /dev/null
@@ -1,35 +0,0 @@
-from __future__ import annotations
-
-import re
-from typing import Iterable
-
-__all__ = ("join_paths", "normalize_path")
-
-
-multi_slash_pattern = re.compile("//+")
-
-
-def normalize_path(path: str) -> str:
-    """Normalize a given path by ensuring it starts with a slash and does not end with a slash.
-
-    Args:
-        path: Path string
-
-    Returns:
-        Path string
-    """
-    path = path.strip("/")
-    path = f"/{path}"
-    return multi_slash_pattern.sub("/", path)
-
-
-def join_paths(paths: Iterable[str]) -> str:
-    """Normalize and joins path fragments.
-
-    Args:
-        paths: An iterable of path fragments.
-
-    Returns:
-        A normalized joined path string.
-    """
-    return normalize_path("/".join(paths))
diff --git a/venv/lib/python3.11/site-packages/litestar/utils/predicates.py b/venv/lib/python3.11/site-packages/litestar/utils/predicates.py
deleted file mode 100644
index 11d5f79..0000000
--- a/venv/lib/python3.11/site-packages/litestar/utils/predicates.py
+++ /dev/null
@@ -1,339 +0,0 @@
-from __future__ import annotations
-
-from asyncio import iscoroutinefunction
-from collections import defaultdict, deque
-from collections.abc import Iterable as CollectionsIterable
-from dataclasses import is_dataclass
-from inspect import isasyncgenfunction, isclass, isgeneratorfunction
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Awaitable,
-    Callable,
-    ClassVar,
-    DefaultDict,
-    Deque,
-    Dict,
-    FrozenSet,
-    Generic,
-    Iterable,
-    List,
-    Mapping,
-    Optional,
-    Sequence,
-    Set,
-    Tuple,
-    TypeVar,
-)
-
-from typing_extensions import (
-    ParamSpec,
-    TypeGuard,
-    _AnnotatedAlias,
-    get_args,
-)
-
-from litestar.constants import UNDEFINED_SENTINELS
-from litestar.types import Empty
-from litestar.types.builtin_types import NoneType, UnionTypes
-from litestar.utils.deprecation import warn_deprecation
-from litestar.utils.helpers import unwrap_partial
-from litestar.utils.typing import get_origin_or_inner_type
-
-if TYPE_CHECKING:
-    from litestar.types.callable_types import AnyGenerator
-    from litestar.types.protocols import DataclassProtocol
-
-try:
-    import attrs
-except ImportError:
-    attrs = Empty  # type: ignore[assignment]
-
-__all__ = (
-    "is_annotated_type",
-    "is_any",
-    "is_async_callable",
-    "is_attrs_class",
-    "is_class_and_subclass",
-    "is_class_var",
-    "is_dataclass_class",
-    "is_dataclass_instance",
-    "is_generic",
-    "is_mapping",
-    "is_non_string_iterable",
-    "is_non_string_sequence",
-    "is_optional_union",
-    "is_undefined_sentinel",
-    "is_union",
-)
-
-P = ParamSpec("P")
-T = TypeVar("T")
-
-
-def is_async_callable(value: Callable[P, T]) -> TypeGuard[Callable[P, Awaitable[T]]]:
-    """Extend :func:`asyncio.iscoroutinefunction` to additionally detect async :func:`functools.partial` objects and
-    class instances with ``async def __call__()`` defined.
-
-    Args:
-        value: Any
-
-    Returns:
-        Bool determining if type of ``value`` is an awaitable.
-    """
-    value = unwrap_partial(value)
-
-    return iscoroutinefunction(value) or (
-        callable(value) and iscoroutinefunction(value.__call__)  # type: ignore[operator]
-    )
-
-
-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 is_dataclass_class(annotation: Any) -> TypeGuard[type[DataclassProtocol]]:
-    """Wrap :func:`is_dataclass <dataclasses.is_dataclass>` in a :data:`typing.TypeGuard`.
-
-    Args:
-        annotation: tested to determine if instance or type of :class:`dataclasses.dataclass`.
-
-    Returns:
-        ``True`` if instance or type of ``dataclass``.
-    """
-    try:
-        origin = get_origin_or_inner_type(annotation)
-        annotation = origin or annotation
-
-        return isclass(annotation) and is_dataclass(annotation)
-    except TypeError:  # pragma: no cover
-        return False
-
-
-def is_class_and_subclass(annotation: Any, type_or_type_tuple: type[T] | tuple[type[T], ...]) -> TypeGuard[type[T]]:
-    """Return ``True`` if ``value`` is a ``class`` and is a subtype of ``t_type``.
-
-    See https://github.com/litestar-org/litestar/issues/367
-
-    Args:
-        annotation: The value to check if is class and subclass of ``t_type``.
-        type_or_type_tuple: Type used for :func:`issubclass` check of ``value``
-
-    Returns:
-        bool
-    """
-    origin = get_origin_or_inner_type(annotation)
-    if not origin and not isclass(annotation):
-        return False
-    try:
-        return issubclass(origin or annotation, type_or_type_tuple)
-    except TypeError:  # pragma: no cover
-        return False
-
-
-def is_generic(annotation: Any) -> bool:
-    """Given a type annotation determine if the annotation is a generic class.
-
-    Args:
-    annotation: A type.
-
-    Returns:
-        True if the annotation is a subclass of :data:`Generic <typing.Generic>` otherwise ``False``.
-    """
-    return is_class_and_subclass(annotation, Generic)  # type: ignore[arg-type]
-
-
-def is_mapping(annotation: Any) -> TypeGuard[Mapping[Any, Any]]:
-    """Given a type annotation determine if the annotation is a mapping type.
-
-    Args:
-    annotation: A type.
-
-    Returns:
-        A typeguard determining whether the type can be cast as :class:`Mapping <typing.Mapping>`.
-    """
-    _type = get_origin_or_inner_type(annotation) or annotation
-    return isclass(_type) and issubclass(_type, (dict, defaultdict, DefaultDict, Mapping))
-
-
-def is_non_string_iterable(annotation: Any) -> TypeGuard[Iterable[Any]]:
-    """Given a type annotation determine if the annotation is an iterable.
-
-    Args:
-    annotation: A type.
-
-    Returns:
-        A typeguard determining whether the type can be cast as :class:`Iterable <typing.Iterable>` that is not a string.
-    """
-    origin = get_origin_or_inner_type(annotation)
-    if not origin and not isclass(annotation):
-        return False
-    try:
-        return not issubclass(origin or annotation, (str, bytes)) and (
-            issubclass(origin or annotation, (Iterable, CollectionsIterable, Dict, dict, Mapping))
-            or is_non_string_sequence(annotation)
-        )
-    except TypeError:  # pragma: no cover
-        return False
-
-
-def is_non_string_sequence(annotation: Any) -> TypeGuard[Sequence[Any]]:
-    """Given a type annotation determine if the annotation is a sequence.
-
-    Args:
-    annotation: A type.
-
-    Returns:
-        A typeguard determining whether the type can be cast as :class`Sequence <typing.Sequence>` that is not a string.
-    """
-    origin = get_origin_or_inner_type(annotation)
-    if not origin and not isclass(annotation):
-        return False
-    try:
-        return not issubclass(origin or annotation, (str, bytes)) and issubclass(
-            origin or annotation,
-            (  # type: ignore[arg-type]
-                Tuple,
-                List,
-                Set,
-                FrozenSet,
-                Deque,
-                Sequence,
-                list,
-                tuple,
-                deque,
-                set,
-                frozenset,
-            ),
-        )
-    except TypeError:  # pragma: no cover
-        return False
-
-
-def is_any(annotation: Any) -> TypeGuard[Any]:
-    """Given a type annotation determine if the annotation is Any.
-
-    Args:
-        annotation: A type.
-
-    Returns:
-        A typeguard determining whether the type is :data:`Any <typing.Any>`.
-    """
-    return (
-        annotation is Any
-        or getattr(annotation, "_name", "") == "typing.Any"
-        or (get_origin_or_inner_type(annotation) in UnionTypes and Any in get_args(annotation))
-    )
-
-
-def is_union(annotation: Any) -> bool:
-    """Given a type annotation determine if the annotation infers an optional union.
-
-    Args:
-        annotation: A type.
-
-    Returns:
-        A boolean determining whether the type is :data:`Union typing.Union>`.
-    """
-    return get_origin_or_inner_type(annotation) in UnionTypes
-
-
-def is_optional_union(annotation: Any) -> TypeGuard[Any | None]:
-    """Given a type annotation determine if the annotation infers an optional union.
-
-    Args:
-        annotation: A type.
-
-    Returns:
-        A typeguard determining whether the type is :data:`Union typing.Union>` with a
-            None value or :data:`Optional <typing.Optional>` which is equivalent.
-    """
-    origin = get_origin_or_inner_type(annotation)
-    return origin is Optional or (
-        get_origin_or_inner_type(annotation) in UnionTypes and NoneType in get_args(annotation)
-    )
-
-
-def is_attrs_class(annotation: Any) -> TypeGuard[type[attrs.AttrsInstance]]:  # pyright: ignore
-    """Given a type annotation determine if the annotation is a class that includes an attrs attribute.
-
-    Args:
-        annotation: A type.
-
-    Returns:
-        A typeguard determining whether the type is an attrs class.
-    """
-    return attrs.has(annotation) if attrs is not Empty else False  # type: ignore[comparison-overlap]
-
-
-def is_class_var(annotation: Any) -> bool:
-    """Check if the given annotation is a ClassVar.
-
-    Args:
-        annotation: A type annotation
-
-    Returns:
-        A boolean.
-    """
-    annotation = get_origin_or_inner_type(annotation) or annotation
-    return annotation is ClassVar
-
-
-def _is_sync_or_async_generator(obj: Any) -> TypeGuard[AnyGenerator]:
-    """Check if the given annotation is a sync or async generator.
-
-    Args:
-        obj: type to be tested for sync or async generator.
-
-    Returns:
-        A boolean.
-    """
-    return isgeneratorfunction(obj) or isasyncgenfunction(obj)
-
-
-def is_annotated_type(annotation: Any) -> bool:
-    """Check if the given annotation is an Annotated.
-
-    Args:
-        annotation: A type annotation
-
-    Returns:
-        A boolean.
-    """
-    return isinstance(annotation, _AnnotatedAlias) and getattr(annotation, "__args__", None) is not None
-
-
-def is_undefined_sentinel(value: Any) -> bool:
-    """Check if the given value is the undefined sentinel.
-
-    Args:
-        value: A value to be tested for undefined sentinel.
-
-    Returns:
-        A boolean.
-    """
-    return any(v is value for v in UNDEFINED_SENTINELS)
-
-
-_deprecated_names = {"is_sync_or_async_generator": _is_sync_or_async_generator}
-
-
-def __getattr__(name: str) -> Any:
-    if name in _deprecated_names:
-        warn_deprecation(
-            deprecated_name=f"litestar.utils.scope.{name}",
-            version="2.4",
-            kind="import",
-            removal_in="3.0",
-            info=f"'litestar.utils.predicates.{name}' is deprecated.",
-        )
-        return globals()["_deprecated_names"][name]
-    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")  # pragma: no cover
diff --git a/venv/lib/python3.11/site-packages/litestar/utils/scope/__init__.py b/venv/lib/python3.11/site-packages/litestar/utils/scope/__init__.py
deleted file mode 100644
index e5757d3..0000000
--- a/venv/lib/python3.11/site-packages/litestar/utils/scope/__init__.py
+++ /dev/null
@@ -1,62 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any
-
-from litestar.serialization import get_serializer
-from litestar.utils.deprecation import warn_deprecation
-from litestar.utils.scope.state import delete_litestar_scope_state as _delete_litestar_scope_state
-from litestar.utils.scope.state import get_litestar_scope_state as _get_litestar_scope_state
-from litestar.utils.scope.state import set_litestar_scope_state as _set_litestar_scope_state
-
-if TYPE_CHECKING:
-    from litestar.types import Scope, Serializer
-
-__all__ = ("get_serializer_from_scope",)
-
-
-def get_serializer_from_scope(scope: Scope) -> Serializer:
-    """Return a serializer given a scope object.
-
-    Args:
-        scope: The ASGI connection scope.
-
-    Returns:
-        A serializer function
-    """
-    route_handler = scope["route_handler"]
-    app = scope["app"]
-
-    if hasattr(route_handler, "resolve_type_encoders"):
-        type_encoders = route_handler.resolve_type_encoders()
-    else:
-        type_encoders = app.type_encoders or {}
-
-    if response_class := (
-        route_handler.resolve_response_class()  # pyright: ignore
-        if hasattr(route_handler, "resolve_response_class")
-        else app.response_class
-    ):
-        type_encoders = {**type_encoders, **(response_class.type_encoders or {})}
-
-    return get_serializer(type_encoders)
-
-
-_deprecated_names = {
-    "get_litestar_scope_state": _get_litestar_scope_state,
-    "set_litestar_scope_state": _set_litestar_scope_state,
-    "delete_litestar_scope_state": _delete_litestar_scope_state,
-}
-
-
-def __getattr__(name: str) -> Any:
-    if name in _deprecated_names:
-        warn_deprecation(
-            deprecated_name=f"litestar.utils.scope.{name}",
-            version="2.4",
-            kind="import",
-            removal_in="3.0",
-            info=f"'litestar.utils.scope.{name}' is deprecated. The Litestar scope state is private and should not be "
-            f"used. Plugin authors should maintain their own scope state namespace.",
-        )
-        return globals()["_deprecated_names"][name]
-    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")  # pragma: no cover
diff --git a/venv/lib/python3.11/site-packages/litestar/utils/scope/__pycache__/__init__.cpython-311.pyc b/venv/lib/python3.11/site-packages/litestar/utils/scope/__pycache__/__init__.cpython-311.pyc
deleted file mode 100644
index ee218d5..0000000
--- a/venv/lib/python3.11/site-packages/litestar/utils/scope/__pycache__/__init__.cpython-311.pyc
+++ /dev/null
diff --git a/venv/lib/python3.11/site-packages/litestar/utils/scope/__pycache__/state.cpython-311.pyc b/venv/lib/python3.11/site-packages/litestar/utils/scope/__pycache__/state.cpython-311.pyc
deleted file mode 100644
index 4615004..0000000
--- a/venv/lib/python3.11/site-packages/litestar/utils/scope/__pycache__/state.cpython-311.pyc
+++ /dev/null
diff --git a/venv/lib/python3.11/site-packages/litestar/utils/scope/state.py b/venv/lib/python3.11/site-packages/litestar/utils/scope/state.py
deleted file mode 100644
index bed4394..0000000
--- a/venv/lib/python3.11/site-packages/litestar/utils/scope/state.py
+++ /dev/null
@@ -1,158 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Final
-
-from litestar.types import Empty, EmptyType
-from litestar.utils.empty import value_or_default
-
-if TYPE_CHECKING:
-    from typing_extensions import Self
-
-    from litestar.datastructures import URL, Accept, Headers
-    from litestar.types.asgi_types import Scope
-
-CONNECTION_STATE_KEY: Final = "_ls_connection_state"
-
-
-@dataclass
-class ScopeState:
-    """An object for storing connection state.
-
-    This is an internal API, and subject to change without notice.
-
-    All types are a union with `EmptyType` and are seeded with the `Empty` value.
-    """
-
-    __slots__ = (
-        "accept",
-        "base_url",
-        "body",
-        "content_type",
-        "cookies",
-        "csrf_token",
-        "dependency_cache",
-        "do_cache",
-        "form",
-        "headers",
-        "is_cached",
-        "json",
-        "log_context",
-        "msgpack",
-        "parsed_query",
-        "response_compressed",
-        "session_id",
-        "url",
-        "_compat_ns",
-    )
-
-    def __init__(self) -> None:
-        self.accept = Empty
-        self.base_url = Empty
-        self.body = Empty
-        self.content_type = Empty
-        self.cookies = Empty
-        self.csrf_token = Empty
-        self.dependency_cache = Empty
-        self.do_cache = Empty
-        self.form = Empty
-        self.headers = Empty
-        self.is_cached = Empty
-        self.json = Empty
-        self.log_context: dict[str, Any] = {}
-        self.msgpack = Empty
-        self.parsed_query = Empty
-        self.response_compressed = Empty
-        self.session_id = Empty
-        self.url = Empty
-        self._compat_ns: dict[str, Any] = {}
-
-    accept: Accept | EmptyType
-    base_url: URL | EmptyType
-    body: bytes | EmptyType
-    content_type: tuple[str, dict[str, str]] | EmptyType
-    cookies: dict[str, str] | EmptyType
-    csrf_token: str | EmptyType
-    dependency_cache: dict[str, Any] | EmptyType
-    do_cache: bool | EmptyType
-    form: dict[str, str | list[str]] | EmptyType
-    headers: Headers | EmptyType
-    is_cached: bool | EmptyType
-    json: Any | EmptyType
-    log_context: dict[str, Any]
-    msgpack: Any | EmptyType
-    parsed_query: tuple[tuple[str, str], ...] | EmptyType
-    response_compressed: bool | EmptyType
-    session_id: str | None | EmptyType
-    url: URL | EmptyType
-    _compat_ns: dict[str, Any]
-
-    @classmethod
-    def from_scope(cls, scope: Scope) -> Self:
-        """Create a new `ConnectionState` object from a scope.
-
-        Object is cached in the scope's state under the `SCOPE_STATE_NAMESPACE` key.
-
-        Args:
-            scope: The ASGI connection scope.
-
-        Returns:
-            A `ConnectionState` object.
-        """
-        base_scope_state = scope.setdefault("state", {})
-        if (state := base_scope_state.get(CONNECTION_STATE_KEY)) is None:
-            state = base_scope_state[CONNECTION_STATE_KEY] = cls()
-        return state
-
-
-def get_litestar_scope_state(scope: Scope, key: str, default: Any = None, pop: bool = False) -> Any:
-    """Get an internal value from connection scope state.
-
-    Args:
-        scope: The connection scope.
-        key: Key to get from internal namespace in scope state.
-        default: Default value to return.
-        pop: Boolean flag dictating whether the value should be deleted from the state.
-
-    Returns:
-        Value mapped to ``key`` in internal connection scope namespace.
-    """
-    scope_state = ScopeState.from_scope(scope)
-    try:
-        val = value_or_default(getattr(scope_state, key), default)
-        if pop:
-            setattr(scope_state, key, Empty)
-        return val
-    except AttributeError:
-        if pop:
-            return scope_state._compat_ns.pop(key, default)
-        return scope_state._compat_ns.get(key, default)
-
-
-def set_litestar_scope_state(scope: Scope, key: str, value: Any) -> None:
-    """Set an internal value in connection scope state.
-
-    Args:
-        scope: The connection scope.
-        key: Key to set under internal namespace in scope state.
-        value: Value for key.
-    """
-    scope_state = ScopeState.from_scope(scope)
-    if hasattr(scope_state, key):
-        setattr(scope_state, key, value)
-    else:
-        scope_state._compat_ns[key] = value
-
-
-def delete_litestar_scope_state(scope: Scope, key: str) -> None:
-    """Delete an internal value from connection scope state.
-
-    Args:
-        scope: The connection scope.
-        key: Key to set under internal namespace in scope state.
-    """
-    scope_state = ScopeState.from_scope(scope)
-    if hasattr(scope_state, key):
-        setattr(scope_state, key, Empty)
-    else:
-        del scope_state._compat_ns[key]
diff --git a/venv/lib/python3.11/site-packages/litestar/utils/sequence.py b/venv/lib/python3.11/site-packages/litestar/utils/sequence.py
deleted file mode 100644
index 01ef1a8..0000000
--- a/venv/lib/python3.11/site-packages/litestar/utils/sequence.py
+++ /dev/null
@@ -1,28 +0,0 @@
-from __future__ import annotations
-
-from typing import Callable, Sequence, TypeVar
-
-__all__ = ("find_index", "unique")
-
-
-T = TypeVar("T")
-
-
-def find_index(target_list: Sequence[T], predicate: Callable[[T], bool]) -> int:
-    """Find element in list given a key and value.
-
-    List elements can be dicts or classes
-    """
-    return next((i for i, element in enumerate(target_list) if predicate(element)), -1)
-
-
-def unique(value: Sequence[T]) -> list[T]:
-    """Return all unique values in a given sequence or iterator."""
-    try:
-        return list(set(value))
-    except TypeError:
-        output: list[T] = []
-        for element in value:
-            if element not in output:
-                output.append(element)
-        return output
diff --git a/venv/lib/python3.11/site-packages/litestar/utils/signature.py b/venv/lib/python3.11/site-packages/litestar/utils/signature.py
deleted file mode 100644
index eb58599..0000000
--- a/venv/lib/python3.11/site-packages/litestar/utils/signature.py
+++ /dev/null
@@ -1,267 +0,0 @@
-from __future__ import annotations
-
-import sys
-import typing
-from copy import deepcopy
-from dataclasses import dataclass, replace
-from inspect import Signature, getmembers, isclass, ismethod
-from itertools import chain
-from typing import TYPE_CHECKING, Any, Union
-
-from typing_extensions import Annotated, Self, get_args, get_origin, get_type_hints
-
-from litestar import connection, datastructures, types
-from litestar.exceptions import ImproperlyConfiguredException
-from litestar.types import Empty
-from litestar.typing import FieldDefinition
-from litestar.utils.typing import unwrap_annotation
-
-if TYPE_CHECKING:
-    from typing import Sequence
-
-    from litestar.types import AnyCallable
-
-if sys.version_info < (3, 11):
-    from typing import _get_defaults  # type: ignore[attr-defined]
-else:
-
-    def _get_defaults(_: Any) -> Any: ...
-
-
-__all__ = (
-    "add_types_to_signature_namespace",
-    "get_fn_type_hints",
-    "ParsedSignature",
-)
-
-_GLOBAL_NAMES = {
-    namespace: export
-    for namespace, export in chain(
-        tuple(getmembers(types)), tuple(getmembers(connection)), tuple(getmembers(datastructures))
-    )
-    if namespace[0].isupper() and namespace in chain(types.__all__, connection.__all__, datastructures.__all__)  # pyright: ignore
-}
-"""A mapping of names used for handler signature forward-ref resolution.
-
-This allows users to include these names within an `if TYPE_CHECKING:` block in their handler module.
-"""
-
-
-def _unwrap_implicit_optional_hints(defaults: dict[str, Any], hints: dict[str, Any]) -> dict[str, Any]:
-    """Unwrap implicit optional hints.
-
-    On Python<3.11, if a function parameter annotation has a ``None`` default, it is unconditionally wrapped in an
-    ``Optional`` type.
-
-    If the annotation is not annotated, then any nested unions are flattened, e.g.,:
-
-    .. code-block:: python
-
-        def foo(a: Optional[Union[str, int]] = None): ...
-
-    ...will become `Union[str, int, NoneType]`.
-
-    However, if the annotation is annotated, then we end up with an optional union around the annotated type, e.g.,:
-
-    .. code-block:: python
-
-        def foo(a: Annotated[Optional[Union[str, int]], ...] = None): ...
-
-    ... becomes `Union[Annotated[Union[str, int, NoneType], ...], NoneType]`
-
-    This function makes the latter case consistent with the former by either removing the outer union if it is redundant
-    or flattening the union if it is not. The latter case would become `Annotated[Union[str, int, NoneType], ...]`.
-
-    Args:
-        defaults: Mapping of names to default values.
-        hints: Mapping of names to types.
-
-    Returns:
-        Mapping of names to types.
-    """
-
-    def _is_two_arg_optional(origin_: Any, args_: Any) -> bool:
-        """Check if a type is a two-argument optional type.
-
-        If the type has been wrapped in `Optional` by `get_type_hints()` it will always be a union of a type and
-        `NoneType`.
-
-        See: https://github.com/litestar-org/litestar/pull/2516
-        """
-        return origin_ is Union and len(args_) == 2 and args_[1] is type(None)
-
-    def _is_any_optional(origin_: Any, args_: tuple[Any, ...]) -> bool:
-        """Detect if a type is a union with `NoneType`.
-
-        After detecting that a type is a two-argument optional type, this function can be used to detect if the
-        inner type is a union with `NoneType` at all.
-
-        We only want to perform the unwrapping of the optional union if the inner type is optional as well.
-        """
-        return origin_ is Union and any(arg is type(None) for arg in args_)
-
-    for name, default in defaults.items():
-        if default is not None:
-            continue
-
-        hint = hints[name]
-        origin = get_origin(hint)
-        args = get_args(hint)
-
-        if _is_two_arg_optional(origin, args):
-            unwrapped_inner, meta, wrappers = unwrap_annotation(args[0])
-
-            if Annotated not in wrappers:
-                continue
-
-            inner_args = get_args(unwrapped_inner)
-
-            if not _is_any_optional(get_origin(unwrapped_inner), inner_args):
-                # this is where hint is like `Union[Annotated[Union[str, int], ...], NoneType]`, we add the outer union
-                # into the inner one, and re-wrap with Annotated
-                union_args = (*(inner_args or (unwrapped_inner,)), type(None))
-                # calling `__class_getitem__` directly as in earlier py vers it is a syntax error to unpack into
-                # the getitem brackets, e.g., Annotated[T, *meta].
-                hints[name] = Annotated.__class_getitem__((Union[union_args], *meta))  # type: ignore[attr-defined]
-                continue
-
-            # this is where hint is like `Union[Annotated[Union[str, NoneType], ...], NoneType]`, we remove the
-            # redundant outer union
-            hints[name] = args[0]
-    return hints
-
-
-def get_fn_type_hints(fn: Any, namespace: dict[str, Any] | None = None) -> dict[str, Any]:
-    """Resolve type hints for ``fn``.
-
-    Args:
-        fn: Callable that is being inspected
-        namespace: Extra names for resolution of forward references.
-
-    Returns:
-        Mapping of names to types.
-    """
-    fn_to_inspect: Any = fn
-
-    module_name = fn_to_inspect.__module__
-
-    if isclass(fn_to_inspect):
-        fn_to_inspect = fn_to_inspect.__init__
-
-    # detect objects that are not functions and that have a `__call__` method
-    if callable(fn_to_inspect) and ismethod(fn_to_inspect.__call__):
-        fn_to_inspect = fn_to_inspect.__call__
-
-    # inspect the underlying function for methods
-    if hasattr(fn_to_inspect, "__func__"):
-        fn_to_inspect = fn_to_inspect.__func__
-
-    # Order important. If a litestar name has been overridden in the function module, we want
-    # to use that instead of the litestar one.
-    namespace = {
-        **_GLOBAL_NAMES,
-        **vars(typing),
-        **vars(sys.modules[module_name]),
-        **(namespace or {}),
-    }
-    hints = get_type_hints(fn_to_inspect, globalns=namespace, include_extras=True)
-
-    if sys.version_info < (3, 11):
-        # see https://github.com/litestar-org/litestar/pull/2516
-        defaults = _get_defaults(fn_to_inspect)
-        hints = _unwrap_implicit_optional_hints(defaults, hints)
-
-    return hints
-
-
-@dataclass(frozen=True)
-class ParsedSignature:
-    """Parsed signature.
-
-    This object is the primary source of handler/dependency signature information.
-
-    The only post-processing that occurs is the conversion of any forward referenced type annotations.
-    """
-
-    __slots__ = ("parameters", "return_type", "original_signature")
-
-    parameters: dict[str, FieldDefinition]
-    """A mapping of parameter names to ParsedSignatureParameter instances."""
-    return_type: FieldDefinition
-    """The return annotation of the callable."""
-    original_signature: Signature
-    """The raw signature as returned by :func:`inspect.signature`"""
-
-    def __deepcopy__(self, memo: dict[str, Any]) -> Self:
-        return type(self)(
-            parameters={k: deepcopy(v) for k, v in self.parameters.items()},
-            return_type=deepcopy(self.return_type),
-            original_signature=deepcopy(self.original_signature),
-        )
-
-    @classmethod
-    def from_fn(cls, fn: AnyCallable, signature_namespace: dict[str, Any]) -> Self:
-        """Parse a function signature.
-
-        Args:
-            fn: Any callable.
-            signature_namespace: mapping of names to types for forward reference resolution
-
-        Returns:
-            ParsedSignature
-        """
-        signature = Signature.from_callable(fn)
-        fn_type_hints = get_fn_type_hints(fn, namespace=signature_namespace)
-
-        return cls.from_signature(signature, fn_type_hints)
-
-    @classmethod
-    def from_signature(cls, signature: Signature, fn_type_hints: dict[str, type]) -> Self:
-        """Parse an :class:`inspect.Signature` instance.
-
-        Args:
-            signature: An :class:`inspect.Signature` instance.
-            fn_type_hints: mapping of types
-
-        Returns:
-            ParsedSignature
-        """
-
-        parameters = tuple(
-            FieldDefinition.from_parameter(parameter=parameter, fn_type_hints=fn_type_hints)
-            for name, parameter in signature.parameters.items()
-            if name not in ("self", "cls")
-        )
-
-        return_type = FieldDefinition.from_annotation(fn_type_hints.get("return", Any))
-
-        return cls(
-            parameters={p.name: p for p in parameters},
-            return_type=return_type if "return" in fn_type_hints else replace(return_type, annotation=Empty),
-            original_signature=signature,
-        )
-
-
-def add_types_to_signature_namespace(
-    signature_types: Sequence[Any], signature_namespace: dict[str, Any]
-) -> dict[str, Any]:
-    """Add types to ith signature namespace mapping.
-
-    Types are added mapped to their `__name__` attribute.
-
-    Args:
-        signature_types: A list of types to add to the signature namespace.
-        signature_namespace: The signature namespace to add types to.
-
-    Raises:
-        ImproperlyConfiguredException: If a type is already defined in the signature namespace.
-        AttributeError: If a type does not have a `__name__` attribute.
-
-    Returns:
-        The updated signature namespace.
-    """
-    for typ in signature_types:
-        if (name := typ.__name__) in signature_namespace:
-            raise ImproperlyConfiguredException(f"Type '{name}' is already defined in the signature namespace")
-        signature_namespace[name] = typ
-    return signature_namespace
diff --git a/venv/lib/python3.11/site-packages/litestar/utils/sync.py b/venv/lib/python3.11/site-packages/litestar/utils/sync.py
deleted file mode 100644
index 02acabf..0000000
--- a/venv/lib/python3.11/site-packages/litestar/utils/sync.py
+++ /dev/null
@@ -1,79 +0,0 @@
-from __future__ import annotations
-
-from typing import (
-    AsyncGenerator,
-    Awaitable,
-    Callable,
-    Generic,
-    Iterable,
-    Iterator,
-    TypeVar,
-)
-
-from typing_extensions import ParamSpec
-
-from litestar.concurrency import sync_to_thread
-from litestar.utils.predicates import is_async_callable
-
-__all__ = ("ensure_async_callable", "AsyncIteratorWrapper", "AsyncCallable", "is_async_callable")
-
-
-P = ParamSpec("P")
-T = TypeVar("T")
-
-
-def ensure_async_callable(fn: Callable[P, T]) -> Callable[P, Awaitable[T]]:
-    """Ensure that ``fn`` is an asynchronous callable.
-    If it is an asynchronous, return the original object, else wrap it in an
-    ``AsyncCallable``
-    """
-    if is_async_callable(fn):
-        return fn
-    return AsyncCallable(fn)  # pyright: ignore
-
-
-class AsyncCallable:
-    """Wrap a given callable to be called in a thread pool using
-    ``anyio.to_thread.run_sync``, keeping a reference to the original callable as
-    :attr:`func`
-    """
-
-    def __init__(self, fn: Callable[P, T]) -> None:  # pyright: ignore
-        self.func = fn
-
-    def __call__(self, *args: P.args, **kwargs: P.kwargs) -> Awaitable[T]:  # pyright: ignore
-        return sync_to_thread(self.func, *args, **kwargs)  # pyright: ignore
-
-
-class AsyncIteratorWrapper(Generic[T]):
-    """Asynchronous generator, wrapping an iterable or iterator."""
-
-    __slots__ = ("iterator", "generator")
-
-    def __init__(self, iterator: Iterator[T] | Iterable[T]) -> None:
-        """Take a sync iterator or iterable and yields values from it asynchronously.
-
-        Args:
-            iterator: A sync iterator or iterable.
-        """
-        self.iterator = iterator if isinstance(iterator, Iterator) else iter(iterator)
-        self.generator = self._async_generator()
-
-    def _call_next(self) -> T:
-        try:
-            return next(self.iterator)
-        except StopIteration as e:
-            raise ValueError from e
-
-    async def _async_generator(self) -> AsyncGenerator[T, None]:
-        while True:
-            try:
-                yield await sync_to_thread(self._call_next)
-            except ValueError:
-                return
-
-    def __aiter__(self) -> AsyncIteratorWrapper[T]:
-        return self
-
-    async def __anext__(self) -> T:
-        return await self.generator.__anext__()
diff --git a/venv/lib/python3.11/site-packages/litestar/utils/typing.py b/venv/lib/python3.11/site-packages/litestar/utils/typing.py
deleted file mode 100644
index 9da6c2a..0000000
--- a/venv/lib/python3.11/site-packages/litestar/utils/typing.py
+++ /dev/null
@@ -1,284 +0,0 @@
-from __future__ import annotations
-
-import re
-from collections import abc, defaultdict, deque
-from typing import (
-    AbstractSet,
-    Any,
-    AsyncGenerator,
-    AsyncIterable,
-    AsyncIterator,
-    Awaitable,
-    Collection,
-    Container,
-    Coroutine,
-    DefaultDict,
-    Deque,
-    Dict,
-    FrozenSet,
-    Generator,
-    ItemsView,
-    Iterable,
-    Iterator,
-    KeysView,
-    List,
-    Mapping,
-    MappingView,
-    MutableMapping,
-    MutableSequence,
-    MutableSet,
-    Reversible,
-    Sequence,
-    Set,
-    Tuple,
-    TypeVar,
-    Union,
-    ValuesView,
-    cast,
-)
-
-from typing_extensions import Annotated, NotRequired, Required, get_args, get_origin, get_type_hints
-
-from litestar.types.builtin_types import NoneType, UnionTypes
-
-__all__ = (
-    "get_instantiable_origin",
-    "get_origin_or_inner_type",
-    "get_safe_generic_origin",
-    "instantiable_type_mapping",
-    "make_non_optional_union",
-    "safe_generic_origin_map",
-    "unwrap_annotation",
-)
-
-
-T = TypeVar("T")
-UnionT = TypeVar("UnionT", bound="Union")
-
-tuple_types_regex = re.compile(
-    "^"
-    + "|".join(
-        [*[repr(x) for x in (List, Sequence, Iterable, Iterator, Tuple, Deque)], "tuple", "list", "collections.deque"]
-    )
-)
-
-instantiable_type_mapping = {
-    AbstractSet: set,
-    DefaultDict: defaultdict,
-    Deque: deque,
-    Dict: dict,
-    FrozenSet: frozenset,
-    List: list,
-    Mapping: dict,
-    MutableMapping: dict,
-    MutableSequence: list,
-    MutableSet: set,
-    Sequence: list,
-    Set: set,
-    Tuple: tuple,
-    abc.Mapping: dict,
-    abc.MutableMapping: dict,
-    abc.MutableSequence: list,
-    abc.MutableSet: set,
-    abc.Sequence: list,
-    abc.Set: set,
-    defaultdict: defaultdict,
-    deque: deque,
-    dict: dict,
-    frozenset: frozenset,
-    list: list,
-    set: set,
-    tuple: tuple,
-}
-
-safe_generic_origin_map = {
-    set: AbstractSet,
-    defaultdict: DefaultDict,
-    deque: Deque,
-    dict: Dict,
-    frozenset: FrozenSet,
-    list: List,
-    tuple: Tuple,
-    abc.Mapping: Mapping,
-    abc.MutableMapping: MutableMapping,
-    abc.MutableSequence: MutableSequence,
-    abc.MutableSet: MutableSet,
-    abc.Sequence: Sequence,
-    abc.Set: AbstractSet,
-    abc.Collection: Collection,
-    abc.Container: Container,
-    abc.ItemsView: ItemsView,
-    abc.KeysView: KeysView,
-    abc.MappingView: MappingView,
-    abc.ValuesView: ValuesView,
-    abc.Iterable: Iterable,
-    abc.Iterator: Iterator,
-    abc.Generator: Generator,
-    abc.Reversible: Reversible,
-    abc.Coroutine: Coroutine,
-    abc.AsyncGenerator: AsyncGenerator,
-    abc.AsyncIterable: AsyncIterable,
-    abc.AsyncIterator: AsyncIterator,
-    abc.Awaitable: Awaitable,
-    **{union_t: Union for union_t in UnionTypes},
-}
-"""A mapping of types to equivalent types that are safe to be used as generics across all Python versions.
-
-This is necessary because occasionally we want to rebuild a generic outer type with different args, and types such as
-``collections.abc.Mapping``, are not valid generic types in Python 3.8.
-"""
-
-wrapper_type_set = {Annotated, Required, NotRequired}
-"""Types that always contain a wrapped type annotation as their first arg."""
-
-
-def normalize_type_annotation(annotation: Any) -> Any:
-    """Normalize a type annotation to a standard form."""
-    return instantiable_type_mapping.get(annotation, annotation)
-
-
-def make_non_optional_union(annotation: UnionT | None) -> UnionT:
-    """Make a :data:`Union <typing.Union>` type that excludes ``NoneType``.
-
-    Args:
-        annotation: A type annotation.
-
-    Returns:
-        The union with all original members, except ``NoneType``.
-    """
-    args = tuple(tp for tp in get_args(annotation) if tp is not NoneType)
-    return cast("UnionT", Union[args])  # pyright: ignore
-
-
-def unwrap_annotation(annotation: Any) -> tuple[Any, tuple[Any, ...], set[Any]]:
-    """Remove "wrapper" annotation types, such as ``Annotated``, ``Required``, and ``NotRequired``.
-
-    Note:
-        ``annotation`` should have been retrieved from :func:`get_type_hints()` with ``include_extras=True``. This
-        ensures that any nested ``Annotated`` types are flattened according to the PEP 593 specification.
-
-    Args:
-        annotation: A type annotation.
-
-    Returns:
-        A tuple of the unwrapped annotation and any ``Annotated`` metadata, and a set of any wrapper types encountered.
-    """
-    origin = get_origin(annotation)
-    wrappers = set()
-    metadata = []
-    while origin in wrapper_type_set:
-        wrappers.add(origin)
-        annotation, *meta = get_args(annotation)
-        metadata.extend(meta)
-        origin = get_origin(annotation)
-    return annotation, tuple(metadata), wrappers
-
-
-def get_origin_or_inner_type(annotation: Any) -> Any:
-    """Get origin or unwrap it. Returns None for non-generic types.
-
-    Args:
-        annotation: A type annotation.
-
-    Returns:
-        Any type.
-    """
-    origin = get_origin(annotation)
-    if origin in wrapper_type_set:
-        inner, _, _ = unwrap_annotation(annotation)
-        # we need to recursively call here 'get_origin_or_inner_type' because we might be dealing
-        # with a generic type alias e.g. Annotated[dict[str, list[int]]
-        origin = get_origin_or_inner_type(inner)
-    return instantiable_type_mapping.get(origin, origin)
-
-
-def get_safe_generic_origin(origin_type: Any, annotation: Any) -> Any:
-    """Get a type that is safe to use as a generic type across all supported Python versions.
-
-    If a builtin collection type is annotated without generic args, e.g, ``a: dict``, then the origin type will be
-    ``None``. In this case, we can use the annotation to determine the correct generic type, if one exists.
-
-    Args:
-        origin_type: A type - would be the return value of :func:`get_origin()`.
-        annotation: Type annotation associated with the origin type. Should be unwrapped from any wrapper types, such
-            as ``Annotated``.
-
-    Returns:
-        The ``typing`` module equivalent of the given type, if it exists. Otherwise, the original type is returned.
-    """
-    if origin_type is None:
-        return safe_generic_origin_map.get(annotation)
-    return safe_generic_origin_map.get(origin_type, origin_type)
-
-
-def get_instantiable_origin(origin_type: Any, annotation: Any) -> Any:
-    """Get a type that is safe to instantiate for the given origin type.
-
-    If a builtin collection type is annotated without generic args, e.g, ``a: dict``, then the origin type will be
-    ``None``. In this case, we can use the annotation to determine the correct instantiable type, if one exists.
-
-    Args:
-        origin_type: A type - would be the return value of :func:`get_origin()`.
-        annotation: Type annotation associated with the origin type. Should be unwrapped from any wrapper types, such
-            as ``Annotated``.
-
-    Returns:
-        A builtin type that is safe to instantiate for the given origin type.
-    """
-    if origin_type is None:
-        return instantiable_type_mapping.get(annotation)
-    return instantiable_type_mapping.get(origin_type, origin_type)
-
-
-def get_type_hints_with_generics_resolved(
-    annotation: Any,
-    globalns: dict[str, Any] | None = None,
-    localns: dict[str, Any] | None = None,
-    include_extras: bool = False,
-    type_hints: dict[str, Any] | None = None,
-) -> dict[str, Any]:
-    """Get the type hints for the given object after resolving the generic types as much as possible.
-
-    Args:
-        annotation: A type annotation.
-        globalns: The global namespace.
-        localns: The local namespace.
-        include_extras: A flag indicating whether to include the ``Annotated[T, ...]`` or not.
-        type_hints: Already resolved type hints
-    """
-    origin = get_origin(annotation)
-
-    if origin is None:
-        # Implies the generic types have not been specified in the annotation
-        if type_hints is None:  # pragma: no cover
-            type_hints = get_type_hints(annotation, globalns=globalns, localns=localns, include_extras=include_extras)
-        typevar_map = {p: p for p in annotation.__parameters__}
-    else:
-        if type_hints is None:  # pragma: no cover
-            type_hints = get_type_hints(origin, globalns=globalns, localns=localns, include_extras=include_extras)
-        # the __parameters__ is only available on the origin itself and not the annotation
-        typevar_map = dict(zip(origin.__parameters__, get_args(annotation)))
-
-    return {n: _substitute_typevars(type_, typevar_map) for n, type_ in type_hints.items()}
-
-
-def _substitute_typevars(obj: Any, typevar_map: Mapping[Any, Any]) -> Any:
-    if params := getattr(obj, "__parameters__", None):
-        args = tuple(_substitute_typevars(typevar_map.get(p, p), typevar_map) for p in params)
-        return obj[args]
-
-    if isinstance(obj, TypeVar):
-        # If there's a mapped type for the TypeVar already, then it should be returned instead
-        # of considering __constraints__ or __bound__. For a generic `Foo[T]`, if Foo[int] is given
-        # then int should be returned and if `Foo` is given then the __bounds__ and __constraints__
-        # should be considered.
-        if (type_ := typevar_map.get(obj, None)) is not None and not isinstance(type_, TypeVar):
-            return type_
-
-        if obj.__bound__ is not None:
-            return obj.__bound__
-
-        if obj.__constraints__:
-            return Union[obj.__constraints__]  # pyright: ignore
-
-    return obj
diff --git a/venv/lib/python3.11/site-packages/litestar/utils/version.py b/venv/lib/python3.11/site-packages/litestar/utils/version.py
deleted file mode 100644
index d7974eb..0000000
--- a/venv/lib/python3.11/site-packages/litestar/utils/version.py
+++ /dev/null
@@ -1,62 +0,0 @@
-from __future__ import annotations
-
-import re
-import sys
-from typing import Literal, NamedTuple
-
-__all__ = ("Version", "get_version", "parse_version")
-
-
-if sys.version_info >= (3, 10):
-    import importlib.metadata as importlib_metadata
-else:
-    import importlib_metadata
-
-
-_ReleaseLevel = Literal["alpha", "beta", "rc", "final"]
-_PRE_RELEASE_TAGS = {"alpha", "a", "beta", "b", "rc"}
-_PRE_RELEASE_TAGS_CONVERSIONS: dict[str, _ReleaseLevel] = {"a": "alpha", "b": "beta"}
-
-_VERSION_PARTS_RE = re.compile(r"(\d+|[a-z]+|\.)")
-
-
-class Version(NamedTuple):
-    """Litestar version information"""
-
-    major: int
-    minor: int
-    patch: int
-    release_level: _ReleaseLevel
-    serial: int
-
-    def formatted(self, short: bool = False) -> str:
-        version = f"{self.major}.{self.minor}.{self.patch}"
-        if not short:
-            version += f"{self.release_level}{self.serial}"
-        return version
-
-
-def parse_version(raw_version: str) -> Version:
-    """Parse a version string into a :class:`Version`"""
-    parts = [p for p in _VERSION_PARTS_RE.split(raw_version) if p and p != "."]
-    release_level: _ReleaseLevel = "final"
-    serial = "0"
-
-    if len(parts) == 3:
-        major, minor, patch = parts
-    elif len(parts) == 5:
-        major, minor, patch, release_level, serial = parts  # type: ignore[assignment]
-        if release_level not in _PRE_RELEASE_TAGS:
-            raise ValueError(f"Invalid release level: {release_level}")
-        release_level = _PRE_RELEASE_TAGS_CONVERSIONS.get(release_level, release_level)
-    else:
-        raise ValueError(f"Invalid version: {raw_version}")
-
-    return Version(
-        major=int(major), minor=int(minor), patch=int(patch), release_level=release_level, serial=int(serial)
-    )
-
-
-def get_version() -> Version:
-    """Get the version of the installed litestar package"""
-    return parse_version(importlib_metadata.version("litestar"))
diff --git a/venv/lib/python3.11/site-packages/litestar/utils/warnings.py b/venv/lib/python3.11/site-packages/litestar/utils/warnings.py
deleted file mode 100644
index e20484b..0000000
--- a/venv/lib/python3.11/site-packages/litestar/utils/warnings.py
+++ /dev/null
@@ -1,51 +0,0 @@
-import os
-import warnings
-
-from litestar.exceptions import LitestarWarning
-from litestar.types import AnyCallable, AnyGenerator
-
-
-def warn_implicit_sync_to_thread(source: AnyCallable, stacklevel: int = 2) -> None:
-    if os.getenv("LITESTAR_WARN_IMPLICIT_SYNC_TO_THREAD") == "0":
-        return
-
-    warnings.warn(
-        f"Use of a synchronous callable {source} without setting sync_to_thread is "
-        "discouraged since synchronous callables can block the main thread if they "
-        "perform blocking operations. If the callable is guaranteed to be non-blocking, "
-        "you can set sync_to_thread=False to skip this warning, or set the environment"
-        "variable LITESTAR_WARN_IMPLICIT_SYNC_TO_THREAD=0 to disable warnings of this "
-        "type entirely.",
-        category=LitestarWarning,
-        stacklevel=stacklevel,
-    )
-
-
-def warn_sync_to_thread_with_async_callable(source: AnyCallable, stacklevel: int = 2) -> None:
-    if os.getenv("LITESTAR_WARN_SYNC_TO_THREAD_WITH_ASYNC") == "0":
-        return
-
-    warnings.warn(
-        f"Use of an asynchronous callable {source} with sync_to_thread; sync_to_thread "
-        "has no effect on async callable. You can disable this warning by setting "
-        "LITESTAR_WARN_SYNC_TO_THREAD_WITH_ASYNC=0",
-        category=LitestarWarning,
-        stacklevel=stacklevel,
-    )
-
-
-def warn_sync_to_thread_with_generator(source: AnyGenerator, stacklevel: int = 2) -> None:
-    if os.getenv("LITESTAR_WARN_SYNC_TO_THREAD_WITH_GENERATOR") == "0":
-        return
-
-    warnings.warn(
-        f"Use of generator {source} with sync_to_thread; sync_to_thread has no effect "
-        "on generators. You can disable this warning by setting "
-        "LITESTAR_WARN_SYNC_TO_THREAD_WITH_GENERATOR=0",
-        category=LitestarWarning,
-        stacklevel=stacklevel,
-    )
-
-
-def warn_pdb_on_exception(stacklevel: int = 2) -> None:
-    warnings.warn("Python Debugger on exception enabled", category=LitestarWarning, stacklevel=stacklevel)