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

prefect/_vendor/starlette/applications.py

@@ -1,261 +0,0 @@
-from __future__ import annotations
-
-import typing
-import warnings
-
-from prefect._vendor.starlette.datastructures import State, URLPath
-from prefect._vendor.starlette.middleware import Middleware
-from prefect._vendor.starlette.middleware.base import BaseHTTPMiddleware
-from prefect._vendor.starlette.middleware.errors import ServerErrorMiddleware
-from prefect._vendor.starlette.middleware.exceptions import ExceptionMiddleware
-from prefect._vendor.starlette.requests import Request
-from prefect._vendor.starlette.responses import Response
-from prefect._vendor.starlette.routing import BaseRoute, Router
-from prefect._vendor.starlette.types import (
-    ASGIApp,
-    ExceptionHandler,
-    Lifespan,
-    Receive,
-    Scope,
-    Send,
-)
-from prefect._vendor.starlette.websockets import WebSocket
-
-AppType = typing.TypeVar("AppType", bound="Starlette")
-
-
-class Starlette:
-    """
-    Creates an application instance.
-
-    **Parameters:**
-
-    * **debug** - Boolean indicating if debug tracebacks should be returned on errors.
-    * **routes** - A list of routes to serve incoming HTTP and WebSocket requests.
-    * **middleware** - A list of middleware to run for every request. A starlette
-    application will always automatically include two middleware classes.
-    `ServerErrorMiddleware` is added as the very outermost middleware, to handle
-    any uncaught errors occurring anywhere in the entire stack.
-    `ExceptionMiddleware` is added as the very innermost middleware, to deal
-    with handled exception cases occurring in the routing or endpoints.
-    * **exception_handlers** - A mapping of either integer status codes,
-    or exception class types onto callables which handle the exceptions.
-    Exception handler callables should be of the form
-    `handler(request, exc) -> response` and may be either standard functions, or
-    async functions.
-    * **on_startup** - A list of callables to run on application startup.
-    Startup handler callables do not take any arguments, and may be either
-    standard functions, or async functions.
-    * **on_shutdown** - A list of callables to run on application shutdown.
-    Shutdown handler callables do not take any arguments, and may be either
-    standard functions, or async functions.
-    * **lifespan** - A lifespan context function, which can be used to perform
-    startup and shutdown tasks. This is a newer style that replaces the
-    `on_startup` and `on_shutdown` handlers. Use one or the other, not both.
-    """
-
-    def __init__(
-        self: "AppType",
-        debug: bool = False,
-        routes: typing.Sequence[BaseRoute] | None = None,
-        middleware: typing.Sequence[Middleware] | None = None,
-        exception_handlers: typing.Mapping[typing.Any, ExceptionHandler] | None = None,
-        on_startup: typing.Sequence[typing.Callable[[], typing.Any]] | None = None,
-        on_shutdown: typing.Sequence[typing.Callable[[], typing.Any]] | None = None,
-        lifespan: typing.Optional[Lifespan["AppType"]] = None,
-    ) -> None:
-        # The lifespan context function is a newer style that replaces
-        # on_startup / on_shutdown handlers. Use one or the other, not both.
-        assert lifespan is None or (
-            on_startup is None and on_shutdown is None
-        ), "Use either 'lifespan' or 'on_startup'/'on_shutdown', not both."
-
-        self.debug = debug
-        self.state = State()
-        self.router = Router(
-            routes, on_startup=on_startup, on_shutdown=on_shutdown, lifespan=lifespan
-        )
-        self.exception_handlers = (
-            {} if exception_handlers is None else dict(exception_handlers)
-        )
-        self.user_middleware = [] if middleware is None else list(middleware)
-        self.middleware_stack: typing.Optional[ASGIApp] = None
-
-    def build_middleware_stack(self) -> ASGIApp:
-        debug = self.debug
-        error_handler = None
-        exception_handlers: typing.Dict[
-            typing.Any, typing.Callable[[Request, Exception], Response]
-        ] = {}
-
-        for key, value in self.exception_handlers.items():
-            if key in (500, Exception):
-                error_handler = value
-            else:
-                exception_handlers[key] = value
-
-        middleware = (
-            [Middleware(ServerErrorMiddleware, handler=error_handler, debug=debug)]
-            + self.user_middleware
-            + [
-                Middleware(
-                    ExceptionMiddleware, handlers=exception_handlers, debug=debug
-                )
-            ]
-        )
-
-        app = self.router
-        for cls, options in reversed(middleware):
-            app = cls(app=app, **options)
-        return app
-
-    @property
-    def routes(self) -> typing.List[BaseRoute]:
-        return self.router.routes
-
-    def url_path_for(self, name: str, /, **path_params: typing.Any) -> URLPath:
-        return self.router.url_path_for(name, **path_params)
-
-    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
-        scope["app"] = self
-        if self.middleware_stack is None:
-            self.middleware_stack = self.build_middleware_stack()
-        await self.middleware_stack(scope, receive, send)
-
-    def on_event(self, event_type: str) -> typing.Callable:  # type: ignore[type-arg]
-        return self.router.on_event(event_type)  # pragma: nocover
-
-    def mount(self, path: str, app: ASGIApp, name: str | None = None) -> None:
-        self.router.mount(path, app=app, name=name)  # pragma: no cover
-
-    def host(self, host: str, app: ASGIApp, name: str | None = None) -> None:
-        self.router.host(host, app=app, name=name)  # pragma: no cover
-
-    def add_middleware(self, middleware_class: type, **options: typing.Any) -> None:
-        if self.middleware_stack is not None:  # pragma: no cover
-            raise RuntimeError("Cannot add middleware after an application has started")
-        self.user_middleware.insert(0, Middleware(middleware_class, **options))
-
-    def add_exception_handler(
-        self,
-        exc_class_or_status_code: int | typing.Type[Exception],
-        handler: ExceptionHandler,
-    ) -> None:  # pragma: no cover
-        self.exception_handlers[exc_class_or_status_code] = handler
-
-    def add_event_handler(
-        self,
-        event_type: str,
-        func: typing.Callable,  # type: ignore[type-arg]
-    ) -> None:  # pragma: no cover
-        self.router.add_event_handler(event_type, func)
-
-    def add_route(
-        self,
-        path: str,
-        route: typing.Callable[[Request], typing.Awaitable[Response] | Response],
-        methods: typing.Optional[typing.List[str]] = None,
-        name: typing.Optional[str] = None,
-        include_in_schema: bool = True,
-    ) -> None:  # pragma: no cover
-        self.router.add_route(
-            path, route, methods=methods, name=name, include_in_schema=include_in_schema
-        )
-
-    def add_websocket_route(
-        self,
-        path: str,
-        route: typing.Callable[[WebSocket], typing.Awaitable[None]],
-        name: str | None = None,
-    ) -> None:  # pragma: no cover
-        self.router.add_websocket_route(path, route, name=name)
-
-    def exception_handler(
-        self, exc_class_or_status_code: int | typing.Type[Exception]
-    ) -> typing.Callable:  # type: ignore[type-arg]
-        warnings.warn(
-            "The `exception_handler` decorator is deprecated, and will be removed in version 1.0.0. "  # noqa: E501
-            "Refer to https://www.starlette.io/exceptions/ for the recommended approach.",  # noqa: E501
-            DeprecationWarning,
-        )
-
-        def decorator(func: typing.Callable) -> typing.Callable:  # type: ignore[type-arg]  # noqa: E501
-            self.add_exception_handler(exc_class_or_status_code, func)
-            return func
-
-        return decorator
-
-    def route(
-        self,
-        path: str,
-        methods: typing.List[str] | None = None,
-        name: str | None = None,
-        include_in_schema: bool = True,
-    ) -> typing.Callable:  # type: ignore[type-arg]
-        """
-        We no longer document this decorator style API, and its usage is discouraged.
-        Instead you should use the following approach:
-
-        >>> routes = [Route(path, endpoint=...), ...]
-        >>> app = Starlette(routes=routes)
-        """
-        warnings.warn(
-            "The `route` decorator is deprecated, and will be removed in version 1.0.0. "  # noqa: E501
-            "Refer to https://www.starlette.io/routing/ for the recommended approach.",  # noqa: E501
-            DeprecationWarning,
-        )
-
-        def decorator(func: typing.Callable) -> typing.Callable:  # type: ignore[type-arg]  # noqa: E501
-            self.router.add_route(
-                path,
-                func,
-                methods=methods,
-                name=name,
-                include_in_schema=include_in_schema,
-            )
-            return func
-
-        return decorator
-
-    def websocket_route(self, path: str, name: str | None = None) -> typing.Callable:  # type: ignore[type-arg]
-        """
-        We no longer document this decorator style API, and its usage is discouraged.
-        Instead you should use the following approach:
-
-        >>> routes = [WebSocketRoute(path, endpoint=...), ...]
-        >>> app = Starlette(routes=routes)
-        """
-        warnings.warn(
-            "The `websocket_route` decorator is deprecated, and will be removed in version 1.0.0. "  # noqa: E501
-            "Refer to https://www.starlette.io/routing/#websocket-routing for the recommended approach.",  # noqa: E501
-            DeprecationWarning,
-        )
-
-        def decorator(func: typing.Callable) -> typing.Callable:  # type: ignore[type-arg]  # noqa: E501
-            self.router.add_websocket_route(path, func, name=name)
-            return func
-
-        return decorator
-
-    def middleware(self, middleware_type: str) -> typing.Callable:  # type: ignore[type-arg]  # noqa: E501
-        """
-        We no longer document this decorator style API, and its usage is discouraged.
-        Instead you should use the following approach:
-
-        >>> middleware = [Middleware(...), ...]
-        >>> app = Starlette(middleware=middleware)
-        """
-        warnings.warn(
-            "The `middleware` decorator is deprecated, and will be removed in version 1.0.0. "  # noqa: E501
-            "Refer to https://www.starlette.io/middleware/#using-middleware for recommended approach.",  # noqa: E501
-            DeprecationWarning,
-        )
-        assert (
-            middleware_type == "http"
-        ), 'Currently only middleware("http") is supported.'
-
-        def decorator(func: typing.Callable) -> typing.Callable:  # type: ignore[type-arg]  # noqa: E501
-            self.add_middleware(BaseHTTPMiddleware, dispatch=func)
-            return func
-
-        return decorator

prefect/_vendor/starlette/authentication.py

@@ -1,159 +0,0 @@
-import functools
-import inspect
-import sys
-import typing
-from urllib.parse import urlencode
-
-if sys.version_info >= (3, 10):  # pragma: no cover
-    from typing import ParamSpec
-else:  # pragma: no cover
-    from typing_extensions import ParamSpec
-
-from prefect._vendor.starlette._utils import is_async_callable
-from prefect._vendor.starlette.exceptions import HTTPException
-from prefect._vendor.starlette.requests import HTTPConnection, Request
-from prefect._vendor.starlette.responses import RedirectResponse
-from prefect._vendor.starlette.websockets import WebSocket
-
-_P = ParamSpec("_P")
-
-
-def has_required_scope(conn: HTTPConnection, scopes: typing.Sequence[str]) -> bool:
-    for scope in scopes:
-        if scope not in conn.auth.scopes:
-            return False
-    return True
-
-
-def requires(
-    scopes: typing.Union[str, typing.Sequence[str]],
-    status_code: int = 403,
-    redirect: typing.Optional[str] = None,
-) -> typing.Callable[
-    [typing.Callable[_P, typing.Any]], typing.Callable[_P, typing.Any]
-]:
-    scopes_list = [scopes] if isinstance(scopes, str) else list(scopes)
-
-    def decorator(
-        func: typing.Callable[_P, typing.Any],
-    ) -> typing.Callable[_P, typing.Any]:
-        sig = inspect.signature(func)
-        for idx, parameter in enumerate(sig.parameters.values()):
-            if parameter.name == "request" or parameter.name == "websocket":
-                type_ = parameter.name
-                break
-        else:
-            raise Exception(
-                f'No "request" or "websocket" argument on function "{func}"'
-            )
-
-        if type_ == "websocket":
-            # Handle websocket functions. (Always async)
-            @functools.wraps(func)
-            async def websocket_wrapper(*args: _P.args, **kwargs: _P.kwargs) -> None:
-                websocket = kwargs.get(
-                    "websocket", args[idx] if idx < len(args) else None
-                )
-                assert isinstance(websocket, WebSocket)
-
-                if not has_required_scope(websocket, scopes_list):
-                    await websocket.close()
-                else:
-                    await func(*args, **kwargs)
-
-            return websocket_wrapper
-
-        elif is_async_callable(func):
-            # Handle async request/response functions.
-            @functools.wraps(func)
-            async def async_wrapper(*args: _P.args, **kwargs: _P.kwargs) -> typing.Any:
-                request = kwargs.get("request", args[idx] if idx < len(args) else None)
-                assert isinstance(request, Request)
-
-                if not has_required_scope(request, scopes_list):
-                    if redirect is not None:
-                        orig_request_qparam = urlencode({"next": str(request.url)})
-                        next_url = "{redirect_path}?{orig_request}".format(
-                            redirect_path=request.url_for(redirect),
-                            orig_request=orig_request_qparam,
-                        )
-                        return RedirectResponse(url=next_url, status_code=303)
-                    raise HTTPException(status_code=status_code)
-                return await func(*args, **kwargs)
-
-            return async_wrapper
-
-        else:
-            # Handle sync request/response functions.
-            @functools.wraps(func)
-            def sync_wrapper(*args: _P.args, **kwargs: _P.kwargs) -> typing.Any:
-                request = kwargs.get("request", args[idx] if idx < len(args) else None)
-                assert isinstance(request, Request)
-
-                if not has_required_scope(request, scopes_list):
-                    if redirect is not None:
-                        orig_request_qparam = urlencode({"next": str(request.url)})
-                        next_url = "{redirect_path}?{orig_request}".format(
-                            redirect_path=request.url_for(redirect),
-                            orig_request=orig_request_qparam,
-                        )
-                        return RedirectResponse(url=next_url, status_code=303)
-                    raise HTTPException(status_code=status_code)
-                return func(*args, **kwargs)
-
-            return sync_wrapper
-
-    return decorator
-
-
-class AuthenticationError(Exception):
-    pass
-
-
-class AuthenticationBackend:
-    async def authenticate(
-        self, conn: HTTPConnection
-    ) -> typing.Optional[typing.Tuple["AuthCredentials", "BaseUser"]]:
-        raise NotImplementedError()  # pragma: no cover
-
-
-class AuthCredentials:
-    def __init__(self, scopes: typing.Optional[typing.Sequence[str]] = None):
-        self.scopes = [] if scopes is None else list(scopes)
-
-
-class BaseUser:
-    @property
-    def is_authenticated(self) -> bool:
-        raise NotImplementedError()  # pragma: no cover
-
-    @property
-    def display_name(self) -> str:
-        raise NotImplementedError()  # pragma: no cover
-
-    @property
-    def identity(self) -> str:
-        raise NotImplementedError()  # pragma: no cover
-
-
-class SimpleUser(BaseUser):
-    def __init__(self, username: str) -> None:
-        self.username = username
-
-    @property
-    def is_authenticated(self) -> bool:
-        return True
-
-    @property
-    def display_name(self) -> str:
-        return self.username
-
-
-class UnauthenticatedUser(BaseUser):
-    @property
-    def is_authenticated(self) -> bool:
-        return False
-
-    @property
-    def display_name(self) -> str:
-        return ""

prefect/_vendor/starlette/background.py

@@ -1,43 +0,0 @@
-import sys
-import typing
-
-if sys.version_info >= (3, 10):  # pragma: no cover
-    from typing import ParamSpec
-else:  # pragma: no cover
-    from typing_extensions import ParamSpec
-
-from prefect._vendor.starlette._utils import is_async_callable
-from prefect._vendor.starlette.concurrency import run_in_threadpool
-
-P = ParamSpec("P")
-
-
-class BackgroundTask:
-    def __init__(
-        self, func: typing.Callable[P, typing.Any], *args: P.args, **kwargs: P.kwargs
-    ) -> None:
-        self.func = func
-        self.args = args
-        self.kwargs = kwargs
-        self.is_async = is_async_callable(func)
-
-    async def __call__(self) -> None:
-        if self.is_async:
-            await self.func(*self.args, **self.kwargs)
-        else:
-            await run_in_threadpool(self.func, *self.args, **self.kwargs)
-
-
-class BackgroundTasks(BackgroundTask):
-    def __init__(self, tasks: typing.Optional[typing.Sequence[BackgroundTask]] = None):
-        self.tasks = list(tasks) if tasks else []
-
-    def add_task(
-        self, func: typing.Callable[P, typing.Any], *args: P.args, **kwargs: P.kwargs
-    ) -> None:
-        task = BackgroundTask(func, *args, **kwargs)
-        self.tasks.append(task)
-
-    async def __call__(self) -> None:
-        for task in self.tasks:
-            await task()

prefect/_vendor/starlette/concurrency.py

@@ -1,59 +0,0 @@
-import functools
-import typing
-import warnings
-
-import anyio.to_thread
-
-T = typing.TypeVar("T")
-
-
-async def run_until_first_complete(*args: typing.Tuple[typing.Callable, dict]) -> None:  # type: ignore[type-arg]  # noqa: E501
-    warnings.warn(
-        "run_until_first_complete is deprecated "
-        "and will be removed in a future version.",
-        DeprecationWarning,
-    )
-
-    async with anyio.create_task_group() as task_group:
-
-        async def run(func: typing.Callable[[], typing.Coroutine]) -> None:  # type: ignore[type-arg]  # noqa: E501
-            await func()
-            task_group.cancel_scope.cancel()
-
-        for func, kwargs in args:
-            task_group.start_soon(run, functools.partial(func, **kwargs))
-
-
-# TODO: We should use `ParamSpec` here, but mypy doesn't support it yet.
-# Check https://github.com/python/mypy/issues/12278 for more details.
-async def run_in_threadpool(
-    func: typing.Callable[..., T], *args: typing.Any, **kwargs: typing.Any
-) -> T:
-    if kwargs:  # pragma: no cover
-        # run_sync doesn't accept 'kwargs', so bind them in here
-        func = functools.partial(func, **kwargs)
-    return await anyio.to_thread.run_sync(func, *args)
-
-
-class _StopIteration(Exception):
-    pass
-
-
-def _next(iterator: typing.Iterator[T]) -> T:
-    # We can't raise `StopIteration` from within the threadpool iterator
-    # and catch it outside that context, so we coerce them into a different
-    # exception type.
-    try:
-        return next(iterator)
-    except StopIteration:
-        raise _StopIteration
-
-
-async def iterate_in_threadpool(
-    iterator: typing.Iterator[T],
-) -> typing.AsyncIterator[T]:
-    while True:
-        try:
-            yield await anyio.to_thread.run_sync(_next, iterator)
-        except _StopIteration:
-            break

prefect/_vendor/starlette/config.py

@@ -1,151 +0,0 @@
-import os
-import typing
-from pathlib import Path
-
-
-class undefined:
-    pass
-
-
-class EnvironError(Exception):
-    pass
-
-
-class Environ(typing.MutableMapping[str, str]):
-    def __init__(self, environ: typing.MutableMapping[str, str] = os.environ):
-        self._environ = environ
-        self._has_been_read: typing.Set[str] = set()
-
-    def __getitem__(self, key: str) -> str:
-        self._has_been_read.add(key)
-        return self._environ.__getitem__(key)
-
-    def __setitem__(self, key: str, value: str) -> None:
-        if key in self._has_been_read:
-            raise EnvironError(
-                f"Attempting to set environ['{key}'], but the value has already been "
-                "read."
-            )
-        self._environ.__setitem__(key, value)
-
-    def __delitem__(self, key: str) -> None:
-        if key in self._has_been_read:
-            raise EnvironError(
-                f"Attempting to delete environ['{key}'], but the value has already "
-                "been read."
-            )
-        self._environ.__delitem__(key)
-
-    def __iter__(self) -> typing.Iterator[str]:
-        return iter(self._environ)
-
-    def __len__(self) -> int:
-        return len(self._environ)
-
-
-environ = Environ()
-
-T = typing.TypeVar("T")
-
-
-class Config:
-    def __init__(
-        self,
-        env_file: typing.Optional[typing.Union[str, Path]] = None,
-        environ: typing.Mapping[str, str] = environ,
-        env_prefix: str = "",
-    ) -> None:
-        self.environ = environ
-        self.env_prefix = env_prefix
-        self.file_values: typing.Dict[str, str] = {}
-        if env_file is not None and os.path.isfile(env_file):
-            self.file_values = self._read_file(env_file)
-
-    @typing.overload
-    def __call__(self, key: str, *, default: None) -> typing.Optional[str]:
-        ...
-
-    @typing.overload
-    def __call__(self, key: str, cast: typing.Type[T], default: T = ...) -> T:
-        ...
-
-    @typing.overload
-    def __call__(
-        self, key: str, cast: typing.Type[str] = ..., default: str = ...
-    ) -> str:
-        ...
-
-    @typing.overload
-    def __call__(
-        self,
-        key: str,
-        cast: typing.Callable[[typing.Any], T] = ...,
-        default: typing.Any = ...,
-    ) -> T:
-        ...
-
-    @typing.overload
-    def __call__(
-        self, key: str, cast: typing.Type[str] = ..., default: T = ...
-    ) -> typing.Union[T, str]:
-        ...
-
-    def __call__(
-        self,
-        key: str,
-        cast: typing.Optional[typing.Callable[[typing.Any], typing.Any]] = None,
-        default: typing.Any = undefined,
-    ) -> typing.Any:
-        return self.get(key, cast, default)
-
-    def get(
-        self,
-        key: str,
-        cast: typing.Optional[typing.Callable[[typing.Any], typing.Any]] = None,
-        default: typing.Any = undefined,
-    ) -> typing.Any:
-        key = self.env_prefix + key
-        if key in self.environ:
-            value = self.environ[key]
-            return self._perform_cast(key, value, cast)
-        if key in self.file_values:
-            value = self.file_values[key]
-            return self._perform_cast(key, value, cast)
-        if default is not undefined:
-            return self._perform_cast(key, default, cast)
-        raise KeyError(f"Config '{key}' is missing, and has no default.")
-
-    def _read_file(self, file_name: typing.Union[str, Path]) -> typing.Dict[str, str]:
-        file_values: typing.Dict[str, str] = {}
-        with open(file_name) as input_file:
-            for line in input_file.readlines():
-                line = line.strip()
-                if "=" in line and not line.startswith("#"):
-                    key, value = line.split("=", 1)
-                    key = key.strip()
-                    value = value.strip().strip("\"'")
-                    file_values[key] = value
-        return file_values
-
-    def _perform_cast(
-        self,
-        key: str,
-        value: typing.Any,
-        cast: typing.Optional[typing.Callable[[typing.Any], typing.Any]] = None,
-    ) -> typing.Any:
-        if cast is None or value is None:
-            return value
-        elif cast is bool and isinstance(value, str):
-            mapping = {"true": True, "1": True, "false": False, "0": False}
-            value = value.lower()
-            if value not in mapping:
-                raise ValueError(
-                    f"Config '{key}' has value '{value}'. Not a valid bool."
-                )
-            return mapping[value]
-        try:
-            return cast(value)
-        except (TypeError, ValueError):
-            raise ValueError(
-                f"Config '{key}' has value '{value}'. Not a valid {cast.__name__}."
-            )