omlish 0.0.0.dev4__py3-none-any.whl → 0.0.0.dev6__py3-none-any.whl

omlish/http/collections.py

@@ -0,0 +1,15 @@
+import typing as ta
+
+
+V = ta.TypeVar('V')
+
+
+class HttpMap(ta.Mapping[str, V]):
+    def __getitem__(self, k):
+        raise NotImplementedError
+
+    def __len__(self):
+        raise NotImplementedError
+
+    def __iter__(self):
+        raise NotImplementedError

omlish/http/consts.py

@@ -1,4 +1,8 @@
-import http  # noqa
+import base64
+import http
+
+
+##
 
 
 def format_status(status: http.HTTPStatus) -> str:
@@ -6,15 +10,53 @@ def format_status(status: http.HTTPStatus) -> str:
 
 
 STATUS_OK = format_status(http.HTTPStatus.OK)
+
+STATUS_FOUND = format_status(http.HTTPStatus.FOUND)
+STATUS_TEMPORARY_REDIRECT = format_status(http.HTTPStatus.TEMPORARY_REDIRECT)
+
 STATUS_BAD_REQUEST = format_status(http.HTTPStatus.BAD_REQUEST)
+STATUS_UNAUTHORIZED = format_status(http.HTTPStatus.UNAUTHORIZED)
 STATUS_FORBIDDEN = format_status(http.HTTPStatus.FORBIDDEN)
 STATUS_NOT_FOUND = format_status(http.HTTPStatus.NOT_FOUND)
 STATUS_METHOD_NOT_ALLOWED = format_status(http.HTTPStatus.METHOD_NOT_ALLOWED)
+STATUS_REQUEST_TIMEOUT = format_status(http.HTTPStatus.REQUEST_TIMEOUT)
+
+STATUS_INTERNAL_SERVER_ERROR = format_status(http.HTTPStatus.INTERNAL_SERVER_ERROR)
+STATUS_NOT_IMPLEMENTED = format_status(http.HTTPStatus.NOT_IMPLEMENTED)
+STATUS_BAD_GATEWAY = format_status(http.HTTPStatus.BAD_GATEWAY)
+STATUS_SERVICE_UNAVAILABLE = format_status(http.HTTPStatus.SERVICE_UNAVAILABLE)
+STATUS_GATEWAY_TIMEOUT = format_status(http.HTTPStatus.GATEWAY_TIMEOUT)
+
+
+##
 
 
 HEADER_CONTENT_TYPE = b'Content-Type'
-CONTENT_TYPE_TEXT = b'text/plain'
-CONTENT_TYPE_TEXT_UTF8 = CONTENT_TYPE_TEXT + b'; charset=utf-8'
-CONTENT_TYPE_JSON = b'application/json'
-CONTENT_TYPE_ICON = b'image/x-icon'
+HEADER_ACCEPT = b'Accept'
+
+CONTENT_CHARSET_UTF8 = b'charset=utf-8'
+
 CONTENT_TYPE_BYTES = b'application/octet-stream'
+
+CONTENT_TYPE_HTML = b'text/html'
+CONTENT_TYPE_HTML_UTF8 = b'; '.join([CONTENT_TYPE_HTML, CONTENT_CHARSET_UTF8])
+
+CONTENT_TYPE_ICON = b'image/x-icon'
+
+CONTENT_TYPE_JSON = b'application/json'
+CONTENT_TYPE_JSON_UTF8 = b'; '.join([CONTENT_TYPE_JSON, CONTENT_CHARSET_UTF8])
+
+CONTENT_TYPE_TEXT = b'text/plain'
+CONTENT_TYPE_TEXT_UTF8 = b'; '.join([CONTENT_TYPE_TEXT, CONTENT_CHARSET_UTF8])
+
+
+##
+
+
+HEADER_AUTH = b'Authorization'
+BEARER_AUTH_HEADER_PREFIX = b'Bearer '
+BASIC_AUTH_HEADER_PREFIX = b'Basic '
+
+
+def format_basic_auth_header(username: str, password: str) -> bytes:
+    return BASIC_AUTH_HEADER_PREFIX + base64.b64encode(':'.join([username, password]).encode())

omlish/http/cookies.py

@@ -0,0 +1,194 @@
+"""
+https://github.com/pallets/werkzeug/blob/9e050f7750214d6779636813b8d661250804e811/src/werkzeug/http.py
+https://github.com/pallets/werkzeug/blob/9e050f7750214d6779636813b8d661250804e811/src/werkzeug/sansio/http.py
+"""
+# Copyright 2007 Pallets
+#
+# Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
+# following conditions are met:
+#
+# 1.  Redistributions of source code must retain the above copyright notice, this list of conditions and the following
+#     disclaimer.
+#
+# 2.  Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the
+#     following disclaimer in the documentation and/or other materials provided with the distribution.
+#
+# 3.  Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote
+#     products derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+# INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+import datetime
+import re
+import typing as ta
+import urllib.parse
+
+from .. import collections as col
+from .dates import http_date
+
+
+##
+
+
+_COOKIE_RE = re.compile(
+    r"""
+    ([^=;]*)
+    (?:\s*=\s*
+      (
+        "(?:[^\\"]|\\.)*"
+      |
+        .*?
+      )
+    )?
+    \s*;\s*
+    """,
+    flags=re.ASCII | re.VERBOSE,
+)
+_COOKIE_UNSLASH_RE = re.compile(rb'\\([0-3][0-7]{2}|.)')
+
+
+def _cookie_unslash_replace(m: ta.Match[bytes]) -> bytes:
+    v = m.group(1)
+
+    if len(v) == 1:
+        return v
+
+    return int(v, 8).to_bytes(1, 'big')
+
+
+def parse_cookie(
+        cookie: str | None = None,
+        *,
+        no_latin1: bool = False,
+) -> ta.MutableMapping[str, list[str]]:
+    if (not no_latin1) and cookie:
+        cookie = cookie.encode('latin1').decode()
+
+    if not cookie:
+        return {}
+
+    cookie = f'{cookie};'
+    out = []
+
+    for ck, cv in _COOKIE_RE.findall(cookie):
+        ck = ck.strip()
+        cv = cv.strip()
+
+        if not ck:
+            continue
+
+        if len(cv) >= 2 and cv[0] == cv[-1] == '"':
+            # Work with bytes here, since a UTF-8 character could be multiple bytes.
+            cv = _COOKIE_UNSLASH_RE.sub(
+                _cookie_unslash_replace,
+                cv[1:-1].encode(),
+            ).decode(errors='replace')
+
+        out.append((ck, cv))
+
+    return col.multi_map(out)
+
+
+##
+
+
+_COOKIE_NO_QUOTE_RE = re.compile(r"[\w!#$%&'()*+\-./:<=>?@\[\]^`{|}~]*", re.ASCII)
+_COOKIE_SLASH_RE = re.compile(rb'[\x00-\x19\",;\\\x7f-\xff]', re.ASCII)
+_COOKIE_SLASH_MAP = {b'"': b'\\"', b'\\': b'\\\\'}
+_COOKIE_SLASH_MAP.update(
+    (v.to_bytes(1, 'big'), b'\\%03o' % v)
+    for v in [*range(0x20), *b',;', *range(0x7F, 256)]
+)
+
+
+class CookieTooBigError(Exception):
+    pass
+
+
+def dump_cookie(
+        key: str,
+        value: str = '',
+        *,
+        max_age: datetime.timedelta | int | None = None,
+        expires: str | datetime.datetime | float | None = None,
+        path: str | None = '/',
+        domain: str | None = None,
+        secure: bool = False,
+        httponly: bool = False,
+        sync_expires: bool = True,
+        max_size: int = 4093,
+        samesite: str | None = None,
+        partitioned: bool = False,
+) -> str:
+    if path is not None:
+        # safe = https://url.spec.whatwg.org/#url-path-segment-string as well as percent for things that are already
+        # quoted excluding semicolon since it's part of the header syntax
+        path = urllib.parse.quote(path, safe="%!$&'()*+,/:=@")
+
+    if domain:
+        domain = domain.partition(':')[0].lstrip('.').encode('idna').decode('ascii')
+
+    if isinstance(max_age, datetime.timedelta):
+        max_age = int(max_age.total_seconds())
+
+    if expires is not None:
+        if not isinstance(expires, str):
+            expires = http_date(expires)
+    elif max_age is not None and sync_expires:
+        expires = http_date(datetime.datetime.now(tz=datetime.UTC).timestamp() + max_age)
+
+    if samesite is not None:
+        samesite = samesite.title()
+
+        if samesite not in {'Strict', 'Lax', 'None'}:
+            raise ValueError("SameSite must be 'Strict', 'Lax', or 'None'.")
+
+    if partitioned:
+        secure = True
+
+    # Quote value if it contains characters not allowed by RFC 6265. Slash-escape with
+    # three octal digits, which matches http.cookies, although the RFC suggests base64.
+    if not _COOKIE_NO_QUOTE_RE.fullmatch(value):
+        # Work with bytes here, since a UTF-8 character could be multiple bytes.
+        value = _COOKIE_SLASH_RE.sub(
+            lambda m: _COOKIE_SLASH_MAP[m.group()], value.encode(),
+        ).decode('ascii')
+        value = f'"{value}"'
+
+    # Send a non-ASCII key as mojibake. Everything else should already be ASCII.
+    # TODO Remove encoding dance, it seems like clients accept UTF-8 keys
+    buf = [f"{key.encode().decode('latin1')}={value}"]
+
+    for k, v in (
+            ('Domain', domain),
+            ('Expires', expires),
+            ('Max-Age', max_age),
+            ('Secure', secure),
+            ('HttpOnly', httponly),
+            ('Path', path),
+            ('SameSite', samesite),
+            ('Partitioned', partitioned),
+    ):
+        if v is None or v is False:
+            continue
+
+        if v is True:
+            buf.append(k)
+            continue
+
+        buf.append(f'{k}={v}')
+
+    rv = '; '.join(buf)
+
+    # Warn if the final value of the cookie is larger than the limit. If the cookie is too large, then it may be
+    # silently ignored by the browser, which can be quite hard to debug.
+    cookie_size = len(rv)
+    if max_size and cookie_size > max_size:
+        raise CookieTooBigError(cookie_size)
+
+    return rv

omlish/http/dates.py

@@ -0,0 +1,70 @@
+# Copyright 2007 Pallets
+#
+# Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
+# following conditions are met:
+#
+# 1.  Redistributions of source code must retain the above copyright notice, this list of conditions and the following
+#     disclaimer.
+#
+# 2.  Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the
+#     following disclaimer in the documentation and/or other materials provided with the distribution.
+#
+# 3.  Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote
+#     products derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+# INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+import datetime
+import email.utils
+import time
+
+from .. import check
+
+
+def _dt_as_utc(dt: datetime.datetime | None) -> datetime.datetime | None:
+    if dt is None:
+        return dt
+
+    if dt.tzinfo is None:
+        return dt.replace(tzinfo=datetime.UTC)
+    elif dt.tzinfo != datetime.UTC:
+        return dt.astimezone(datetime.UTC)
+
+    return dt
+
+
+def http_date(timestamp: datetime.datetime | datetime.date | float | time.struct_time | None = None) -> str:
+    if isinstance(timestamp, datetime.date):
+        if not isinstance(timestamp, datetime.datetime):
+            # Assume plain date is midnight UTC.
+            timestamp = datetime.datetime.combine(timestamp, datetime.time(), tzinfo=datetime.UTC)
+        else:
+            # Ensure datetime is timezone-aware.
+            timestamp = _dt_as_utc(timestamp)
+
+        return email.utils.format_datetime(check.not_none(timestamp), usegmt=True)
+
+    if isinstance(timestamp, time.struct_time):
+        timestamp = time.mktime(timestamp)
+
+    return email.utils.formatdate(timestamp, usegmt=True)
+
+
+def parse_date(value: str | None) -> datetime.datetime | None:
+    if value is None:
+        return None
+
+    try:
+        dt = email.utils.parsedate_to_datetime(value)
+    except (TypeError, ValueError):
+        return None
+
+    if dt.tzinfo is None:
+        return dt.replace(tzinfo=datetime.UTC)
+
+    return dt

omlish/http/encodings.py

@@ -0,0 +1,6 @@
+def latin1_decode(s: str) -> str:
+    return s.encode('latin1').decode(errors='replace')
+
+
+def latin1_encode(s: str) -> str:
+    return s.encode().decode('latin1')

omlish/http/json.py

@@ -0,0 +1,273 @@
+# Copyright 2010 Pallets
+#
+# Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
+# following conditions are met:
+#
+# 1.  Redistributions of source code must retain the above copyright notice, this list of conditions and the following
+#     disclaimer.
+#
+# 2.  Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the
+#     following disclaimer in the documentation and/or other materials provided with the distribution.
+#
+# 3.  Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote
+#     products derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+# INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+import base64
+import dataclasses as dc
+import datetime
+import decimal
+import json as _json
+import typing as ta
+import uuid
+
+from .. import lang
+from .dates import http_date
+from .dates import parse_date
+
+
+if ta.TYPE_CHECKING:
+    import markupsafe
+else:
+    markupsafe = lang.proxy_import('markupsafe')
+
+
+##
+
+
+def _default(o: ta.Any) -> ta.Any:
+    if isinstance(o, datetime.date):
+        return http_date(o)
+
+    if isinstance(o, (decimal.Decimal, uuid.UUID)):
+        return str(o)
+
+    if dc.is_dataclass(o):
+        return dc.asdict(o)  # type: ignore
+
+    if hasattr(o, '__html__'):
+        return str(o.__html__())
+
+    raise TypeError(f'Object of type {type(o).__name__} is not Json serializable')
+
+
+def json_dumps(obj: ta.Any, **kwargs: ta.Any) -> str:
+    kwargs.setdefault('default', _default)
+    return _json.dumps(obj, **kwargs)
+
+
+def json_loads(s: str | bytes, **kwargs: ta.Any) -> ta.Any:
+    return _json.loads(s, **kwargs)
+
+
+##
+
+
+class JsonTag:
+    key: str = ''
+
+    def __init__(self, tagger: 'JsonTagger') -> None:
+        super().__init__()
+
+        self.tagger = tagger
+
+    def check(self, value: ta.Any) -> bool:
+        raise NotImplementedError
+
+    def to_json(self, value: ta.Any) -> ta.Any:
+        raise NotImplementedError
+
+    def to_python(self, value: ta.Any) -> ta.Any:
+        raise NotImplementedError
+
+    def tag(self, value: ta.Any) -> dict[str, ta.Any]:
+        return {self.key: self.to_json(value)}
+
+
+class TagDict(JsonTag):
+    key = ' di'
+
+    def check(self, value: ta.Any) -> bool:
+        return (
+            isinstance(value, dict)
+            and len(value) == 1
+            and next(iter(value)) in self.tagger.tags
+        )
+
+    def to_json(self, value: ta.Any) -> ta.Any:
+        key = next(iter(value))
+        return {f'{key}__': self.tagger.tag(value[key])}
+
+    def to_python(self, value: ta.Any) -> ta.Any:
+        key = next(iter(value))
+        return {key[:-2]: value[key]}
+
+
+class PassDict(JsonTag):
+    def check(self, value: ta.Any) -> bool:
+        return isinstance(value, dict)
+
+    def to_json(self, value: ta.Any) -> ta.Any:
+        return {k: self.tagger.tag(v) for k, v in value.items()}
+
+    tag = to_json
+
+
+class TagTuple(JsonTag):
+    key = ' t'
+
+    def check(self, value: ta.Any) -> bool:
+        return isinstance(value, tuple)
+
+    def to_json(self, value: ta.Any) -> ta.Any:
+        return [self.tagger.tag(item) for item in value]
+
+    def to_python(self, value: ta.Any) -> ta.Any:
+        return tuple(value)
+
+
+class PassList(JsonTag):
+    def check(self, value: ta.Any) -> bool:
+        return isinstance(value, list)
+
+    def to_json(self, value: ta.Any) -> ta.Any:
+        return [self.tagger.tag(item) for item in value]
+
+    tag = to_json
+
+
+class TagBytes(JsonTag):
+    key = ' b'
+
+    def check(self, value: ta.Any) -> bool:
+        return isinstance(value, bytes)
+
+    def to_json(self, value: ta.Any) -> ta.Any:
+        return base64.b64encode(value).decode('ascii')
+
+    def to_python(self, value: ta.Any) -> ta.Any:
+        return base64.b64decode(value)
+
+
+class TagMarkup(JsonTag):
+    key = ' m'
+
+    def check(self, value: ta.Any) -> bool:
+        return callable(getattr(value, '__html__', None))
+
+    def to_json(self, value: ta.Any) -> ta.Any:
+        return str(value.__html__())
+
+    def to_python(self, value: ta.Any) -> ta.Any:
+        return markupsafe.Markup(value)
+
+
+class TagUuid(JsonTag):
+    key = ' u'
+
+    def check(self, value: ta.Any) -> bool:
+        return isinstance(value, uuid.UUID)
+
+    def to_json(self, value: ta.Any) -> ta.Any:
+        return value.hex
+
+    def to_python(self, value: ta.Any) -> ta.Any:
+        return uuid.UUID(value)
+
+
+class TagDatetime(JsonTag):
+    key = ' dt'
+
+    def check(self, value: ta.Any) -> bool:
+        return isinstance(value, datetime.datetime)
+
+    def to_json(self, value: ta.Any) -> ta.Any:
+        return http_date(value)
+
+    def to_python(self, value: ta.Any) -> ta.Any:
+        return parse_date(value)
+
+
+class JsonTagger:
+    default_tags: ta.ClassVar[ta.Sequence[type[JsonTag]]] = [
+        TagDict,
+        PassDict,
+        TagTuple,
+        PassList,
+        TagBytes,
+        *([TagMarkup] if lang.can_import('markupsafe') else []),
+        TagUuid,
+        TagDatetime,
+    ]
+
+    def __init__(self) -> None:
+        super().__init__()
+
+        self.tags: dict[str, JsonTag] = {}
+        self.order: list[JsonTag] = []
+
+        for cls in self.default_tags:
+            self.register(cls)
+
+    def register(
+            self,
+            tag_class: type[JsonTag],
+            force: bool = False,
+            index: int | None = None,
+    ) -> None:
+        tag = tag_class(self)
+        key = tag.key
+
+        if key:
+            if not force and key in self.tags:
+                raise KeyError(f"Tag '{key}' is already registered.")
+
+            self.tags[key] = tag
+
+        if index is None:
+            self.order.append(tag)
+        else:
+            self.order.insert(index, tag)
+
+    def tag(self, value: ta.Any) -> ta.Any:
+        for tag in self.order:
+            if tag.check(value):
+                return tag.tag(value)
+
+        return value
+
+    def untag(self, value: dict[str, ta.Any]) -> ta.Any:
+        if len(value) != 1:
+            return value
+
+        key = next(iter(value))
+
+        if key not in self.tags:
+            return value
+
+        return self.tags[key].to_python(value[key])
+
+    def untag_scan(self, value: ta.Any) -> ta.Any:
+        if isinstance(value, dict):
+            value = {k: self.untag_scan(v) for k, v in value.items()}
+            value = self.untag(value)
+
+        elif isinstance(value, list):
+            value = [self.untag_scan(item) for item in value]
+
+        return value
+
+    def dumps(self, value: ta.Any) -> str:
+        return json_dumps(self.tag(value), separators=(',', ':'))
+
+    def loads(self, value: str) -> ta.Any:
+        return self.untag_scan(json_loads(value))
+
+
+JSON_TAGGER = JsonTagger()