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

prefect/_vendor/starlette/requests.py

@@ -1,328 +0,0 @@
-import json
-import typing
-from http import cookies as http_cookies
-
-import anyio
-from prefect._vendor.starlette._utils import (
-    AwaitableOrContextManager,
-    AwaitableOrContextManagerWrapper,
-)
-from prefect._vendor.starlette.datastructures import (
-    URL,
-    Address,
-    FormData,
-    Headers,
-    QueryParams,
-    State,
-)
-from prefect._vendor.starlette.exceptions import HTTPException
-from prefect._vendor.starlette.formparsers import (
-    FormParser,
-    MultiPartException,
-    MultiPartParser,
-)
-from prefect._vendor.starlette.types import Message, Receive, Scope, Send
-
-try:
-    from multipart.multipart import parse_options_header
-except ModuleNotFoundError:  # pragma: nocover
-    parse_options_header = None
-
-
-if typing.TYPE_CHECKING:
-    from prefect._vendor.starlette.routing import Router
-
-
-SERVER_PUSH_HEADERS_TO_COPY = {
-    "accept",
-    "accept-encoding",
-    "accept-language",
-    "cache-control",
-    "user-agent",
-}
-
-
-def cookie_parser(cookie_string: str) -> typing.Dict[str, str]:
-    """
-    This function parses a ``Cookie`` HTTP header into a dict of key/value pairs.
-
-    It attempts to mimic browser cookie parsing behavior: browsers and web servers
-    frequently disregard the spec (RFC 6265) when setting and reading cookies,
-    so we attempt to suit the common scenarios here.
-
-    This function has been adapted from Django 3.1.0.
-    Note: we are explicitly _NOT_ using `SimpleCookie.load` because it is based
-    on an outdated spec and will fail on lots of input we want to support
-    """
-    cookie_dict: typing.Dict[str, str] = {}
-    for chunk in cookie_string.split(";"):
-        if "=" in chunk:
-            key, val = chunk.split("=", 1)
-        else:
-            # Assume an empty name per
-            # https://bugzilla.mozilla.org/show_bug.cgi?id=169091
-            key, val = "", chunk
-        key, val = key.strip(), val.strip()
-        if key or val:
-            # unquote using Python's algorithm.
-            cookie_dict[key] = http_cookies._unquote(val)
-    return cookie_dict
-
-
-class ClientDisconnect(Exception):
-    pass
-
-
-class HTTPConnection(typing.Mapping[str, typing.Any]):
-    """
-    A base class for incoming HTTP connections, that is used to provide
-    any functionality that is common to both `Request` and `WebSocket`.
-    """
-
-    def __init__(self, scope: Scope, receive: typing.Optional[Receive] = None) -> None:
-        assert scope["type"] in ("http", "websocket")
-        self.scope = scope
-
-    def __getitem__(self, key: str) -> typing.Any:
-        return self.scope[key]
-
-    def __iter__(self) -> typing.Iterator[str]:
-        return iter(self.scope)
-
-    def __len__(self) -> int:
-        return len(self.scope)
-
-    # Don't use the `abc.Mapping.__eq__` implementation.
-    # Connection instances should never be considered equal
-    # unless `self is other`.
-    __eq__ = object.__eq__
-    __hash__ = object.__hash__
-
-    @property
-    def app(self) -> typing.Any:
-        return self.scope["app"]
-
-    @property
-    def url(self) -> URL:
-        if not hasattr(self, "_url"):
-            self._url = URL(scope=self.scope)
-        return self._url
-
-    @property
-    def base_url(self) -> URL:
-        if not hasattr(self, "_base_url"):
-            base_url_scope = dict(self.scope)
-            base_url_scope["path"] = "/"
-            base_url_scope["query_string"] = b""
-            base_url_scope["root_path"] = base_url_scope.get("root_path", "")
-            self._base_url = URL(scope=base_url_scope)
-        return self._base_url
-
-    @property
-    def headers(self) -> Headers:
-        if not hasattr(self, "_headers"):
-            self._headers = Headers(scope=self.scope)
-        return self._headers
-
-    @property
-    def query_params(self) -> QueryParams:
-        if not hasattr(self, "_query_params"):
-            self._query_params = QueryParams(self.scope["query_string"])
-        return self._query_params
-
-    @property
-    def path_params(self) -> typing.Dict[str, typing.Any]:
-        return self.scope.get("path_params", {})
-
-    @property
-    def cookies(self) -> typing.Dict[str, str]:
-        if not hasattr(self, "_cookies"):
-            cookies: typing.Dict[str, str] = {}
-            cookie_header = self.headers.get("cookie")
-
-            if cookie_header:
-                cookies = cookie_parser(cookie_header)
-            self._cookies = cookies
-        return self._cookies
-
-    @property
-    def client(self) -> typing.Optional[Address]:
-        # client is a 2 item tuple of (host, port), None or missing
-        host_port = self.scope.get("client")
-        if host_port is not None:
-            return Address(*host_port)
-        return None
-
-    @property
-    def session(self) -> typing.Dict[str, typing.Any]:
-        assert (
-            "session" in self.scope
-        ), "SessionMiddleware must be installed to access request.session"
-        return self.scope["session"]  # type: ignore[no-any-return]
-
-    @property
-    def auth(self) -> typing.Any:
-        assert (
-            "auth" in self.scope
-        ), "AuthenticationMiddleware must be installed to access request.auth"
-        return self.scope["auth"]
-
-    @property
-    def user(self) -> typing.Any:
-        assert (
-            "user" in self.scope
-        ), "AuthenticationMiddleware must be installed to access request.user"
-        return self.scope["user"]
-
-    @property
-    def state(self) -> State:
-        if not hasattr(self, "_state"):
-            # Ensure 'state' has an empty dict if it's not already populated.
-            self.scope.setdefault("state", {})
-            # Create a state instance with a reference to the dict in which it should
-            # store info
-            self._state = State(self.scope["state"])
-        return self._state
-
-    def url_for(self, name: str, /, **path_params: typing.Any) -> URL:
-        router: Router = self.scope["router"]
-        url_path = router.url_path_for(name, **path_params)
-        return url_path.make_absolute_url(base_url=self.base_url)
-
-
-async def empty_receive() -> typing.NoReturn:
-    raise RuntimeError("Receive channel has not been made available")
-
-
-async def empty_send(message: Message) -> typing.NoReturn:
-    raise RuntimeError("Send channel has not been made available")
-
-
-class Request(HTTPConnection):
-    _form: typing.Optional[FormData]
-
-    def __init__(
-        self, scope: Scope, receive: Receive = empty_receive, send: Send = empty_send
-    ):
-        super().__init__(scope)
-        assert scope["type"] == "http"
-        self._receive = receive
-        self._send = send
-        self._stream_consumed = False
-        self._is_disconnected = False
-        self._form = None
-
-    @property
-    def method(self) -> str:
-        return typing.cast(str, self.scope["method"])
-
-    @property
-    def receive(self) -> Receive:
-        return self._receive
-
-    async def stream(self) -> typing.AsyncGenerator[bytes, None]:
-        if hasattr(self, "_body"):
-            yield self._body
-            yield b""
-            return
-        if self._stream_consumed:
-            raise RuntimeError("Stream consumed")
-        while not self._stream_consumed:
-            message = await self._receive()
-            if message["type"] == "http.request":
-                body = message.get("body", b"")
-                if not message.get("more_body", False):
-                    self._stream_consumed = True
-                if body:
-                    yield body
-            elif message["type"] == "http.disconnect":
-                self._is_disconnected = True
-                raise ClientDisconnect()
-        yield b""
-
-    async def body(self) -> bytes:
-        if not hasattr(self, "_body"):
-            chunks: "typing.List[bytes]" = []
-            async for chunk in self.stream():
-                chunks.append(chunk)
-            self._body = b"".join(chunks)
-        return self._body
-
-    async def json(self) -> typing.Any:
-        if not hasattr(self, "_json"):
-            body = await self.body()
-            self._json = json.loads(body)
-        return self._json
-
-    async def _get_form(
-        self,
-        *,
-        max_files: typing.Union[int, float] = 1000,
-        max_fields: typing.Union[int, float] = 1000,
-    ) -> FormData:
-        if self._form is None:
-            assert (
-                parse_options_header is not None
-            ), "The `python-multipart` library must be installed to use form parsing."
-            content_type_header = self.headers.get("Content-Type")
-            content_type: bytes
-            content_type, _ = parse_options_header(content_type_header)
-            if content_type == b"multipart/form-data":
-                try:
-                    multipart_parser = MultiPartParser(
-                        self.headers,
-                        self.stream(),
-                        max_files=max_files,
-                        max_fields=max_fields,
-                    )
-                    self._form = await multipart_parser.parse()
-                except MultiPartException as exc:
-                    if "app" in self.scope:
-                        raise HTTPException(status_code=400, detail=exc.message)
-                    raise exc
-            elif content_type == b"application/x-www-form-urlencoded":
-                form_parser = FormParser(self.headers, self.stream())
-                self._form = await form_parser.parse()
-            else:
-                self._form = FormData()
-        return self._form
-
-    def form(
-        self,
-        *,
-        max_files: typing.Union[int, float] = 1000,
-        max_fields: typing.Union[int, float] = 1000,
-    ) -> AwaitableOrContextManager[FormData]:
-        return AwaitableOrContextManagerWrapper(
-            self._get_form(max_files=max_files, max_fields=max_fields)
-        )
-
-    async def close(self) -> None:
-        if self._form is not None:
-            await self._form.close()
-
-    async def is_disconnected(self) -> bool:
-        if not self._is_disconnected:
-            message: Message = {}
-
-            # If message isn't immediately available, move on
-            with anyio.CancelScope() as cs:
-                cs.cancel()
-                message = await self._receive()
-
-            if message.get("type") == "http.disconnect":
-                self._is_disconnected = True
-
-        return self._is_disconnected
-
-    async def send_push_promise(self, path: str) -> None:
-        if "http.response.push" in self.scope.get("extensions", {}):
-            raw_headers: "typing.List[typing.Tuple[bytes, bytes]]" = []
-            for name in SERVER_PUSH_HEADERS_TO_COPY:
-                for value in self.headers.getlist(name):
-                    raw_headers.append(
-                        (name.encode("latin-1"), value.encode("latin-1"))
-                    )
-            await self._send(
-                {"type": "http.response.push", "path": path, "headers": raw_headers}
-            )

prefect/_vendor/starlette/responses.py

@@ -1,347 +0,0 @@
-import http.cookies
-import json
-import os
-import stat
-import typing
-from datetime import datetime
-from email.utils import format_datetime, formatdate
-from functools import partial
-from mimetypes import guess_type
-from urllib.parse import quote
-
-import anyio
-from prefect._vendor.starlette._compat import md5_hexdigest
-from prefect._vendor.starlette.background import BackgroundTask
-from prefect._vendor.starlette.concurrency import iterate_in_threadpool
-from prefect._vendor.starlette.datastructures import URL, MutableHeaders
-from prefect._vendor.starlette.types import Receive, Scope, Send
-
-
-class Response:
-    media_type = None
-    charset = "utf-8"
-
-    def __init__(
-        self,
-        content: typing.Any = None,
-        status_code: int = 200,
-        headers: typing.Optional[typing.Mapping[str, str]] = None,
-        media_type: typing.Optional[str] = None,
-        background: typing.Optional[BackgroundTask] = None,
-    ) -> None:
-        self.status_code = status_code
-        if media_type is not None:
-            self.media_type = media_type
-        self.background = background
-        self.body = self.render(content)
-        self.init_headers(headers)
-
-    def render(self, content: typing.Any) -> bytes:
-        if content is None:
-            return b""
-        if isinstance(content, bytes):
-            return content
-        return content.encode(self.charset)  # type: ignore
-
-    def init_headers(
-        self, headers: typing.Optional[typing.Mapping[str, str]] = None
-    ) -> None:
-        if headers is None:
-            raw_headers: typing.List[typing.Tuple[bytes, bytes]] = []
-            populate_content_length = True
-            populate_content_type = True
-        else:
-            raw_headers = [
-                (k.lower().encode("latin-1"), v.encode("latin-1"))
-                for k, v in headers.items()
-            ]
-            keys = [h[0] for h in raw_headers]
-            populate_content_length = b"content-length" not in keys
-            populate_content_type = b"content-type" not in keys
-
-        body = getattr(self, "body", None)
-        if (
-            body is not None
-            and populate_content_length
-            and not (self.status_code < 200 or self.status_code in (204, 304))
-        ):
-            content_length = str(len(body))
-            raw_headers.append((b"content-length", content_length.encode("latin-1")))
-
-        content_type = self.media_type
-        if content_type is not None and populate_content_type:
-            if content_type.startswith("text/"):
-                content_type += "; charset=" + self.charset
-            raw_headers.append((b"content-type", content_type.encode("latin-1")))
-
-        self.raw_headers = raw_headers
-
-    @property
-    def headers(self) -> MutableHeaders:
-        if not hasattr(self, "_headers"):
-            self._headers = MutableHeaders(raw=self.raw_headers)
-        return self._headers
-
-    def set_cookie(
-        self,
-        key: str,
-        value: str = "",
-        max_age: typing.Optional[int] = None,
-        expires: typing.Optional[typing.Union[datetime, str, int]] = None,
-        path: str = "/",
-        domain: typing.Optional[str] = None,
-        secure: bool = False,
-        httponly: bool = False,
-        samesite: typing.Optional[typing.Literal["lax", "strict", "none"]] = "lax",
-    ) -> None:
-        cookie: "http.cookies.BaseCookie[str]" = http.cookies.SimpleCookie()
-        cookie[key] = value
-        if max_age is not None:
-            cookie[key]["max-age"] = max_age
-        if expires is not None:
-            if isinstance(expires, datetime):
-                cookie[key]["expires"] = format_datetime(expires, usegmt=True)
-            else:
-                cookie[key]["expires"] = expires
-        if path is not None:
-            cookie[key]["path"] = path
-        if domain is not None:
-            cookie[key]["domain"] = domain
-        if secure:
-            cookie[key]["secure"] = True
-        if httponly:
-            cookie[key]["httponly"] = True
-        if samesite is not None:
-            assert samesite.lower() in [
-                "strict",
-                "lax",
-                "none",
-            ], "samesite must be either 'strict', 'lax' or 'none'"
-            cookie[key]["samesite"] = samesite
-        cookie_val = cookie.output(header="").strip()
-        self.raw_headers.append((b"set-cookie", cookie_val.encode("latin-1")))
-
-    def delete_cookie(
-        self,
-        key: str,
-        path: str = "/",
-        domain: typing.Optional[str] = None,
-        secure: bool = False,
-        httponly: bool = False,
-        samesite: typing.Optional[typing.Literal["lax", "strict", "none"]] = "lax",
-    ) -> None:
-        self.set_cookie(
-            key,
-            max_age=0,
-            expires=0,
-            path=path,
-            domain=domain,
-            secure=secure,
-            httponly=httponly,
-            samesite=samesite,
-        )
-
-    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
-        await send(
-            {
-                "type": "http.response.start",
-                "status": self.status_code,
-                "headers": self.raw_headers,
-            }
-        )
-        await send({"type": "http.response.body", "body": self.body})
-
-        if self.background is not None:
-            await self.background()
-
-
-class HTMLResponse(Response):
-    media_type = "text/html"
-
-
-class PlainTextResponse(Response):
-    media_type = "text/plain"
-
-
-class JSONResponse(Response):
-    media_type = "application/json"
-
-    def __init__(
-        self,
-        content: typing.Any,
-        status_code: int = 200,
-        headers: typing.Optional[typing.Mapping[str, str]] = None,
-        media_type: typing.Optional[str] = None,
-        background: typing.Optional[BackgroundTask] = None,
-    ) -> None:
-        super().__init__(content, status_code, headers, media_type, background)
-
-    def render(self, content: typing.Any) -> bytes:
-        return json.dumps(
-            content,
-            ensure_ascii=False,
-            allow_nan=False,
-            indent=None,
-            separators=(",", ":"),
-        ).encode("utf-8")
-
-
-class RedirectResponse(Response):
-    def __init__(
-        self,
-        url: typing.Union[str, URL],
-        status_code: int = 307,
-        headers: typing.Optional[typing.Mapping[str, str]] = None,
-        background: typing.Optional[BackgroundTask] = None,
-    ) -> None:
-        super().__init__(
-            content=b"", status_code=status_code, headers=headers, background=background
-        )
-        self.headers["location"] = quote(str(url), safe=":/%#?=@[]!$&'()*+,;")
-
-
-Content = typing.Union[str, bytes]
-SyncContentStream = typing.Iterator[Content]
-AsyncContentStream = typing.AsyncIterable[Content]
-ContentStream = typing.Union[AsyncContentStream, SyncContentStream]
-
-
-class StreamingResponse(Response):
-    body_iterator: AsyncContentStream
-
-    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,
-    ) -> None:
-        if isinstance(content, typing.AsyncIterable):
-            self.body_iterator = content
-        else:
-            self.body_iterator = iterate_in_threadpool(content)
-        self.status_code = status_code
-        self.media_type = self.media_type if media_type is None else media_type
-        self.background = background
-        self.init_headers(headers)
-
-    async def listen_for_disconnect(self, receive: Receive) -> None:
-        while True:
-            message = await receive()
-            if message["type"] == "http.disconnect":
-                break
-
-    async def stream_response(self, send: Send) -> None:
-        await send(
-            {
-                "type": "http.response.start",
-                "status": self.status_code,
-                "headers": self.raw_headers,
-            }
-        )
-        async for chunk in self.body_iterator:
-            if not isinstance(chunk, bytes):
-                chunk = chunk.encode(self.charset)
-            await send({"type": "http.response.body", "body": chunk, "more_body": True})
-
-        await send({"type": "http.response.body", "body": b"", "more_body": False})
-
-    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
-        async with anyio.create_task_group() as task_group:
-
-            async def wrap(func: "typing.Callable[[], typing.Awaitable[None]]") -> None:
-                await func()
-                task_group.cancel_scope.cancel()
-
-            task_group.start_soon(wrap, partial(self.stream_response, send))
-            await wrap(partial(self.listen_for_disconnect, receive))
-
-        if self.background is not None:
-            await self.background()
-
-
-class FileResponse(Response):
-    chunk_size = 64 * 1024
-
-    def __init__(
-        self,
-        path: typing.Union[str, "os.PathLike[str]"],
-        status_code: int = 200,
-        headers: typing.Optional[typing.Mapping[str, str]] = None,
-        media_type: typing.Optional[str] = None,
-        background: typing.Optional[BackgroundTask] = None,
-        filename: typing.Optional[str] = None,
-        stat_result: typing.Optional[os.stat_result] = None,
-        method: typing.Optional[str] = None,
-        content_disposition_type: str = "attachment",
-    ) -> None:
-        self.path = path
-        self.status_code = status_code
-        self.filename = filename
-        self.send_header_only = method is not None and method.upper() == "HEAD"
-        if media_type is None:
-            media_type = guess_type(filename or path)[0] or "text/plain"
-        self.media_type = media_type
-        self.background = background
-        self.init_headers(headers)
-        if self.filename is not None:
-            content_disposition_filename = quote(self.filename)
-            if content_disposition_filename != self.filename:
-                content_disposition = "{}; filename*=utf-8''{}".format(
-                    content_disposition_type, content_disposition_filename
-                )
-            else:
-                content_disposition = '{}; filename="{}"'.format(
-                    content_disposition_type, self.filename
-                )
-            self.headers.setdefault("content-disposition", content_disposition)
-        self.stat_result = stat_result
-        if stat_result is not None:
-            self.set_stat_headers(stat_result)
-
-    def set_stat_headers(self, stat_result: os.stat_result) -> None:
-        content_length = str(stat_result.st_size)
-        last_modified = formatdate(stat_result.st_mtime, usegmt=True)
-        etag_base = str(stat_result.st_mtime) + "-" + str(stat_result.st_size)
-        etag = md5_hexdigest(etag_base.encode(), usedforsecurity=False)
-
-        self.headers.setdefault("content-length", content_length)
-        self.headers.setdefault("last-modified", last_modified)
-        self.headers.setdefault("etag", etag)
-
-    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
-        if self.stat_result is None:
-            try:
-                stat_result = await anyio.to_thread.run_sync(os.stat, self.path)
-                self.set_stat_headers(stat_result)
-            except FileNotFoundError:
-                raise RuntimeError(f"File at path {self.path} does not exist.")
-            else:
-                mode = stat_result.st_mode
-                if not stat.S_ISREG(mode):
-                    raise RuntimeError(f"File at path {self.path} is not a file.")
-        await send(
-            {
-                "type": "http.response.start",
-                "status": self.status_code,
-                "headers": self.raw_headers,
-            }
-        )
-        if self.send_header_only:
-            await send({"type": "http.response.body", "body": b"", "more_body": False})
-        else:
-            async with await anyio.open_file(self.path, mode="rb") as file:
-                more_body = True
-                while more_body:
-                    chunk = await file.read(self.chunk_size)
-                    more_body = len(chunk) == self.chunk_size
-                    await send(
-                        {
-                            "type": "http.response.body",
-                            "body": chunk,
-                            "more_body": more_body,
-                        }
-                    )
-        if self.background is not None:
-            await self.background()