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

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()

omlish/http/sessions.py

@@ -0,0 +1,197 @@
+import base64
+import dataclasses as dc
+import datetime
+import hashlib
+import hmac
+import struct
+import time
+import typing as ta
+import zlib
+
+from .. import fnpairs as fps
+from .. import lang
+from .cookies import dump_cookie
+from .cookies import parse_cookie
+from .json import JSON_TAGGER
+
+
+Session: ta.TypeAlias = dict[str, ta.Any]
+
+
+##
+
+
+def base64_encode(b: bytes) -> bytes:
+    return base64.urlsafe_b64encode(b).rstrip(b'=')
+
+
+def base64_decode(b: bytes) -> bytes:
+    b += b'=' * (-len(b) % 4)
+    return base64.urlsafe_b64decode(b)
+
+
+def int_to_bytes(num: int) -> bytes:
+    return struct.pack('>Q', num).lstrip(b'\0')
+
+
+def bytes_to_int(bytestr: bytes) -> int:
+    return struct.unpack('>Q', bytestr.rjust(8, b'\0'))[0]
+
+
+##
+
+
+class Signer:
+    @dc.dataclass(frozen=True)
+    class Config:
+        secret_key: str
+        salt: str = 'cookie-session'
+
+    def __init__(self, config: Config) -> None:
+        super().__init__()
+
+        self._config = config
+
+    @lang.cached_function
+    def digest(self) -> ta.Any:
+        return hashlib.sha1
+
+    @lang.cached_function
+    def derive_key(self) -> bytes:
+        mac = hmac.new(self._config.secret_key.encode(), digestmod=self.digest())
+        mac.update(self._config.salt.encode())
+        return mac.digest()
+
+    def get_signature(self, value: bytes) -> bytes:
+        mac = hmac.new(self.derive_key(), msg=value, digestmod=self.digest())
+        return mac.digest()
+
+    def verify_signature(self, value: bytes, sig: bytes) -> bool:
+        return hmac.compare_digest(sig, self.get_signature(value))
+
+
+##
+
+
+class SessionExpiredError(Exception):
+    pass
+
+
+class SessionVerificationError(Exception):
+    pass
+
+
+class SessionMarshal:
+    def __init__(
+            self,
+            signer: Signer,
+            serializer: fps.ObjectStr = fps.of(JSON_TAGGER.dumps, JSON_TAGGER.loads),
+    ) -> None:
+        super().__init__()
+
+        self._signer = signer
+        self._serializer = serializer
+
+    SEP = b'.'
+
+    def load(self, bs: bytes) -> ta.Any:
+        value, sig = bs.rsplit(self.SEP, 1)
+
+        sig_b = base64_decode(sig)
+
+        if not self._signer.verify_signature(value, sig_b):
+            raise SessionVerificationError
+
+        value, ts_bytes = value.rsplit(self.SEP, 1)
+        ts_int = bytes_to_int(base64_decode(ts_bytes))
+
+        max_age = 31 * 24 * 60 * 60
+        age = int(time.time()) - ts_int
+
+        if age > max_age:
+            raise SessionExpiredError
+        if age < 0:
+            raise SessionExpiredError
+
+        payload = value
+
+        decompress = False
+        if payload.startswith(b'.'):
+            payload = payload[1:]
+            decompress = True
+
+        jb = base64_decode(payload)
+
+        if decompress:
+            jb = zlib.decompress(jb)
+
+        jbs = jb.decode()
+
+        obj = self._serializer.backward(jbs)
+
+        return obj
+
+    def dump(self, obj: ta.Any) -> bytes:
+        jbs = self._serializer.forward(obj)
+
+        jb = jbs.encode()
+
+        is_compressed = False
+        compressed = zlib.compress(jb)
+
+        if len(compressed) < (len(jb) - 1):
+            jb = compressed
+            is_compressed = True
+
+        base64d = base64_encode(jb)
+
+        if is_compressed:
+            base64d = b'.' + base64d
+
+        payload = base64d
+
+        timestamp = base64_encode(int_to_bytes(int(time.time())))
+
+        value = payload + self.SEP + timestamp
+        return value + self.SEP + base64_encode(self._signer.get_signature(value))
+
+
+##
+
+
+class CookieSessionStore:
+    @dc.dataclass(frozen=True)
+    class Config:
+        key: str = 'session'
+        max_age: datetime.timedelta | int | None = None
+
+    def __init__(self, marshal: SessionMarshal, config: Config = Config()) -> None:
+        super().__init__()
+
+        self._marshal = marshal
+        self._config = config
+
+    def extract(self, scope) -> Session:
+        for k, v in scope['headers']:
+            if k == b'cookie':
+                cks = parse_cookie(v.decode('latin-1', 'strict'))
+                sk = cks.get(self._config.key)
+                if sk:
+                    return self._marshal.load(sk[0].encode('latin-1', 'strict'))
+
+        return {}
+
+    def build_headers(self, session: Session) -> list[tuple[bytes, bytes]]:
+        d = self._marshal.dump(session)
+
+        c = dump_cookie(
+            self._config.key,
+            d.decode('latin-1', 'strict'),
+            max_age=self._config.max_age,
+            httponly=True,
+        )
+
+        return [
+            (b'Vary', b'Cookie'),
+            (b'Set-Cookie', c.encode('latin-1', 'strict')),
+        ]

omlish/inject/__init__.py

@@ -40,7 +40,6 @@ from .inspect import (  # noqa
 from .keys import (  # noqa
     Key,
     as_key,
-    multi,
     tag,
 )
 
@@ -48,6 +47,14 @@ from .managed import (  # noqa
     create_managed_injector,
 )
 
+from .multis import (  # noqa
+    MapBinding,
+    SetBinding,
+    bind_map_provider,
+    bind_set_provider,
+)
+
+
 from .overrides import (  # noqa
     override,
 )
@@ -79,7 +86,6 @@ from .scopes import (  # noqa
 )
 
 from .types import (  # noqa
-    Cls,
     Scope,
     Unscoped,
 )

omlish/inject/bindings.py

@@ -36,13 +36,13 @@ def as_binding(o: ta.Any) -> Binding:
         return o
     check.not_isinstance(o, (Element, Elements))
     if isinstance(o, Provider):
-        return Binding(Key(check.not_none(o.provided_cls())), o)  # type: ignore  # noqa
+        return Binding(Key(check.not_none(o.provided_ty())), o)
     if isinstance(o, type):
         return as_binding(ctor(o))
     if callable(o):
         return as_binding(fn(o))
-    cls = type(o)
-    return Binding(Key(cls), const(o, cls))
+    ty = type(o)
+    return Binding(Key(ty), const(o, ty))
 
 
 def as_(k: ta.Any, p: ta.Any) -> Binding:

omlish/inject/exceptions.py

@@ -17,17 +17,17 @@ class BaseKeyError(Exception):
 
 
 @dc.dataclass()
-class UnboundKeyError(KeyError):
+class UnboundKeyError(BaseKeyError):
     pass
 
 
 @dc.dataclass()
-class DuplicateKeyError(KeyError):
+class DuplicateKeyError(BaseKeyError):
     pass
 
 
 @dc.dataclass()
-class CyclicDependencyError(KeyError):
+class CyclicDependencyError(BaseKeyError):
     pass