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

omlish/http/sessions.py

@@ -0,0 +1,204 @@
+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 .. import secrets as sec
+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 | sec.Secret = dc.field()
+        salt: str = 'cookie-session'
+
+    def __init__(
+            self,
+            config: Config,
+            *,
+            secrets: sec.Secrets = sec.EMPTY_SECRETS,
+    ) -> None:
+        super().__init__()
+
+        self._config = config
+        self._secrets = secrets
+
+    @lang.cached_function
+    def digest(self) -> ta.Any:
+        return hashlib.sha1
+
+    @lang.cached_function
+    def derive_key(self) -> bytes:
+        mac = hmac.new(self._secrets.fix(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

@@ -1,26 +1,30 @@
 """
 ~> https://github.com/google/guice/commit/70248eafa90cd70a68b293763e53f6aec656e73c
 """
+from .binder import (  # noqa
+    bind,
+    bind_as_fn,
+)
+
 from .bindings import (  # noqa
     Binding,
-    as_,
-    as_binding,
 )
 
 from .eagers import (  # noqa
-    eager,
+    Eager,
 )
 
 from .elements import (  # noqa
-    as_elements,
     Element,
+    Elemental,
     Elements,
+    as_elements,
 )
 
 from .exceptions import (  # noqa
     BaseKeyError,
+    ConflictingKeyError,
     CyclicDependencyError,
-    DuplicateKeyError,
     ScopeAlreadyOpenError,
     ScopeError,
     ScopeNotOpenError,
@@ -35,51 +39,81 @@ from .injector import (  # noqa
 from .inspect import (  # noqa
     Kwarg,
     KwargsTarget,
+    build_kwargs_target,
+    tag,
 )
 
 from .keys import (  # noqa
     Key,
     as_key,
-    multi,
-    tag,
+)
+
+from .listeners import (  # noqa
+    ProvisionListener,
+    ProvisionListenerBinding,
+    bind_provision_listener,
 )
 
 from .managed import (  # noqa
+    create_async_managed_injector,
     create_managed_injector,
+    make_async_managed_provider,
+    make_managed_provider,
 )
 
+from .multis import (  # noqa
+    MapBinding,
+    MapProvider,
+    SetBinding,
+    SetProvider,
+    MapBinder,
+    SetBinder,
+
+    MapBinder as map_binder,  # noqa
+    SetBinder as set_binder,  # noqa
+)
+
+
 from .overrides import (  # noqa
+    Overrides,
     override,
 )
 
-from .private import (  # noqa
-    expose,
+from .origins import (  # noqa
+    HasOrigins,
+    Origin,
+    Origins,
+)
+
+from .privates import (  # noqa
+    Expose,
+    Private,
     private,
+
+    Expose as expose,  # noqa
 )
 
 from .providers import (  # noqa
+    ConstProvider,
+    CtorProvider,
+    FnProvider,
+    LinkProvider,
     Provider,
-    as_provider,
-    const,
-    ctor,
-    fn,
-    link,
 )
 
 from .scopes import (  # noqa
     ScopeBinding,
+    ScopeSeededProvider,
     SeededScope,
     Singleton,
     Thread,
     bind_scope,
     bind_scope_seed,
     enter_seeded_scope,
-    in_,
-    singleton,
 )
 
 from .types import (  # noqa
-    Cls,
     Scope,
+    Tag,
     Unscoped,
 )

omlish/inject/binder.py

@@ -1,12 +1,192 @@
+"""
+TODO:
+ - multis?
+
+class SetBinding(Element, lang.Final):
+class SetProvider(Provider):
+
+class MapBinding(Element, lang.Final):
+class MapProvider(Provider):
+"""
+import functools
+import inspect
+import types
 import typing as ta
 
+from .. import check
+from .. import dataclasses as dc
+from .. import lang
+from .. import reflect as rfl
+from .bindings import Binding
+from .eagers import Eager
 from .elements import Element
 from .elements import Elements
-from .elements import as_elements
+from .keys import Key
+from .keys import as_key
+from .privates import Expose
+from .providers import ConstProvider
+from .providers import CtorProvider
+from .providers import FnProvider
+from .providers import LinkProvider
+from .providers import Provider
+from .scopes import SCOPE_ALIASES
+from .scopes import Singleton
+from .types import Scope
+from .types import Unscoped
+
+
+if ta.TYPE_CHECKING:
+    from .impl.inspect import inspect as _inspect
+else:
+    _inspect = lang.proxy_import('.impl.inspect', __package__)
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+_FN_TYPES: tuple[type, ...] = (
+    types.FunctionType,
+    types.MethodType,
+
+    classmethod,
+    staticmethod,
+
+    functools.partial,
+    functools.partialmethod,
+)
+
+
+def _is_fn(obj: ta.Any) -> bool:
+    return isinstance(obj, _FN_TYPES)
+
+
+def bind_as_fn(cls: type[T]) -> type[T]:
+    check.isinstance(cls, type)
+    global _FN_TYPES
+    if cls not in _FN_TYPES:
+        _FN_TYPES = (*_FN_TYPES, cls)
+    return cls
+
+
+##
+
+
+_BANNED_BIND_TYPES = (
+    Element,
+    Provider,
+    Elements,
+    Scope,
+)
+
+
+def bind(
+        obj: ta.Any,
+        *,
+        tag: ta.Any = None,
+
+        in_: Scope | None = None,
+        singleton: bool = False,
+
+        to_fn: ta.Any = None,
+        to_ctor: ta.Any = None,
+        to_const: ta.Any = None,
+        to_key: ta.Any = None,
+
+        eager: bool = False,
+        expose: bool = False,
+) -> Element | Elements:
+    if obj is None or obj is inspect.Parameter.empty:
+        raise TypeError(obj)
+    if isinstance(obj, _BANNED_BIND_TYPES):
+        raise TypeError(obj)
+
+    ##
+
+    has_to = (
+        to_fn is not None or
+        to_ctor is not None or
+        to_const is not None or
+        to_key is not None
+    )
+    if isinstance(obj, Key):
+        key = obj
+    elif isinstance(obj, type):
+        if not has_to:
+            to_ctor = obj
+        key = Key(obj)
+    elif isinstance(obj, rfl.TYPES) or rfl.is_type(obj):
+        key = Key(obj)
+    elif _is_fn(obj) and not has_to:
+        sig = _inspect.signature(obj)
+        ty = rfl.type_(sig.return_annotation)
+        to_fn = obj
+        key = Key(ty)
+    else:
+        if to_const is not None:
+            raise TypeError('Cannot bind instance with to_const')
+        to_const = obj
+        key = Key(type(obj))
+    del has_to
+
+    ##
+
+    if tag is not None:
+        if key.tag is not None:
+            raise TypeError('Tag already set')
+        key = dc.replace(key, tag=tag)
+
+    ##
+
+    providers: list[Provider] = []
+    if to_fn is not None:
+        providers.append(FnProvider(to_fn))
+    if to_ctor is not None:
+        providers.append(CtorProvider(to_ctor))
+    if to_const is not None:
+        providers.append(ConstProvider(to_const))
+    if to_key is not None:
+        providers.append(LinkProvider(as_key(to_key)))
+    if not providers:
+        raise TypeError('Must specify provider')
+    if len(providers) > 1:
+        raise TypeError('May not specify multiple providers')
+    provider, = providers
+
+    ##
+
+    scopes: list[Scope] = []
+    if in_ is not None:
+        if isinstance(in_, str):
+            scopes.append(SCOPE_ALIASES[in_])
+        else:
+            scopes.append(check.isinstance(in_, Scope))
+    if singleton:
+        scopes.append(Singleton())
+    if len(scopes) > 1:
+        raise TypeError('May not specify multiple scopes')
+    scope: Scope
+    if not scopes:
+        scope = Unscoped()
+    else:
+        scope, = scopes
+
+    ##
+
+    binding = Binding(key, provider, scope)
+
+    ##
 
+    elements: list[Element] = [binding]
 
-def bind(*args: ta.Any) -> Elements:
-    if all(isinstance(a, (Element, Elements)) for a in args):
-        return as_elements(*args)
+    if eager:
+        elements.append(Eager(key))
+    if expose:
+        elements.append(Expose(key))
 
-    raise TypeError(args)
+    if len(elements) == 1:
+        return elements[0]
+    else:
+        return Elements(frozenset(elements))

omlish/inject/bindings.py

@@ -1,49 +1,16 @@
-import typing as ta
-
 from .. import check
 from .. import dataclasses as dc
 from .. import lang
 from .elements import Element
-from .elements import Elements
 from .keys import Key
-from .keys import as_key
 from .providers import Provider
-from .providers import as_provider
-from .providers import const
-from .providers import ctor
-from .providers import fn
 from .types import Scope
 from .types import Unscoped
 
 
-##
-
-
 @dc.dataclass(frozen=True)
 @dc.extra_params(cache_hash=True)
 class Binding(Element, lang.Final):
-    key: Key
-    provider: Provider
-    scope: Scope = Unscoped()
-
-
-##
-
-
-def as_binding(o: ta.Any) -> Binding:
-    check.not_none(o)
-    if isinstance(o, 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
-    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))
-
-
-def as_(k: ta.Any, p: ta.Any) -> Binding:
-    return Binding(as_key(k), as_provider(p))
+    key: Key = dc.xfield(coerce=check.of_isinstance(Key))
+    provider: Provider = dc.xfield(coerce=check.of_isinstance(Provider))
+    scope: Scope = dc.xfield(default=Unscoped(), coerce=check.of_isinstance(Scope))

omlish/inject/eagers.py

@@ -2,20 +2,14 @@
 TODO:
  - SCOPED - eagers for EACH SCOPE
 """
-import typing as ta
-
+from .. import check
 from .. import dataclasses as dc
 from .. import lang
 from .elements import Element
 from .keys import Key
-from .keys import as_key
 
 
 @dc.dataclass(frozen=True)
 @dc.extra_params(cache_hash=True)
 class Eager(Element, lang.Final):
-    key: Key
-
-
-def eager(k: ta.Any) -> Element:
-    return Eager(as_key(k))
+    key: Key = dc.xfield(coerce=check.of_isinstance(Key))

omlish/inject/elements.py

@@ -1,21 +1,26 @@
-"""
-TODO:
- - as_element[s] - universal
-"""
+import abc
 import typing as ta
 
+from .. import check
 from .. import dataclasses as dc
 from .. import lang
+from .impl.origins import HasOriginsImpl
 
 
-class Element(lang.Abstract):
+class Element(HasOriginsImpl, lang.Abstract, lang.PackageSealed):
     pass
 
 
+class ElementGenerator(lang.Abstract, lang.PackageSealed):
+    @abc.abstractmethod
+    def __iter__(self) -> ta.Iterator[Element]:
+        raise NotImplementedError
+
+
 @dc.dataclass(frozen=True)
 class Elements(lang.Final):
-    es: frozenset[Element] | None = None
-    cs: frozenset['Elements'] | None = None
+    es: frozenset[Element] | None = dc.xfield(None, coerce=check.of_isinstance((frozenset, None)))
+    cs: frozenset['Elements'] | None = dc.xfield(None, coerce=check.of_isinstance((frozenset, None)))
 
     def __iter__(self) -> ta.Generator[Element, None, None]:
         if self.es:
@@ -25,18 +30,34 @@ class Elements(lang.Final):
                 yield from c
 
 
-def as_elements(*args: Element | Elements) -> Elements:
+Elemental = ta.Union[  # noqa
+    Element,
+    Elements,
+    ElementGenerator,
+]
+
+
+def as_elements(*args: Elemental) -> Elements:
     es: set[Element] = set()
     cs: set[Elements] = set()
-    for a in args:
+
+    def rec(a):
         if isinstance(a, Element):
             es.add(a)
         elif isinstance(a, Elements):
             cs.add(a)
+        elif isinstance(a, ElementGenerator):
+            for n in a:
+                rec(n)
         else:
             raise TypeError(a)
+
+    for a in args:
+        rec(a)
+
     if not es and len(cs) == 1:
         return next(iter(cs))
+
     return Elements(
         frozenset(es) if es else None,
         frozenset(cs) if cs else None,

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 ConflictingKeyError(BaseKeyError):
     pass
 
 
 @dc.dataclass()
-class CyclicDependencyError(KeyError):
+class CyclicDependencyError(BaseKeyError):
     pass