omlish 0.0.0.dev338__py3-none-any.whl → 0.0.0.dev340__py3-none-any.whl

omlish/__about__.py

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

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/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/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/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/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/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/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/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/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/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/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/formats/json/backends/default.py

@@ -1,13 +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
-
-
-DEFAULT_BACKED: Backend
-if ORJSON_BACKEND is not None:
-    DEFAULT_BACKED = ORJSON_BACKEND
-elif UJSON_BACKEND is not None:
-    DEFAULT_BACKED = UJSON_BACKEND
-else:
-    DEFAULT_BACKED = STD_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/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/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/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/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/graphs/dags.py

@@ -12,100 +12,164 @@ from .. import check
 from .. import lang
 
 
-K = ta.TypeVar('K')
-V = ta.TypeVar('V')
 T = ta.TypeVar('T')
-U = ta.TypeVar('U')
 
 
-def traverse_links(data: ta.Mapping[T, ta.Iterable[T]], keys: ta.Iterable[T]) -> set[T]:
-    keys = set(keys)
-    todo = set(keys)
+##
+
+
+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)
-        cur = data.get(key, [])
-        todo.update(set(cur) - seen)
-    return seen - keys
-
 
-def invert_set_map(src: ta.Mapping[K, ta.Iterable[V]]) -> dict[V, set[K]]:
-    dst: dict[V, set[K]] = {}
-    for l, rs in src.items():
-        for r in rs:
+        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:
-                s = dst[r]
+                tgt = ret[dst]
             except KeyError:
-                s = dst[r] = set()
-            s.add(l)
-    return dst
+                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
 
-def invert_symmetric_set_map(src: ta.Mapping[T, ta.Iterable[T]]) -> dict[T, set[T]]:
-    dst: dict[T, set[T]] = {l: set() for l in src}
-    for l, rs in src.items():
-        for r in rs:
-            dst[r].add(l)
-    return dst
+
+##
 
 
 class Dag(ta.Generic[T]):
-    def __init__(self, input_its_by_outputs: ta.Mapping[T, ta.Iterable[T]]) -> None:
+    """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
 
-    @lang.cached_property
+    @property
     def output_sets_by_input(self) -> ta.Mapping[T, ta.AbstractSet[T]]:
-        return invert_symmetric_set_map(self._input_sets_by_output)
+        return self._output_sets_by_input
 
-    def subdag(self, *args, **kwargs) -> 'Subdag[T]':
-        return Subdag(self, *args, **kwargs)
+    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[U]):
+class Subdag(ta.Generic[T]):
     def __init__(
             self,
-            dag: 'Dag[U]',
-            targets: ta.Iterable[U],
+            dag: Dag[T],
+            roots: ta.Iterable[T],
             *,
-            ignored: ta.Iterable[U] | None = None,
+            ignored: ta.Iterable[T] | None = None,
     ) -> None:
         super().__init__()
 
-        self._dag: Dag[U] = check.isinstance(dag, Dag)
-        self._targets = set(targets)
-        self._ignored = set(ignored or []) - self._targets
+        self._dag: Dag[T] = check.isinstance(dag, Dag)
+        self._roots = set(roots)
+        self._ignored = set(ignored or []) - self._roots
 
     @property
-    def dag(self) -> 'Dag[U]':
+    def dag(self) -> Dag[T]:
         return self._dag
 
     @property
-    def targets(self) -> ta.AbstractSet[U]:
-        return self._targets
+    def roots(self) -> ta.AbstractSet[T]:
+        return self._roots
 
     @property
-    def ignored(self) -> ta.AbstractSet[U]:
+    def ignored(self) -> ta.AbstractSet[T]:
         return self._ignored
 
     @lang.cached_property
-    def inputs(self) -> ta.AbstractSet[U]:
-        return traverse_links(self.dag.input_sets_by_output, self.targets) - self.ignored
+    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[U]:
-        return traverse_links(self.dag.output_sets_by_input, self.targets) - self.ignored
+    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[U]:
-        return traverse_links(self.dag.input_sets_by_output, self.outputs) - self.ignored
+    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[U]:
-        return self.targets | self.inputs | self.outputs | self.output_inputs
+    def all(self) -> ta.AbstractSet[T]:
+        return self.roots | self.inputs | self.outputs | self.output_inputs

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):