omlish 0.0.0.dev1__py3-none-any.whl

omlish/graphs/trees.py

@@ -0,0 +1,249 @@
+"""
+TODO:
+ - @property dfs, bfs
+"""
+import functools
+import typing as ta
+import weakref
+
+from .. import cached
+from .. import check
+from .. import collections as col
+from .. import lang
+
+
+T = ta.TypeVar('T')
+NodeT = ta.TypeVar('NodeT')
+NodeWalker = ta.Callable[[NodeT], ta.Iterable[NodeT]]
+NodeGenerator = ta.Generator[NodeT, None, None]
+
+
+class NodeException(ta.Generic[NodeT], Exception):
+    def __init__(self, node: NodeT, msg: str, *args, **kwargs) -> None:
+        super().__init__(msg, *args, **kwargs)  # noqa
+        self._node = node
+
+    @property
+    def node(self) -> NodeT:
+        return self._node
+
+
+class DuplicateNodeException(NodeException[NodeT]):
+    def __init__(self, node: NodeT, *args, **kwargs) -> None:
+        super().__init__(node, f'Duplicate node: {node!r}', *args, **kwargs)
+
+
+class UnknownNodeException(NodeException[NodeT]):
+    def __init__(self, node: NodeT, *args, **kwargs) -> None:
+        super().__init__(node, f'Unknown node: {node!r}', *args, **kwargs)
+
+
+class BasicTreeAnalysis(ta.Generic[NodeT]):
+
+    def __init__(
+            self,
+            root: NodeT,
+            walker: NodeWalker[NodeT],
+            *,
+            identity: bool = False,
+    ) -> None:
+        super().__init__()
+
+        self._root = root
+        self._walker = walker
+        self._identity = identity
+
+        self._set_fac: ta.Callable[..., ta.MutableSet[NodeT]] = col.IdentitySet if identity else set
+        self._dict_fac: ta.Callable[..., ta.MutableMapping[NodeT, ta.Any]] = col.IdentityKeyDict if identity else dict
+        self._idx_seq_fac: ta.Callable[..., col.IndexedSeq[NodeT]] = functools.partial(col.IndexedSeq, identity=identity)  # noqa
+
+        def walk(cur: NodeT, parent: ta.Optional[NodeT]) -> None:
+            check.not_none(cur)
+            if cur in node_set:
+                raise DuplicateNodeException(cur)
+
+            nodes.append(cur)
+            node_set.add(cur)
+            if parent is None:
+                check.state(cur is root)
+            elif parent not in node_set:
+                raise UnknownNodeException(parent)
+
+            parents_by_node[cur] = parent
+
+            children_by_node[cur] = children = list(walker(cur))
+            child_sets_by_node[cur] = self._set_fac(children)
+            for child in children:
+                walk(child, cur)
+
+        nodes: list[NodeT] = []
+        node_set: ta.MutableSet[NodeT] = self._set_fac()  # type: ignore
+        children_by_node: ta.MutableMapping[ta.Optional[NodeT], ta.Sequence[NodeT]] = self._dict_fac()  # type: ignore
+        child_sets_by_node: ta.MutableMapping[ta.Optional[NodeT], ta.AbstractSet[NodeT]] = self._dict_fac()  # type: ignore  # noqa
+        parents_by_node: ta.MutableMapping[NodeT, ta.Optional[NodeT]] = self._dict_fac()  # type: ignore
+
+        children_by_node[None] = [root]
+        child_sets_by_node[None] = self._set_fac([root])  # type: ignore
+
+        walk(root, None)
+
+        self._nodes = self._idx_seq_fac(nodes)  # type: ignore
+        self._node_set: ta.AbstractSet[NodeT] = node_set
+        self._children_by_node: ta.Mapping[ta.Optional[NodeT], col.IndexedSeq[NodeT]] = self._dict_fac(  # type: ignore
+            [(n, self._idx_seq_fac(cs)) for n, cs in children_by_node.items()])
+        self._child_sets_by_node: ta.Mapping[ta.Optional[NodeT], ta.AbstractSet[NodeT]] = child_sets_by_node
+        self._parents_by_node: ta.Mapping[NodeT, ta.Optional[NodeT]] = parents_by_node
+
+    @property
+    def root(self) -> NodeT:
+        return self._root
+
+    @property
+    def nodes(self) -> col.IndexedSeq[NodeT]:
+        return self._nodes
+
+    @property
+    def walker(self) -> NodeWalker[NodeT]:
+        return self._walker
+
+    @property
+    def identity(self) -> bool:
+        return self._identity
+
+    @property
+    def node_set(self) -> ta.AbstractSet[NodeT]:
+        return self._node_set
+
+    @property
+    def children_by_node(self) -> ta.Mapping[ta.Optional[NodeT], col.IndexedSeq[NodeT]]:
+        return self._children_by_node
+
+    @property
+    def child_sets_by_node(self) -> ta.Mapping[ta.Optional[NodeT], ta.AbstractSet[NodeT]]:
+        return self._child_sets_by_node
+
+    @property
+    def parents_by_node(self) -> ta.Mapping[NodeT, ta.Optional[NodeT]]:
+        return self._parents_by_node
+
+    @classmethod
+    def from_parents(
+            cls,
+            src: ta.Union[
+                ta.Mapping[NodeT, ta.Optional[NodeT]],
+                ta.Iterable[tuple[NodeT, ta.Optional[NodeT]]],
+            ],
+            *,
+            identity: bool = False,
+            **kwargs
+    ) -> 'BasicTreeAnalysis[NodeT]':
+        pairs: ta.Sequence[tuple[NodeT, NodeT]]
+        if isinstance(src, ta.Mapping):
+            pairs = list(src.items())  # type: ignore
+        elif isinstance(src, ta.Iterable):
+            pairs = list(src)  # type: ignore
+        else:
+            raise TypeError(src)
+
+        pairs = [(check.not_none(n), p) for n, p in pairs]
+
+        root = check.single([n for n, p in pairs if p is None])  # noqa
+
+        children_by_node: ta.MutableMapping[NodeT, ta.MutableSequence[NodeT]] = col.IdentityKeyDict() if identity else {}  # noqa
+        for n, _ in pairs:
+            children_by_node[n] = []
+        for n, p in pairs:
+            if p is not None:
+                children_by_node[p].append(n)
+
+        return cls(
+            root,
+            children_by_node.__getitem__,
+            identity=identity,
+            **kwargs,
+        )
+
+    @classmethod
+    def from_children(
+            cls,
+            src: ta.Union[
+                ta.Mapping[NodeT, ta.Iterable[NodeT]],
+                ta.Iterable[tuple[NodeT, ta.Iterable[NodeT]]],
+            ],
+            *,
+            identity: bool = False,
+            **kwargs
+    ) -> 'BasicTreeAnalysis[NodeT]':
+        pairs: ta.Sequence[tuple[NodeT, ta.Sequence[NodeT]]]
+        if isinstance(src, ta.Mapping):
+            pairs = list(src.items())  # type: ignore
+        elif isinstance(src, ta.Iterable):
+            pairs = list(src)  # type: ignore
+        else:
+            raise TypeError(src)
+
+        pairs = [(check.not_none(n), [check.not_none(c) for c in cs]) for n, cs in pairs]
+
+        children_by_node: ta.MutableMapping[NodeT, ta.Sequence[NodeT]] = col.IdentityKeyDict() if identity else {}
+        parents_by_node: ta.MutableMapping[NodeT, NodeT] = col.IdentityKeyDict() if identity else {}
+        for n, cs in pairs:
+            check.not_in(n, children_by_node)
+            children_by_node[n] = cs
+            for c in cs:
+                check.not_in(c, parents_by_node)
+                parents_by_node[c] = n
+
+        e: ta.Any
+        d: ta.Any
+        if identity:
+            e, d = id, col.unique_dict((id(n), n) for n, _ in pairs)
+        else:
+            e, d = lang.identity, lang.identity
+        tsd = {e(n): {e(p)} for n, p in parents_by_node.items()}
+        ts = list(col.mut_toposort(tsd))
+        root = d(check.single(ts[0]))
+
+        return cls(
+            root,
+            children_by_node.__getitem__,
+            identity=identity,
+            **kwargs,
+        )
+
+    @cached.property
+    def _node_sets_by_type(self) -> ta.MutableMapping[type, ta.AbstractSet[NodeT]]:
+        return weakref.WeakKeyDictionary()
+
+    def get_node_type_set(self, ty: type[T]) -> ta.AbstractSet[T]:
+        try:
+            return self._node_sets_by_type[ty]  # type: ignore
+        except KeyError:
+            ret = self._node_sets_by_type[ty] = self._set_fac(n for n in self.nodes if isinstance(n, ty))
+            return ret  # type: ignore
+
+    def iter_ancestors(self, node: NodeT) -> NodeGenerator[NodeT]:
+        cur: ta.Optional[NodeT] = node
+        while True:
+            cur = self.parents_by_node.get(cur)  # type: ignore
+            if cur is None:
+                break
+            yield cur
+
+    def get_lineage(self, node: NodeT) -> col.IndexedSeq[NodeT]:
+        return self._idx_seq_fac(reversed([node, *self.iter_ancestors(node)]))
+
+    def get_first_parent_of_type(self, node: NodeT, ty: type[T]) -> ta.Optional[T]:
+        for cur in self.iter_ancestors(node):
+            if isinstance(cur, ty):
+                return cur
+        return None
+
+    @cached.property
+    def depths_by_node(self) -> ta.Mapping[NodeT, int]:
+        def rec(n, d):
+            dct[n] = d
+            for c in self._children_by_node[n]:
+                rec(c, d + 1)
+        dct: ta.MutableMapping[NodeT, int] = self._dict_fac()
+        rec(self._root, 0)
+        return dct

omlish/http/consts.py

@@ -0,0 +1,20 @@
+import http  # noqa
+
+
+def format_status(status: http.HTTPStatus) -> str:
+    return '%d %s' % (int(status), status.phrase)
+
+
+STATUS_OK = format_status(http.HTTPStatus.OK)
+STATUS_BAD_REQUEST = format_status(http.HTTPStatus.BAD_REQUEST)
+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)
+
+
+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'
+CONTENT_TYPE_BYTES = b'application/octet-stream'

omlish/http/wsgi.py

@@ -0,0 +1,34 @@
+import typing as ta
+
+from .. import lang
+
+
+Environ = ta.Mapping[str, ta.Any]
+StartResponse = ta.Callable[[str, ta.Iterable[tuple[str | bytes, str | bytes]]], ta.Callable[[lang.BytesLike], None]]
+App = ta.Callable[[Environ, StartResponse], ta.Iterable[lang.BytesLike]]
+
+
+# class App(lang.Abstract):
+#
+#     def __enter__(self: AppT) -> AppT:
+#         return self
+#
+#     def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+#         return None
+#
+#     @abc.abstractmethod
+#     def __call__(self, environ: Environ, start_response: StartResponse) -> ta.Iterable[bytes]:
+#         raise NotImplementedError
+
+
+# class AsyncApp(lang.Abstract):
+#
+#     async def __aenter__(self: AppT) -> AppT:
+#         return self
+#
+#     async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
+#         return None
+#
+#     @abc.abstractmethod
+#     async def __call__(self, scope, receive, send) -> ta.Iterable[bytes]:
+#         raise NotImplementedError

omlish/inject/__init__.py

@@ -0,0 +1,85 @@
+"""
+~> https://github.com/google/guice/commit/70248eafa90cd70a68b293763e53f6aec656e73c
+"""
+from .bindings import (  # noqa
+    Binding,
+    as_,
+    as_binding,
+)
+
+from .eagers import (  # noqa
+    eager,
+)
+
+from .elements import (  # noqa
+    as_elements,
+    Element,
+    Elements,
+)
+
+from .exceptions import (  # noqa
+    CyclicDependencyException,
+    DuplicateKeyException,
+    KeyException,
+    ScopeAlreadyOpenException,
+    ScopeException,
+    ScopeNotOpenException,
+    UnboundKeyException,
+)
+
+from .injector import (  # noqa
+    create_injector,
+    Injector,
+)
+
+from .inspect import (  # noqa
+    Kwarg,
+    KwargsTarget,
+)
+
+from .keys import (  # noqa
+    Key,
+    as_key,
+    multi,
+    tag,
+)
+
+from .managed import (  # noqa
+    create_managed_injector,
+)
+
+from .overrides import (  # noqa
+    override,
+)
+
+from .private import (  # noqa
+    expose,
+    private,
+)
+
+from .providers import (  # noqa
+    Provider,
+    as_provider,
+    const,
+    ctor,
+    fn,
+    link,
+)
+
+from .scopes import (  # noqa
+    ScopeBinding,
+    SeededScope,
+    Singleton,
+    Thread,
+    bind_scope,
+    bind_scope_seed,
+    enter_seeded_scope,
+    in_,
+    singleton,
+)
+
+from .types import (  # noqa
+    Cls,
+    Scope,
+    Unscoped,
+)

omlish/inject/binder.py

@@ -0,0 +1,12 @@
+import typing as ta
+
+from .elements import Element
+from .elements import Elements
+from .elements import as_elements
+
+
+def bind(*args: ta.Any) -> Elements:
+    if all(isinstance(a, (Element, Elements)) for a in args):
+        return as_elements(*args)
+
+    raise TypeError(args)

omlish/inject/bindings.py

@@ -0,0 +1,49 @@
+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))

omlish/inject/eagers.py

@@ -0,0 +1,21 @@
+"""
+TODO:
+ - SCOPED - eagers for EACH SCOPE
+"""
+import typing as ta
+
+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))

omlish/inject/elements.py

@@ -0,0 +1,43 @@
+"""
+TODO:
+ - as_element[s] - universal
+"""
+import typing as ta
+
+from .. import dataclasses as dc
+from .. import lang
+
+
+class Element(lang.Abstract):
+    pass
+
+
+@dc.dataclass(frozen=True)
+class Elements(lang.Final):
+    es: frozenset[Element] | None = None
+    cs: frozenset['Elements'] | None = None
+
+    def __iter__(self) -> ta.Generator[Element, None, None]:
+        if self.es:
+            yield from self.es
+        if self.cs:
+            for c in self.cs:
+                yield from c
+
+
+def as_elements(*args: ta.Union[Element, Elements]) -> Elements:
+    es: set[Element] = set()
+    cs: set['Elements'] = set()
+    for a in args:
+        if isinstance(a, Element):
+            es.add(a)
+        elif isinstance(a, Elements):
+            cs.add(a)
+        else:
+            raise TypeError(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

@@ -0,0 +1,49 @@
+import typing as ta
+
+from .. import dataclasses as dc
+from .keys import Key
+from .types import Scope
+
+
+##
+
+
+@dc.dataclass()
+class KeyException(Exception):
+    key: Key
+
+    source: ta.Any = None
+    name: ta.Optional[str] = None
+
+
+@dc.dataclass()
+class UnboundKeyException(KeyException):
+    pass
+
+
+@dc.dataclass()
+class DuplicateKeyException(KeyException):
+    pass
+
+
+@dc.dataclass()
+class CyclicDependencyException(KeyException):
+    pass
+
+
+##
+
+
+@dc.dataclass()
+class ScopeException(Exception):
+    scope: Scope
+
+
+@dc.dataclass()
+class ScopeAlreadyOpenException(ScopeException):
+    pass
+
+
+@dc.dataclass()
+class ScopeNotOpenException(ScopeException):
+    pass

omlish/inject/impl/bindings.py

@@ -0,0 +1,19 @@
+from ... import dataclasses as dc
+from ... import lang
+from ..bindings import Binding
+from ..keys import Key
+from ..types import Scope
+from ..types import Unscoped
+from .providers import ProviderImpl
+
+
+##
+
+
+@dc.dataclass(frozen=True, eq=False)
+@dc.extra_params(cache_hash=True)
+class BindingImpl(lang.Final):
+    key: Key
+    provider: ProviderImpl
+    scope: Scope = Unscoped()
+    binding: Binding | None = None