prefect-client 2.19.4__py3-none-any.whl → 3.0.0rc2__py3-none-any.whl

prefect/_vendor/fastapi/background.py

@@ -1,3 +0,0 @@
-from prefect._vendor.starlette.background import (
-    BackgroundTasks as BackgroundTasks,
-)

prefect/_vendor/fastapi/concurrency.py

@@ -1,44 +0,0 @@
-from contextlib import AsyncExitStack as AsyncExitStack  # noqa
-from contextlib import asynccontextmanager as asynccontextmanager
-from typing import AsyncGenerator, ContextManager, TypeVar
-
-import anyio
-from anyio import CapacityLimiter
-from prefect._vendor.starlette.concurrency import (
-    iterate_in_threadpool as iterate_in_threadpool,
-)  # noqa
-from prefect._vendor.starlette.concurrency import (
-    run_in_threadpool as run_in_threadpool,
-)  # noqa
-from prefect._vendor.starlette.concurrency import (  # noqa
-    run_until_first_complete as run_until_first_complete,
-)
-
-_T = TypeVar("_T")
-
-
-@asynccontextmanager
-async def contextmanager_in_threadpool(
-    cm: ContextManager[_T],
-) -> AsyncGenerator[_T, None]:
-    # blocking __exit__ from running waiting on a free thread
-    # can create race conditions/deadlocks if the context manager itself
-    # has it's own internal pool (e.g. a database connection pool)
-    # to avoid this we let __exit__ run without a capacity limit
-    # since we're creating a new limiter for each call, any non-zero limit
-    # works (1 is arbitrary)
-    exit_limiter = CapacityLimiter(1)
-    try:
-        yield await run_in_threadpool(cm.__enter__)
-    except Exception as e:
-        ok = bool(
-            await anyio.to_thread.run_sync(
-                cm.__exit__, type(e), e, None, limiter=exit_limiter
-            )
-        )
-        if not ok:
-            raise e
-    else:
-        await anyio.to_thread.run_sync(
-            cm.__exit__, None, None, None, limiter=exit_limiter
-        )

prefect/_vendor/fastapi/datastructures.py

@@ -1,58 +0,0 @@
-from typing import Any, Callable, Dict, Iterable, Type, TypeVar
-
-from prefect._vendor.starlette.datastructures import URL as URL  # noqa: F401
-from prefect._vendor.starlette.datastructures import Address as Address  # noqa: F401
-from prefect._vendor.starlette.datastructures import FormData as FormData  # noqa: F401
-from prefect._vendor.starlette.datastructures import Headers as Headers  # noqa: F401
-from prefect._vendor.starlette.datastructures import (
-    QueryParams as QueryParams,  # noqa: F401
-)
-from prefect._vendor.starlette.datastructures import State as State  # noqa: F401
-from prefect._vendor.starlette.datastructures import UploadFile as StarletteUploadFile
-
-
-class UploadFile(StarletteUploadFile):
-    @classmethod
-    def __get_validators__(cls: Type["UploadFile"]) -> Iterable[Callable[..., Any]]:
-        yield cls.validate
-
-    @classmethod
-    def validate(cls: Type["UploadFile"], v: Any) -> Any:
-        if not isinstance(v, StarletteUploadFile):
-            raise ValueError(f"Expected UploadFile, received: {type(v)}")
-        return v
-
-    @classmethod
-    def __modify_schema__(cls, field_schema: Dict[str, Any]) -> None:
-        field_schema.update({"type": "string", "format": "binary"})
-
-
-class DefaultPlaceholder:
-    """
-    You shouldn't use this class directly.
-
-    It's used internally to recognize when a default value has been overwritten, even
-    if the overridden default value was truthy.
-    """
-
-    def __init__(self, value: Any):
-        self.value = value
-
-    def __bool__(self) -> bool:
-        return bool(self.value)
-
-    def __eq__(self, o: object) -> bool:
-        return isinstance(o, DefaultPlaceholder) and o.value == self.value
-
-
-DefaultType = TypeVar("DefaultType")
-
-
-def Default(value: DefaultType) -> DefaultType:
-    """
-    You shouldn't use this function directly.
-
-    It's used internally to recognize when a default value has been overwritten, even
-    if the overridden default value was truthy.
-    """
-    return DefaultPlaceholder(value)  # type: ignore

prefect/_vendor/fastapi/dependencies/models.py

@@ -1,64 +0,0 @@
-from typing import Any, Callable, List, Optional, Sequence
-
-from prefect._vendor.fastapi.security.base import SecurityBase
-
-from prefect._internal.pydantic import HAS_PYDANTIC_V2
-
-if HAS_PYDANTIC_V2:
-    from pydantic.v1.fields import ModelField
-else:
-    from pydantic.fields import ModelField
-
-
-class SecurityRequirement:
-    def __init__(
-        self, security_scheme: SecurityBase, scopes: Optional[Sequence[str]] = None
-    ):
-        self.security_scheme = security_scheme
-        self.scopes = scopes
-
-
-class Dependant:
-    def __init__(
-        self,
-        *,
-        path_params: Optional[List[ModelField]] = None,
-        query_params: Optional[List[ModelField]] = None,
-        header_params: Optional[List[ModelField]] = None,
-        cookie_params: Optional[List[ModelField]] = None,
-        body_params: Optional[List[ModelField]] = None,
-        dependencies: Optional[List["Dependant"]] = None,
-        security_schemes: Optional[List[SecurityRequirement]] = None,
-        name: Optional[str] = None,
-        call: Optional[Callable[..., Any]] = None,
-        request_param_name: Optional[str] = None,
-        websocket_param_name: Optional[str] = None,
-        http_connection_param_name: Optional[str] = None,
-        response_param_name: Optional[str] = None,
-        background_tasks_param_name: Optional[str] = None,
-        security_scopes_param_name: Optional[str] = None,
-        security_scopes: Optional[List[str]] = None,
-        use_cache: bool = True,
-        path: Optional[str] = None,
-    ) -> None:
-        self.path_params = path_params or []
-        self.query_params = query_params or []
-        self.header_params = header_params or []
-        self.cookie_params = cookie_params or []
-        self.body_params = body_params or []
-        self.dependencies = dependencies or []
-        self.security_requirements = security_schemes or []
-        self.request_param_name = request_param_name
-        self.websocket_param_name = websocket_param_name
-        self.http_connection_param_name = http_connection_param_name
-        self.response_param_name = response_param_name
-        self.background_tasks_param_name = background_tasks_param_name
-        self.security_scopes = security_scopes
-        self.security_scopes_param_name = security_scopes_param_name
-        self.name = name
-        self.call = call
-        self.use_cache = use_cache
-        # Store the path to be able to re-generate a dependable from it in overrides
-        self.path = path
-        # Save the cache key at creation to optimize performance
-        self.cache_key = (self.call, tuple(sorted(set(self.security_scopes or []))))