prefect-client 2.19.2__py3-none-any.whl → 3.0.0rc1__py3-none-any.whl

prefect/_vendor/starlette/middleware/exceptions.py

@@ -1,74 +0,0 @@
-import typing
-
-from prefect._vendor.starlette._exception_handler import (
-    ExceptionHandlers,
-    StatusHandlers,
-    wrap_app_handling_exceptions,
-)
-from prefect._vendor.starlette.exceptions import HTTPException, WebSocketException
-from prefect._vendor.starlette.requests import Request
-from prefect._vendor.starlette.responses import PlainTextResponse, Response
-from prefect._vendor.starlette.types import ASGIApp, Receive, Scope, Send
-from prefect._vendor.starlette.websockets import WebSocket
-
-
-class ExceptionMiddleware:
-    def __init__(
-        self,
-        app: ASGIApp,
-        handlers: typing.Optional[
-            typing.Mapping[typing.Any, typing.Callable[[Request, Exception], Response]]
-        ] = None,
-        debug: bool = False,
-    ) -> None:
-        self.app = app
-        self.debug = debug  # TODO: We ought to handle 404 cases if debug is set.
-        self._status_handlers: StatusHandlers = {}
-        self._exception_handlers: ExceptionHandlers = {
-            HTTPException: self.http_exception,
-            WebSocketException: self.websocket_exception,
-        }
-        if handlers is not None:
-            for key, value in handlers.items():
-                self.add_exception_handler(key, value)
-
-    def add_exception_handler(
-        self,
-        exc_class_or_status_code: typing.Union[int, typing.Type[Exception]],
-        handler: typing.Callable[[Request, Exception], Response],
-    ) -> None:
-        if isinstance(exc_class_or_status_code, int):
-            self._status_handlers[exc_class_or_status_code] = handler
-        else:
-            assert issubclass(exc_class_or_status_code, Exception)
-            self._exception_handlers[exc_class_or_status_code] = handler
-
-    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
-        if scope["type"] not in ("http", "websocket"):
-            await self.app(scope, receive, send)
-            return
-
-        scope["starlette.exception_handlers"] = (
-            self._exception_handlers,
-            self._status_handlers,
-        )
-
-        conn: typing.Union[Request, WebSocket]
-        if scope["type"] == "http":
-            conn = Request(scope, receive, send)
-        else:
-            conn = WebSocket(scope, receive, send)
-
-        await wrap_app_handling_exceptions(self.app, conn)(scope, receive, send)
-
-    def http_exception(self, request: Request, exc: Exception) -> Response:
-        assert isinstance(exc, HTTPException)
-        if exc.status_code in {204, 304}:
-            return Response(status_code=exc.status_code, headers=exc.headers)
-        return PlainTextResponse(
-            exc.detail, status_code=exc.status_code, headers=exc.headers
-        )
-
-    async def websocket_exception(self, websocket: WebSocket, exc: Exception) -> None:
-        assert isinstance(exc, WebSocketException)
-        await websocket.close(code=exc.code, reason=exc.reason)  # pragma: no cover

prefect/_vendor/starlette/middleware/gzip.py

@@ -1,113 +0,0 @@
-import gzip
-import io
-import typing
-
-from prefect._vendor.starlette.datastructures import Headers, MutableHeaders
-from prefect._vendor.starlette.types import ASGIApp, Message, Receive, Scope, Send
-
-
-class GZipMiddleware:
-    def __init__(
-        self, app: ASGIApp, minimum_size: int = 500, compresslevel: int = 9
-    ) -> None:
-        self.app = app
-        self.minimum_size = minimum_size
-        self.compresslevel = compresslevel
-
-    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
-        if scope["type"] == "http":
-            headers = Headers(scope=scope)
-            if "gzip" in headers.get("Accept-Encoding", ""):
-                responder = GZipResponder(
-                    self.app, self.minimum_size, compresslevel=self.compresslevel
-                )
-                await responder(scope, receive, send)
-                return
-        await self.app(scope, receive, send)
-
-
-class GZipResponder:
-    def __init__(self, app: ASGIApp, minimum_size: int, compresslevel: int = 9) -> None:
-        self.app = app
-        self.minimum_size = minimum_size
-        self.send: Send = unattached_send
-        self.initial_message: Message = {}
-        self.started = False
-        self.content_encoding_set = False
-        self.gzip_buffer = io.BytesIO()
-        self.gzip_file = gzip.GzipFile(
-            mode="wb", fileobj=self.gzip_buffer, compresslevel=compresslevel
-        )
-
-    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
-        self.send = send
-        await self.app(scope, receive, self.send_with_gzip)
-
-    async def send_with_gzip(self, message: Message) -> None:
-        message_type = message["type"]
-        if message_type == "http.response.start":
-            # Don't send the initial message until we've determined how to
-            # modify the outgoing headers correctly.
-            self.initial_message = message
-            headers = Headers(raw=self.initial_message["headers"])
-            self.content_encoding_set = "content-encoding" in headers
-        elif message_type == "http.response.body" and self.content_encoding_set:
-            if not self.started:
-                self.started = True
-                await self.send(self.initial_message)
-            await self.send(message)
-        elif message_type == "http.response.body" and not self.started:
-            self.started = True
-            body = message.get("body", b"")
-            more_body = message.get("more_body", False)
-            if len(body) < self.minimum_size and not more_body:
-                # Don't apply GZip to small outgoing responses.
-                await self.send(self.initial_message)
-                await self.send(message)
-            elif not more_body:
-                # Standard GZip response.
-                self.gzip_file.write(body)
-                self.gzip_file.close()
-                body = self.gzip_buffer.getvalue()
-
-                headers = MutableHeaders(raw=self.initial_message["headers"])
-                headers["Content-Encoding"] = "gzip"
-                headers["Content-Length"] = str(len(body))
-                headers.add_vary_header("Accept-Encoding")
-                message["body"] = body
-
-                await self.send(self.initial_message)
-                await self.send(message)
-            else:
-                # Initial body in streaming GZip response.
-                headers = MutableHeaders(raw=self.initial_message["headers"])
-                headers["Content-Encoding"] = "gzip"
-                headers.add_vary_header("Accept-Encoding")
-                del headers["Content-Length"]
-
-                self.gzip_file.write(body)
-                message["body"] = self.gzip_buffer.getvalue()
-                self.gzip_buffer.seek(0)
-                self.gzip_buffer.truncate()
-
-                await self.send(self.initial_message)
-                await self.send(message)
-
-        elif message_type == "http.response.body":
-            # Remaining body in streaming GZip response.
-            body = message.get("body", b"")
-            more_body = message.get("more_body", False)
-
-            self.gzip_file.write(body)
-            if not more_body:
-                self.gzip_file.close()
-
-            message["body"] = self.gzip_buffer.getvalue()
-            self.gzip_buffer.seek(0)
-            self.gzip_buffer.truncate()
-
-            await self.send(message)
-
-
-async def unattached_send(message: Message) -> typing.NoReturn:
-    raise RuntimeError("send awaitable not set")  # pragma: no cover

prefect/_vendor/starlette/middleware/httpsredirect.py

@@ -1,19 +0,0 @@
-from prefect._vendor.starlette.datastructures import URL
-from prefect._vendor.starlette.responses import RedirectResponse
-from prefect._vendor.starlette.types import ASGIApp, Receive, Scope, Send
-
-
-class HTTPSRedirectMiddleware:
-    def __init__(self, app: ASGIApp) -> None:
-        self.app = app
-
-    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
-        if scope["type"] in ("http", "websocket") and scope["scheme"] in ("http", "ws"):
-            url = URL(scope=scope)
-            redirect_scheme = {"http": "https", "ws": "wss"}[url.scheme]
-            netloc = url.hostname if url.port in (80, 443) else url.netloc
-            url = url.replace(scheme=redirect_scheme, netloc=netloc)
-            response = RedirectResponse(url, status_code=307)
-            await response(scope, receive, send)
-        else:
-            await self.app(scope, receive, send)

prefect/_vendor/starlette/middleware/sessions.py

@@ -1,82 +0,0 @@
-import json
-import typing
-from base64 import b64decode, b64encode
-
-import itsdangerous
-from itsdangerous.exc import BadSignature
-from prefect._vendor.starlette.datastructures import MutableHeaders, Secret
-from prefect._vendor.starlette.requests import HTTPConnection
-from prefect._vendor.starlette.types import ASGIApp, Message, Receive, Scope, Send
-
-
-class SessionMiddleware:
-    def __init__(
-        self,
-        app: ASGIApp,
-        secret_key: typing.Union[str, Secret],
-        session_cookie: str = "session",
-        max_age: typing.Optional[int] = 14 * 24 * 60 * 60,  # 14 days, in seconds
-        path: str = "/",
-        same_site: typing.Literal["lax", "strict", "none"] = "lax",
-        https_only: bool = False,
-        domain: typing.Optional[str] = None,
-    ) -> None:
-        self.app = app
-        self.signer = itsdangerous.TimestampSigner(str(secret_key))
-        self.session_cookie = session_cookie
-        self.max_age = max_age
-        self.path = path
-        self.security_flags = "httponly; samesite=" + same_site
-        if https_only:  # Secure flag can be used with HTTPS only
-            self.security_flags += "; secure"
-        if domain is not None:
-            self.security_flags += f"; domain={domain}"
-
-    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
-        if scope["type"] not in ("http", "websocket"):  # pragma: no cover
-            await self.app(scope, receive, send)
-            return
-
-        connection = HTTPConnection(scope)
-        initial_session_was_empty = True
-
-        if self.session_cookie in connection.cookies:
-            data = connection.cookies[self.session_cookie].encode("utf-8")
-            try:
-                data = self.signer.unsign(data, max_age=self.max_age)
-                scope["session"] = json.loads(b64decode(data))
-                initial_session_was_empty = False
-            except BadSignature:
-                scope["session"] = {}
-        else:
-            scope["session"] = {}
-
-        async def send_wrapper(message: Message) -> None:
-            if message["type"] == "http.response.start":
-                if scope["session"]:
-                    # We have session data to persist.
-                    data = b64encode(json.dumps(scope["session"]).encode("utf-8"))
-                    data = self.signer.sign(data)
-                    headers = MutableHeaders(scope=message)
-                    header_value = "{session_cookie}={data}; path={path}; {max_age}{security_flags}".format(  # noqa E501
-                        session_cookie=self.session_cookie,
-                        data=data.decode("utf-8"),
-                        path=self.path,
-                        max_age=f"Max-Age={self.max_age}; " if self.max_age else "",
-                        security_flags=self.security_flags,
-                    )
-                    headers.append("Set-Cookie", header_value)
-                elif not initial_session_was_empty:
-                    # The session has been cleared.
-                    headers = MutableHeaders(scope=message)
-                    header_value = "{session_cookie}={data}; path={path}; {expires}{security_flags}".format(  # noqa E501
-                        session_cookie=self.session_cookie,
-                        data="null",
-                        path=self.path,
-                        expires="expires=Thu, 01 Jan 1970 00:00:00 GMT; ",
-                        security_flags=self.security_flags,
-                    )
-                    headers.append("Set-Cookie", header_value)
-            await send(message)
-
-        await self.app(scope, receive, send_wrapper)

prefect/_vendor/starlette/middleware/trustedhost.py

@@ -1,64 +0,0 @@
-import typing
-
-from prefect._vendor.starlette.datastructures import URL, Headers
-from prefect._vendor.starlette.responses import (
-    PlainTextResponse,
-    RedirectResponse,
-    Response,
-)
-from prefect._vendor.starlette.types import ASGIApp, Receive, Scope, Send
-
-ENFORCE_DOMAIN_WILDCARD = "Domain wildcard patterns must be like '*.example.com'."
-
-
-class TrustedHostMiddleware:
-    def __init__(
-        self,
-        app: ASGIApp,
-        allowed_hosts: typing.Optional[typing.Sequence[str]] = None,
-        www_redirect: bool = True,
-    ) -> None:
-        if allowed_hosts is None:
-            allowed_hosts = ["*"]
-
-        for pattern in allowed_hosts:
-            assert "*" not in pattern[1:], ENFORCE_DOMAIN_WILDCARD
-            if pattern.startswith("*") and pattern != "*":
-                assert pattern.startswith("*."), ENFORCE_DOMAIN_WILDCARD
-        self.app = app
-        self.allowed_hosts = list(allowed_hosts)
-        self.allow_any = "*" in allowed_hosts
-        self.www_redirect = www_redirect
-
-    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
-        if self.allow_any or scope["type"] not in (
-            "http",
-            "websocket",
-        ):  # pragma: no cover
-            await self.app(scope, receive, send)
-            return
-
-        headers = Headers(scope=scope)
-        host = headers.get("host", "").split(":")[0]
-        is_valid_host = False
-        found_www_redirect = False
-        for pattern in self.allowed_hosts:
-            if host == pattern or (
-                pattern.startswith("*") and host.endswith(pattern[1:])
-            ):
-                is_valid_host = True
-                break
-            elif "www." + host == pattern:
-                found_www_redirect = True
-
-        if is_valid_host:
-            await self.app(scope, receive, send)
-        else:
-            response: Response
-            if found_www_redirect and self.www_redirect:
-                url = URL(scope=scope)
-                redirect_url = url.replace(netloc="www." + url.netloc)
-                response = RedirectResponse(url=str(redirect_url))
-            else:
-                response = PlainTextResponse("Invalid host header", status_code=400)
-            await response(scope, receive, send)

prefect/_vendor/starlette/middleware/wsgi.py

@@ -1,147 +0,0 @@
-import io
-import math
-import sys
-import typing
-import warnings
-
-import anyio
-from anyio.abc import ObjectReceiveStream, ObjectSendStream
-from prefect._vendor.starlette.types import Receive, Scope, Send
-
-warnings.warn(
-    "starlette.middleware.wsgi is deprecated and will be removed in a future release. "
-    "Please refer to https://github.com/abersheeran/a2wsgi as a replacement.",
-    DeprecationWarning,
-)
-
-
-def build_environ(scope: Scope, body: bytes) -> typing.Dict[str, typing.Any]:
-    """
-    Builds a scope and request body into a WSGI environ object.
-    """
-    environ = {
-        "REQUEST_METHOD": scope["method"],
-        "SCRIPT_NAME": scope.get("root_path", "").encode("utf8").decode("latin1"),
-        "PATH_INFO": scope["path"].encode("utf8").decode("latin1"),
-        "QUERY_STRING": scope["query_string"].decode("ascii"),
-        "SERVER_PROTOCOL": f"HTTP/{scope['http_version']}",
-        "wsgi.version": (1, 0),
-        "wsgi.url_scheme": scope.get("scheme", "http"),
-        "wsgi.input": io.BytesIO(body),
-        "wsgi.errors": sys.stdout,
-        "wsgi.multithread": True,
-        "wsgi.multiprocess": True,
-        "wsgi.run_once": False,
-    }
-
-    # Get server name and port - required in WSGI, not in ASGI
-    server = scope.get("server") or ("localhost", 80)
-    environ["SERVER_NAME"] = server[0]
-    environ["SERVER_PORT"] = server[1]
-
-    # Get client IP address
-    if scope.get("client"):
-        environ["REMOTE_ADDR"] = scope["client"][0]
-
-    # Go through headers and make them into environ entries
-    for name, value in scope.get("headers", []):
-        name = name.decode("latin1")
-        if name == "content-length":
-            corrected_name = "CONTENT_LENGTH"
-        elif name == "content-type":
-            corrected_name = "CONTENT_TYPE"
-        else:
-            corrected_name = f"HTTP_{name}".upper().replace("-", "_")
-        # HTTPbis say only ASCII chars are allowed in headers, but we latin1 just in
-        # case
-        value = value.decode("latin1")
-        if corrected_name in environ:
-            value = environ[corrected_name] + "," + value
-        environ[corrected_name] = value
-    return environ
-
-
-class WSGIMiddleware:
-    def __init__(self, app: typing.Callable[..., typing.Any]) -> None:
-        self.app = app
-
-    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
-        assert scope["type"] == "http"
-        responder = WSGIResponder(self.app, scope)
-        await responder(receive, send)
-
-
-class WSGIResponder:
-    stream_send: ObjectSendStream[typing.MutableMapping[str, typing.Any]]
-    stream_receive: ObjectReceiveStream[typing.MutableMapping[str, typing.Any]]
-
-    def __init__(self, app: typing.Callable[..., typing.Any], scope: Scope) -> None:
-        self.app = app
-        self.scope = scope
-        self.status = None
-        self.response_headers = None
-        self.stream_send, self.stream_receive = anyio.create_memory_object_stream(
-            math.inf
-        )
-        self.response_started = False
-        self.exc_info: typing.Any = None
-
-    async def __call__(self, receive: Receive, send: Send) -> None:
-        body = b""
-        more_body = True
-        while more_body:
-            message = await receive()
-            body += message.get("body", b"")
-            more_body = message.get("more_body", False)
-        environ = build_environ(self.scope, body)
-
-        async with anyio.create_task_group() as task_group:
-            task_group.start_soon(self.sender, send)
-            async with self.stream_send:
-                await anyio.to_thread.run_sync(self.wsgi, environ, self.start_response)
-        if self.exc_info is not None:
-            raise self.exc_info[0].with_traceback(self.exc_info[1], self.exc_info[2])
-
-    async def sender(self, send: Send) -> None:
-        async with self.stream_receive:
-            async for message in self.stream_receive:
-                await send(message)
-
-    def start_response(
-        self,
-        status: str,
-        response_headers: typing.List[typing.Tuple[str, str]],
-        exc_info: typing.Any = None,
-    ) -> None:
-        self.exc_info = exc_info
-        if not self.response_started:
-            self.response_started = True
-            status_code_string, _ = status.split(" ", 1)
-            status_code = int(status_code_string)
-            headers = [
-                (name.strip().encode("ascii").lower(), value.strip().encode("ascii"))
-                for name, value in response_headers
-            ]
-            anyio.from_thread.run(
-                self.stream_send.send,
-                {
-                    "type": "http.response.start",
-                    "status": status_code,
-                    "headers": headers,
-                },
-            )
-
-    def wsgi(
-        self,
-        environ: typing.Dict[str, typing.Any],
-        start_response: typing.Callable[..., typing.Any],
-    ) -> None:
-        for chunk in self.app(environ, start_response):
-            anyio.from_thread.run(
-                self.stream_send.send,
-                {"type": "http.response.body", "body": chunk, "more_body": True},
-            )
-
-        anyio.from_thread.run(
-            self.stream_send.send, {"type": "http.response.body", "body": b""}
-        )