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

omlish/formats/yaml.py

@@ -0,0 +1,223 @@
+"""
+TODO:
+ - !! shared 'object format' node hierarchy
+  - fuse yaml and hocon - marks, *COMMENTS*, etc
+ - goal: perfect rewrites (comments, whitespace)
+  - or at least comments
+ - rename 'objects'? codecs/serde interplay still unresolved
+"""
+import datetime
+import types
+import typing as ta
+
+from .. import check
+from .. import dataclasses as dc
+from .. import lang
+
+
+if ta.TYPE_CHECKING:
+    import yaml
+    import yaml.nodes as yaml_nodes
+else:
+    yaml = lang.proxy_import('yaml')
+    yaml_nodes = lang.proxy_import('yaml.nodes')
+
+
+T = ta.TypeVar('T')
+
+
+@dc.dataclass(frozen=True)
+class NodeWrapped(lang.Final, ta.Generic[T]):
+    value: T
+    node: 'yaml_nodes.Node'
+
+    def __post_init__(self) -> None:
+        if isinstance(self.value, NodeWrapped):
+            raise TypeError(self.value)
+        if not isinstance(self.node, yaml_nodes.Node):
+            raise TypeError(self.node)
+
+
+class NodeUnwrapper:
+
+    seq_types: tuple[type, ...] = (
+        list,
+        set,
+        tuple,
+    )
+
+    def unwrap_seq(self, nw: NodeWrapped[T]) -> T:
+        return nw.value.__class__(map(self.unwrap, nw.value))  # type: ignore
+
+    map_types: tuple[type, ...] = (
+        dict,
+    )
+
+    def unwrap_map(self, nw: NodeWrapped[T]) -> T:
+        return nw.value.__class__({self.unwrap(k): self.unwrap(v) for k, v in nw.value.items()})  # type: ignore
+
+    scalar_types: tuple[type, ...] = (
+        bool,
+        bytes,
+        datetime.datetime,
+        float,
+        int,
+        str,
+        type(None),
+    )
+
+    def unwrap_scalar(self, nw: NodeWrapped[T]) -> T:
+        return nw.value
+
+    def unwrap_unknown(self, nw: NodeWrapped[T]) -> T:
+        raise TypeError(nw.value)
+
+    def unwrap(self, nw: NodeWrapped[T]) -> T:
+        check.isinstance(nw, NodeWrapped)
+        if isinstance(nw.value, self.seq_types):
+            return self.unwrap_seq(nw)
+        elif isinstance(nw.value, self.map_types):
+            return self.unwrap_map(nw)
+        elif isinstance(nw.value, self.scalar_types):
+            return self.unwrap_scalar(nw)
+        else:
+            return self.unwrap_unknown(nw)
+
+
+def unwrap(nw: NodeWrapped[T]) -> T:
+    return NodeUnwrapper().unwrap(nw)
+
+
+class NodeWrappingConstructorMixin:
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        ctors = {
+            fn.__name__: fn for fn in [
+                self.__class__.construct_yaml_omap,
+                self.__class__.construct_yaml_pairs,
+            ]
+        }
+        self.yaml_constructors = {
+            tag: ctors.get(ctor.__name__, ctor)
+            for tag, ctor in self.yaml_constructors.items()  # type: ignore  # noqa
+        }
+
+    def construct_object(self, node, deep=False):
+        value = super().construct_object(node, deep=deep)  # type: ignore
+        return NodeWrapped(value, node)
+
+    def __construct_yaml_pairs(self, node, fn):
+        omap = []  # type: ignore
+        gen = check.isinstance(fn(node), types.GeneratorType)
+        yield omap
+        uomap = next(gen)
+        lang.exhaust(gen)
+        for key, value in uomap:  # type: ignore
+            omap.append(NodeWrapped((key, value), node))
+
+    def construct_yaml_omap(self, node):
+        return self.__construct_yaml_pairs(node, super().construct_yaml_omap)  # type: ignore  # noqa
+
+    def construct_yaml_pairs(self, node):
+        return self.__construct_yaml_pairs(node, super().construct_yaml_pairs)  # type: ignore  # noqa
+
+
+class _cached_class_property:  # noqa
+    def __init__(self, fn):
+        super().__init__()
+        self._fn = fn
+        self._attr = None
+
+    def __call__(self, *args, **kwargs):
+        raise TypeError
+
+    def __set_name__(self, owner, name):
+        self._attr = '_' + name
+
+    def __get__(self, instance, owner=None):
+        if owner is None:
+            if instance is None:
+                raise RuntimeError
+            owner = instance.__class__
+        try:
+            return owner.__dict__[self._attr]
+        except KeyError:
+            ret = self._fn(owner)
+            setattr(owner, self._attr, ret)  # type: ignore
+            return ret
+
+
+class WrappedLoaders(lang.Namespace):
+
+    @staticmethod
+    def _wrap(cls):  # noqa
+        return type('NodeWrapping$' + cls.__name__, (NodeWrappingConstructorMixin, cls), {})
+
+    Base: type['yaml.BaseLoader'] = _cached_class_property(lambda cls: cls._wrap(yaml.BaseLoader))  # type: ignore
+
+    @classmethod
+    def base(cls, *args, **kwargs) -> 'yaml.BaseLoader':
+        return cls.Base(*args, **kwargs)
+
+    Full: type['yaml.FullLoader'] = _cached_class_property(lambda cls: cls._wrap(yaml.FullLoader))  # type: ignore
+
+    @classmethod
+    def full(cls, *args, **kwargs) -> 'yaml.FullLoader':
+        return cls.Full(*args, **kwargs)
+
+    Safe: type['yaml.SafeLoader'] = _cached_class_property(lambda cls: cls._wrap(yaml.SafeLoader))  # type: ignore
+
+    @classmethod
+    def safe(cls, *args, **kwargs) -> 'yaml.SafeLoader':
+        return cls.Safe(*args, **kwargs)
+
+    Unsafe: type['yaml.UnsafeLoader'] = _cached_class_property(lambda cls: cls._wrap(yaml.UnsafeLoader))  # type: ignore
+
+    @classmethod
+    def unsafe(cls, *args, **kwargs) -> 'yaml.UnsafeLoader':
+        return cls.Unsafe(*args, **kwargs)
+
+    CBase: type['yaml.CBaseLoader'] = _cached_class_property(lambda cls: cls._wrap(yaml.CBaseLoader))  # type: ignore
+
+    @classmethod
+    def cbase(cls, *args, **kwargs) -> 'yaml.CBaseLoader':
+        return cls.CBase(*args, **kwargs)
+
+    CFull: type['yaml.CFullLoader'] = _cached_class_property(lambda cls: cls._wrap(yaml.CFullLoader))  # type: ignore
+
+    @classmethod
+    def cfull(cls, *args, **kwargs) -> 'yaml.CFullLoader':
+        return cls.CFull(*args, **kwargs)
+
+    CSafe: type['yaml.CSafeLoader'] = _cached_class_property(lambda cls: cls._wrap(yaml.CSafeLoader))  # type: ignore
+
+    @classmethod
+    def csafe(cls, *args, **kwargs) -> 'yaml.CSafeLoader':
+        return cls.CSafe(*args, **kwargs)
+
+    CUnsafe: type['yaml.CUnsafeLoader'] = _cached_class_property(lambda cls: cls._wrap(yaml.CUnsafeLoader))  # type: ignore  # noqa
+
+    @classmethod
+    def cunsafe(cls, *args, **kwargs) -> 'yaml.CUnsafeLoader':
+        return cls.CUnsafe(*args, **kwargs)
+
+
+def load(stream, Loader):  # noqa
+    with lang.disposing(Loader(stream)) as loader:
+        return loader.get_single_data()
+
+
+def load_all(stream, Loader):  # noqa
+    with lang.disposing(Loader(stream)) as loader:
+        while loader.check_data():
+            yield loader.get_data()
+
+
+def full_load(stream):  # noqa
+    return load(stream, yaml.FullLoader)
+
+
+def full_load_all(stream):  # noqa  # noqa
+    return load_all(stream, yaml.FullLoader)

omlish/graphs/trees.py

@@ -190,7 +190,7 @@ class BasicTreeAnalysis(ta.Generic[NodeT]):
         e: ta.Any
         d: ta.Any
         if identity:
-            e, d = id, col.unique_map((id(n), n) for n, _ in pairs)
+            e, d = id, col.unique_map(((id(n), n) for n, _ in pairs), strict=True)
         else:
             e, d = lang.identity, lang.identity
         tsd = {e(n): {e(p)} for n, p in parents_by_node.items()}

omlish/http/asgi.py

@@ -18,9 +18,10 @@ AsgiMessage: ta.TypeAlias = ta.Mapping[str, ta.Any]
 AsgiRecv: ta.TypeAlias = ta.Callable[[], ta.Awaitable[AsgiMessage]]
 AsgiSend: ta.TypeAlias = ta.Callable[[AsgiMessage], ta.Awaitable[None]]
 AsgiApp: ta.TypeAlias = ta.Callable[[AsgiScope, AsgiRecv, AsgiSend], ta.Awaitable[None]]
+AsgiWrapper: ta.TypeAlias = ta.Callable[[AsgiApp, AsgiScope, AsgiRecv, AsgiSend], ta.Awaitable[None]]
 
 
-class AbstractAsgiApp(abc.ABC):
+class AsgiApp_(abc.ABC):  # noqa
     @abc.abstractmethod
     async def __call__(self, scope: AsgiScope, recv: AsgiRecv, send: AsgiSend) -> None:
         raise NotImplementedError

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,9 @@
-import http  # noqa
+"""
+TODO:
+ - import mimetypes lol
+"""
+import base64
+import http
 
 
 ##
@@ -31,6 +36,8 @@ STATUS_GATEWAY_TIMEOUT = format_status(http.HTTPStatus.GATEWAY_TIMEOUT)
 
 
 HEADER_CONTENT_TYPE = b'Content-Type'
+HEADER_ACCEPT = b'Accept'
+
 CONTENT_CHARSET_UTF8 = b'charset=utf-8'
 
 CONTENT_TYPE_BYTES = b'application/octet-stream'
@@ -43,5 +50,19 @@ 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_PNG = b'image/png'
+
 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/sessions.py

@@ -10,6 +10,7 @@ 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
@@ -44,13 +45,19 @@ def bytes_to_int(bytestr: bytes) -> int:
 class Signer:
     @dc.dataclass(frozen=True)
     class Config:
-        secret_key: str
+        secret_key: str | sec.SecretRef = dc.field()
         salt: str = 'cookie-session'
 
-    def __init__(self, config: Config) -> None:
+    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:
@@ -58,7 +65,7 @@ class Signer:
 
     @lang.cached_function
     def derive_key(self) -> bytes:
-        mac = hmac.new(self._config.secret_key.encode(), digestmod=self.digest())
+        mac = hmac.new(self._secrets.fix(self._config.secret_key).reveal().encode(), digestmod=self.digest())
         mac.update(self._config.salt.encode())
         return mac.digest()
 

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,57 +39,85 @@ from .injector import (  # noqa
 from .inspect import (  # noqa
     Kwarg,
     KwargsTarget,
+    build_kwargs_target,
+    tag,
 )
 
 from .keys import (  # noqa
     Key,
     as_key,
-    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,
-    bind_map_provider,
-    bind_set_provider,
+    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
     Scope,
+    Tag,
     Unscoped,
 )
+
+from .utils import (  # noqa
+    ConstFn,
+)

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,
+
+        to_fn: ta.Any = None,
+        to_ctor: ta.Any = None,
+        to_const: ta.Any = None,
+        to_key: ta.Any = None,
+
+        in_: Scope | None = None,
+        singleton: bool = False,
+
+        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))