kettu 0.1__tar.gz

kettu-0.1/MANIFEST.in

@@ -0,0 +1,8 @@
+graft src
+graft examples
+
+include *.rst
+include *.txt
+include pyproject.toml
+
+global-exclude __pycache__ *.py[cod] *~

kettu-0.1/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: kettu
+Version: 0.1
+Author-email: Souheil Chelfouh <trollfot@gmail.com>
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.10
+Requires-Dist: biscuits>=0.3.0
+Requires-Dist: frozendict
+Requires-Dist: langcodes
+Requires-Dist: multifruits>=0.1.5
+Requires-Dist: orjson
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pyhamcrest; extra == "test"
+Requires-Dist: webtest; extra == "test"

kettu-0.1/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "kettu"
+version = "0.1"
+authors = [
+    {name = "Souheil Chelfouh", email = "trollfot@gmail.com"},
+]
+requires-python = ">=3.10"
+classifiers = ["License :: OSI Approved :: MIT License"]
+dependencies = [
+  "biscuits >= 0.3.0",
+  "frozendict",
+  "langcodes",
+  "multifruits >= 0.1.5",
+  "orjson",
+]
+
+[project.optional-dependencies]
+test = [
+    "pytest",
+    "pyhamcrest",
+    "webtest",
+]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["kettu"]
+namespaces = false

kettu-0.1/requirements.txt

@@ -0,0 +1,2 @@
+-e git+https://github.com/WolfSGI/autorouting.git#egg=autorouting
+-e .

kettu-0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

kettu-0.1/src/kettu/constants.py

@@ -0,0 +1,25 @@
+from http import HTTPStatus
+
+
+REDIRECT_STATUSES = frozenset(
+    (
+        HTTPStatus.MULTIPLE_CHOICES,
+        HTTPStatus.MOVED_PERMANENTLY,
+        HTTPStatus.FOUND,
+        HTTPStatus.SEE_OTHER,
+        HTTPStatus.NOT_MODIFIED,
+        HTTPStatus.USE_PROXY,
+        HTTPStatus.TEMPORARY_REDIRECT,
+        HTTPStatus.PERMANENT_REDIRECT,
+    )
+)
+
+EMPTY_STATUSES = frozenset(
+    (
+        HTTPStatus.CONTINUE,
+        HTTPStatus.SWITCHING_PROTOCOLS,
+        HTTPStatus.PROCESSING,
+        HTTPStatus.NO_CONTENT,
+        HTTPStatus.NOT_MODIFIED,
+    )
+)

kettu-0.1/src/kettu/cors.py

@@ -0,0 +1,63 @@
+from dataclasses import dataclass
+from collections.abc import Iterator, Sequence
+from kettu.types import HTTPMethod
+
+
+Header = tuple[str, str]
+
+
+@dataclass
+class CORSPolicy:
+    origin: str = "*"
+    methods: Sequence[HTTPMethod] | None = None
+    allow_headers: Sequence[str] | None = None
+    expose_headers: Sequence[str] | None = None
+    credentials: bool | None = None
+    max_age: int | None = None
+
+    def headers(self) -> Iterator[Header]:
+        yield "Access-Control-Allow-Origin", self.origin
+        if self.methods is not None:
+            values = ", ".join(self.methods)
+            yield "Access-Control-Allow-Methods", values
+        if self.allow_headers is not None:
+            values = ", ".join(self.allow_headers)
+            yield "Access-Control-Allow-Headers", values
+        if self.expose_headers is not None:
+            values = ", ".join(self.expose_headers)
+            yield "Access-Control-Expose-Headers", values
+        if self.max_age is not None:
+            yield "Access-Control-Max-Age", str(self.max_age)
+        if self.credentials:
+            yield "Access-Control-Allow-Credentials", "true"
+
+    def preflight(
+        self,
+        origin: str | None = None,
+        acr_method: str | None = None,
+        acr_headers: str | None = None,
+    ) -> Iterator[Header]:
+        if origin:
+            if self.origin == "*":
+                yield "Access-Control-Allow-Origin", "*"
+            elif origin == self.origin:
+                yield "Access-Control-Allow-Origin", origin
+                yield "Vary", "Origin"
+            else:
+                yield "Access-Control-Allow-Origin", self.origin
+                yield "Vary", "Origin"
+
+        if self.methods is not None:
+            yield "Access-Control-Allow-Methods", ", ".join(self.methods)
+        elif acr_method:
+            yield "Access-Control-Allow-Methods", acr_method
+
+        if self.allow_headers is not None:
+            values = ", ".join(self.allow_headers)
+            yield "Access-Control-Allow-Headers", values
+        elif acr_headers:
+            yield "Access-Control-Allow-Headers", acr_headers
+
+        if self.expose_headers is not None:
+            values = ", ".join(self.expose_headers)
+            yield "Access-Control-Expose-Headers", values

kettu-0.1/src/kettu/datastructures.py

@@ -0,0 +1,7 @@
+from typing import NamedTuple, Any
+from collections.abc import Sequence
+
+
+class Data(NamedTuple):
+    form: Sequence[tuple[str, Any]] | None = None
+    json: int | float | str | dict | list | None = None  # not too specific

kettu-0.1/src/kettu/exceptions.py

@@ -0,0 +1,17 @@
+from http import HTTPStatus
+from kettu.types import HTTPCode
+
+
+class ParsingException(ValueError):
+    pass
+
+
+class HTTPError(Exception):
+    def __init__(self, status: HTTPCode, body: str | bytes | None = None):
+        self.status = HTTPStatus(status)
+        body = self.status.description if body is None else body
+        if isinstance(body, str):
+            body = body.encode("utf-8")
+        elif not isinstance(body, bytes):
+            raise ValueError("Body must be string or bytes.")
+        self.body: bytes = body

kettu-0.1/src/kettu/headers/__init__.py

@@ -0,0 +1,26 @@
+from .authorization import Authorization
+from .cookies import Cookie, Cookies
+from .query import Query
+from .ranges import Ranges
+from .content_type import ContentType, MediaType, Accept
+from .language import Language, Languages
+from .etag import ETag, ETags
+from .link import Link, Links
+from .utils import parse_list_header, parse_header
+from .utils import parse_http_datetime, parse_host, parse_wsgi_path
+from .utils import encode_uri, serialize_http_datetime
+
+
+__all__ = [
+    "Authorization",
+    "Cookie", "Cookies",
+    "Query",
+    "Ranges",
+    "ContentType", "MediaType", "Accept",
+    "Language", "Languages",
+    "ETag", "ETags",
+    "Link", "Links",
+    "parse_list_header", "parse_header",
+    "parse_http_datetime", "parse_host", "parse_wsgi_path",
+    "encode_uri", "serialize_http_datetime"
+]

kettu-0.1/src/kettu/headers/authorization.py

@@ -0,0 +1,11 @@
+from typing import NamedTuple
+
+
+class Authorization(NamedTuple):
+    scheme: str
+    credentials: str
+
+    @classmethod
+    def from_string(cls, value: str):
+        scheme, _, credentials = value.strip(' ').partition(' ')
+        return cls(scheme.lower(), credentials.strip())

kettu-0.1/src/kettu/headers/constants.py

@@ -0,0 +1,11 @@
+import re
+from enum import Enum
+
+WEIGHT = re.compile(r"^(0\.[0-9]{1,3}|1\.0{1,3})$")  # 3 decimals.
+WEIGHT_PARAM = re.compile(r"^q=(0\.[0-9]{1,3}|1\.0{1,3})$")
+
+
+class Specificity(int, Enum):
+    NONSPECIFIC = 0
+    PARTIALLY_SPECIFIC = 1
+    SPECIFIC = 2

kettu-0.1/src/kettu/headers/content_type.py

@@ -0,0 +1,198 @@
+from fnmatch import fnmatch
+from typing import Mapping, Any, Sequence
+from frozendict import frozendict
+from kettu.headers.constants import WEIGHT, Specificity
+from kettu.types import MIMEType
+from kettu.headers.utils import parse_header
+
+
+class ContentType:
+    __slots__ = ("mimetype", "options")
+
+    quality: float
+    formatted: str
+    mimetype: MIMEType
+    options: Mapping[str, str]
+
+    def __init__(
+            self,
+            mimetype: MIMEType,
+            options: Mapping[str, str],
+    ):
+        self.mimetype = mimetype
+        self.options = options
+
+    @classmethod
+    def caster(cls, value: "str | ContentType"):
+        if isinstance(value, ContentType):
+            return value.as_header()
+        return cls.from_string(value).as_header()
+
+    @classmethod
+    def from_string(cls, value: str):
+        mimetype, params = parse_header(value)
+        return cls(
+            mimetype=mimetype,
+            options=frozendict(params)
+        )
+
+    def as_header(self):
+        return self.mimetype + "".join(
+            f";{k}={v}" for k, v in sorted(self.options.items())
+        )
+
+    def __bool__(self):
+        return bool(self.mimetype)
+
+    def __str__(self):
+        return self.formatted
+
+    def __eq__(self, other: Any) -> bool:
+        if isinstance(other, ContentType):
+            return (
+                self.mimetype == other.mimetype and
+                self.options == self.options
+            )
+        if isinstance(other, str):
+            return self.mimetype == other
+        return False
+
+
+class MediaType(ContentType):
+    __slots__ = (
+        "options", "specificity", "maintype", "subtype", "quality")
+
+    maintype: str
+    subtype: str
+    specificity: Specificity
+
+    def __init__(
+            self,
+            maintype: str,
+            subtype: str,
+            options: Mapping[str, str],
+            quality: float = 1.0,
+    ):
+        mimetype = maintype + '/' + subtype
+        self.quality = quality
+        self.maintype = maintype
+        self.subtype = subtype
+
+        if maintype == "*" and subtype == "*":
+            self.specificity = Specificity.NONSPECIFIC
+        elif subtype == "*":
+            self.specificity = Specificity.PARTIALLY_SPECIFIC
+        else:
+            self.specificity = Specificity.SPECIFIC
+        super().__init__(mimetype, options)
+
+    @classmethod
+    def from_string(cls, value: str):
+        mimetype, params = parse_header(value)
+        if mimetype == "*":
+            maintype = "*"
+            subtype = "*"
+        elif "/" in mimetype:
+            maintype, _, subtype = mimetype.partition("/")
+            if not subtype:
+                subtype = "*"
+            elif maintype == '*' and subtype != '*':
+                raise ValueError()
+        else:
+            maintype = mimetype
+            subtype = "*"
+
+        params = frozendict(params)
+        if 'q' in params:
+            q = params['q']
+            if not WEIGHT.match(q):
+                raise ValueError()
+            quality = float(q)
+        else:
+            quality = 1.0
+        return cls(
+            maintype=maintype,
+            subtype=subtype,
+            options=params,
+            quality=quality
+        )
+
+    @classmethod
+    def caster(cls, value: str):
+        return cls.from_string(value).as_header()
+
+    def as_header(self):
+        return self.mimetype + "".join(
+            f";{k}={v}" for k, v in sorted(self.options.items())
+        )
+
+    def __eq__(self, other: Any) -> bool:
+        if isinstance(other, str):
+            return self.mimetype == other
+        if isinstance(other, ContentType):
+            return self.mimetype == self.mimetype
+
+    def __lt__(self, other: Any) -> bool:
+        if isinstance(other, MediaType):
+            if self.quality == other.quality:
+                return self.specificity > other.specificity
+            return self.quality > other.quality
+        raise TypeError()
+
+    def match(self, other: str | ContentType) -> bool:
+        if isinstance(other, ContentType):
+            other = other.mimetype
+        if self.specificity == Specificity.NONSPECIFIC:
+            return True
+        if self.specificity == Specificity.PARTIALLY_SPECIFIC:
+            return fnmatch(other, self.mimetype)
+        return self.mimetype == other
+
+
+class Accept(tuple[MediaType, ...]):
+
+    def __new__(cls, values: Sequence[MediaType]):
+        if values:
+            return super().__new__(cls, sorted(values))
+        return super().__new__(cls, (MediaType('*', '*', {}),))
+
+    def as_header(self):
+        return ','.join((media.as_header() for media in self))
+
+    @classmethod
+    def caster(cls, value: str):
+        return cls.from_string(value).as_header()
+
+    @classmethod
+    def from_string(cls, header: str, keep_null: bool = False):
+        if ',' not in header:
+            header = header.strip()
+            if header:
+                media = MediaType.from_string(header)
+                if not keep_null and not media.quality:
+                    raise ValueError()
+                return cls((media,))
+
+        medias = []
+        values = header.split(',')
+        for value in values:
+            value = value.strip()
+            if value:
+                media = MediaType.from_string(value)
+                if not keep_null and not media.quality:
+                    continue
+                medias.append(media)
+        if not medias:
+            raise ValueError()
+        return cls(medias)
+
+    def negotiate(self, supported: Sequence[str | MediaType]):
+        if not self:
+            if not supported:
+                return None
+            return supported[0]
+        for accepted in self:
+            for candidate in supported:
+                if accepted.match(candidate):
+                    return candidate
+        return None

kettu-0.1/src/kettu/headers/cookies.py

@@ -0,0 +1,15 @@
+from biscuits import Cookie, parse
+
+
+class Cookies(dict[str, Cookie]):
+    """A Cookies management class, built on top of biscuits."""
+
+    def set(self, name: str, *args, **kwargs):
+        self[name] = Cookie(name, *args, **kwargs)
+
+    @staticmethod
+    def from_string(value: str) -> "Cookies":
+        return parse(value)
+
+    def as_header(self) -> str:
+        return ",".join(str(c) for c in self.values())

kettu-0.1/src/kettu/headers/etag.py

@@ -0,0 +1,72 @@
+from typing import NamedTuple
+
+
+class ETag(NamedTuple):
+    value: str
+    weak: bool = False
+
+    def __str__(self):
+        return self.as_header()
+
+    def __hash__(self):
+        return hash(self.value)
+
+    def __eq__(self, other):
+        if isinstance(other, str):
+            return self.value == other
+        return tuple.__eq__(self, other)
+
+    @classmethod
+    def from_string(cls, value: str) -> 'ETag':
+        weak = False
+        if value.startswith(('W/', 'w/')):
+            weak = True
+            value = value[2:]
+
+        # Etag value SHOULD be quoted.
+        return cls(value.strip('"'), weak=weak)
+
+    def compare(self, other: 'ETag') -> bool:
+        return self.value == other.value and not (self.weak or other.weak)
+
+    def as_header(self) -> str:
+        if self.weak:
+            return f'W/"{self.value}"'
+        return f'"{self.value}"'
+
+    @classmethod
+    def caster(cls, value: "str | ETag"):
+        if isinstance(value, ETag):
+            return value.as_header()
+        return cls(value).as_header()
+
+
+class ETags(frozenset[ETag]):
+    # IfMatch / IfMatchNone
+
+    def as_header(self) -> str:
+        return ','.join((etag.as_header() for etag in self))
+
+    @classmethod
+    def from_string(cls, header: str) -> frozenset[ETag]:
+        if ',' not in header:
+            header = header.strip()
+            if header:
+                etag = ETag.from_string(header)
+                return cls((etag,))
+
+        etags = []
+        values = header.split(',')
+        for value in values:
+            value = value.strip()
+            if value:
+                etags.append(ETag.from_string(value))
+        if not etags:
+            raise ValueError()
+        return cls(etags)
+
+    @classmethod
+    def caster(cls, value: "str | ETags"):
+        if isinstance(value, ETags):
+            return value.as_header()
+        return cls.from_string(value).as_header()

kettu-0.1/src/kettu/headers/language.py

@@ -0,0 +1,133 @@
+from typing import Any, Union, Sequence
+from langcodes import Language as LangCode
+from kettu.headers.constants import WEIGHT_PARAM, Specificity
+
+
+class Language:
+    __slots__ = ("language", "quality", "specificity")
+
+    quality: float
+    language: LangCode | None
+    specificity: Specificity
+
+    def __init__(
+            self,
+            locale: str,
+            quality: float = 1.0
+    ):
+        self.quality = quality
+        if locale != "*":
+            self.language = LangCode.get(locale)
+            self.specificity = (
+                Specificity.SPECIFIC if (
+                    self.language.territory or self.language.script
+                )
+                else Specificity.PARTIALLY_SPECIFIC
+            )
+        else:
+            self.language = None
+            self.specificity = Specificity.NONSPECIFIC
+
+    @classmethod
+    def from_string(cls, value: str) -> 'Language':
+        locale, _, rest = value.partition(';')
+        rest = rest.strip()
+        if rest:
+            matched = WEIGHT_PARAM.match(rest)
+            if not matched:
+                raise ValueError()
+            quality = float(matched.group(1))
+            return cls(locale.strip(), quality)
+        return cls(locale.strip())
+
+    def __str__(self):
+        if not self.language:
+            return "*"
+        return self.language.to_tag()
+
+    def as_header(self):
+        return f"{str(self)};q={self.quality}"
+
+    @classmethod
+    def caster(cls, value: str):
+        return cls.from_string(value).as_header()
+
+    def __lt__(self, other: Any) -> bool:
+        if isinstance(other, Language):
+            if self.quality == other.quality:
+                return self.specificity > other.specificity
+            return self.quality > other.quality
+        raise TypeError()
+
+    def __eq__(self, other: Any) -> bool:
+        if isinstance(other, Language):
+            return self.language == other.language
+        if isinstance(other, str):
+            return str(self) == other
+        return False
+
+    def match(self, other: Union[str, 'Language']) -> bool:
+        if self.specificity == Specificity.NONSPECIFIC:
+            return True
+
+        if isinstance(other, str):
+            language = LangCode.get(other)
+        else:
+            language = other.language
+
+        if (
+                self.specificity == Specificity.PARTIALLY_SPECIFIC or
+                not language.territory or not language.script
+        ):
+            return language.language == self.language.language
+
+        return language == self.language
+
+
+class Languages(tuple[Language, ...]):
+
+    def __new__(cls, values: Sequence[Language]):
+        if values:
+            return super().__new__(cls, sorted(values))
+        return super().__new__(cls, (Language('*'),))
+
+    def as_header(self):
+        return ','.join((lang.as_header() for lang in self))
+
+    @classmethod
+    def caster(cls, value: str):
+        return cls.from_string(value).as_header()
+
+    @classmethod
+    def from_string(cls, header: str, keep_null: bool = False):
+        if ',' not in header:
+            header = header.strip()
+            if header:
+                lang = Language.from_string(header)
+                if not keep_null and not lang.quality:
+                    raise ValueError()
+                return cls((lang,))
+
+        langs = []
+        values = header.split(',')
+        for value in values:
+            value = value.strip()
+            if value:
+                lang = Language.from_string(value)
+                if not keep_null and not lang.quality:
+                    continue
+                langs.append(lang)
+        if not langs:
+            raise ValueError()
+        return cls(langs)
+
+    def negotiate(self, supported: Sequence[str | Language]):
+        if not self:
+            if not supported:
+                return None
+            return supported[0]
+        for accepted in self:
+            for candidate in supported:
+                if accepted.match(candidate):
+                    return candidate
+        return None