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

prefect/_vendor/starlette/schemas.py

@@ -1,154 +0,0 @@
-import inspect
-import re
-import typing
-
-from prefect._vendor.starlette.requests import Request
-from prefect._vendor.starlette.responses import Response
-from prefect._vendor.starlette.routing import BaseRoute, Host, Mount, Route
-
-try:
-    import yaml
-except ModuleNotFoundError:  # pragma: nocover
-    yaml = None  # type: ignore[assignment]
-
-
-class OpenAPIResponse(Response):
-    media_type = "application/vnd.oai.openapi"
-
-    def render(self, content: typing.Any) -> bytes:
-        assert yaml is not None, "`pyyaml` must be installed to use OpenAPIResponse."
-        assert isinstance(
-            content, dict
-        ), "The schema passed to OpenAPIResponse should be a dictionary."
-        return yaml.dump(content, default_flow_style=False).encode("utf-8")
-
-
-class EndpointInfo(typing.NamedTuple):
-    path: str
-    http_method: str
-    func: typing.Callable[..., typing.Any]
-
-
-class BaseSchemaGenerator:
-    def get_schema(
-        self, routes: typing.List[BaseRoute]
-    ) -> typing.Dict[str, typing.Any]:
-        raise NotImplementedError()  # pragma: no cover
-
-    def get_endpoints(
-        self, routes: typing.List[BaseRoute]
-    ) -> typing.List[EndpointInfo]:
-        """
-        Given the routes, yields the following information:
-
-        - path
-            eg: /users/
-        - http_method
-            one of 'get', 'post', 'put', 'patch', 'delete', 'options'
-        - func
-            method ready to extract the docstring
-        """
-        endpoints_info: typing.List[EndpointInfo] = []
-
-        for route in routes:
-            if isinstance(route, (Mount, Host)):
-                routes = route.routes or []
-                if isinstance(route, Mount):
-                    path = self._remove_converter(route.path)
-                else:
-                    path = ""
-                sub_endpoints = [
-                    EndpointInfo(
-                        path="".join((path, sub_endpoint.path)),
-                        http_method=sub_endpoint.http_method,
-                        func=sub_endpoint.func,
-                    )
-                    for sub_endpoint in self.get_endpoints(routes)
-                ]
-                endpoints_info.extend(sub_endpoints)
-
-            elif not isinstance(route, Route) or not route.include_in_schema:
-                continue
-
-            elif inspect.isfunction(route.endpoint) or inspect.ismethod(route.endpoint):
-                path = self._remove_converter(route.path)
-                for method in route.methods or ["GET"]:
-                    if method == "HEAD":
-                        continue
-                    endpoints_info.append(
-                        EndpointInfo(path, method.lower(), route.endpoint)
-                    )
-            else:
-                path = self._remove_converter(route.path)
-                for method in ["get", "post", "put", "patch", "delete", "options"]:
-                    if not hasattr(route.endpoint, method):
-                        continue
-                    func = getattr(route.endpoint, method)
-                    endpoints_info.append(EndpointInfo(path, method.lower(), func))
-
-        return endpoints_info
-
-    def _remove_converter(self, path: str) -> str:
-        """
-        Remove the converter from the path.
-        For example, a route like this:
-            Route("/users/{id:int}", endpoint=get_user, methods=["GET"])
-        Should be represented as `/users/{id}` in the OpenAPI schema.
-        """
-        return re.sub(r":\w+}", "}", path)
-
-    def parse_docstring(
-        self, func_or_method: typing.Callable[..., typing.Any]
-    ) -> typing.Dict[str, typing.Any]:
-        """
-        Given a function, parse the docstring as YAML and return a dictionary of info.
-        """
-        docstring = func_or_method.__doc__
-        if not docstring:
-            return {}
-
-        assert yaml is not None, "`pyyaml` must be installed to use parse_docstring."
-
-        # We support having regular docstrings before the schema
-        # definition. Here we return just the schema part from
-        # the docstring.
-        docstring = docstring.split("---")[-1]
-
-        parsed = yaml.safe_load(docstring)
-
-        if not isinstance(parsed, dict):
-            # A regular docstring (not yaml formatted) can return
-            # a simple string here, which wouldn't follow the schema.
-            return {}
-
-        return parsed
-
-    def OpenAPIResponse(self, request: Request) -> Response:
-        routes = request.app.routes
-        schema = self.get_schema(routes=routes)
-        return OpenAPIResponse(schema)
-
-
-class SchemaGenerator(BaseSchemaGenerator):
-    def __init__(self, base_schema: typing.Dict[str, typing.Any]) -> None:
-        self.base_schema = base_schema
-
-    def get_schema(
-        self, routes: typing.List[BaseRoute]
-    ) -> typing.Dict[str, typing.Any]:
-        schema = dict(self.base_schema)
-        schema.setdefault("paths", {})
-        endpoints_info = self.get_endpoints(routes)
-
-        for endpoint in endpoints_info:
-            parsed = self.parse_docstring(endpoint.func)
-
-            if not parsed:
-                continue
-
-            if endpoint.path not in schema["paths"]:
-                schema["paths"][endpoint.path] = {}
-
-            schema["paths"][endpoint.path][endpoint.http_method] = parsed
-
-        return schema

prefect/_vendor/starlette/staticfiles.py

@@ -1,248 +0,0 @@
-import importlib.util
-import os
-import re
-import stat
-import typing
-from email.utils import parsedate
-
-import anyio
-from prefect._vendor.starlette.datastructures import URL, Headers
-from prefect._vendor.starlette.exceptions import HTTPException
-from prefect._vendor.starlette.responses import FileResponse, RedirectResponse, Response
-from prefect._vendor.starlette.types import Receive, Scope, Send
-
-PathLike = typing.Union[str, "os.PathLike[str]"]
-
-
-class NotModifiedResponse(Response):
-    NOT_MODIFIED_HEADERS = (
-        "cache-control",
-        "content-location",
-        "date",
-        "etag",
-        "expires",
-        "vary",
-    )
-
-    def __init__(self, headers: Headers):
-        super().__init__(
-            status_code=304,
-            headers={
-                name: value
-                for name, value in headers.items()
-                if name in self.NOT_MODIFIED_HEADERS
-            },
-        )
-
-
-class StaticFiles:
-    def __init__(
-        self,
-        *,
-        directory: typing.Optional[PathLike] = None,
-        packages: typing.Optional[
-            typing.List[typing.Union[str, typing.Tuple[str, str]]]
-        ] = None,
-        html: bool = False,
-        check_dir: bool = True,
-        follow_symlink: bool = False,
-    ) -> None:
-        self.directory = directory
-        self.packages = packages
-        self.all_directories = self.get_directories(directory, packages)
-        self.html = html
-        self.config_checked = False
-        self.follow_symlink = follow_symlink
-        if check_dir and directory is not None and not os.path.isdir(directory):
-            raise RuntimeError(f"Directory '{directory}' does not exist")
-
-    def get_directories(
-        self,
-        directory: typing.Optional[PathLike] = None,
-        packages: typing.Optional[
-            typing.List[typing.Union[str, typing.Tuple[str, str]]]
-        ] = None,
-    ) -> typing.List[PathLike]:
-        """
-        Given `directory` and `packages` arguments, return a list of all the
-        directories that should be used for serving static files from.
-        """
-        directories = []
-        if directory is not None:
-            directories.append(directory)
-
-        for package in packages or []:
-            if isinstance(package, tuple):
-                package, statics_dir = package
-            else:
-                statics_dir = "statics"
-            spec = importlib.util.find_spec(package)
-            assert spec is not None, f"Package {package!r} could not be found."
-            assert spec.origin is not None, f"Package {package!r} could not be found."
-            package_directory = os.path.normpath(
-                os.path.join(spec.origin, "..", statics_dir)
-            )
-            assert os.path.isdir(
-                package_directory
-            ), f"Directory '{statics_dir!r}' in package {package!r} could not be found."
-            directories.append(package_directory)
-
-        return directories
-
-    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
-        """
-        The ASGI entry point.
-        """
-        assert scope["type"] == "http"
-
-        if not self.config_checked:
-            await self.check_config()
-            self.config_checked = True
-
-        path = self.get_path(scope)
-        response = await self.get_response(path, scope)
-        await response(scope, receive, send)
-
-    def get_path(self, scope: Scope) -> str:
-        """
-        Given the ASGI scope, return the `path` string to serve up,
-        with OS specific path separators, and any '..', '.' components removed.
-        """
-        root_path = scope.get("route_root_path", scope.get("root_path", ""))
-        path = scope.get("route_path", re.sub(r"^" + root_path, "", scope["path"]))
-        return os.path.normpath(os.path.join(*path.split("/")))  # type: ignore[no-any-return]  # noqa: E501
-
-    async def get_response(self, path: str, scope: Scope) -> Response:
-        """
-        Returns an HTTP response, given the incoming path, method and request headers.
-        """
-        if scope["method"] not in ("GET", "HEAD"):
-            raise HTTPException(status_code=405)
-
-        try:
-            full_path, stat_result = await anyio.to_thread.run_sync(
-                self.lookup_path, path
-            )
-        except PermissionError:
-            raise HTTPException(status_code=401)
-        except OSError:
-            raise
-
-        if stat_result and stat.S_ISREG(stat_result.st_mode):
-            # We have a static file to serve.
-            return self.file_response(full_path, stat_result, scope)
-
-        elif stat_result and stat.S_ISDIR(stat_result.st_mode) and self.html:
-            # We're in HTML mode, and have got a directory URL.
-            # Check if we have 'index.html' file to serve.
-            index_path = os.path.join(path, "index.html")
-            full_path, stat_result = await anyio.to_thread.run_sync(
-                self.lookup_path, index_path
-            )
-            if stat_result is not None and stat.S_ISREG(stat_result.st_mode):
-                if not scope["path"].endswith("/"):
-                    # Directory URLs should redirect to always end in "/".
-                    url = URL(scope=scope)
-                    url = url.replace(path=url.path + "/")
-                    return RedirectResponse(url=url)
-                return self.file_response(full_path, stat_result, scope)
-
-        if self.html:
-            # Check for '404.html' if we're in HTML mode.
-            full_path, stat_result = await anyio.to_thread.run_sync(
-                self.lookup_path, "404.html"
-            )
-            if stat_result and stat.S_ISREG(stat_result.st_mode):
-                return FileResponse(
-                    full_path,
-                    stat_result=stat_result,
-                    method=scope["method"],
-                    status_code=404,
-                )
-        raise HTTPException(status_code=404)
-
-    def lookup_path(
-        self, path: str
-    ) -> typing.Tuple[str, typing.Optional[os.stat_result]]:
-        for directory in self.all_directories:
-            joined_path = os.path.join(directory, path)
-            if self.follow_symlink:
-                full_path = os.path.abspath(joined_path)
-            else:
-                full_path = os.path.realpath(joined_path)
-            directory = os.path.realpath(directory)
-            if os.path.commonpath([full_path, directory]) != directory:
-                # Don't allow misbehaving clients to break out of the static files
-                # directory.
-                continue
-            try:
-                return full_path, os.stat(full_path)
-            except (FileNotFoundError, NotADirectoryError):
-                continue
-        return "", None
-
-    def file_response(
-        self,
-        full_path: PathLike,
-        stat_result: os.stat_result,
-        scope: Scope,
-        status_code: int = 200,
-    ) -> Response:
-        method = scope["method"]
-        request_headers = Headers(scope=scope)
-
-        response = FileResponse(
-            full_path, status_code=status_code, stat_result=stat_result, method=method
-        )
-        if self.is_not_modified(response.headers, request_headers):
-            return NotModifiedResponse(response.headers)
-        return response
-
-    async def check_config(self) -> None:
-        """
-        Perform a one-off configuration check that StaticFiles is actually
-        pointed at a directory, so that we can raise loud errors rather than
-        just returning 404 responses.
-        """
-        if self.directory is None:
-            return
-
-        try:
-            stat_result = await anyio.to_thread.run_sync(os.stat, self.directory)
-        except FileNotFoundError:
-            raise RuntimeError(
-                f"StaticFiles directory '{self.directory}' does not exist."
-            )
-        if not (stat.S_ISDIR(stat_result.st_mode) or stat.S_ISLNK(stat_result.st_mode)):
-            raise RuntimeError(
-                f"StaticFiles path '{self.directory}' is not a directory."
-            )
-
-    def is_not_modified(
-        self, response_headers: Headers, request_headers: Headers
-    ) -> bool:
-        """
-        Given the request and response headers, return `True` if an HTTP
-        "Not Modified" response could be returned instead.
-        """
-        try:
-            if_none_match = request_headers["if-none-match"]
-            etag = response_headers["etag"]
-            if if_none_match == etag:
-                return True
-        except KeyError:
-            pass
-
-        try:
-            if_modified_since = parsedate(request_headers["if-modified-since"])
-            last_modified = parsedate(response_headers["last-modified"])
-            if (
-                if_modified_since is not None
-                and last_modified is not None
-                and if_modified_since >= last_modified
-            ):
-                return True
-        except KeyError:
-            pass
-
-        return False

prefect/_vendor/starlette/status.py

@@ -1,199 +0,0 @@
-"""
-HTTP codes
-See HTTP Status Code Registry:
-https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
-
-And RFC 2324 - https://tools.ietf.org/html/rfc2324
-"""
-import warnings
-from typing import List
-
-__all__ = (
-    "HTTP_100_CONTINUE",
-    "HTTP_101_SWITCHING_PROTOCOLS",
-    "HTTP_102_PROCESSING",
-    "HTTP_103_EARLY_HINTS",
-    "HTTP_200_OK",
-    "HTTP_201_CREATED",
-    "HTTP_202_ACCEPTED",
-    "HTTP_203_NON_AUTHORITATIVE_INFORMATION",
-    "HTTP_204_NO_CONTENT",
-    "HTTP_205_RESET_CONTENT",
-    "HTTP_206_PARTIAL_CONTENT",
-    "HTTP_207_MULTI_STATUS",
-    "HTTP_208_ALREADY_REPORTED",
-    "HTTP_226_IM_USED",
-    "HTTP_300_MULTIPLE_CHOICES",
-    "HTTP_301_MOVED_PERMANENTLY",
-    "HTTP_302_FOUND",
-    "HTTP_303_SEE_OTHER",
-    "HTTP_304_NOT_MODIFIED",
-    "HTTP_305_USE_PROXY",
-    "HTTP_306_RESERVED",
-    "HTTP_307_TEMPORARY_REDIRECT",
-    "HTTP_308_PERMANENT_REDIRECT",
-    "HTTP_400_BAD_REQUEST",
-    "HTTP_401_UNAUTHORIZED",
-    "HTTP_402_PAYMENT_REQUIRED",
-    "HTTP_403_FORBIDDEN",
-    "HTTP_404_NOT_FOUND",
-    "HTTP_405_METHOD_NOT_ALLOWED",
-    "HTTP_406_NOT_ACCEPTABLE",
-    "HTTP_407_PROXY_AUTHENTICATION_REQUIRED",
-    "HTTP_408_REQUEST_TIMEOUT",
-    "HTTP_409_CONFLICT",
-    "HTTP_410_GONE",
-    "HTTP_411_LENGTH_REQUIRED",
-    "HTTP_412_PRECONDITION_FAILED",
-    "HTTP_413_REQUEST_ENTITY_TOO_LARGE",
-    "HTTP_414_REQUEST_URI_TOO_LONG",
-    "HTTP_415_UNSUPPORTED_MEDIA_TYPE",
-    "HTTP_416_REQUESTED_RANGE_NOT_SATISFIABLE",
-    "HTTP_417_EXPECTATION_FAILED",
-    "HTTP_418_IM_A_TEAPOT",
-    "HTTP_421_MISDIRECTED_REQUEST",
-    "HTTP_422_UNPROCESSABLE_ENTITY",
-    "HTTP_423_LOCKED",
-    "HTTP_424_FAILED_DEPENDENCY",
-    "HTTP_425_TOO_EARLY",
-    "HTTP_426_UPGRADE_REQUIRED",
-    "HTTP_428_PRECONDITION_REQUIRED",
-    "HTTP_429_TOO_MANY_REQUESTS",
-    "HTTP_431_REQUEST_HEADER_FIELDS_TOO_LARGE",
-    "HTTP_451_UNAVAILABLE_FOR_LEGAL_REASONS",
-    "HTTP_500_INTERNAL_SERVER_ERROR",
-    "HTTP_501_NOT_IMPLEMENTED",
-    "HTTP_502_BAD_GATEWAY",
-    "HTTP_503_SERVICE_UNAVAILABLE",
-    "HTTP_504_GATEWAY_TIMEOUT",
-    "HTTP_505_HTTP_VERSION_NOT_SUPPORTED",
-    "HTTP_506_VARIANT_ALSO_NEGOTIATES",
-    "HTTP_507_INSUFFICIENT_STORAGE",
-    "HTTP_508_LOOP_DETECTED",
-    "HTTP_510_NOT_EXTENDED",
-    "HTTP_511_NETWORK_AUTHENTICATION_REQUIRED",
-    "WS_1000_NORMAL_CLOSURE",
-    "WS_1001_GOING_AWAY",
-    "WS_1002_PROTOCOL_ERROR",
-    "WS_1003_UNSUPPORTED_DATA",
-    "WS_1005_NO_STATUS_RCVD",
-    "WS_1006_ABNORMAL_CLOSURE",
-    "WS_1007_INVALID_FRAME_PAYLOAD_DATA",
-    "WS_1008_POLICY_VIOLATION",
-    "WS_1009_MESSAGE_TOO_BIG",
-    "WS_1010_MANDATORY_EXT",
-    "WS_1011_INTERNAL_ERROR",
-    "WS_1012_SERVICE_RESTART",
-    "WS_1013_TRY_AGAIN_LATER",
-    "WS_1014_BAD_GATEWAY",
-    "WS_1015_TLS_HANDSHAKE",
-)
-
-HTTP_100_CONTINUE = 100
-HTTP_101_SWITCHING_PROTOCOLS = 101
-HTTP_102_PROCESSING = 102
-HTTP_103_EARLY_HINTS = 103
-HTTP_200_OK = 200
-HTTP_201_CREATED = 201
-HTTP_202_ACCEPTED = 202
-HTTP_203_NON_AUTHORITATIVE_INFORMATION = 203
-HTTP_204_NO_CONTENT = 204
-HTTP_205_RESET_CONTENT = 205
-HTTP_206_PARTIAL_CONTENT = 206
-HTTP_207_MULTI_STATUS = 207
-HTTP_208_ALREADY_REPORTED = 208
-HTTP_226_IM_USED = 226
-HTTP_300_MULTIPLE_CHOICES = 300
-HTTP_301_MOVED_PERMANENTLY = 301
-HTTP_302_FOUND = 302
-HTTP_303_SEE_OTHER = 303
-HTTP_304_NOT_MODIFIED = 304
-HTTP_305_USE_PROXY = 305
-HTTP_306_RESERVED = 306
-HTTP_307_TEMPORARY_REDIRECT = 307
-HTTP_308_PERMANENT_REDIRECT = 308
-HTTP_400_BAD_REQUEST = 400
-HTTP_401_UNAUTHORIZED = 401
-HTTP_402_PAYMENT_REQUIRED = 402
-HTTP_403_FORBIDDEN = 403
-HTTP_404_NOT_FOUND = 404
-HTTP_405_METHOD_NOT_ALLOWED = 405
-HTTP_406_NOT_ACCEPTABLE = 406
-HTTP_407_PROXY_AUTHENTICATION_REQUIRED = 407
-HTTP_408_REQUEST_TIMEOUT = 408
-HTTP_409_CONFLICT = 409
-HTTP_410_GONE = 410
-HTTP_411_LENGTH_REQUIRED = 411
-HTTP_412_PRECONDITION_FAILED = 412
-HTTP_413_REQUEST_ENTITY_TOO_LARGE = 413
-HTTP_414_REQUEST_URI_TOO_LONG = 414
-HTTP_415_UNSUPPORTED_MEDIA_TYPE = 415
-HTTP_416_REQUESTED_RANGE_NOT_SATISFIABLE = 416
-HTTP_417_EXPECTATION_FAILED = 417
-HTTP_418_IM_A_TEAPOT = 418
-HTTP_421_MISDIRECTED_REQUEST = 421
-HTTP_422_UNPROCESSABLE_ENTITY = 422
-HTTP_423_LOCKED = 423
-HTTP_424_FAILED_DEPENDENCY = 424
-HTTP_425_TOO_EARLY = 425
-HTTP_426_UPGRADE_REQUIRED = 426
-HTTP_428_PRECONDITION_REQUIRED = 428
-HTTP_429_TOO_MANY_REQUESTS = 429
-HTTP_431_REQUEST_HEADER_FIELDS_TOO_LARGE = 431
-HTTP_451_UNAVAILABLE_FOR_LEGAL_REASONS = 451
-HTTP_500_INTERNAL_SERVER_ERROR = 500
-HTTP_501_NOT_IMPLEMENTED = 501
-HTTP_502_BAD_GATEWAY = 502
-HTTP_503_SERVICE_UNAVAILABLE = 503
-HTTP_504_GATEWAY_TIMEOUT = 504
-HTTP_505_HTTP_VERSION_NOT_SUPPORTED = 505
-HTTP_506_VARIANT_ALSO_NEGOTIATES = 506
-HTTP_507_INSUFFICIENT_STORAGE = 507
-HTTP_508_LOOP_DETECTED = 508
-HTTP_510_NOT_EXTENDED = 510
-HTTP_511_NETWORK_AUTHENTICATION_REQUIRED = 511
-
-
-"""
-WebSocket codes
-https://www.iana.org/assignments/websocket/websocket.xml#close-code-number
-https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent
-"""
-WS_1000_NORMAL_CLOSURE = 1000
-WS_1001_GOING_AWAY = 1001
-WS_1002_PROTOCOL_ERROR = 1002
-WS_1003_UNSUPPORTED_DATA = 1003
-WS_1005_NO_STATUS_RCVD = 1005
-WS_1006_ABNORMAL_CLOSURE = 1006
-WS_1007_INVALID_FRAME_PAYLOAD_DATA = 1007
-WS_1008_POLICY_VIOLATION = 1008
-WS_1009_MESSAGE_TOO_BIG = 1009
-WS_1010_MANDATORY_EXT = 1010
-WS_1011_INTERNAL_ERROR = 1011
-WS_1012_SERVICE_RESTART = 1012
-WS_1013_TRY_AGAIN_LATER = 1013
-WS_1014_BAD_GATEWAY = 1014
-WS_1015_TLS_HANDSHAKE = 1015
-
-
-__deprecated__ = {"WS_1004_NO_STATUS_RCVD": 1004, "WS_1005_ABNORMAL_CLOSURE": 1005}
-
-
-def __getattr__(name: str) -> int:
-    deprecation_changes = {
-        "WS_1004_NO_STATUS_RCVD": "WS_1005_NO_STATUS_RCVD",
-        "WS_1005_ABNORMAL_CLOSURE": "WS_1006_ABNORMAL_CLOSURE",
-    }
-    deprecated = __deprecated__.get(name)
-    if deprecated:
-        warnings.warn(
-            f"'{name}' is deprecated. Use '{deprecation_changes[name]}' instead.",
-            category=DeprecationWarning,
-            stacklevel=3,
-        )
-        return deprecated
-    raise AttributeError(f"module '{__name__}' has no attribute '{name}'")
-
-
-def __dir__() -> List[str]:
-    return sorted(list(__all__) + list(__deprecated__.keys()))  # pragma: no cover