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

prefect/_vendor/starlette/endpoints.py

@@ -1,130 +0,0 @@
-import json
-import typing
-
-from prefect._vendor.starlette import status
-from prefect._vendor.starlette._utils import is_async_callable
-from prefect._vendor.starlette.concurrency import run_in_threadpool
-from prefect._vendor.starlette.exceptions import HTTPException
-from prefect._vendor.starlette.requests import Request
-from prefect._vendor.starlette.responses import PlainTextResponse, Response
-from prefect._vendor.starlette.types import Message, Receive, Scope, Send
-from prefect._vendor.starlette.websockets import WebSocket
-
-
-class HTTPEndpoint:
-    def __init__(self, scope: Scope, receive: Receive, send: Send) -> None:
-        assert scope["type"] == "http"
-        self.scope = scope
-        self.receive = receive
-        self.send = send
-        self._allowed_methods = [
-            method
-            for method in ("GET", "HEAD", "POST", "PUT", "PATCH", "DELETE", "OPTIONS")
-            if getattr(self, method.lower(), None) is not None
-        ]
-
-    def __await__(self) -> typing.Generator[typing.Any, None, None]:
-        return self.dispatch().__await__()
-
-    async def dispatch(self) -> None:
-        request = Request(self.scope, receive=self.receive)
-        handler_name = (
-            "get"
-            if request.method == "HEAD" and not hasattr(self, "head")
-            else request.method.lower()
-        )
-
-        handler: typing.Callable[[Request], typing.Any] = getattr(
-            self, handler_name, self.method_not_allowed
-        )
-        is_async = is_async_callable(handler)
-        if is_async:
-            response = await handler(request)
-        else:
-            response = await run_in_threadpool(handler, request)
-        await response(self.scope, self.receive, self.send)
-
-    async def method_not_allowed(self, request: Request) -> Response:
-        # If we're running inside a starlette application then raise an
-        # exception, so that the configurable exception handler can deal with
-        # returning the response. For plain ASGI apps, just return the response.
-        headers = {"Allow": ", ".join(self._allowed_methods)}
-        if "app" in self.scope:
-            raise HTTPException(status_code=405, headers=headers)
-        return PlainTextResponse("Method Not Allowed", status_code=405, headers=headers)
-
-
-class WebSocketEndpoint:
-    encoding: typing.Optional[str] = None  # May be "text", "bytes", or "json".
-
-    def __init__(self, scope: Scope, receive: Receive, send: Send) -> None:
-        assert scope["type"] == "websocket"
-        self.scope = scope
-        self.receive = receive
-        self.send = send
-
-    def __await__(self) -> typing.Generator[typing.Any, None, None]:
-        return self.dispatch().__await__()
-
-    async def dispatch(self) -> None:
-        websocket = WebSocket(self.scope, receive=self.receive, send=self.send)
-        await self.on_connect(websocket)
-
-        close_code = status.WS_1000_NORMAL_CLOSURE
-
-        try:
-            while True:
-                message = await websocket.receive()
-                if message["type"] == "websocket.receive":
-                    data = await self.decode(websocket, message)
-                    await self.on_receive(websocket, data)
-                elif message["type"] == "websocket.disconnect":
-                    close_code = int(
-                        message.get("code") or status.WS_1000_NORMAL_CLOSURE
-                    )
-                    break
-        except Exception as exc:
-            close_code = status.WS_1011_INTERNAL_ERROR
-            raise exc
-        finally:
-            await self.on_disconnect(websocket, close_code)
-
-    async def decode(self, websocket: WebSocket, message: Message) -> typing.Any:
-        if self.encoding == "text":
-            if "text" not in message:
-                await websocket.close(code=status.WS_1003_UNSUPPORTED_DATA)
-                raise RuntimeError("Expected text websocket messages, but got bytes")
-            return message["text"]
-
-        elif self.encoding == "bytes":
-            if "bytes" not in message:
-                await websocket.close(code=status.WS_1003_UNSUPPORTED_DATA)
-                raise RuntimeError("Expected bytes websocket messages, but got text")
-            return message["bytes"]
-
-        elif self.encoding == "json":
-            if message.get("text") is not None:
-                text = message["text"]
-            else:
-                text = message["bytes"].decode("utf-8")
-
-            try:
-                return json.loads(text)
-            except json.decoder.JSONDecodeError:
-                await websocket.close(code=status.WS_1003_UNSUPPORTED_DATA)
-                raise RuntimeError("Malformed JSON data received.")
-
-        assert (
-            self.encoding is None
-        ), f"Unsupported 'encoding' attribute {self.encoding}"
-        return message["text"] if message.get("text") else message["bytes"]
-
-    async def on_connect(self, websocket: WebSocket) -> None:
-        """Override to handle an incoming websocket connection"""
-        await websocket.accept()
-
-    async def on_receive(self, websocket: WebSocket, data: typing.Any) -> None:
-        """Override to handle an incoming websocket message"""
-
-    async def on_disconnect(self, websocket: WebSocket, close_code: int) -> None:
-        """Override to handle a disconnecting websocket"""

prefect/_vendor/starlette/exceptions.py

@@ -1,60 +0,0 @@
-import http
-import typing
-import warnings
-
-__all__ = ("HTTPException", "WebSocketException")
-
-
-class HTTPException(Exception):
-    def __init__(
-        self,
-        status_code: int,
-        detail: typing.Optional[str] = None,
-        headers: typing.Optional[typing.Dict[str, str]] = None,
-    ) -> None:
-        if detail is None:
-            detail = http.HTTPStatus(status_code).phrase
-        self.status_code = status_code
-        self.detail = detail
-        self.headers = headers
-
-    def __str__(self) -> str:
-        return f"{self.status_code}: {self.detail}"
-
-    def __repr__(self) -> str:
-        class_name = self.__class__.__name__
-        return f"{class_name}(status_code={self.status_code!r}, detail={self.detail!r})"
-
-
-class WebSocketException(Exception):
-    def __init__(self, code: int, reason: typing.Optional[str] = None) -> None:
-        self.code = code
-        self.reason = reason or ""
-
-    def __str__(self) -> str:
-        return f"{self.code}: {self.reason}"
-
-    def __repr__(self) -> str:
-        class_name = self.__class__.__name__
-        return f"{class_name}(code={self.code!r}, reason={self.reason!r})"
-
-
-__deprecated__ = "ExceptionMiddleware"
-
-
-def __getattr__(name: str) -> typing.Any:  # pragma: no cover
-    if name == __deprecated__:
-        from prefect._vendor.starlette.middleware.exceptions import ExceptionMiddleware
-
-        warnings.warn(
-            f"{__deprecated__} is deprecated on `starlette.exceptions`. "
-            f"Import it from `starlette.middleware.exceptions` instead.",
-            category=DeprecationWarning,
-            stacklevel=3,
-        )
-        return ExceptionMiddleware
-    raise AttributeError(f"module '{__name__}' has no attribute '{name}'")
-
-
-def __dir__() -> typing.List[str]:
-    return sorted(list(__all__) + [__deprecated__])  # pragma: no cover

prefect/_vendor/starlette/formparsers.py

@@ -1,276 +0,0 @@
-import typing
-from dataclasses import dataclass, field
-from enum import Enum
-from tempfile import SpooledTemporaryFile
-from urllib.parse import unquote_plus
-
-from prefect._vendor.starlette.datastructures import FormData, Headers, UploadFile
-
-try:
-    import multipart
-    from multipart.multipart import parse_options_header
-except ModuleNotFoundError:  # pragma: nocover
-    parse_options_header = None
-    multipart = None
-
-
-class FormMessage(Enum):
-    FIELD_START = 1
-    FIELD_NAME = 2
-    FIELD_DATA = 3
-    FIELD_END = 4
-    END = 5
-
-
-@dataclass
-class MultipartPart:
-    content_disposition: typing.Optional[bytes] = None
-    field_name: str = ""
-    data: bytes = b""
-    file: typing.Optional[UploadFile] = None
-    item_headers: typing.List[typing.Tuple[bytes, bytes]] = field(default_factory=list)
-
-
-def _user_safe_decode(src: bytes, codec: str) -> str:
-    try:
-        return src.decode(codec)
-    except (UnicodeDecodeError, LookupError):
-        return src.decode("latin-1")
-
-
-class MultiPartException(Exception):
-    def __init__(self, message: str) -> None:
-        self.message = message
-
-
-class FormParser:
-    def __init__(
-        self, headers: Headers, stream: typing.AsyncGenerator[bytes, None]
-    ) -> None:
-        assert (
-            multipart is not None
-        ), "The `python-multipart` library must be installed to use form parsing."
-        self.headers = headers
-        self.stream = stream
-        self.messages: typing.List[typing.Tuple[FormMessage, bytes]] = []
-
-    def on_field_start(self) -> None:
-        message = (FormMessage.FIELD_START, b"")
-        self.messages.append(message)
-
-    def on_field_name(self, data: bytes, start: int, end: int) -> None:
-        message = (FormMessage.FIELD_NAME, data[start:end])
-        self.messages.append(message)
-
-    def on_field_data(self, data: bytes, start: int, end: int) -> None:
-        message = (FormMessage.FIELD_DATA, data[start:end])
-        self.messages.append(message)
-
-    def on_field_end(self) -> None:
-        message = (FormMessage.FIELD_END, b"")
-        self.messages.append(message)
-
-    def on_end(self) -> None:
-        message = (FormMessage.END, b"")
-        self.messages.append(message)
-
-    async def parse(self) -> FormData:
-        # Callbacks dictionary.
-        callbacks = {
-            "on_field_start": self.on_field_start,
-            "on_field_name": self.on_field_name,
-            "on_field_data": self.on_field_data,
-            "on_field_end": self.on_field_end,
-            "on_end": self.on_end,
-        }
-
-        # Create the parser.
-        parser = multipart.QuerystringParser(callbacks)
-        field_name = b""
-        field_value = b""
-
-        items: typing.List[typing.Tuple[str, typing.Union[str, UploadFile]]] = []
-
-        # Feed the parser with data from the request.
-        async for chunk in self.stream:
-            if chunk:
-                parser.write(chunk)
-            else:
-                parser.finalize()
-            messages = list(self.messages)
-            self.messages.clear()
-            for message_type, message_bytes in messages:
-                if message_type == FormMessage.FIELD_START:
-                    field_name = b""
-                    field_value = b""
-                elif message_type == FormMessage.FIELD_NAME:
-                    field_name += message_bytes
-                elif message_type == FormMessage.FIELD_DATA:
-                    field_value += message_bytes
-                elif message_type == FormMessage.FIELD_END:
-                    name = unquote_plus(field_name.decode("latin-1"))
-                    value = unquote_plus(field_value.decode("latin-1"))
-                    items.append((name, value))
-
-        return FormData(items)
-
-
-class MultiPartParser:
-    max_file_size = 1024 * 1024
-
-    def __init__(
-        self,
-        headers: Headers,
-        stream: typing.AsyncGenerator[bytes, None],
-        *,
-        max_files: typing.Union[int, float] = 1000,
-        max_fields: typing.Union[int, float] = 1000,
-    ) -> None:
-        assert (
-            multipart is not None
-        ), "The `python-multipart` library must be installed to use form parsing."
-        self.headers = headers
-        self.stream = stream
-        self.max_files = max_files
-        self.max_fields = max_fields
-        self.items: typing.List[typing.Tuple[str, typing.Union[str, UploadFile]]] = []
-        self._current_files = 0
-        self._current_fields = 0
-        self._current_partial_header_name: bytes = b""
-        self._current_partial_header_value: bytes = b""
-        self._current_part = MultipartPart()
-        self._charset = ""
-        self._file_parts_to_write: typing.List[typing.Tuple[MultipartPart, bytes]] = []
-        self._file_parts_to_finish: typing.List[MultipartPart] = []
-        self._files_to_close_on_error: typing.List[SpooledTemporaryFile[bytes]] = []
-
-    def on_part_begin(self) -> None:
-        self._current_part = MultipartPart()
-
-    def on_part_data(self, data: bytes, start: int, end: int) -> None:
-        message_bytes = data[start:end]
-        if self._current_part.file is None:
-            self._current_part.data += message_bytes
-        else:
-            self._file_parts_to_write.append((self._current_part, message_bytes))
-
-    def on_part_end(self) -> None:
-        if self._current_part.file is None:
-            self.items.append(
-                (
-                    self._current_part.field_name,
-                    _user_safe_decode(self._current_part.data, self._charset),
-                )
-            )
-        else:
-            self._file_parts_to_finish.append(self._current_part)
-            # The file can be added to the items right now even though it's not
-            # finished yet, because it will be finished in the `parse()` method, before
-            # self.items is used in the return value.
-            self.items.append((self._current_part.field_name, self._current_part.file))
-
-    def on_header_field(self, data: bytes, start: int, end: int) -> None:
-        self._current_partial_header_name += data[start:end]
-
-    def on_header_value(self, data: bytes, start: int, end: int) -> None:
-        self._current_partial_header_value += data[start:end]
-
-    def on_header_end(self) -> None:
-        field = self._current_partial_header_name.lower()
-        if field == b"content-disposition":
-            self._current_part.content_disposition = self._current_partial_header_value
-        self._current_part.item_headers.append(
-            (field, self._current_partial_header_value)
-        )
-        self._current_partial_header_name = b""
-        self._current_partial_header_value = b""
-
-    def on_headers_finished(self) -> None:
-        disposition, options = parse_options_header(
-            self._current_part.content_disposition
-        )
-        try:
-            self._current_part.field_name = _user_safe_decode(
-                options[b"name"], self._charset
-            )
-        except KeyError:
-            raise MultiPartException(
-                'The Content-Disposition header field "name" must be ' "provided."
-            )
-        if b"filename" in options:
-            self._current_files += 1
-            if self._current_files > self.max_files:
-                raise MultiPartException(
-                    f"Too many files. Maximum number of files is {self.max_files}."
-                )
-            filename = _user_safe_decode(options[b"filename"], self._charset)
-            tempfile = SpooledTemporaryFile(max_size=self.max_file_size)
-            self._files_to_close_on_error.append(tempfile)
-            self._current_part.file = UploadFile(
-                file=tempfile,  # type: ignore[arg-type]
-                size=0,
-                filename=filename,
-                headers=Headers(raw=self._current_part.item_headers),
-            )
-        else:
-            self._current_fields += 1
-            if self._current_fields > self.max_fields:
-                raise MultiPartException(
-                    f"Too many fields. Maximum number of fields is {self.max_fields}."
-                )
-            self._current_part.file = None
-
-    def on_end(self) -> None:
-        pass
-
-    async def parse(self) -> FormData:
-        # Parse the Content-Type header to get the multipart boundary.
-        _, params = parse_options_header(self.headers["Content-Type"])
-        charset = params.get(b"charset", "utf-8")
-        if isinstance(charset, bytes):
-            charset = charset.decode("latin-1")
-        self._charset = charset
-        try:
-            boundary = params[b"boundary"]
-        except KeyError:
-            raise MultiPartException("Missing boundary in multipart.")
-
-        # Callbacks dictionary.
-        callbacks = {
-            "on_part_begin": self.on_part_begin,
-            "on_part_data": self.on_part_data,
-            "on_part_end": self.on_part_end,
-            "on_header_field": self.on_header_field,
-            "on_header_value": self.on_header_value,
-            "on_header_end": self.on_header_end,
-            "on_headers_finished": self.on_headers_finished,
-            "on_end": self.on_end,
-        }
-
-        # Create the parser.
-        parser = multipart.MultipartParser(boundary, callbacks)
-        try:
-            # Feed the parser with data from the request.
-            async for chunk in self.stream:
-                parser.write(chunk)
-                # Write file data, it needs to use await with the UploadFile methods
-                # that call the corresponding file methods *in a threadpool*,
-                # otherwise, if they were called directly in the callback methods above
-                # (regular, non-async functions), that would block the event loop in
-                # the main thread.
-                for part, data in self._file_parts_to_write:
-                    assert part.file  # for type checkers
-                    await part.file.write(data)
-                for part in self._file_parts_to_finish:
-                    assert part.file  # for type checkers
-                    await part.file.seek(0)
-                self._file_parts_to_write.clear()
-                self._file_parts_to_finish.clear()
-        except MultiPartException as exc:
-            # Close all the files if there was an error.
-            for file in self._files_to_close_on_error:
-                file.close()
-            raise exc
-
-        parser.finalize()
-        return FormData(self.items)

prefect/_vendor/starlette/middleware/__init__.py

@@ -1,17 +0,0 @@
-import typing
-
-
-class Middleware:
-    def __init__(self, cls: type, **options: typing.Any) -> None:
-        self.cls = cls
-        self.options = options
-
-    def __iter__(self) -> typing.Iterator[typing.Any]:
-        as_tuple = (self.cls, self.options)
-        return iter(as_tuple)
-
-    def __repr__(self) -> str:
-        class_name = self.__class__.__name__
-        option_strings = [f"{key}={value!r}" for key, value in self.options.items()]
-        args_repr = ", ".join([self.cls.__name__] + option_strings)
-        return f"{class_name}({args_repr})"

prefect/_vendor/starlette/middleware/authentication.py

@@ -1,52 +0,0 @@
-import typing
-
-from prefect._vendor.starlette.authentication import (
-    AuthCredentials,
-    AuthenticationBackend,
-    AuthenticationError,
-    UnauthenticatedUser,
-)
-from prefect._vendor.starlette.requests import HTTPConnection
-from prefect._vendor.starlette.responses import PlainTextResponse, Response
-from prefect._vendor.starlette.types import ASGIApp, Receive, Scope, Send
-
-
-class AuthenticationMiddleware:
-    def __init__(
-        self,
-        app: ASGIApp,
-        backend: AuthenticationBackend,
-        on_error: typing.Optional[
-            typing.Callable[[HTTPConnection, AuthenticationError], Response]
-        ] = None,
-    ) -> None:
-        self.app = app
-        self.backend = backend
-        self.on_error: typing.Callable[
-            [HTTPConnection, AuthenticationError], Response
-        ] = on_error if on_error is not None else self.default_on_error
-
-    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
-
-        conn = HTTPConnection(scope)
-        try:
-            auth_result = await self.backend.authenticate(conn)
-        except AuthenticationError as exc:
-            response = self.on_error(conn, exc)
-            if scope["type"] == "websocket":
-                await send({"type": "websocket.close", "code": 1000})
-            else:
-                await response(scope, receive, send)
-            return
-
-        if auth_result is None:
-            auth_result = AuthCredentials(), UnauthenticatedUser()
-        scope["auth"], scope["user"] = auth_result
-        await self.app(scope, receive, send)
-
-    @staticmethod
-    def default_on_error(conn: HTTPConnection, exc: Exception) -> Response:
-        return PlainTextResponse(str(exc), status_code=400)