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

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
 
 

omlish/inject/impl/elements.py

@@ -10,11 +10,13 @@ Multi's + Scopes:
 
 Element Types:
  - Binding
+ - SetBinding
+ - MapBinding
  - Eager
  - Overrides
  - Expose
  - Private
- - ScopeSeed
+ - ScopeBinding
 """
 import typing as ta
 
@@ -27,15 +29,22 @@ from ..elements import Element
 from ..elements import Elements
 from ..exceptions import DuplicateKeyError
 from ..keys import Key
+from ..multis import MapBinding
+from ..multis import MapProvider
+from ..multis import SetBinding
+from ..multis import SetProvider
 from ..overrides import Overrides
 from ..private import Expose
 from ..private import Private
 from ..scopes import ScopeBinding
+from ..types import Scope
 from .bindings import BindingImpl
-from .providers import MultiProviderImpl
+from .multis import make_multi_provider_impl
+from .providers import ProviderImpl
 from .providers import make_provider_impl
 from .scopes import make_scope_impl
 
+
 if ta.TYPE_CHECKING:
     from . import private as private_
 else:
@@ -91,10 +100,13 @@ class ElementCollection(lang.Final):
                 pi = self._get_private_info(e)
                 self._build_raw_element_multimap(pi.owner_elements(), out)
 
+            elif isinstance(e, (SetBinding, MapBinding)):
+                add(e.multi_key, e)
+
             elif isinstance(e, Overrides):
                 ovr = self._build_raw_element_multimap(e.ovr)
                 src = self._build_raw_element_multimap(e.src)
-                for k, b in src.items():
+                for k, b in src.items():  # FIXME: merge None keys?
                     try:
                         bs = ovr[k]
                     except KeyError:
@@ -116,39 +128,48 @@ class ElementCollection(lang.Final):
 
     ##
 
-    def _make_binding_impls(self, e: Element) -> ta.Iterable[BindingImpl]:
-        if isinstance(e, Binding):
-            p = make_provider_impl(e.provider)
-            return (BindingImpl(e.key, p, e.scope, e),)
-
-        elif isinstance(e, (Eager, Expose)):
-            return ()
-
-        else:
-            raise TypeError(e)
-
     def _build_binding_impl_map(self, em: ta.Mapping[Key | None, ta.Sequence[Element]]) -> dict[Key, BindingImpl]:
         pm: dict[Key, BindingImpl] = {}
-        mm: dict[Key, list[BindingImpl]] = {}
         for k, es in em.items():
             if k is None:
                 continue
 
-            bis = [bi for e in es for bi in self._make_binding_impls(e)]
-            if k.multi:
-                mm.setdefault(k, []).extend(bis)
-            else:
-                if len(bis) > 1:
+            es_by_ty = col.multi_map_by(type, es)
+
+            es_by_ty.pop(Eager, None)
+            es_by_ty.pop(Expose, None)
+
+            if (bs := es_by_ty.pop(Binding, None)):
+                if len(bs) > 1:
                     raise DuplicateKeyError(k)
-                [pm[k]] = bis
 
-        if mm:
-            for k, aps in mm.items():
-                mp = MultiProviderImpl([ap.provider for ap in aps])
-                pm[k] = BindingImpl(k, mp)  # FIXME: SCOPING
+                b: Binding = check.isinstance(check.single(bs), Binding)
+                p: ProviderImpl
+
+                if isinstance(b.provider, (SetProvider, MapProvider)):
+                    p = make_multi_provider_impl(b.provider, es_by_ty)
+
+                else:
+                    p = make_provider_impl(b.provider)
+
+                pm[k] = BindingImpl(b.key, p, b.scope, b)
+
+            if es_by_ty:
+                raise TypeError(set(es_by_ty))
 
         return pm
 
     @lang.cached_function
     def binding_impl_map(self) -> ta.Mapping[Key, BindingImpl]:
         return self._build_binding_impl_map(self.element_multimap())
+
+    ##
+
+    @lang.cached_function
+    def eager_keys_by_scope(self) -> ta.Mapping[Scope, ta.Sequence[Key]]:
+        bim = self.binding_impl_map()
+        ret: dict[Scope, list[Key]] = {}
+        for e in self.elements_of_type(Eager):
+            bi = bim[e.key]
+            ret.setdefault(bi.scope, []).append(e.key)
+        return ret

omlish/inject/impl/injector.py

@@ -7,6 +7,9 @@ TODO:
   - config is probably shared with ElementCollection... but not 'bound', must be shared everywhere
   - InjectorRoot object?
  - ** eagers in any scope, on scope init/open
+ - injection listeners
+ - unions - raise on ambiguous - usecase: sql.AsyncEngineLike
+ - multiple live request scopes on single injector - use private injectors?
 """
 import contextlib
 import typing as ta
@@ -14,7 +17,6 @@ import weakref
 
 from ... import check
 from ... import lang
-from ..eagers import Eager
 from ..elements import Elements
 from ..exceptions import CyclicDependencyError
 from ..exceptions import UnboundKeyError
@@ -52,6 +54,7 @@ class InjectorImpl(Injector, lang.Final):
         }
 
         self._bim = ec.binding_impl_map()
+        self._ekbs = ec.eager_keys_by_scope()
 
         self._cs: weakref.WeakSet[InjectorImpl] | None = None
         self._root: InjectorImpl = p._root if p is not None else self  # noqa
@@ -66,13 +69,13 @@ class InjectorImpl(Injector, lang.Final):
             s: make_scope_impl(s) for s in ss
         }
 
-        self._instantiate_eagers()
+        self._instantiate_eagers(Unscoped())
 
     _root: 'InjectorImpl'
 
-    def _instantiate_eagers(self) -> None:
-        for e in self._ec.elements_of_type(Eager):
-            self.provide(e.key)
+    def _instantiate_eagers(self, sc: Scope) -> None:
+        for k in self._ekbs.get(sc, ()):
+            self.provide(k)
 
     def get_scope_impl(self, sc: Scope) -> ScopeImpl:
         return self._scopes[sc]

omlish/inject/impl/multis.py

@@ -0,0 +1,74 @@
+import typing as ta
+
+from ... import dataclasses as dc
+from ... import lang
+from ..elements import Element
+from ..injector import Injector
+from ..multis import MapBinding
+from ..multis import MapProvider
+from ..multis import SetBinding
+from ..multis import SetProvider
+from ..providers import LinkProvider
+from ..providers import Provider
+from .providers import LinkProviderImpl
+from .providers import ProviderImpl
+
+
+@dc.dataclass(frozen=True, eq=False)
+class SetProviderImpl(ProviderImpl, lang.Final):
+    ps: ta.Sequence[ProviderImpl]
+
+    @property
+    def providers(self) -> ta.Iterable[Provider]:
+        for p in self.ps:
+            yield from p.providers
+
+    def provide(self, injector: Injector) -> ta.Any:
+        rv = set()
+        for ep in self.ps:
+            o = ep.provide(injector)
+            rv.add(o)
+        return rv
+
+
+@dc.dataclass(frozen=True, eq=False)
+class MapProviderImpl(ProviderImpl, lang.Final):
+    class Entry(ta.NamedTuple):
+        k: ta.Any
+        v: ProviderImpl
+
+    es: ta.Sequence[Entry]
+
+    @property
+    def providers(self) -> ta.Iterable[Provider]:
+        for e in self.es:
+            yield from e.v.providers
+
+    def provide(self, injector: Injector) -> ta.Any:
+        rv = {}
+        for e in self.es:
+            o = e.v.provide(injector)
+            rv[e.k] = o
+        return rv
+
+
+def make_multi_provider_impl(p: Provider, es_by_ty: ta.MutableMapping[type, list[Element]]) -> ProviderImpl:
+    if isinstance(p, SetProvider):
+        sbs: ta.Iterable[SetBinding] = es_by_ty.pop(SetBinding, ())  # type: ignore
+        return SetProviderImpl([
+            LinkProviderImpl(LinkProvider(sb.dst))
+            for sb in sbs
+        ])
+
+    elif isinstance(p, MapProvider):
+        mbs: ta.Iterable[MapBinding] = es_by_ty.pop(MapBinding, ())  # type: ignore
+        return MapProviderImpl([
+            MapProviderImpl.Entry(
+                mb.map_key,
+                LinkProviderImpl(LinkProvider(mb.dst)),
+            )
+            for mb in mbs
+        ])
+
+    else:
+        raise TypeError(p)

omlish/inject/impl/providers.py

@@ -5,10 +5,9 @@ TODO:
 import abc
 import typing as ta
 
-from .. import Cls
-from ... import check
 from ... import dataclasses as dc
 from ... import lang
+from ... import reflect as rfl
 from ..injector import Injector
 from ..inspect import KwargsTarget
 from ..providers import ConstProvider
@@ -19,6 +18,9 @@ from ..providers import Provider
 from .inspect import build_kwargs_target
 
 
+##
+
+
 class ProviderImpl(lang.Abstract):
     @property
     @abc.abstractmethod
@@ -30,14 +32,20 @@ class ProviderImpl(lang.Abstract):
         raise NotImplementedError
 
 
+##
+
+
 @dc.dataclass(frozen=True, eq=False)
 class InternalProvider(Provider):
     impl: ProviderImpl
 
-    def provided_cls(self) -> Cls | None:
+    def provided_ty(self) -> rfl.Type | None:
         raise TypeError
 
 
+##
+
+
 @dc.dataclass(frozen=True, eq=False)
 class CallableProviderImpl(ProviderImpl, lang.Final):
     p: FnProvider | CtorProvider
@@ -51,6 +59,9 @@ class CallableProviderImpl(ProviderImpl, lang.Final):
         return injector.inject(self.kt)
 
 
+##
+
+
 @dc.dataclass(frozen=True, eq=False)
 class ConstProviderImpl(ProviderImpl, lang.Final):
     p: ConstProvider
@@ -63,6 +74,9 @@ class ConstProviderImpl(ProviderImpl, lang.Final):
         return self.p.v
 
 
+##
+
+
 @dc.dataclass(frozen=True, eq=False)
 class LinkProviderImpl(ProviderImpl, lang.Final):
     p: LinkProvider
@@ -75,46 +89,12 @@ class LinkProviderImpl(ProviderImpl, lang.Final):
         return injector.provide(self.p.k)
 
 
-_ILLEGAL_MULTI_TYPES = (str, bytes, bytearray)
-
-
-def _unnest_multi_providers(ps: ta.Iterable[ProviderImpl]) -> ta.Sequence[ProviderImpl]:
-    lst = []
-
-    def rec(o):
-        if isinstance(o, MultiProviderImpl):
-            for c in o.ps:
-                rec(c)
-        else:
-            lst.append(check.isinstance(o, ProviderImpl))
-
-    for o in ps:
-        rec(o)
-    return tuple(lst)
-
-
-@dc.dataclass(frozen=True, eq=False)
-class MultiProviderImpl(ProviderImpl, lang.Final):
-    ps: ta.Sequence[ProviderImpl] = dc.xfield(coerce=_unnest_multi_providers)
-
-    @property
-    def providers(self) -> ta.Iterable[Provider]:
-        for p in self.ps:
-            yield from p.providers
-
-    def provide(self, injector: Injector) -> ta.Any:
-        rv = []
-        for ep in self.ps:
-            o = ep.provide(injector)
-            if isinstance(o, _ILLEGAL_MULTI_TYPES):
-                raise TypeError(o)
-            rv.extend(o)
-        return rv
+##
 
 
 PROVIDER_IMPLS_BY_PROVIDER: dict[type[Provider], ta.Callable[..., ProviderImpl]] = {
     FnProvider: lambda p: CallableProviderImpl(p, build_kwargs_target(p.fn)),
-    CtorProvider: lambda p: CallableProviderImpl(p, build_kwargs_target(p.cls)),
+    CtorProvider: lambda p: CallableProviderImpl(p, build_kwargs_target(p.ty)),
     ConstProvider: ConstProviderImpl,
     LinkProvider: LinkProviderImpl,
     InternalProvider: lambda p: p.impl,

omlish/inject/{proxy.py → impl/proxy.py}

@@ -1,7 +1,7 @@
 import typing as ta
 
-from .. import lang
-from .. import check
+from ... import check
+from ... import lang
 
 
 @lang.cached_function

omlish/inject/impl/scopes.py

@@ -25,6 +25,7 @@ from .bindings import BindingImpl
 from .providers import PROVIDER_IMPLS_BY_PROVIDER
 from .providers import ProviderImpl
 
+
 if ta.TYPE_CHECKING:
     from . import injector as injector_
 else:
@@ -141,8 +142,8 @@ class SeededScopeImpl(ScopeImpl):
         def __init__(self, ss: SeededScope, i: Injector) -> None:
             super().__init__()
             self._ss = check.isinstance(ss, SeededScope)
-            ii = check.isinstance(i, injector_.InjectorImpl)
-            self._ssi = check.isinstance(ii.get_scope_impl(self._ss), SeededScopeImpl)
+            self._ii = check.isinstance(i, injector_.InjectorImpl)
+            self._ssi = check.isinstance(self._ii.get_scope_impl(self._ss), SeededScopeImpl)
 
         @contextlib.contextmanager
         def __call__(self, seeds: ta.Mapping[Key, ta.Any]) -> ta.Generator[None, None, None]:
@@ -150,6 +151,7 @@ class SeededScopeImpl(ScopeImpl):
                 if self._ssi._st is not None:  # noqa
                     raise ScopeAlreadyOpenError(self._ss)
                 self._ssi._st = SeededScopeImpl.State(dict(seeds))  # noqa
+                self._ii._instantiate_eagers(self._ss)  # noqa
                 yield
             finally:
                 if self._ssi._st is None:  # noqa

omlish/inject/injector.py

@@ -6,6 +6,7 @@ from .elements import Elements
 from .inspect import KwargsTarget
 from .keys import Key
 
+
 _impl = lang.proxy_import('.impl.injector', __package__)
 
 

omlish/inject/keys.py

@@ -3,6 +3,7 @@ import typing as ta
 
 from .. import dataclasses as dc
 from .. import lang
+from .. import reflect as rfl
 
 
 T = ta.TypeVar('T')
@@ -14,9 +15,8 @@ T = ta.TypeVar('T')
 @dc.dataclass(frozen=True)
 @dc.extra_params(cache_hash=True)
 class Key(lang.Final, ta.Generic[T]):
-    cls: type[T] | ta.NewType
+    ty: rfl.Type = dc.xfield(coerce=rfl.type_)
     tag: ta.Any = dc.field(default=None, kw_only=True)
-    multi: bool = dc.field(default=False, kw_only=True)
 
 
 ##
@@ -27,17 +27,11 @@ def as_key(o: ta.Any) -> Key:
         raise TypeError(o)
     if isinstance(o, Key):
         return o
-    if isinstance(o, (type, ta.NewType)):  # noqa
-        return Key(o)
-    raise TypeError(o)
+    return Key(rfl.type_(o))
 
 
 ##
 
 
-def multi(o: ta.Any) -> Key:
-    return dc.replace(as_key(o), multi=True)
-
-
 def tag(o: ta.Any, t: ta.Any) -> Key:
     return dc.replace(as_key(o), tag=t)