omlish 0.0.0.dev338__tar.gz → 0.0.0.dev340__tar.gz

{omlish-0.0.0.dev338/omlish.egg-info → omlish-0.0.0.dev340}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omlish
-Version: 0.0.0.dev338
+Version: 0.0.0.dev340
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause

{omlish-0.0.0.dev338 → omlish-0.0.0.dev340}/README.md

@@ -14,7 +14,7 @@ Core utilities and foundational code. It's relatively large but completely self-
     late-loaded module globals.
   - **[classes](lang/classes)** - Class tools and bases, such as `Abstract` (which checks at subclass definition not
     instantiation), `Sealed` / `PackageSealed`, and `Final`.
-  - **[maybes](lang/maybes.py)** - A simple, nestable formalization of the presence or absence of an object, as in
+  - **[maybes](lite/maybes.py)** - A simple, nestable formalization of the presence or absence of an object, as in
     [many](https://en.cppreference.com/w/cpp/utility/optional)
     [other](https://docs.oracle.com/javase/8/docs/api/java/util/Optional.html)
     [languages](https://doc.rust-lang.org/std/option/).

{omlish-0.0.0.dev338 → omlish-0.0.0.dev340}/omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev338'
-__revision__ = '8d983648c5770796c8addb2cf217a0d7235a9b29'
+__version__ = '0.0.0.dev340'
+__revision__ = 'de9a88b0e8d5578e5348e4f23db01e09dd3ebbd0'
 
 
 #

{omlish-0.0.0.dev338 → omlish-0.0.0.dev340}/omlish/asyncs/bluelet/LICENSE

@@ -1,6 +1,6 @@
 Based on bluelet ( https://github.com/sampsyo/bluelet ) by Adrian Sampson, original license:
 
-THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
 WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

{omlish-0.0.0.dev338 → omlish-0.0.0.dev340}/omlish/asyncs/bluelet/api.py

@@ -1,7 +1,7 @@
 # ruff: noqa: UP006 UP007
 # @omlish-lite
 # Based on bluelet ( https://github.com/sampsyo/bluelet ) by Adrian Sampson, original license:
-# THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
 # WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 # COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 # OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

{omlish-0.0.0.dev338 → omlish-0.0.0.dev340}/omlish/asyncs/bluelet/core.py

@@ -1,7 +1,7 @@
 # ruff: noqa: UP006 UP007
 # @omlish-lite
 # Based on bluelet ( https://github.com/sampsyo/bluelet ) by Adrian Sampson, original license:
-# THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
 # WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 # COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 # OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

{omlish-0.0.0.dev338 → omlish-0.0.0.dev340}/omlish/asyncs/bluelet/events.py

@@ -1,7 +1,7 @@
 # ruff: noqa: UP007
 # @omlish-lite
 # Based on bluelet ( https://github.com/sampsyo/bluelet ) by Adrian Sampson, original license:
-# THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
 # WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 # COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 # OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

{omlish-0.0.0.dev338 → omlish-0.0.0.dev340}/omlish/asyncs/bluelet/files.py

@@ -1,7 +1,7 @@
 # ruff: noqa: UP006 UP007
 # @omlish-lite
 # Based on bluelet ( https://github.com/sampsyo/bluelet ) by Adrian Sampson, original license:
-# THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
 # WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 # COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 # OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

{omlish-0.0.0.dev338 → omlish-0.0.0.dev340}/omlish/asyncs/bluelet/runner.py

@@ -1,7 +1,7 @@
 # ruff: noqa: UP006 UP007
 # @omlish-lite
 # Based on bluelet ( https://github.com/sampsyo/bluelet ) by Adrian Sampson, original license:
-# THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
 # WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 # COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 # OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

{omlish-0.0.0.dev338 → omlish-0.0.0.dev340}/omlish/asyncs/bluelet/sockets.py

@@ -1,7 +1,7 @@
 # ruff: noqa: UP006 UP007
 # @omlish-lite
 # Based on bluelet ( https://github.com/sampsyo/bluelet ) by Adrian Sampson, original license:
-# THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
 # WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 # COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 # OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

{omlish-0.0.0.dev338 → omlish-0.0.0.dev340}/omlish/collections/__init__.py

@@ -76,6 +76,25 @@ from .mappings import (  # noqa
     multikey_dict,
 )
 
+from .multimaps import (  # noqa
+    MultiMap,
+
+    SequenceMultiMap,
+    AbstractSetMultiMap,
+
+    BiMultiMap,
+    InverseBiMultiMap,
+
+    SequenceBiMultiMap,
+    AbstractSetBiMultiMap,
+
+    TupleBiMultiMap,
+    seq_bi_multi_map,
+
+    FrozensetBiMultiMap,
+    abs_set_bi_multi_map,
+)
+
 from .ordered import (  # noqa
     OrderedFrozenSet,
     OrderedSet,

omlish-0.0.0.dev340/omlish/collections/multimaps.py

@@ -0,0 +1,151 @@
+import abc
+import typing as ta
+
+from .. import lang
+
+
+K = ta.TypeVar('K')
+V = ta.TypeVar('V')
+MV = ta.TypeVar('MV', bound=ta.Iterable)
+
+
+##
+
+
+class MultiMap(ta.Mapping[K, MV], abc.ABC, ta.Generic[K, V, MV]):
+    pass
+
+
+SequenceMultiMap: ta.TypeAlias = MultiMap[K, V, ta.Sequence[V]]
+AbstractSetMultiMap: ta.TypeAlias = MultiMap[K, V, ta.AbstractSet[V]]
+
+
+##
+
+
+class BiMultiMap(MultiMap[K, V, MV], abc.ABC, ta.Generic[K, V, MV]):
+    @abc.abstractmethod
+    def inverse(self) -> 'InverseBiMultiMap[K, V, MV]':
+        raise NotImplementedError
+
+
+class InverseBiMultiMap(ta.Mapping[V, K], abc.ABC, ta.Generic[K, V, MV]):
+    @abc.abstractmethod
+    def inverse(self) -> BiMultiMap[K, V, MV]:
+        raise NotImplementedError
+
+
+SequenceBiMultiMap: ta.TypeAlias = BiMultiMap[K, V, ta.Sequence[V]]
+AbstractSetBiMultiMap: ta.TypeAlias = BiMultiMap[K, V, ta.AbstractSet[V]]
+
+
+##
+
+
+class InverseBiMultiMapImpl(InverseBiMultiMap[K, V, MV], ta.Generic[K, V, MV]):
+    def __init__(self, m: BiMultiMap[K, V, MV], dct: ta.Mapping[V, K]) -> None:
+        super().__init__()
+
+        self._m = m
+        self._dct = dct
+
+    def inverse(self) -> BiMultiMap[K, V, MV]:
+        return self._m
+
+    def __getitem__(self, key: V, /) -> K:
+        return self._dct[key]
+
+    def __len__(self) -> int:
+        return len(self._dct)
+
+    def __iter__(self) -> ta.Iterator[V]:
+        return iter(self._dct)
+
+
+class BaseBiMultiMap(BiMultiMap[K, V, MV], abc.ABC, ta.Generic[K, V, MV]):
+    def __init__(self, *args: ta.Any, **kwargs: ta.Any) -> None:
+        super().__init__()
+
+        dct: dict[K, MV] = {}
+        i_dct: dict[V, K] = {}
+        for k, mv in lang.yield_dict_init(*args, **kwargs):
+            l: list[V] = []
+            for v in mv:
+                if v in i_dct:
+                    raise KeyError(v)
+                l.append(v)
+                i_dct[v] = k
+            dct[k] = self._aggregate_values(l)
+
+        self._dct = dct
+        self._i: InverseBiMultiMap[K, V, MV] = InverseBiMultiMapImpl(self, i_dct)
+
+    @abc.abstractmethod
+    def _aggregate_values(self, vs: list[V]) -> MV:
+        raise NotImplementedError
+
+    def inverse(self) -> 'InverseBiMultiMap[K, V, MV]':
+        return self._i
+
+    def __getitem__(self, key: K, /) -> MV:
+        return self._dct[key]
+
+    def __len__(self) -> int:
+        return len(self._dct)
+
+    def __iter__(self) -> ta.Iterator[K]:
+        return iter(self._dct)
+
+
+#
+
+
+class TupleBiMultiMap(BaseBiMultiMap[K, V, tuple[V, ...]], ta.Generic[K, V]):
+    def _aggregate_values(self, vs: list[V]) -> tuple[V, ...]:
+        return tuple(vs)
+
+
+# FIXME: lame
+# lang.static_check_issubclass[BiMultiMap[int, str, tuple[str, ...]]](TupleBiMultiMap[int, str])
+# lang.static_check_issubclass[BiMultiMap[int, str, ta.Sequence[str]]](TupleBiMultiMap[int, str])
+# lang.static_check_issubclass[SequenceBiMultiMap[int, str]](TupleBiMultiMap[int, str])
+
+
+@ta.overload
+def seq_bi_multi_map(dct: ta.Mapping[K, ta.Iterable[V]]) -> SequenceBiMultiMap[K, V]:
+    ...
+
+
+@ta.overload
+def seq_bi_multi_map(items: ta.Iterable[tuple[K, ta.Iterable[V]]]) -> SequenceBiMultiMap[K, V]:
+    ...
+
+
+def seq_bi_multi_map(*args, **kwargs):
+    return TupleBiMultiMap(*args, **kwargs)
+
+
+#
+
+
+class FrozensetBiMultiMap(BaseBiMultiMap[K, V, frozenset[V]], ta.Generic[K, V]):
+    def _aggregate_values(self, vs: list[V]) -> frozenset[V]:
+        return frozenset(vs)
+
+
+# FIXME: lame
+# lang.static_check_issubclass[AbstractSetBiMultiMap[int, str]](FrozensetBiMultiMap[int, str])
+
+
+@ta.overload
+def abs_set_bi_multi_map(dct: ta.Mapping[K, ta.Iterable[V]]) -> AbstractSetBiMultiMap[K, V]:
+    ...
+
+
+@ta.overload
+def abs_set_bi_multi_map(items: ta.Iterable[tuple[K, ta.Iterable[V]]]) -> AbstractSetBiMultiMap[K, V]:
+    ...
+
+
+def abs_set_bi_multi_map(*args, **kwargs):
+    return FrozensetBiMultiMap(*args, **kwargs)

{omlish-0.0.0.dev338 → omlish-0.0.0.dev340}/omlish/formats/json/__init__.py

@@ -12,10 +12,21 @@ from ... import lang as _lang
 from .backends import (  # noqa
     Backend,
 
-    DEFAULT_BACKED,
+    default_backend,
 
     StdBackend,
-    STD_BACKEND,
+    std_backend,
+)
+
+from .backends.default import (  # noqa
+    dump,
+    dump_compact,
+    dump_pretty,
+    dumps,
+    dumps_compact,
+    dumps_pretty,
+    load,
+    loads,
 )
 
 from .consts import (  # noqa
@@ -32,17 +43,6 @@ from .encoding import (  # noqa
     detect_encoding,
 )
 
-from .json import (  # noqa
-    dump,
-    dump_compact,
-    dump_pretty,
-    dumps,
-    dumps_compact,
-    dumps_pretty,
-    load,
-    loads,
-)
-
 if _ta.TYPE_CHECKING:
     from .rendering import (  # noqa
         JsonRenderer,

{omlish-0.0.0.dev338 → omlish-0.0.0.dev340}/omlish/formats/json/backends/__init__.py

@@ -3,10 +3,10 @@ from .base import (  # noqa
 )
 
 from .default import (  # noqa
-    DEFAULT_BACKED,
+    default_backend,
 )
 
 from .std import (  # noqa
     StdBackend,
-    STD_BACKEND,
+    std_backend,
 )

omlish-0.0.0.dev340/omlish/formats/json/backends/default.py

@@ -0,0 +1,57 @@
+import typing as ta
+
+from .... import lang
+from .base import Backend
+from .orjson import orjson_backend
+from .std import std_backend
+from .ujson import ujson_backend
+
+
+##
+
+
+@lang.cached_function
+def default_backend() -> Backend:
+    for fn in [
+        orjson_backend,
+        ujson_backend,
+    ]:
+        if (be := fn()) is not None:
+            return be
+
+    return std_backend()
+
+
+##
+
+
+def dump(obj: ta.Any, fp: ta.Any, **kwargs: ta.Any) -> None:
+    return default_backend().dump(obj, fp, **kwargs)
+
+
+def dumps(obj: ta.Any, **kwargs: ta.Any) -> str:
+    return default_backend().dumps(obj, **kwargs)
+
+
+def load(fp: ta.Any, **kwargs: ta.Any) -> ta.Any:
+    return default_backend().load(fp, **kwargs)
+
+
+def loads(s: str | bytes | bytearray, **kwargs: ta.Any) -> ta.Any:
+    return default_backend().loads(s, **kwargs)
+
+
+def dump_pretty(obj: ta.Any, fp: ta.Any, **kwargs: ta.Any) -> None:
+    return default_backend().dump_pretty(obj, fp, **kwargs)
+
+
+def dumps_pretty(obj: ta.Any, **kwargs: ta.Any) -> str:
+    return default_backend().dumps_pretty(obj, **kwargs)
+
+
+def dump_compact(obj: ta.Any, fp: ta.Any, **kwargs: ta.Any) -> None:
+    return default_backend().dump_compact(obj, fp, **kwargs)
+
+
+def dumps_compact(obj: ta.Any, **kwargs: ta.Any) -> str:
+    return default_backend().dumps_compact(obj, **kwargs)

{omlish-0.0.0.dev338 → omlish-0.0.0.dev340}/omlish/formats/json/backends/orjson.py

@@ -109,8 +109,9 @@ class OrjsonBackend(Backend):
         return self.dumps(obj, **kwargs)
 
 
-ORJSON_BACKEND: OrjsonBackend | None
-if lang.can_import('orjson'):
-    ORJSON_BACKEND = OrjsonBackend()
-else:
-    ORJSON_BACKEND = None
+@lang.cached_function
+def orjson_backend() -> OrjsonBackend | None:
+    if lang.can_import('orjson'):
+        return OrjsonBackend()
+    else:
+        return None

{omlish-0.0.0.dev338 → omlish-0.0.0.dev340}/omlish/formats/json/backends/std.py

@@ -8,6 +8,7 @@ import dataclasses as dc
 import json
 import typing as ta
 
+from .... import lang
 from ..consts import COMPACT_KWARGS
 from ..consts import PRETTY_KWARGS
 from .base import Backend
@@ -73,4 +74,6 @@ class StdBackend(Backend):
         return json.dumps(obj, **COMPACT_KWARGS, **kwargs)
 
 
-STD_BACKEND = StdBackend()
+@lang.cached_function
+def std_backend() -> StdBackend:
+    return StdBackend()

{omlish-0.0.0.dev338 → omlish-0.0.0.dev340}/omlish/formats/json/backends/ujson.py

@@ -67,8 +67,9 @@ class UjsonBackend(Backend):
         return uj.dumps(obj, **kwargs)
 
 
-UJSON_BACKEND: UjsonBackend | None
-if lang.can_import('ujson'):
-    UJSON_BACKEND = UjsonBackend()
-else:
-    UJSON_BACKEND = None
+@lang.cached_function
+def ujson_backend() -> UjsonBackend | None:
+    if lang.can_import('ujson'):
+        return UjsonBackend()
+    else:
+        return None

{omlish-0.0.0.dev338 → omlish-0.0.0.dev340}/omlish/formats/json/codecs.py

@@ -1,9 +1,9 @@
 from ..codecs import make_object_lazy_loaded_codec
 from ..codecs import make_str_object_codec
-from .json import dumps
-from .json import dumps_compact
-from .json import dumps_pretty
-from .json import loads
+from .backends.default import dumps
+from .backends.default import dumps_compact
+from .backends.default import dumps_pretty
+from .backends.default import loads
 
 
 ##

omlish-0.0.0.dev340/omlish/graphs/dags.py

@@ -0,0 +1,175 @@
+"""
+TODO:
+ - parser?
+ - js? viz.js, d3, visjs
+ - cycle detection
+ - networkx adapter
+ - https://docs.python.org/3.9/library/graphlib.html#module-graphlib
+"""
+import typing as ta
+
+from .. import check
+from .. import lang
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+class LinkError(KeyError):
+    pass
+
+
+def traverse_links(
+        links: ta.Mapping[T, ta.Iterable[T]],
+        roots: ta.Iterable[T],
+        *,
+        include_roots: bool = False,
+        strict: bool = False,
+) -> set[T]:
+    """Returns all keys deeply reachable from given roots. Handles cycles."""
+
+    roots = set(roots)
+
+    todo = set(roots)
+    seen: set[T] = set()
+    while todo:
+        key = todo.pop()
+        seen.add(key)
+
+        try:
+            cur = links[key]
+        except KeyError:
+            if strict:
+                raise LinkError(key) from None
+        else:
+            todo.update(set(cur) - seen)
+
+    if include_roots:
+        return seen
+    else:
+        return seen - roots
+
+
+def invert_links(
+        links: ta.Mapping[T, ta.Iterable[T]],
+        *,
+        auto_add_roots: bool = False,
+        if_absent: ta.Literal['raise', 'ignore', 'add'] = 'add',
+) -> dict[T, set[T]]:
+    check.in_(if_absent, ('raise', 'ignore', 'add'))
+    if if_absent != 'add':
+        check.arg(auto_add_roots, 'auto_add_roots must be True with given if_absent is not "add"')
+
+    ret: dict[T, set[T]]
+    if auto_add_roots:
+        ret = {src: set() for src in links}
+    else:
+        ret = {}
+
+    for src, dsts in links.items():
+        for dst in dsts:
+            try:
+                tgt = ret[dst]
+            except KeyError:
+                if if_absent == 'raise':
+                    raise LinkError(dst) from None
+                elif if_absent == 'ignore':
+                    continue
+                elif if_absent == 'add':
+                    tgt = ret[dst] = set()
+                else:
+                    raise RuntimeError from None
+
+            tgt.add(src)
+
+    return ret
+
+
+##
+
+
+class Dag(ta.Generic[T]):
+    """Given 'input_its_by_outputs', or a map from nodes to that node's dependencies."""
+
+    def __init__(
+            self,
+            input_its_by_outputs: ta.Mapping[T, ta.Iterable[T]],
+            *,
+            auto_add_outputs: bool = True,
+            if_absent: ta.Literal['raise', 'ignore', 'add'] = 'add',
+    ) -> None:
+        super().__init__()
+
+        self._input_sets_by_output = {u: set(d) for u, d in input_its_by_outputs.items()}
+
+        self._output_sets_by_input = invert_links(
+            self._input_sets_by_output,
+            auto_add_roots=auto_add_outputs,
+            if_absent=if_absent,
+        )
+
+    @property
+    def input_sets_by_output(self) -> ta.Mapping[T, ta.AbstractSet[T]]:
+        return self._input_sets_by_output
+
+    @property
+    def output_sets_by_input(self) -> ta.Mapping[T, ta.AbstractSet[T]]:
+        return self._output_sets_by_input
+
+    def subdag(
+            self,
+            roots: ta.Iterable[T],
+            *,
+            ignored: ta.Iterable[T] | None = None,
+    ) -> 'Subdag[T]':
+        return Subdag(
+            self,
+            roots,
+            ignored=ignored,
+        )
+
+
+class Subdag(ta.Generic[T]):
+    def __init__(
+            self,
+            dag: Dag[T],
+            roots: ta.Iterable[T],
+            *,
+            ignored: ta.Iterable[T] | None = None,
+    ) -> None:
+        super().__init__()
+
+        self._dag: Dag[T] = check.isinstance(dag, Dag)
+        self._roots = set(roots)
+        self._ignored = set(ignored or []) - self._roots
+
+    @property
+    def dag(self) -> Dag[T]:
+        return self._dag
+
+    @property
+    def roots(self) -> ta.AbstractSet[T]:
+        return self._roots
+
+    @property
+    def ignored(self) -> ta.AbstractSet[T]:
+        return self._ignored
+
+    @lang.cached_property
+    def inputs(self) -> ta.AbstractSet[T]:
+        return traverse_links(self._dag.input_sets_by_output, self._roots) - self._ignored
+
+    @lang.cached_property
+    def outputs(self) -> ta.AbstractSet[T]:
+        return traverse_links(self._dag.output_sets_by_input, self._roots) - self._ignored
+
+    @lang.cached_property
+    def output_inputs(self) -> ta.AbstractSet[T]:
+        return traverse_links(self._dag.input_sets_by_output, self.outputs) - self._ignored
+
+    @lang.cached_property
+    def all(self) -> ta.AbstractSet[T]:
+        return self.roots | self.inputs | self.outputs | self.output_inputs

{omlish-0.0.0.dev338 → omlish-0.0.0.dev340}/omlish/graphs/domination.py

@@ -9,7 +9,11 @@ from .. import lang
 V = ta.TypeVar('V')
 MK = ta.TypeVar('MK')
 MV = ta.TypeVar('MV')
-SetMap = ta.Mapping[MK, ta.AbstractSet[MV]]
+
+SetMap: ta.TypeAlias = ta.Mapping[MK, ta.AbstractSet[MV]]
+
+
+##
 
 
 class DirectedGraph(ta.Generic[V], lang.Abstract):

{omlish-0.0.0.dev338 → omlish-0.0.0.dev340}/omlish/graphs/dot/items.py

@@ -12,6 +12,9 @@ from ... import dataclasses as dc
 from ... import lang
 
 
+##
+
+
 class Item(dc.Frozen, lang.Abstract, lang.Sealed):
     pass
 

{omlish-0.0.0.dev338 → omlish-0.0.0.dev340}/omlish/graphs/dot/make.py

@@ -9,6 +9,9 @@ from .items import Node
 T = ta.TypeVar('T')
 
 
+##
+
+
 def make_simple(graph: ta.Mapping[T, ta.Iterable[T]]) -> Graph:
     return Graph([
         *[Node(n) for n in {*graph, *lang.flatten(graph.values())}],

{omlish-0.0.0.dev338 → omlish-0.0.0.dev340}/omlish/graphs/dot/rendering.py

@@ -20,6 +20,9 @@ from .items import Table
 from .items import Text
 
 
+##
+
+
 class Renderer:
     def __init__(self, out: ta.TextIO) -> None:
         super().__init__()