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

prefect/_vendor/starlette/middleware/base.py

@@ -1,220 +0,0 @@
-import typing
-
-import anyio
-from anyio.abc import ObjectReceiveStream, ObjectSendStream
-from prefect._vendor.starlette._utils import collapse_excgroups
-from prefect._vendor.starlette.background import BackgroundTask
-from prefect._vendor.starlette.requests import ClientDisconnect, Request
-from prefect._vendor.starlette.responses import (
-    ContentStream,
-    Response,
-    StreamingResponse,
-)
-from prefect._vendor.starlette.types import ASGIApp, Message, Receive, Scope, Send
-
-RequestResponseEndpoint = typing.Callable[[Request], typing.Awaitable[Response]]
-DispatchFunction = typing.Callable[
-    [Request, RequestResponseEndpoint], typing.Awaitable[Response]
-]
-T = typing.TypeVar("T")
-
-
-class _CachedRequest(Request):
-    """
-    If the user calls Request.body() from their dispatch function
-    we cache the entire request body in memory and pass that to downstream middlewares,
-    but if they call Request.stream() then all we do is send an
-    empty body so that downstream things don't hang forever.
-    """
-
-    def __init__(self, scope: Scope, receive: Receive):
-        super().__init__(scope, receive)
-        self._wrapped_rcv_disconnected = False
-        self._wrapped_rcv_consumed = False
-        self._wrapped_rc_stream = self.stream()
-
-    async def wrapped_receive(self) -> Message:
-        # wrapped_rcv state 1: disconnected
-        if self._wrapped_rcv_disconnected:
-            # we've already sent a disconnect to the downstream app
-            # we don't need to wait to get another one
-            # (although most ASGI servers will just keep sending it)
-            return {"type": "http.disconnect"}
-        # wrapped_rcv state 1: consumed but not yet disconnected
-        if self._wrapped_rcv_consumed:
-            # since the downstream app has consumed us all that is left
-            # is to send it a disconnect
-            if self._is_disconnected:
-                # the middleware has already seen the disconnect
-                # since we know the client is disconnected no need to wait
-                # for the message
-                self._wrapped_rcv_disconnected = True
-                return {"type": "http.disconnect"}
-            # we don't know yet if the client is disconnected or not
-            # so we'll wait until we get that message
-            msg = await self.receive()
-            if msg["type"] != "http.disconnect":  # pragma: no cover
-                # at this point a disconnect is all that we should be receiving
-                # if we get something else, things went wrong somewhere
-                raise RuntimeError(f"Unexpected message received: {msg['type']}")
-            return msg
-
-        # wrapped_rcv state 3: not yet consumed
-        if getattr(self, "_body", None) is not None:
-            # body() was called, we return it even if the client disconnected
-            self._wrapped_rcv_consumed = True
-            return {
-                "type": "http.request",
-                "body": self._body,
-                "more_body": False,
-            }
-        elif self._stream_consumed:
-            # stream() was called to completion
-            # return an empty body so that downstream apps don't hang
-            # waiting for a disconnect
-            self._wrapped_rcv_consumed = True
-            return {
-                "type": "http.request",
-                "body": b"",
-                "more_body": False,
-            }
-        else:
-            # body() was never called and stream() wasn't consumed
-            try:
-                stream = self.stream()
-                chunk = await stream.__anext__()
-                self._wrapped_rcv_consumed = self._stream_consumed
-                return {
-                    "type": "http.request",
-                    "body": chunk,
-                    "more_body": not self._stream_consumed,
-                }
-            except ClientDisconnect:
-                self._wrapped_rcv_disconnected = True
-                return {"type": "http.disconnect"}
-
-
-class BaseHTTPMiddleware:
-    def __init__(
-        self, app: ASGIApp, dispatch: typing.Optional[DispatchFunction] = None
-    ) -> None:
-        self.app = app
-        self.dispatch_func = self.dispatch if dispatch is None else dispatch
-
-    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
-        if scope["type"] != "http":
-            await self.app(scope, receive, send)
-            return
-
-        request = _CachedRequest(scope, receive)
-        wrapped_receive = request.wrapped_receive
-        response_sent = anyio.Event()
-
-        async def call_next(request: Request) -> Response:
-            app_exc: typing.Optional[Exception] = None
-            send_stream: ObjectSendStream[typing.MutableMapping[str, typing.Any]]
-            recv_stream: ObjectReceiveStream[typing.MutableMapping[str, typing.Any]]
-            send_stream, recv_stream = anyio.create_memory_object_stream()
-
-            async def receive_or_disconnect() -> Message:
-                if response_sent.is_set():
-                    return {"type": "http.disconnect"}
-
-                async with anyio.create_task_group() as task_group:
-
-                    async def wrap(func: typing.Callable[[], typing.Awaitable[T]]) -> T:
-                        result = await func()
-                        task_group.cancel_scope.cancel()
-                        return result
-
-                    task_group.start_soon(wrap, response_sent.wait)
-                    message = await wrap(wrapped_receive)
-
-                if response_sent.is_set():
-                    return {"type": "http.disconnect"}
-
-                return message
-
-            async def close_recv_stream_on_response_sent() -> None:
-                await response_sent.wait()
-                recv_stream.close()
-
-            async def send_no_error(message: Message) -> None:
-                try:
-                    await send_stream.send(message)
-                except anyio.BrokenResourceError:
-                    # recv_stream has been closed, i.e. response_sent has been set.
-                    return
-
-            async def coro() -> None:
-                nonlocal app_exc
-
-                async with send_stream:
-                    try:
-                        await self.app(scope, receive_or_disconnect, send_no_error)
-                    except Exception as exc:
-                        app_exc = exc
-
-            task_group.start_soon(close_recv_stream_on_response_sent)
-            task_group.start_soon(coro)
-
-            try:
-                message = await recv_stream.receive()
-                info = message.get("info", None)
-                if message["type"] == "http.response.debug" and info is not None:
-                    message = await recv_stream.receive()
-            except anyio.EndOfStream:
-                if app_exc is not None:
-                    raise app_exc
-                raise RuntimeError("No response returned.")
-
-            assert message["type"] == "http.response.start"
-
-            async def body_stream() -> typing.AsyncGenerator[bytes, None]:
-                async with recv_stream:
-                    async for message in recv_stream:
-                        assert message["type"] == "http.response.body"
-                        body = message.get("body", b"")
-                        if body:
-                            yield body
-                        if not message.get("more_body", False):
-                            break
-
-                if app_exc is not None:
-                    raise app_exc
-
-            response = _StreamingResponse(
-                status_code=message["status"], content=body_stream(), info=info
-            )
-            response.raw_headers = message["headers"]
-            return response
-
-        with collapse_excgroups():
-            async with anyio.create_task_group() as task_group:
-                response = await self.dispatch_func(request, call_next)
-                await response(scope, wrapped_receive, send)
-                response_sent.set()
-
-    async def dispatch(
-        self, request: Request, call_next: RequestResponseEndpoint
-    ) -> Response:
-        raise NotImplementedError()  # pragma: no cover
-
-
-class _StreamingResponse(StreamingResponse):
-    def __init__(
-        self,
-        content: ContentStream,
-        status_code: int = 200,
-        headers: typing.Optional[typing.Mapping[str, str]] = None,
-        media_type: typing.Optional[str] = None,
-        background: typing.Optional[BackgroundTask] = None,
-        info: typing.Optional[typing.Mapping[str, typing.Any]] = None,
-    ) -> None:
-        self._info = info
-        super().__init__(content, status_code, headers, media_type, background)
-
-    async def stream_response(self, send: Send) -> None:
-        if self._info:
-            await send({"type": "http.response.debug", "info": self._info})
-        return await super().stream_response(send)

prefect/_vendor/starlette/middleware/cors.py

@@ -1,176 +0,0 @@
-import functools
-import re
-import typing
-
-from prefect._vendor.starlette.datastructures import Headers, MutableHeaders
-from prefect._vendor.starlette.responses import PlainTextResponse, Response
-from prefect._vendor.starlette.types import ASGIApp, Message, Receive, Scope, Send
-
-ALL_METHODS = ("DELETE", "GET", "HEAD", "OPTIONS", "PATCH", "POST", "PUT")
-SAFELISTED_HEADERS = {"Accept", "Accept-Language", "Content-Language", "Content-Type"}
-
-
-class CORSMiddleware:
-    def __init__(
-        self,
-        app: ASGIApp,
-        allow_origins: typing.Sequence[str] = (),
-        allow_methods: typing.Sequence[str] = ("GET",),
-        allow_headers: typing.Sequence[str] = (),
-        allow_credentials: bool = False,
-        allow_origin_regex: typing.Optional[str] = None,
-        expose_headers: typing.Sequence[str] = (),
-        max_age: int = 600,
-    ) -> None:
-        if "*" in allow_methods:
-            allow_methods = ALL_METHODS
-
-        compiled_allow_origin_regex = None
-        if allow_origin_regex is not None:
-            compiled_allow_origin_regex = re.compile(allow_origin_regex)
-
-        allow_all_origins = "*" in allow_origins
-        allow_all_headers = "*" in allow_headers
-        preflight_explicit_allow_origin = not allow_all_origins or allow_credentials
-
-        simple_headers = {}
-        if allow_all_origins:
-            simple_headers["Access-Control-Allow-Origin"] = "*"
-        if allow_credentials:
-            simple_headers["Access-Control-Allow-Credentials"] = "true"
-        if expose_headers:
-            simple_headers["Access-Control-Expose-Headers"] = ", ".join(expose_headers)
-
-        preflight_headers = {}
-        if preflight_explicit_allow_origin:
-            # The origin value will be set in preflight_response() if it is allowed.
-            preflight_headers["Vary"] = "Origin"
-        else:
-            preflight_headers["Access-Control-Allow-Origin"] = "*"
-        preflight_headers.update(
-            {
-                "Access-Control-Allow-Methods": ", ".join(allow_methods),
-                "Access-Control-Max-Age": str(max_age),
-            }
-        )
-        allow_headers = sorted(SAFELISTED_HEADERS | set(allow_headers))
-        if allow_headers and not allow_all_headers:
-            preflight_headers["Access-Control-Allow-Headers"] = ", ".join(allow_headers)
-        if allow_credentials:
-            preflight_headers["Access-Control-Allow-Credentials"] = "true"
-
-        self.app = app
-        self.allow_origins = allow_origins
-        self.allow_methods = allow_methods
-        self.allow_headers = [h.lower() for h in allow_headers]
-        self.allow_all_origins = allow_all_origins
-        self.allow_all_headers = allow_all_headers
-        self.preflight_explicit_allow_origin = preflight_explicit_allow_origin
-        self.allow_origin_regex = compiled_allow_origin_regex
-        self.simple_headers = simple_headers
-        self.preflight_headers = preflight_headers
-
-    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
-        if scope["type"] != "http":  # pragma: no cover
-            await self.app(scope, receive, send)
-            return
-
-        method = scope["method"]
-        headers = Headers(scope=scope)
-        origin = headers.get("origin")
-
-        if origin is None:
-            await self.app(scope, receive, send)
-            return
-
-        if method == "OPTIONS" and "access-control-request-method" in headers:
-            response = self.preflight_response(request_headers=headers)
-            await response(scope, receive, send)
-            return
-
-        await self.simple_response(scope, receive, send, request_headers=headers)
-
-    def is_allowed_origin(self, origin: str) -> bool:
-        if self.allow_all_origins:
-            return True
-
-        if self.allow_origin_regex is not None and self.allow_origin_regex.fullmatch(
-            origin
-        ):
-            return True
-
-        return origin in self.allow_origins
-
-    def preflight_response(self, request_headers: Headers) -> Response:
-        requested_origin = request_headers["origin"]
-        requested_method = request_headers["access-control-request-method"]
-        requested_headers = request_headers.get("access-control-request-headers")
-
-        headers = dict(self.preflight_headers)
-        failures = []
-
-        if self.is_allowed_origin(origin=requested_origin):
-            if self.preflight_explicit_allow_origin:
-                # The "else" case is already accounted for in self.preflight_headers
-                # and the value would be "*".
-                headers["Access-Control-Allow-Origin"] = requested_origin
-        else:
-            failures.append("origin")
-
-        if requested_method not in self.allow_methods:
-            failures.append("method")
-
-        # If we allow all headers, then we have to mirror back any requested
-        # headers in the response.
-        if self.allow_all_headers and requested_headers is not None:
-            headers["Access-Control-Allow-Headers"] = requested_headers
-        elif requested_headers is not None:
-            for header in [h.lower() for h in requested_headers.split(",")]:
-                if header.strip() not in self.allow_headers:
-                    failures.append("headers")
-                    break
-
-        # We don't strictly need to use 400 responses here, since its up to
-        # the browser to enforce the CORS policy, but its more informative
-        # if we do.
-        if failures:
-            failure_text = "Disallowed CORS " + ", ".join(failures)
-            return PlainTextResponse(failure_text, status_code=400, headers=headers)
-
-        return PlainTextResponse("OK", status_code=200, headers=headers)
-
-    async def simple_response(
-        self, scope: Scope, receive: Receive, send: Send, request_headers: Headers
-    ) -> None:
-        send = functools.partial(self.send, send=send, request_headers=request_headers)
-        await self.app(scope, receive, send)
-
-    async def send(
-        self, message: Message, send: Send, request_headers: Headers
-    ) -> None:
-        if message["type"] != "http.response.start":
-            await send(message)
-            return
-
-        message.setdefault("headers", [])
-        headers = MutableHeaders(scope=message)
-        headers.update(self.simple_headers)
-        origin = request_headers["Origin"]
-        has_cookie = "cookie" in request_headers
-
-        # If request includes any cookie headers, then we must respond
-        # with the specific origin instead of '*'.
-        if self.allow_all_origins and has_cookie:
-            self.allow_explicit_origin(headers, origin)
-
-        # If we only allow specific origins, then we have to mirror back
-        # the Origin header in the response.
-        elif not self.allow_all_origins and self.is_allowed_origin(origin=origin):
-            self.allow_explicit_origin(headers, origin)
-
-        await send(message)
-
-    @staticmethod
-    def allow_explicit_origin(headers: MutableHeaders, origin: str) -> None:
-        headers["Access-Control-Allow-Origin"] = origin
-        headers.add_vary_header("Origin")

prefect/_vendor/starlette/middleware/errors.py

@@ -1,265 +0,0 @@
-import html
-import inspect
-import traceback
-import typing
-
-from prefect._vendor.starlette._utils import is_async_callable
-from prefect._vendor.starlette.concurrency import run_in_threadpool
-from prefect._vendor.starlette.requests import Request
-from prefect._vendor.starlette.responses import (
-    HTMLResponse,
-    PlainTextResponse,
-    Response,
-)
-from prefect._vendor.starlette.types import ASGIApp, Message, Receive, Scope, Send
-
-STYLES = """
-p {
-    color: #211c1c;
-}
-.traceback-container {
-    border: 1px solid #038BB8;
-}
-.traceback-title {
-    background-color: #038BB8;
-    color: lemonchiffon;
-    padding: 12px;
-    font-size: 20px;
-    margin-top: 0px;
-}
-.frame-line {
-    padding-left: 10px;
-    font-family: monospace;
-}
-.frame-filename {
-    font-family: monospace;
-}
-.center-line {
-    background-color: #038BB8;
-    color: #f9f6e1;
-    padding: 5px 0px 5px 5px;
-}
-.lineno {
-    margin-right: 5px;
-}
-.frame-title {
-    font-weight: unset;
-    padding: 10px 10px 10px 10px;
-    background-color: #E4F4FD;
-    margin-right: 10px;
-    color: #191f21;
-    font-size: 17px;
-    border: 1px solid #c7dce8;
-}
-.collapse-btn {
-    float: right;
-    padding: 0px 5px 1px 5px;
-    border: solid 1px #96aebb;
-    cursor: pointer;
-}
-.collapsed {
-  display: none;
-}
-.source-code {
-  font-family: courier;
-  font-size: small;
-  padding-bottom: 10px;
-}
-"""
-
-JS = """
-<script type="text/javascript">
-    function collapse(element){
-        const frameId = element.getAttribute("data-frame-id");
-        const frame = document.getElementById(frameId);
-
-        if (frame.classList.contains("collapsed")){
-            element.innerHTML = "&#8210;";
-            frame.classList.remove("collapsed");
-        } else {
-            element.innerHTML = "+";
-            frame.classList.add("collapsed");
-        }
-    }
-</script>
-"""
-
-TEMPLATE = """
-<html>
-    <head>
-        <style type='text/css'>
-            {styles}
-        </style>
-        <title>Starlette Debugger</title>
-    </head>
-    <body>
-        <h1>500 Server Error</h1>
-        <h2>{error}</h2>
-        <div class="traceback-container">
-            <p class="traceback-title">Traceback</p>
-            <div>{exc_html}</div>
-        </div>
-        {js}
-    </body>
-</html>
-"""
-
-FRAME_TEMPLATE = """
-<div>
-    <p class="frame-title">File <span class="frame-filename">{frame_filename}</span>,
-    line <i>{frame_lineno}</i>,
-    in <b>{frame_name}</b>
-    <span class="collapse-btn" data-frame-id="{frame_filename}-{frame_lineno}" onclick="collapse(this)">{collapse_button}</span>
-    </p>
-    <div id="{frame_filename}-{frame_lineno}" class="source-code {collapsed}">{code_context}</div>
-</div>
-"""  # noqa: E501
-
-LINE = """
-<p><span class="frame-line">
-<span class="lineno">{lineno}.</span> {line}</span></p>
-"""
-
-CENTER_LINE = """
-<p class="center-line"><span class="frame-line center-line">
-<span class="lineno">{lineno}.</span> {line}</span></p>
-"""
-
-
-class ServerErrorMiddleware:
-    """
-    Handles returning 500 responses when a server error occurs.
-
-    If 'debug' is set, then traceback responses will be returned,
-    otherwise the designated 'handler' will be called.
-
-    This middleware class should generally be used to wrap *everything*
-    else up, so that unhandled exceptions anywhere in the stack
-    always result in an appropriate 500 response.
-    """
-
-    def __init__(
-        self,
-        app: ASGIApp,
-        handler: typing.Optional[
-            typing.Callable[[Request, Exception], typing.Any]
-        ] = None,
-        debug: bool = False,
-    ) -> None:
-        self.app = app
-        self.handler = handler
-        self.debug = debug
-
-    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
-        if scope["type"] != "http":
-            await self.app(scope, receive, send)
-            return
-
-        response_started = False
-
-        async def _send(message: Message) -> None:
-            nonlocal response_started, send
-
-            if message["type"] == "http.response.start":
-                response_started = True
-            await send(message)
-
-        try:
-            await self.app(scope, receive, _send)
-        except Exception as exc:
-            request = Request(scope)
-            if self.debug:
-                # In debug mode, return traceback responses.
-                response = self.debug_response(request, exc)
-            elif self.handler is None:
-                # Use our default 500 error handler.
-                response = self.error_response(request, exc)
-            else:
-                # Use an installed 500 error handler.
-                if is_async_callable(self.handler):
-                    response = await self.handler(request, exc)
-                else:
-                    response = await run_in_threadpool(self.handler, request, exc)
-
-            if not response_started:
-                await response(scope, receive, send)
-
-            # We always continue to raise the exception.
-            # This allows servers to log the error, or allows test clients
-            # to optionally raise the error within the test case.
-            raise exc
-
-    def format_line(
-        self, index: int, line: str, frame_lineno: int, frame_index: int
-    ) -> str:
-        values = {
-            # HTML escape - line could contain < or >
-            "line": html.escape(line).replace(" ", "&nbsp"),
-            "lineno": (frame_lineno - frame_index) + index,
-        }
-
-        if index != frame_index:
-            return LINE.format(**values)
-        return CENTER_LINE.format(**values)
-
-    def generate_frame_html(self, frame: inspect.FrameInfo, is_collapsed: bool) -> str:
-        code_context = "".join(
-            self.format_line(
-                index,
-                line,
-                frame.lineno,
-                frame.index,  # type: ignore[arg-type]
-            )
-            for index, line in enumerate(frame.code_context or [])
-        )
-
-        values = {
-            # HTML escape - filename could contain < or >, especially if it's a virtual
-            # file e.g. <stdin> in the REPL
-            "frame_filename": html.escape(frame.filename),
-            "frame_lineno": frame.lineno,
-            # HTML escape - if you try very hard it's possible to name a function with <
-            # or >
-            "frame_name": html.escape(frame.function),
-            "code_context": code_context,
-            "collapsed": "collapsed" if is_collapsed else "",
-            "collapse_button": "+" if is_collapsed else "&#8210;",
-        }
-        return FRAME_TEMPLATE.format(**values)
-
-    def generate_html(self, exc: Exception, limit: int = 7) -> str:
-        traceback_obj = traceback.TracebackException.from_exception(
-            exc, capture_locals=True
-        )
-
-        exc_html = ""
-        is_collapsed = False
-        exc_traceback = exc.__traceback__
-        if exc_traceback is not None:
-            frames = inspect.getinnerframes(exc_traceback, limit)
-            for frame in reversed(frames):
-                exc_html += self.generate_frame_html(frame, is_collapsed)
-                is_collapsed = True
-
-        # escape error class and text
-        error = (
-            f"{html.escape(traceback_obj.exc_type.__name__)}: "
-            f"{html.escape(str(traceback_obj))}"
-        )
-
-        return TEMPLATE.format(styles=STYLES, js=JS, error=error, exc_html=exc_html)
-
-    def generate_plain_text(self, exc: Exception) -> str:
-        return "".join(traceback.format_exception(type(exc), exc, exc.__traceback__))
-
-    def debug_response(self, request: Request, exc: Exception) -> Response:
-        accept = request.headers.get("accept", "")
-
-        if "text/html" in accept:
-            content = self.generate_html(exc)
-            return HTMLResponse(content, status_code=500)
-        content = self.generate_plain_text(exc)
-        return PlainTextResponse(content, status_code=500)
-
-    def error_response(self, request: Request, exc: Exception) -> Response:
-        return PlainTextResponse("Internal Server Error", status_code=500)