omlish 0.0.0.dev339__py3-none-any.whl → 0.0.0.dev341__py3-none-any.whl

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

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/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/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__()

omlish/graphs/dot/utils.py

@@ -2,6 +2,9 @@ import html
 import typing as ta
 
 
+##
+
+
 def escape(s: str) -> str:
     return html.escape(s).replace('@', '@')
 

omlish/graphs/trees.py

@@ -10,13 +10,14 @@ from .. import cached
 from .. import check
 from .. import collections as col
 from .. import lang
-from ..algorithm import all as alg
+from ..algorithm.toposort import mut_toposort
 
 
 T = ta.TypeVar('T')
 NodeT = ta.TypeVar('NodeT')
-NodeWalker = ta.Callable[[NodeT], ta.Iterable[NodeT]]
-NodeGenerator = ta.Generator[NodeT, None, None]
+
+NodeWalker: ta.TypeAlias = ta.Callable[[NodeT], ta.Iterable[NodeT]]
+NodeGenerator: ta.TypeAlias = ta.Generator[NodeT, None, None]
 
 
 ##
@@ -200,7 +201,7 @@ class BasicTreeAnalysis(ta.Generic[NodeT]):
         else:
             e, d = lang.identity, lang.identity
         tsd = {e(n): {e(p)} for n, p in parents_by_node.items()}
-        ts = list(alg.mut_toposort(tsd))
+        ts = list(mut_toposort(tsd))
         root = d(check.single(ts[0]))
 
         return cls(

omlish/lang/classes/bindable.py

@@ -27,6 +27,8 @@ class BindableClass(ta.Generic[T]):
         setattr(self, '_bound', _bound)
 
     def __class_getitem__(cls, *args, **kwargs):
+        # FIXME: this could handle __mro_items__ to be subclassable, but it's not currently really intended to be
+        #   subclassed
         if cls is BindableClass:
             return super().__class_getitem__(*args, **kwargs)  # type: ignore[misc]
 

omlish/lite/check.py

@@ -177,7 +177,7 @@ class Checks:
 
         return inner
 
-    def cast(self, v: ta.Any, cls: ta.Type[T], msg: CheckMessage = None) -> T:  # noqa
+    def cast(self, v: ta.Any, cls: ta.Type[T], msg: CheckMessage = None) -> T:
         if not isinstance(v, cls):
             self._raise(
                 TypeError,
@@ -226,7 +226,7 @@ class Checks:
 
         return v
 
-    def not_issubclass(self, v: ta.Type[T], spec: ta.Any, msg: CheckMessage = None) -> ta.Type[T]:  # noqa
+    def not_issubclass(self, v: ta.Type[T], spec: ta.Any, msg: CheckMessage = None) -> ta.Type[T]:
         if issubclass(v, spec):
             self._raise(
                 TypeError,
@@ -317,21 +317,21 @@ class Checks:
 
         return it
 
-    def single(self, obj: ta.Iterable[T], message: CheckMessage = None) -> T:
+    def single(self, obj: ta.Iterable[T], msg: CheckMessage = None) -> T:
         try:
             [value] = obj
         except ValueError:
             self._raise(
                 ValueError,
                 'Must be single',
-                message,
+                msg,
                 Checks._ArgsKwargs(obj),
                 render_fmt='%s',
             )
 
         return value
 
-    def opt_single(self, obj: ta.Iterable[T], message: CheckMessage = None) -> ta.Optional[T]:
+    def opt_single(self, obj: ta.Iterable[T], msg: CheckMessage = None) -> ta.Optional[T]:
         it = iter(obj)
         try:
             value = next(it)
@@ -346,7 +346,7 @@ class Checks:
         self._raise(
             ValueError,
             'Must be empty or single',
-            message,
+            msg,
             Checks._ArgsKwargs(obj),
             render_fmt='%s',
         )

omlish/math/__init__.py

@@ -35,11 +35,11 @@ from .fixed import (  # noqa
     CheckedInt64,
     CheckedInt128,
 
-    CheckedUInt8,
-    CheckedUInt16,
-    CheckedUInt32,
-    CheckedUInt64,
-    CheckedUInt128,
+    CheckedUint8,
+    CheckedUint16,
+    CheckedUint32,
+    CheckedUint64,
+    CheckedUint128,
 
     ClampedInt8,
     ClampedInt16,
@@ -47,11 +47,11 @@ from .fixed import (  # noqa
     ClampedInt64,
     ClampedInt128,
 
-    ClampedUInt8,
-    ClampedUInt16,
-    ClampedUInt32,
-    ClampedUInt64,
-    ClampedUInt128,
+    ClampedUint8,
+    ClampedUint16,
+    ClampedUint32,
+    ClampedUint64,
+    ClampedUint128,
 
     WrappedInt8,
     WrappedInt16,
@@ -59,11 +59,11 @@ from .fixed import (  # noqa
     WrappedInt64,
     WrappedInt128,
 
-    WrappedUInt8,
-    WrappedUInt16,
-    WrappedUInt32,
-    WrappedUInt64,
-    WrappedUInt128,
+    WrappedUint8,
+    WrappedUint16,
+    WrappedUint32,
+    WrappedUint64,
+    WrappedUint128,
 )
 
 from .floats import (  # noqa

omlish/math/fixed.py

@@ -183,6 +183,16 @@ class FixedWidthInt(int, lang.Abstract):
         locals()[_proxy_name] = _gen_tuple_proxy_method(_proxy_name)
     del _proxy_name
 
+    #
+
+    def __invert__(self) -> ta.Self:
+        if not self.SIGNED:
+            return self.__class__(~int(self) & self.MASK)
+        else:
+            return self.__class__(super().__invert__())
+
+    #
+
     def __repr__(self) -> str:
         return f'{self.__class__.__name__}({int(self)})'
 
@@ -278,23 +288,23 @@ class CheckedInt128(CheckedInt, SignedInt, AnyInt128):
 #
 
 
-class CheckedUInt8(CheckedInt, UnsignedInt, AnyInt8):
+class CheckedUint8(CheckedInt, UnsignedInt, AnyInt8):
     pass
 
 
-class CheckedUInt16(CheckedInt, UnsignedInt, AnyInt16):
+class CheckedUint16(CheckedInt, UnsignedInt, AnyInt16):
     pass
 
 
-class CheckedUInt32(CheckedInt, UnsignedInt, AnyInt32):
+class CheckedUint32(CheckedInt, UnsignedInt, AnyInt32):
     pass
 
 
-class CheckedUInt64(CheckedInt, UnsignedInt, AnyInt64):
+class CheckedUint64(CheckedInt, UnsignedInt, AnyInt64):
     pass
 
 
-class CheckedUInt128(CheckedInt, UnsignedInt, AnyInt128):
+class CheckedUint128(CheckedInt, UnsignedInt, AnyInt128):
     pass
 
 
@@ -324,23 +334,23 @@ class ClampedInt128(ClampedInt, SignedInt, AnyInt128):
 #
 
 
-class ClampedUInt8(ClampedInt, UnsignedInt, AnyInt8):
+class ClampedUint8(ClampedInt, UnsignedInt, AnyInt8):
     pass
 
 
-class ClampedUInt16(ClampedInt, UnsignedInt, AnyInt16):
+class ClampedUint16(ClampedInt, UnsignedInt, AnyInt16):
     pass
 
 
-class ClampedUInt32(ClampedInt, UnsignedInt, AnyInt32):
+class ClampedUint32(ClampedInt, UnsignedInt, AnyInt32):
     pass
 
 
-class ClampedUInt64(ClampedInt, UnsignedInt, AnyInt64):
+class ClampedUint64(ClampedInt, UnsignedInt, AnyInt64):
     pass
 
 
-class ClampedUInt128(ClampedInt, UnsignedInt, AnyInt128):
+class ClampedUint128(ClampedInt, UnsignedInt, AnyInt128):
     pass
 
 
@@ -370,21 +380,21 @@ class WrappedInt128(WrappedInt, SignedInt, AnyInt128):
 #
 
 
-class WrappedUInt8(WrappedInt, UnsignedInt, AnyInt8):
+class WrappedUint8(WrappedInt, UnsignedInt, AnyInt8):
     pass
 
 
-class WrappedUInt16(WrappedInt, UnsignedInt, AnyInt16):
+class WrappedUint16(WrappedInt, UnsignedInt, AnyInt16):
     pass
 
 
-class WrappedUInt32(WrappedInt, UnsignedInt, AnyInt32):
+class WrappedUint32(WrappedInt, UnsignedInt, AnyInt32):
     pass
 
 
-class WrappedUInt64(WrappedInt, UnsignedInt, AnyInt64):
+class WrappedUint64(WrappedInt, UnsignedInt, AnyInt64):
     pass
 
 
-class WrappedUInt128(WrappedInt, UnsignedInt, AnyInt128):
+class WrappedUint128(WrappedInt, UnsignedInt, AnyInt128):
     pass

omlish/os/forkhooks.py

@@ -36,9 +36,9 @@ class _ForkHookManager:
 
     #
 
-    _hooks_by_key: ta.ClassVar[ta.Dict[str, Hook]] = {}
+    _hooks_by_key: ta.ClassVar[ta.Dict[ta.Any, Hook]] = {}
 
-    _hook_keys: ta.ClassVar[ta.FrozenSet[str]] = frozenset()
+    _hook_keys: ta.ClassVar[ta.FrozenSet[ta.Any]] = frozenset()
     _priority_ordered_hooks: ta.ClassVar[ta.List[Hook]] = []
 
     @classmethod
@@ -191,7 +191,7 @@ class ForkHook(abc.ABC):  # noqa
 ##
 
 
-class _ForkDepthTracker(ForkHook):
+class ForkDepthTracker(ForkHook):
     _hook_priority = -1000
 
     _fork_depth: ta.ClassVar[int] = 0
@@ -208,7 +208,7 @@ class _ForkDepthTracker(ForkHook):
 
 
 def get_fork_depth() -> int:
-    return _ForkDepthTracker.get_fork_depth()
+    return ForkDepthTracker.get_fork_depth()
 
 
 ##

omlish/typedvalues/__init__.py

@@ -6,12 +6,16 @@ from .collection import (  # noqa
     DuplicateUniqueTypedValueError,
 
     TypedValues,
+
+    collect,
 )
 
 from .consumer import (  # noqa
     UnconsumedTypedValuesError,
 
     TypedValuesConsumer,
+
+    consume,
 )
 
 from .generic import (  # noqa

omlish/typedvalues/collection.py

@@ -205,3 +205,6 @@ class TypedValues(
         ret = tuple(tv for tv in self if isinstance(tv, cls))
         any_dct[cls] = ret
         return ret
+
+
+collect = TypedValues

omlish/typedvalues/consumer.py

@@ -173,3 +173,15 @@ class TypedValuesConsumer(ta.Generic[TypedValueT]):
                 continue
             dct[k] = v.v  # type: ignore[attr-defined]
         return dct
+
+
+def consume(
+    *tvs: TypedValueT,
+    override: bool = False,
+    check_type: type | tuple[type, ...] | None = None,
+) -> TypedValuesConsumer[TypedValueT]:
+    return tvc.TypedValues(
+        *tvs,
+        override=override,
+        check_type=check_type,
+    ).consume()

{omlish-0.0.0.dev339.dist-info → omlish-0.0.0.dev341.dist-info}/METADATA

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