wellapi 0.2.1__py3-none-any.whl

wellapi/cli/main.py

@@ -0,0 +1,67 @@
+import json
+
+import click
+
+from wellapi import WellApi
+from wellapi.local.server import run_local_server
+from wellapi.openapi.utils import get_openapi
+from wellapi.utils import import_app, load_handlers
+
+# ruff: noqa: W291
+WELLAPI_ACII = """
+ _     _  _______  ___      ___        _______  _______  ___  
+| | _ | ||       ||   |    |   |      |   _   ||       ||   | 
+| || || ||    ___||   |    |   |      |  |_|  ||    _  ||   | 
+|       ||   |___ |   |    |   |      |       ||   |_| ||   | 
+|       ||    ___||   |___ |   |___   |       ||    ___||   | 
+|   _   ||   |___ |       ||       |  |   _   ||   |    |   | 
+|__| |__||_______||_______||_______|  |__| |__||___|    |___| 
+"""
+
+
+@click.group()
+def cli():
+    click.echo(click.style(WELLAPI_ACII, fg="magenta"))
+
+
+@cli.command()
+@click.argument("app_srt", default="main:app")
+@click.argument(
+    "handlers_dir", default="handlers", type=click.Path(exists=True, resolve_path=True)
+)
+def build(app_srt: str, handlers_dir: str):
+    app: WellApi = import_app(app_srt)
+    load_handlers(handlers_dir)
+
+    resp = get_openapi(
+        title=app.title,
+        version=app.version,
+        openapi_version="3.0.1",
+        description=app.description,
+        lambdas=app.lambdas,
+        tags=app.openapi_tags,
+        servers=app.servers,
+    )
+
+    with open("openapi.json", "w") as f:
+        json.dump(resp, f)
+
+
+@cli.command()
+@click.argument("app_srt", default="main:app")
+@click.argument(
+    "handlers_dir", default="handlers", type=click.Path(exists=True, resolve_path=True)
+)
+@click.option("--host", default="127.0.0.1")
+@click.option("--port", default=8000, type=click.INT)
+@click.option(
+    "--autoreload/--no-autoreload",
+    default=True,
+    help="Automatically restart server when code changes.",
+)
+def run(app_srt: str, handlers_dir: str, host="127.0.0.1", port=8000, autoreload=True):
+    run_local_server(app_srt, handlers_dir, host, port, autoreload)
+
+
+if __name__ == "__main__":
+    cli()

wellapi/convertors.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+
+import math
+import typing
+import uuid
+
+T = typing.TypeVar("T")
+
+
+class Convertor(typing.Generic[T]):
+    regex: typing.ClassVar[str] = ""
+
+    def convert(self, value: str) -> T:
+        raise NotImplementedError()  # pragma: no cover
+
+    def to_string(self, value: T) -> str:
+        raise NotImplementedError()  # pragma: no cover
+
+
+class StringConvertor(Convertor[str]):
+    regex = "[^/]+"
+
+    def convert(self, value: str) -> str:
+        return value
+
+    def to_string(self, value: str) -> str:
+        value = str(value)
+        assert "/" not in value, "May not contain path separators"
+        assert value, "Must not be empty"
+        return value
+
+
+class PathConvertor(Convertor[str]):
+    regex = ".*"
+
+    def convert(self, value: str) -> str:
+        return str(value)
+
+    def to_string(self, value: str) -> str:
+        return str(value)
+
+
+class IntegerConvertor(Convertor[int]):
+    regex = "[0-9]+"
+
+    def convert(self, value: str) -> int:
+        return int(value)
+
+    def to_string(self, value: int) -> str:
+        value = int(value)
+        assert value >= 0, "Negative integers are not supported"
+        return str(value)
+
+
+class FloatConvertor(Convertor[float]):
+    regex = r"[0-9]+(\.[0-9]+)?"
+
+    def convert(self, value: str) -> float:
+        return float(value)
+
+    def to_string(self, value: float) -> str:
+        value = float(value)
+        assert value >= 0.0, "Negative floats are not supported"
+        assert not math.isnan(value), "NaN values are not supported"
+        assert not math.isinf(value), "Infinite values are not supported"
+        return ("%0.20f" % value).rstrip("0").rstrip(".")  # noqa: UP031
+
+
+class UUIDConvertor(Convertor[uuid.UUID]):
+    regex = "[0-9a-fA-F]{8}-?[0-9a-fA-F]{4}-?[0-9a-fA-F]{4}-?[0-9a-fA-F]{4}-?[0-9a-fA-F]{12}"
+
+    def convert(self, value: str) -> uuid.UUID:
+        return uuid.UUID(value)
+
+    def to_string(self, value: uuid.UUID) -> str:
+        return str(value)
+
+
+CONVERTOR_TYPES: dict[str, Convertor[typing.Any]] = {
+    "str": StringConvertor(),
+    "path": PathConvertor(),
+    "int": IntegerConvertor(),
+    "float": FloatConvertor(),
+    "uuid": UUIDConvertor(),
+}
+
+
+def register_url_convertor(key: str, convertor: Convertor[typing.Any]) -> None:
+    CONVERTOR_TYPES[key] = convertor

wellapi/datastructures.py

@@ -0,0 +1,383 @@
+import typing
+from urllib.parse import parse_qsl, urlencode
+
+_KeyType = typing.TypeVar("_KeyType")
+# Mapping keys are invariant but their values are covariant since
+# you can only read them
+# that is, you can't do `Mapping[str, Animal]()["fido"] = Dog()`
+_CovariantValueType = typing.TypeVar("_CovariantValueType", covariant=True)
+
+
+class ImmutableMultiDict(typing.Mapping[_KeyType, _CovariantValueType]):
+    _dict: dict[_KeyType, _CovariantValueType]
+
+    def __init__(
+        self,
+        *args: "ImmutableMultiDict[_KeyType, _CovariantValueType]"
+        | typing.Mapping[_KeyType, _CovariantValueType]
+        | typing.Iterable[tuple[_KeyType, _CovariantValueType]],
+        **kwargs: typing.Any,
+    ) -> None:
+        assert len(args) < 2, "Too many arguments."
+
+        value: typing.Any = args[0] if args else []
+        if kwargs:
+            value = (
+                ImmutableMultiDict(value).multi_items()
+                + ImmutableMultiDict(kwargs).multi_items()
+            )
+
+        if not value:
+            _items: list[tuple[typing.Any, typing.Any]] = []
+        elif hasattr(value, "multi_items"):
+            value = typing.cast(
+                ImmutableMultiDict[_KeyType, _CovariantValueType], value
+            )
+            _items = list(value.multi_items())
+        elif hasattr(value, "items"):
+            value = typing.cast(typing.Mapping[_KeyType, _CovariantValueType], value)
+            _items = list(value.items())
+        else:
+            value = typing.cast("list[tuple[typing.Any, typing.Any]]", value)
+            _items = list(value)
+
+        self._dict = dict(_items)
+        self._list = _items
+
+    def getlist(self, key: typing.Any) -> list[_CovariantValueType]:
+        return [item_value for item_key, item_value in self._list if item_key == key]
+
+    def keys(self) -> typing.KeysView[_KeyType]:
+        return self._dict.keys()
+
+    def values(self) -> typing.ValuesView[_CovariantValueType]:
+        return self._dict.values()
+
+    def items(self) -> typing.ItemsView[_KeyType, _CovariantValueType]:
+        return self._dict.items()
+
+    def multi_items(self) -> list[tuple[_KeyType, _CovariantValueType]]:
+        return list(self._list)
+
+    def __getitem__(self, key: _KeyType) -> _CovariantValueType:
+        return self._dict[key]
+
+    def __contains__(self, key: typing.Any) -> bool:
+        return key in self._dict
+
+    def __iter__(self) -> typing.Iterator[_KeyType]:
+        return iter(self.keys())
+
+    def __len__(self) -> int:
+        return len(self._dict)
+
+    def __eq__(self, other: typing.Any) -> bool:
+        if not isinstance(other, self.__class__):
+            return False
+        return sorted(self._list) == sorted(other._list)
+
+    def __repr__(self) -> str:
+        class_name = self.__class__.__name__
+        items = self.multi_items()
+        return f"{class_name}({items!r})"
+
+
+class MultiDict(ImmutableMultiDict[typing.Any, typing.Any]):
+    def __setitem__(self, key: typing.Any, value: typing.Any) -> None:
+        self.setlist(key, [value])
+
+    def __delitem__(self, key: typing.Any) -> None:
+        self._list = [(k, v) for k, v in self._list if k != key]
+        del self._dict[key]
+
+    def pop(self, key: typing.Any, default: typing.Any = None) -> typing.Any:
+        self._list = [(k, v) for k, v in self._list if k != key]
+        return self._dict.pop(key, default)
+
+    def popitem(self) -> tuple[typing.Any, typing.Any]:
+        key, value = self._dict.popitem()
+        self._list = [(k, v) for k, v in self._list if k != key]
+        return key, value
+
+    def poplist(self, key: typing.Any) -> list[typing.Any]:
+        values = [v for k, v in self._list if k == key]
+        self.pop(key)
+        return values
+
+    def clear(self) -> None:
+        self._dict.clear()
+        self._list.clear()
+
+    def setdefault(self, key: typing.Any, default: typing.Any = None) -> typing.Any:
+        if key not in self:
+            self._dict[key] = default
+            self._list.append((key, default))
+
+        return self[key]
+
+    def setlist(self, key: typing.Any, values: list[typing.Any]) -> None:
+        if not values:
+            self.pop(key, None)
+        else:
+            existing_items = [(k, v) for (k, v) in self._list if k != key]
+            self._list = existing_items + [(key, value) for value in values]
+            self._dict[key] = values[-1]
+
+    def append(self, key: typing.Any, value: typing.Any) -> None:
+        self._list.append((key, value))
+        self._dict[key] = value
+
+    def update(
+        self,
+        *args: "MultiDict"
+        | typing.Mapping[typing.Any, typing.Any]
+        | list[tuple[typing.Any, typing.Any]],
+        **kwargs: typing.Any,
+    ) -> None:
+        value = MultiDict(*args, **kwargs)
+        existing_items = [(k, v) for (k, v) in self._list if k not in value.keys()]
+        self._list = existing_items + value.multi_items()
+        self._dict.update(value)
+
+
+class QueryParams(ImmutableMultiDict[str, str]):
+    """
+    An immutable multidict.
+    """
+
+    def __init__(
+        self,
+        *args: ImmutableMultiDict[typing.Any, typing.Any]
+        | typing.Mapping[typing.Any, typing.Any]
+        | list[tuple[typing.Any, typing.Any]]
+        | str
+        | bytes,
+        **kwargs: typing.Any,
+    ) -> None:
+        assert len(args) < 2, "Too many arguments."
+
+        value = args[0] if args else []
+
+        if isinstance(value, str):
+            super().__init__(parse_qsl(value, keep_blank_values=True), **kwargs)
+        elif isinstance(value, bytes):
+            super().__init__(
+                parse_qsl(value.decode("latin-1"), keep_blank_values=True), **kwargs
+            )
+        else:
+            super().__init__(*args, **kwargs)  # type: ignore[arg-type]
+        self._list = [(str(k), str(v)) for k, v in self._list]
+        self._dict = {str(k): str(v) for k, v in self._dict.items()}
+
+    def __str__(self) -> str:
+        return urlencode(self._list)
+
+    def __repr__(self) -> str:
+        class_name = self.__class__.__name__
+        query_string = str(self)
+        return f"{class_name}({query_string!r})"
+
+
+class Headers(typing.Mapping[str, str]):
+    """
+    An immutable, case-insensitive multidict.
+    """
+
+    def __init__(
+        self,
+        headers: typing.Mapping[str, str] | None = None,
+        raw: list[tuple[bytes, bytes]] | None = None,
+        scope: typing.MutableMapping[str, typing.Any] | None = None,
+    ) -> None:
+        self._list: list[tuple[bytes, bytes]] = []
+        if headers is not None:
+            assert raw is None, 'Cannot set both "headers" and "raw".'
+            assert scope is None, 'Cannot set both "headers" and "scope".'
+            self._list = [
+                (key.lower().encode("latin-1"), value.encode("latin-1"))
+                for key, value in headers.items()
+            ]
+        elif raw is not None:
+            assert scope is None, 'Cannot set both "raw" and "scope".'
+            self._list = raw
+        elif scope is not None:
+            # scope["headers"] isn't necessarily a list
+            # it might be a tuple or other iterable
+            self._list = scope["headers"] = list(scope["headers"])
+
+    @property
+    def raw(self) -> list[tuple[bytes, bytes]]:
+        return list(self._list)
+
+    def keys(self) -> list[str]:  # type: ignore[override]
+        return [key.decode("latin-1") for key, value in self._list]
+
+    def values(self) -> list[str]:  # type: ignore[override]
+        return [value.decode("latin-1") for key, value in self._list]
+
+    def items(self) -> list[tuple[str, str]]:  # type: ignore[override]
+        return [
+            (key.decode("latin-1"), value.decode("latin-1"))
+            for key, value in self._list
+        ]
+
+    def getlist(self, key: str) -> list[str]:
+        get_header_key = key.lower().encode("latin-1")
+        return [
+            item_value.decode("latin-1")
+            for item_key, item_value in self._list
+            if item_key == get_header_key
+        ]
+
+    def mutablecopy(self) -> "MutableHeaders":
+        return MutableHeaders(raw=self._list[:])
+
+    def __getitem__(self, key: str) -> str:
+        get_header_key = key.lower().encode("latin-1")
+        for header_key, header_value in self._list:
+            if header_key == get_header_key:
+                return header_value.decode("latin-1")
+        raise KeyError(key)
+
+    def __contains__(self, key: typing.Any) -> bool:
+        get_header_key = key.lower().encode("latin-1")
+        for header_key, _header_value in self._list:
+            if header_key == get_header_key:
+                return True
+        return False
+
+    def __iter__(self) -> typing.Iterator[typing.Any]:
+        return iter(self.keys())
+
+    def __len__(self) -> int:
+        return len(self._list)
+
+    def __eq__(self, other: typing.Any) -> bool:
+        if not isinstance(other, Headers):
+            return False
+        return sorted(self._list) == sorted(other._list)
+
+    def __repr__(self) -> str:
+        class_name = self.__class__.__name__
+        as_dict = dict(self.items())
+        if len(as_dict) == len(self):
+            return f"{class_name}({as_dict!r})"
+        return f"{class_name}(raw={self.raw!r})"
+
+
+class MutableHeaders(Headers):
+    def __setitem__(self, key: str, value: str) -> None:
+        """
+        Set the header `key` to `value`, removing any duplicate entries.
+        Retains insertion order.
+        """
+        set_key = key.lower().encode("latin-1")
+        set_value = value.encode("latin-1")
+
+        found_indexes: list[int] = []
+        for idx, (item_key, _item_value) in enumerate(self._list):
+            if item_key == set_key:
+                found_indexes.append(idx)
+
+        for idx in reversed(found_indexes[1:]):
+            del self._list[idx]
+
+        if found_indexes:
+            idx = found_indexes[0]
+            self._list[idx] = (set_key, set_value)
+        else:
+            self._list.append((set_key, set_value))
+
+    def __delitem__(self, key: str) -> None:
+        """
+        Remove the header `key`.
+        """
+        del_key = key.lower().encode("latin-1")
+
+        pop_indexes: list[int] = []
+        for idx, (item_key, _item_value) in enumerate(self._list):
+            if item_key == del_key:
+                pop_indexes.append(idx)
+
+        for idx in reversed(pop_indexes):
+            del self._list[idx]
+
+    def __ior__(self, other: typing.Mapping[str, str]) -> "MutableHeaders":
+        if not isinstance(other, typing.Mapping):
+            raise TypeError(f"Expected a mapping but got {other.__class__.__name__}")
+        self.update(other)
+        return self
+
+    def __or__(self, other: typing.Mapping[str, str]) -> "MutableHeaders":
+        if not isinstance(other, typing.Mapping):
+            raise TypeError(f"Expected a mapping but got {other.__class__.__name__}")
+        new = self.mutablecopy()
+        new.update(other)
+        return new
+
+    @property
+    def raw(self) -> list[tuple[bytes, bytes]]:
+        return self._list
+
+    def setdefault(self, key: str, value: str) -> str:
+        """
+        If the header `key` does not exist, then set it to `value`.
+        Returns the header value.
+        """
+        set_key = key.lower().encode("latin-1")
+        set_value = value.encode("latin-1")
+
+        for _idx, (item_key, item_value) in enumerate(self._list):
+            if item_key == set_key:
+                return item_value.decode("latin-1")
+        self._list.append((set_key, set_value))
+        return value
+
+    def update(self, other: typing.Mapping[str, str]) -> None:
+        for key, val in other.items():
+            self[key] = val
+
+    def append(self, key: str, value: str) -> None:
+        """
+        Append a header, preserving any duplicate entries.
+        """
+        append_key = key.lower().encode("latin-1")
+        append_value = value.encode("latin-1")
+        self._list.append((append_key, append_value))
+
+    def add_vary_header(self, vary: str) -> None:
+        existing = self.get("vary")
+        if existing is not None:
+            vary = ", ".join([existing, vary])
+        self["vary"] = vary
+
+
+class DefaultPlaceholder:
+    """
+    You shouldn't use this class directly.
+
+    It's used internally to recognize when a default value has been overwritten, even
+    if the overridden default value was truthy.
+    """
+
+    def __init__(self, value: typing.Any):
+        self.value = value
+
+    def __bool__(self) -> bool:
+        return bool(self.value)
+
+    def __eq__(self, o: object) -> bool:
+        return isinstance(o, DefaultPlaceholder) and o.value == self.value
+
+
+DefaultType = typing.TypeVar("DefaultType")
+
+
+def Default(value: DefaultType) -> DefaultType:
+    """
+    You shouldn't use this function directly.
+
+    It's used internally to recognize when a default value has been overwritten, even
+    if the overridden default value was truthy.
+    """
+    return DefaultPlaceholder(value)  # type: ignore

wellapi/dependencies/models.py

@@ -0,0 +1,138 @@
+from collections.abc import Callable, Sequence
+from dataclasses import dataclass, field
+from typing import (
+    Annotated,
+    Any,
+    Literal,
+)
+
+from pydantic import TypeAdapter, ValidationError
+from pydantic.fields import FieldInfo
+from pydantic.main import IncEx
+from pydantic_core import PydanticUndefined
+
+from wellapi.security import SecurityBase
+
+
+def _regenerate_error_with_loc(
+    *, errors: Sequence[Any], loc_prefix: tuple[str | int, ...]
+) -> list[dict[str, Any]]:
+    updated_loc_errors: list[Any] = [
+        {**err, "loc": loc_prefix + err.get("loc", ())} for err in errors
+    ]
+
+    return updated_loc_errors
+
+
+@dataclass
+class ModelField:
+    field_info: FieldInfo
+    name: str
+    mode: Literal["validation", "serialization"] = "validation"
+
+    @property
+    def alias(self) -> str:
+        a = self.field_info.alias
+        return a if a is not None else self.name
+
+    @property
+    def required(self) -> bool:
+        return self.field_info.is_required()
+
+    @property
+    def default(self) -> Any:
+        return self.get_default()
+
+    @property
+    def type_(self) -> Any:
+        return self.field_info.annotation
+
+    def __post_init__(self) -> None:
+        self._type_adapter: TypeAdapter[Any] = TypeAdapter(
+            Annotated[self.field_info.annotation, self.field_info]
+        )
+
+    def get_default(self) -> Any:
+        if self.field_info.is_required():
+            return PydanticUndefined
+        return self.field_info.get_default(call_default_factory=True)
+
+    def validate(
+        self,
+        value: Any,
+        values: dict[str, Any] = {},  # noqa: B006
+        *,
+        loc: tuple[int | str, ...] = (),
+    ) -> tuple[Any, list[dict[str, Any]] | None]:
+        try:
+            return (
+                self._type_adapter.validate_python(value, from_attributes=True),
+                None,
+            )
+        except ValidationError as exc:
+            return None, _regenerate_error_with_loc(
+                errors=exc.errors(include_url=False), loc_prefix=loc
+            )
+
+    def serialize(
+        self,
+        value: Any,
+        *,
+        mode: Literal["json", "python"] = "json",
+        include: IncEx | None = None,
+        exclude: IncEx | None = None,
+        by_alias: bool = True,
+        exclude_unset: bool = False,
+        exclude_defaults: bool = False,
+        exclude_none: bool = False,
+    ) -> Any:
+        # What calls this code passes a value that already called
+        # self._type_adapter.validate_python(value)
+        return self._type_adapter.dump_python(
+            value,
+            mode=mode,
+            include=include,
+            exclude=exclude,
+            by_alias=by_alias,
+            exclude_unset=exclude_unset,
+            exclude_defaults=exclude_defaults,
+            exclude_none=exclude_none,
+        )
+
+    def __hash__(self) -> int:
+        # Each ModelField is unique for our purposes, to allow making a dict from
+        # ModelField to its JSON Schema.
+        return id(self)
+
+
+@dataclass
+class SecurityRequirement:
+    security_scheme: SecurityBase
+    scopes: Sequence[str] | None = None
+
+
+@dataclass
+class Dependant:
+    path_params: list[ModelField] = field(default_factory=list)
+    query_params: list[ModelField] = field(default_factory=list)
+    header_params: list[ModelField] = field(default_factory=list)
+    cookie_params: list[ModelField] = field(default_factory=list)
+    body_params: list[ModelField] = field(default_factory=list)
+    dependencies: list["Dependant"] = field(default_factory=list)
+    security_requirements: list[SecurityRequirement] = field(default_factory=list)
+    name: str | None = None
+    call: Callable[..., Any] | None = None
+    request_param_name: str | None = None
+    request_sqs_param_name: str | None = None
+    websocket_param_name: str | None = None
+    http_connection_param_name: str | None = None
+    response_param_name: str | None = None
+    background_tasks_param_name: str | None = None
+    security_scopes_param_name: str | None = None
+    security_scopes: list[str] | None = None
+    use_cache: bool = True
+    path: str | None = None
+    cache_key: tuple[Callable[..., Any] | None, tuple[str, ...]] = field(init=False)
+
+    def __post_init__(self) -> None:
+        self.cache_key = (self.call, tuple(sorted(set(self.security_scopes or []))))