prefect-client 2.20.4__py3-none-any.whl → 3.0.0__py3-none-any.whl

prefect/_vendor/fastapi/utils.py

@@ -1,235 +0,0 @@
-import re
-import warnings
-from dataclasses import is_dataclass
-from enum import Enum
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Dict,
-    MutableMapping,
-    Optional,
-    Set,
-    Type,
-    Union,
-    cast,
-)
-from weakref import WeakKeyDictionary
-
-from prefect._vendor.fastapi.datastructures import DefaultPlaceholder, DefaultType
-from prefect._vendor.fastapi.exceptions import FastAPIError
-from prefect._vendor.fastapi.openapi.constants import REF_PREFIX
-
-from prefect._internal.pydantic import HAS_PYDANTIC_V2
-
-if HAS_PYDANTIC_V2:
-    from pydantic.v1 import BaseConfig, BaseModel, create_model
-    from pydantic.v1.class_validators import Validator
-    from pydantic.v1.fields import FieldInfo, ModelField, UndefinedType
-    from pydantic.v1.schema import model_process_schema
-    from pydantic.v1.utils import lenient_issubclass
-else:
-    from pydantic import BaseConfig, BaseModel, create_model
-    from pydantic.class_validators import Validator
-    from pydantic.fields import FieldInfo, ModelField, UndefinedType
-    from pydantic.schema import model_process_schema
-    from pydantic.utils import lenient_issubclass
-
-
-if TYPE_CHECKING:  # pragma: nocover
-    from .routing import APIRoute
-
-# Cache for `create_cloned_field`
-_CLONED_TYPES_CACHE: MutableMapping[
-    Type[BaseModel], Type[BaseModel]
-] = WeakKeyDictionary()
-
-
-def is_body_allowed_for_status_code(status_code: Union[int, str, None]) -> bool:
-    if status_code is None:
-        return True
-    # Ref: https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#patterned-fields-1
-    if status_code in {
-        "default",
-        "1XX",
-        "2XX",
-        "3XX",
-        "4XX",
-        "5XX",
-    }:
-        return True
-    current_status_code = int(status_code)
-    return not (current_status_code < 200 or current_status_code in {204, 304})
-
-
-def get_model_definitions(
-    *,
-    flat_models: Set[Union[Type[BaseModel], Type[Enum]]],
-    model_name_map: Dict[Union[Type[BaseModel], Type[Enum]], str],
-) -> Dict[str, Any]:
-    definitions: Dict[str, Dict[str, Any]] = {}
-    for model in flat_models:
-        m_schema, m_definitions, m_nested_models = model_process_schema(
-            model, model_name_map=model_name_map, ref_prefix=REF_PREFIX
-        )
-        definitions.update(m_definitions)
-        model_name = model_name_map[model]
-        if "description" in m_schema:
-            m_schema["description"] = m_schema["description"].split("\f")[0]
-        definitions[model_name] = m_schema
-    return definitions
-
-
-def get_path_param_names(path: str) -> Set[str]:
-    return set(re.findall("{(.*?)}", path))
-
-
-def create_response_field(
-    name: str,
-    type_: Type[Any],
-    class_validators: Optional[Dict[str, Validator]] = None,
-    default: Optional[Any] = None,
-    required: Union[bool, UndefinedType] = True,
-    model_config: Type[BaseConfig] = BaseConfig,
-    field_info: Optional[FieldInfo] = None,
-    alias: Optional[str] = None,
-) -> ModelField:
-    """
-    Create a new response field. Raises if type_ is invalid.
-    """
-    class_validators = class_validators or {}
-    field_info = field_info or FieldInfo()
-
-    try:
-        return ModelField(
-            name=name,
-            type_=type_,
-            class_validators=class_validators,
-            default=default,
-            required=required,
-            model_config=model_config,
-            alias=alias,
-            field_info=field_info,
-        )
-    except RuntimeError:
-        raise FastAPIError(
-            "Invalid args for response field! Hint: "
-            f"check that {type_} is a valid Pydantic field type. "
-            "If you are using a return type annotation that is not a valid Pydantic "
-            "field (e.g. Union[Response, dict, None]) you can disable generating the "
-            "response model from the type annotation with the path operation decorator "
-            "parameter response_model=None. Read more: "
-            "https://fastapi.tiangolo.com/tutorial/response-model/"
-        ) from None
-
-
-def create_cloned_field(
-    field: ModelField,
-    *,
-    cloned_types: Optional[MutableMapping[Type[BaseModel], Type[BaseModel]]] = None,
-) -> ModelField:
-    # cloned_types caches already cloned types to support recursive models and improve
-    # performance by avoiding unecessary cloning
-    if cloned_types is None:
-        cloned_types = _CLONED_TYPES_CACHE
-
-    original_type = field.type_
-    if is_dataclass(original_type) and hasattr(original_type, "__pydantic_model__"):
-        original_type = original_type.__pydantic_model__
-    use_type = original_type
-    if lenient_issubclass(original_type, BaseModel):
-        original_type = cast(Type[BaseModel], original_type)
-        use_type = cloned_types.get(original_type)
-        if use_type is None:
-            use_type = create_model(original_type.__name__, __base__=original_type)
-            cloned_types[original_type] = use_type
-            for f in original_type.__fields__.values():
-                use_type.__fields__[f.name] = create_cloned_field(
-                    f, cloned_types=cloned_types
-                )
-    new_field = create_response_field(name=field.name, type_=use_type)
-    new_field.has_alias = field.has_alias
-    new_field.alias = field.alias
-    new_field.class_validators = field.class_validators
-    new_field.default = field.default
-    new_field.required = field.required
-    new_field.model_config = field.model_config
-    new_field.field_info = field.field_info
-    new_field.allow_none = field.allow_none
-    new_field.validate_always = field.validate_always
-    if field.sub_fields:
-        new_field.sub_fields = [
-            create_cloned_field(sub_field, cloned_types=cloned_types)
-            for sub_field in field.sub_fields
-        ]
-    if field.key_field:
-        new_field.key_field = create_cloned_field(
-            field.key_field, cloned_types=cloned_types
-        )
-    new_field.validators = field.validators
-    new_field.pre_validators = field.pre_validators
-    new_field.post_validators = field.post_validators
-    new_field.parse_json = field.parse_json
-    new_field.shape = field.shape
-    new_field.populate_validators()
-    return new_field
-
-
-def generate_operation_id_for_path(
-    *, name: str, path: str, method: str
-) -> str:  # pragma: nocover
-    warnings.warn(
-        (
-            "fastapi.utils.generate_operation_id_for_path() was deprecated, "
-            "it is not used internally, and will be removed soon"
-        ),
-        DeprecationWarning,
-        stacklevel=2,
-    )
-    operation_id = name + path
-    operation_id = re.sub(r"\W", "_", operation_id)
-    operation_id = operation_id + "_" + method.lower()
-    return operation_id
-
-
-def generate_unique_id(route: "APIRoute") -> str:
-    operation_id = route.name + route.path_format
-    operation_id = re.sub(r"\W", "_", operation_id)
-    assert route.methods
-    operation_id = operation_id + "_" + list(route.methods)[0].lower()
-    return operation_id
-
-
-def deep_dict_update(main_dict: Dict[Any, Any], update_dict: Dict[Any, Any]) -> None:
-    for key, value in update_dict.items():
-        if (
-            key in main_dict
-            and isinstance(main_dict[key], dict)
-            and isinstance(value, dict)
-        ):
-            deep_dict_update(main_dict[key], value)
-        elif (
-            key in main_dict
-            and isinstance(main_dict[key], list)
-            and isinstance(update_dict[key], list)
-        ):
-            main_dict[key] = main_dict[key] + update_dict[key]
-        else:
-            main_dict[key] = value
-
-
-def get_value_or_default(
-    first_item: Union[DefaultPlaceholder, DefaultType],
-    *extra_items: Union[DefaultPlaceholder, DefaultType],
-) -> Union[DefaultPlaceholder, DefaultType]:
-    """
-    Pass items or `DefaultPlaceholder`s by descending priority.
-
-    The first one to _not_ be a `DefaultPlaceholder` will be returned.
-
-    Otherwise, the first item (a `DefaultPlaceholder`) will be returned.
-    """
-    items = (first_item,) + extra_items
-    for item in items:
-        if not isinstance(item, DefaultPlaceholder):
-            return item
-    return first_item

prefect/_vendor/fastapi/websockets.py

@@ -1,7 +0,0 @@
-from prefect._vendor.starlette.websockets import WebSocket as WebSocket  # noqa
-from prefect._vendor.starlette.websockets import (
-    WebSocketDisconnect as WebSocketDisconnect,
-)  # noqa
-from prefect._vendor.starlette.websockets import (
-    WebSocketState as WebSocketState,
-)  # noqa

prefect/_vendor/starlette/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.33.0"

prefect/_vendor/starlette/_compat.py

@@ -1,28 +0,0 @@
-import hashlib
-
-# Compat wrapper to always include the `usedforsecurity=...` parameter,
-# which is only added from Python 3.9 onwards.
-# We use this flag to indicate that we use `md5` hashes only for non-security
-# cases (our ETag checksums).
-# If we don't indicate that we're using MD5 for non-security related reasons,
-# then attempting to use this function will raise an error when used
-# environments which enable a strict "FIPs mode".
-#
-# See issue: https://github.com/encode/starlette/issues/1365
-try:
-    # check if the Python version supports the parameter
-    # using usedforsecurity=False to avoid an exception on FIPS systems
-    # that reject usedforsecurity=True
-    hashlib.md5(b"data", usedforsecurity=False)  # type: ignore[call-arg]
-
-    def md5_hexdigest(
-        data: bytes, *, usedforsecurity: bool = True
-    ) -> str:  # pragma: no cover
-        return hashlib.md5(  # type: ignore[call-arg]
-            data, usedforsecurity=usedforsecurity
-        ).hexdigest()
-
-except TypeError:  # pragma: no cover
-
-    def md5_hexdigest(data: bytes, *, usedforsecurity: bool = True) -> str:
-        return hashlib.md5(data).hexdigest()

prefect/_vendor/starlette/_exception_handler.py

@@ -1,80 +0,0 @@
-import typing
-
-from prefect._vendor.starlette._utils import is_async_callable
-from prefect._vendor.starlette.concurrency import run_in_threadpool
-from prefect._vendor.starlette.exceptions import HTTPException
-from prefect._vendor.starlette.requests import Request
-from prefect._vendor.starlette.types import (
-    ASGIApp,
-    ExceptionHandler,
-    Message,
-    Receive,
-    Scope,
-    Send,
-)
-from prefect._vendor.starlette.websockets import WebSocket
-
-ExceptionHandlers = typing.Dict[typing.Any, ExceptionHandler]
-StatusHandlers = typing.Dict[int, ExceptionHandler]
-
-
-def _lookup_exception_handler(
-    exc_handlers: ExceptionHandlers, exc: Exception
-) -> typing.Optional[ExceptionHandler]:
-    for cls in type(exc).__mro__:
-        if cls in exc_handlers:
-            return exc_handlers[cls]
-    return None
-
-
-def wrap_app_handling_exceptions(
-    app: ASGIApp, conn: typing.Union[Request, WebSocket]
-) -> ASGIApp:
-    exception_handlers: ExceptionHandlers
-    status_handlers: StatusHandlers
-    try:
-        exception_handlers, status_handlers = conn.scope["starlette.exception_handlers"]
-    except KeyError:
-        exception_handlers, status_handlers = {}, {}
-
-    async def wrapped_app(scope: Scope, receive: Receive, send: Send) -> None:
-        response_started = False
-
-        async def sender(message: Message) -> None:
-            nonlocal response_started
-
-            if message["type"] == "http.response.start":
-                response_started = True
-            await send(message)
-
-        try:
-            await app(scope, receive, sender)
-        except Exception as exc:
-            handler = None
-
-            if isinstance(exc, HTTPException):
-                handler = status_handlers.get(exc.status_code)
-
-            if handler is None:
-                handler = _lookup_exception_handler(exception_handlers, exc)
-
-            if handler is None:
-                raise exc
-
-            if response_started:
-                msg = "Caught handled exception, but response already started."
-                raise RuntimeError(msg) from exc
-
-            if scope["type"] == "http":
-                if is_async_callable(handler):
-                    response = await handler(conn, exc)
-                else:
-                    response = await run_in_threadpool(handler, conn, exc)
-                await response(scope, receive, sender)
-            elif scope["type"] == "websocket":
-                if is_async_callable(handler):
-                    await handler(conn, exc)
-                else:
-                    await run_in_threadpool(handler, conn, exc)
-
-    return wrapped_app

prefect/_vendor/starlette/_utils.py

@@ -1,88 +0,0 @@
-import asyncio
-import functools
-import sys
-import typing
-from contextlib import contextmanager
-
-if sys.version_info >= (3, 10):  # pragma: no cover
-    from typing import TypeGuard
-else:  # pragma: no cover
-    from typing_extensions import TypeGuard
-
-has_exceptiongroups = True
-if sys.version_info < (3, 11):  # pragma: no cover
-    try:
-        from exceptiongroup import BaseExceptionGroup
-    except ImportError:
-        has_exceptiongroups = False
-
-T = typing.TypeVar("T")
-AwaitableCallable = typing.Callable[..., typing.Awaitable[T]]
-
-
-@typing.overload
-def is_async_callable(obj: AwaitableCallable[T]) -> TypeGuard[AwaitableCallable[T]]:
-    ...
-
-
-@typing.overload
-def is_async_callable(obj: typing.Any) -> TypeGuard[AwaitableCallable[typing.Any]]:
-    ...
-
-
-def is_async_callable(obj: typing.Any) -> typing.Any:
-    while isinstance(obj, functools.partial):
-        obj = obj.func
-
-    return asyncio.iscoroutinefunction(obj) or (
-        callable(obj) and asyncio.iscoroutinefunction(obj.__call__)
-    )
-
-
-T_co = typing.TypeVar("T_co", covariant=True)
-
-
-class AwaitableOrContextManager(
-    typing.Awaitable[T_co], typing.AsyncContextManager[T_co], typing.Protocol[T_co]
-):
-    ...
-
-
-class SupportsAsyncClose(typing.Protocol):
-    async def close(self) -> None:
-        ...  # pragma: no cover
-
-
-SupportsAsyncCloseType = typing.TypeVar(
-    "SupportsAsyncCloseType", bound=SupportsAsyncClose, covariant=False
-)
-
-
-class AwaitableOrContextManagerWrapper(typing.Generic[SupportsAsyncCloseType]):
-    __slots__ = ("aw", "entered")
-
-    def __init__(self, aw: typing.Awaitable[SupportsAsyncCloseType]) -> None:
-        self.aw = aw
-
-    def __await__(self) -> typing.Generator[typing.Any, None, SupportsAsyncCloseType]:
-        return self.aw.__await__()
-
-    async def __aenter__(self) -> SupportsAsyncCloseType:
-        self.entered = await self.aw
-        return self.entered
-
-    async def __aexit__(self, *args: typing.Any) -> typing.Union[None, bool]:
-        await self.entered.close()
-        return None
-
-
-@contextmanager
-def collapse_excgroups() -> typing.Generator[None, None, None]:
-    try:
-        yield
-    except BaseException as exc:
-        if has_exceptiongroups:
-            while isinstance(exc, BaseExceptionGroup) and len(exc.exceptions) == 1:
-                exc = exc.exceptions[0]  # pragma: no cover
-
-        raise exc