omlish 0.0.0.dev1__py3-none-any.whl → 0.0.0.dev3__py3-none-any.whl

omlish/collections/treap.py

@@ -16,6 +16,8 @@ WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEM
 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.
 """
+# ruff: noqa: SLF001
+
 import typing as ta
 
 
@@ -41,6 +43,9 @@ class TreapNode(ta.Generic[T]):
         self._left = _left
         self._right = _right
 
+    def __repr__(self) -> str:
+        return f'TreapNode(value={self._value!r}, priority={self._priority!r})'
+
     @property
     def value(self) -> T:
         return self._value
@@ -65,7 +70,7 @@ class TreapNode(ta.Generic[T]):
             yield from self._right
 
 
-def find(n: ta.Optional[TreapNode[T]], v: T, c: Comparer[T]) -> ta.Optional[TreapNode[T]]:
+def find(n: TreapNode[T] | None, v: T, c: Comparer[T]) -> TreapNode[T] | None:
     while True:
         if n is None:
             return None
@@ -78,12 +83,32 @@ def find(n: ta.Optional[TreapNode[T]], v: T, c: Comparer[T]) -> ta.Optional[Trea
             n = n._left  # noqa
 
 
+def place(n: TreapNode[T] | None, v: T, c: Comparer[T], *, desc: bool = False) -> list[TreapNode[T]]:
+    ret: list[TreapNode[T]] = []
+    while True:
+        if n is None:
+            break
+        diff = c(n._value, v)  # noqa
+        if diff == 0:
+            ret.append(n)
+            break
+        elif diff < 0:
+            if desc:
+                ret.append(n)
+            n = n._right  # noqa
+        else:
+            if not desc:
+                ret.append(n)
+            n = n._left  # noqa
+    return ret
+
+
 def union(
-        n: ta.Optional[TreapNode[T]],
-        other: ta.Optional[TreapNode[T]],
+        n: TreapNode[T] | None,
+        other: TreapNode[T] | None,
         c: Comparer[T],
         overwrite: bool,
-) -> ta.Optional[TreapNode[T]]:
+) -> TreapNode[T] | None:
     if n is None:
         return other
     if other is None:
@@ -100,13 +125,13 @@ def union(
 
 
 def split(
-        n: ta.Optional[TreapNode[T]],
+        n: TreapNode[T] | None,
         v: T,
         c: Comparer[T],
 ) -> tuple[
-    ta.Optional[TreapNode[T]],
-    ta.Optional[TreapNode[T]],
-    ta.Optional[TreapNode[T]],
+    TreapNode[T] | None,
+    TreapNode[T] | None,
+    TreapNode[T] | None,
 ]:
     tmp: TreapNode[T] = TreapNode(_value=None, _priority=0, _left=None, _right=None)  # type: ignore
     leftp, rightp = [tmp, 'l'], [tmp, 'r']
@@ -120,7 +145,7 @@ def split(
         else:
             raise ValueError(p)
 
-    cur: ta.Optional[TreapNode[T]] = n
+    cur: TreapNode[T] | None = n
     while True:
         if cur is None:
             setp(leftp, None)
@@ -146,10 +171,10 @@ def split(
 
 
 def intersect(
-        n: ta.Optional[TreapNode[T]],
-        other: ta.Optional[TreapNode[T]],
+        n: TreapNode[T] | None,
+        other: TreapNode[T] | None,
         c: Comparer[T],
-) -> ta.Optional[TreapNode[T]]:
+) -> TreapNode[T] | None:
     if n is None or other is None:
         return None
 
@@ -167,12 +192,12 @@ def intersect(
     return TreapNode(_value=n._value, _priority=n._priority, _left=left, _right=right)
 
 
-def delete(n: ta.Optional[TreapNode[T]], v: T, c: Comparer[T]) -> ta.Optional[TreapNode[T]]:
+def delete(n: TreapNode[T] | None, v: T, c: Comparer[T]) -> TreapNode[T] | None:
     left, _, right = split(n, v, c)
     return _join(left, right)
 
 
-def diff(n: ta.Optional[TreapNode[T]], other: ta.Optional[TreapNode[T]], c: Comparer[T]) -> ta.Optional[TreapNode[T]]:
+def diff(n: TreapNode[T] | None, other: TreapNode[T] | None, c: Comparer[T]) -> TreapNode[T] | None:
     if n is None or other is None:
         return n
 
@@ -190,8 +215,8 @@ def diff(n: ta.Optional[TreapNode[T]], other: ta.Optional[TreapNode[T]], c: Comp
     return _join(left, right)
 
 
-def _join(n: ta.Optional[TreapNode[T]], other: ta.Optional[TreapNode[T]]) -> ta.Optional[TreapNode[T]]:
-    result: ta.Optional[TreapNode[T]] = None
+def _join(n: TreapNode[T] | None, other: TreapNode[T] | None) -> TreapNode[T] | None:
+    result: TreapNode[T] | None = None
     resultp: list[ta.Any] = [None, None]
 
     def setresultp(o):
@@ -206,7 +231,7 @@ def _join(n: ta.Optional[TreapNode[T]], other: ta.Optional[TreapNode[T]]) -> ta.
         else:
             raise ValueError(resultp)
 
-    cur: ta.Optional[TreapNode[T]] = n
+    cur: TreapNode[T] | None = n
     while True:
         if cur is None:
             setresultp(other)

omlish/collections/treapmap.py

@@ -16,6 +16,7 @@ WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEM
 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.
 """
+import abc
 import random
 import typing as ta
 
@@ -33,7 +34,7 @@ class TreapMap(PersistentMap[K, V]):
     def __init__(
             self,
             *,
-            _n: ta.Optional[treap.TreapNode[tuple[K, V]]],
+            _n: treap.TreapNode[tuple[K, V]] | None,
             _c: treap.Comparer[tuple[K, V]],
     ) -> None:
         super().__init__()
@@ -74,13 +75,38 @@ class TreapMap(PersistentMap[K, V]):
         i = TreapMapIterator(
             _st=[],
             _n=self._n,
-            _b=False,
         )
         while (n := i._n) is not None and n.left is not None:  # noqa
             i._st.append(n)  # noqa
             i._n = n.left  # noqa
         return i
 
+    def iterate_from(self, k: K) -> 'TreapMapIterator[K, V]':
+        lst = treap.place(self._n, (k, None), self._c)  # type: ignore
+        i = TreapMapIterator(
+            _st=lst,
+            _n=lst.pop(),
+        )
+        return i
+
+    def reverse_iterate(self) -> 'TreapMapReverseIterator[K, V]':
+        i = TreapMapReverseIterator(
+            _st=[],
+            _n=self._n,
+        )
+        while (n := i._n) is not None and n.right is not None:  # noqa
+            i._st.append(n)  # noqa
+            i._n = n.right  # noqa
+        return i
+
+    def reverse_iterate_from(self, k: K) -> 'TreapMapReverseIterator[K, V]':
+        lst = treap.place(self._n, (k, None), self._c, desc=True)  # type: ignore
+        i = TreapMapReverseIterator(
+            _st=lst,
+            _n=lst.pop(),
+        )
+        return i
+
     def with_(self, k: K, v: V) -> 'TreapMap[K, V]':
         node = treap.TreapNode(
             _value=(k, v),
@@ -108,25 +134,31 @@ def new_treap_map(cmp: ta.Callable[[tuple[K, V], tuple[K, V]], int]) -> Persiste
     return TreapMap(_n=None, _c=cmp)
 
 
-class TreapMapIterator(ta.Generic[K, V]):
-    __slots__ = ('_st', '_n', '_b')
+class BaseTreapMapIterator(abc.ABC, ta.Generic[K, V]):
+    __slots__ = ('_st', '_n')
 
     def __init__(
             self,
             *,
             _st: list[treap.TreapNode[tuple[K, V]]],
-            _n: ta.Optional[treap.TreapNode[tuple[K, V]]],
-            _b: bool,
+            _n: treap.TreapNode[tuple[K, V]] | None,
     ) -> None:
         super().__init__()
 
         self._st = _st
         self._n = _n
-        self._b = _b
 
     def has_next(self) -> bool:
         return self._n is not None
 
+    @abc.abstractmethod
+    def next(self) -> tuple[K, V]:
+        raise NotImplementedError
+
+
+class TreapMapIterator(BaseTreapMapIterator[K, V]):
+    __slots__ = BaseTreapMapIterator.__slots__
+
     def next(self) -> tuple[K, V]:
         n = self._n
         if n is None:
@@ -142,3 +174,23 @@ class TreapMapIterator(ta.Generic[K, V]):
         else:
             self._n = None
         return n.value
+
+
+class TreapMapReverseIterator(BaseTreapMapIterator[K, V]):
+    __slots__ = BaseTreapMapIterator.__slots__
+
+    def next(self) -> tuple[K, V]:
+        n = self._n
+        if n is None:
+            raise StopIteration
+        if n.left is not None:
+            self._n = n.left
+            while self._n.right is not None:
+                self._st.append(self._n)
+                self._n = self._n.right
+        elif len(self._st) > 0:
+            self._n = self._st[-1]
+            self._st.pop()
+        else:
+            self._n = None
+        return n.value

omlish/collections/unmodifiable.py

@@ -22,34 +22,34 @@ class UnmodifiableSequence(ta.Sequence[T], Unmodifiable, lang.Final):
         self._target = target
 
     def __repr__(self) -> str:
-        return '%s(%r)' % (type(self).__name__, self._target)
+        return f'{type(self).__name__}({self._target!r})'
 
-    def __contains__(self, x: object) -> bool:
+    def __contains__(self, x: ta.Any) -> bool:
         return x in self._target
 
     def __eq__(self, o: object) -> bool:
         return self._target == o
 
-    def __ge__(self, other: object) -> bool:
-        return self._target >= other  # type: ignore
+    def __ge__(self, other: ta.Any) -> bool:
+        return self._target >= other
 
-    def __getitem__(self, i: ta.Union[int, slice]) -> T:  # type: ignore
+    def __getitem__(self, i: int | slice) -> T:  # type: ignore
         return self._target[i]  # type: ignore
 
-    def __gt__(self, other: object) -> bool:
-        return self._target > other  # type: ignore
+    def __gt__(self, other: ta.Any) -> bool:
+        return self._target > other
 
     def __iter__(self) -> ta.Iterator[T]:
         return iter(self._target)
 
-    def __le__(self, other: object) -> bool:
-        return self._target <= other  # type: ignore
+    def __le__(self, other: ta.Any) -> bool:
+        return self._target <= other
 
     def __len__(self) -> int:
         return len(self._target)
 
-    def __lt__(self, other: object) -> bool:
-        return self._target < other  # type: ignore
+    def __lt__(self, other: ta.Any) -> bool:
+        return self._target < other
 
     def __ne__(self, o: object) -> bool:
         return self._target != o
@@ -74,12 +74,12 @@ class UnmodifiableSet(ta.AbstractSet[T], Unmodifiable, lang.Final):
         self._target = target
 
     def __repr__(self) -> str:
-        return '%s(%r)' % (type(self).__name__, self._target)
+        return f'{type(self).__name__}({self._target!r})'
 
     def __and__(self, s: ta.AbstractSet[ta.Any]) -> ta.AbstractSet[T]:
         return self._target & s
 
-    def __contains__(self, x: object) -> bool:
+    def __contains__(self, x: ta.Any) -> bool:
         return x in self._target
 
     def __eq__(self, o: object) -> bool:
@@ -120,6 +120,7 @@ class UnmodifiableSet(ta.AbstractSet[T], Unmodifiable, lang.Final):
 
 
 class UnmodifiableMapping(ta.Mapping[K, V], Unmodifiable, lang.Final):
+    # Could be a MappingProxyType but isn't for consistency with the others.
 
     def __init__(self, target: ta.Mapping[K, V]) -> None:
         super().__init__()
@@ -129,39 +130,39 @@ class UnmodifiableMapping(ta.Mapping[K, V], Unmodifiable, lang.Final):
         self._target = target
 
     def __repr__(self) -> str:
-        return '%s(%r)' % (type(self).__name__, self._target)
+        return f'{type(self).__name__}({self._target!r})'
 
-    def __contains__(self, o: object) -> bool:
+    def __contains__(self, o: ta.Any) -> bool:
         return o in self._target
 
     def __eq__(self, o: object) -> bool:
         return self._target == o
 
-    def __ge__(self, other: object) -> bool:
-        return self._target >= other  # type: ignore
+    def __ge__(self, other: ta.Any) -> bool:
+        return self._target >= other
 
     def __getitem__(self, k: K) -> V:
         return self._target[k]
 
-    def __gt__(self, other: object) -> bool:
-        return self._target > other  # type: ignore
+    def __gt__(self, other: ta.Any) -> bool:
+        return self._target > other
 
     def __iter__(self) -> ta.Iterator[T]:
         return iter(self._target)  # type: ignore
 
-    def __le__(self, other: object) -> bool:
-        return self._target <= other  # type: ignore
+    def __le__(self, other: ta.Any) -> bool:
+        return self._target <= other
 
     def __len__(self) -> int:
         return len(self._target)
 
-    def __lt__(self, other: object) -> bool:
-        return self._target < other  # type: ignore
+    def __lt__(self, other: ta.Any) -> bool:
+        return self._target < other
 
     def __ne__(self, o: object) -> bool:
         return self._target != o
 
-    def get(self, k: K, default=None) -> ta.Optional[V]:  # type: ignore
+    def get(self, k: K, default=None) -> V | None:  # type: ignore
         return self._target.get(k)
 
     def items(self) -> ta.ItemsView[K, V]:

omlish/collections/utils.py

@@ -18,7 +18,7 @@ def mut_toposort(data: dict[T, set[T]]) -> ta.Iterator[set[T]]:
     extra_items_in_deps = functools.reduce(set.union, data.values()) - set(data.keys())
     data.update({item: set() for item in extra_items_in_deps})
     while True:
-        ordered = set(item for item, dep in data.items() if not dep)
+        ordered = {item for item, dep in data.items() if not dep}
         if not ordered:
             break
         yield ordered

omlish/configs/flattening.py

@@ -1,4 +1,5 @@
 import abc
+import itertools
 import typing as ta
 
 from .. import check
@@ -34,10 +35,10 @@ class Flattening:
         self._index_close = check.not_empty(index_close)
 
     def flatten(self, unflattened: StrMap) -> StrMap:
-        def rec(prefix: ta.List[str], value: ta.Any) -> None:
+        def rec(prefix: list[str], value: ta.Any) -> None:
             if isinstance(value, dict):
                 for k, v in value.items():
-                    rec(prefix + [k], v)
+                    rec([*prefix, k], v)
             elif isinstance(value, list):
                 check.not_empty(prefix)
                 for i, v in enumerate(value):
@@ -48,7 +49,7 @@ class Flattening:
                     raise KeyError(k)
                 ret[k] = value
 
-        ret: ta.Dict[str, ta.Any] = {}
+        ret: dict[str, ta.Any] = {}
         rec([], unflattened)
         return ret
 
@@ -83,7 +84,7 @@ class Flattening:
         def __init__(self) -> None:
             super().__init__()
 
-            self._dict: ta.Dict[str, ta.Any] = {}
+            self._dict: dict[str, ta.Any] = {}
 
         def get(self, key: str) -> ta.Any:
             return self._dict.get(key, _MISSING)
@@ -100,7 +101,7 @@ class Flattening:
         def __init__(self) -> None:
             super().__init__()
 
-            self._list: ta.List[ta.Any] = []
+            self._list: list[ta.Any] = []
 
         def get(self, key: int) -> ta.Any:
             check.arg(key >= 0)
@@ -119,7 +120,7 @@ class Flattening:
     def unflatten(self, flattened: StrMap) -> StrMap:
         root = Flattening.UnflattenDict()
 
-        def split_keys(fkey: str) -> ta.Iterable[ta.Union[str, int]]:
+        def split_keys(fkey: str) -> ta.Iterable[str | int]:
             for part in fkey.split(self._delimiter):
                 if self._index_open in part:
                     check.state(part.endswith(self._index_close))
@@ -135,7 +136,7 @@ class Flattening:
         for fk, v in flattened.items():
             node: Flattening.UnflattenNode = root
             fks = list(split_keys(fk))
-            for key, nkey in zip(fks, fks[1:]):
+            for key, nkey in itertools.pairwise(fks):
                 if isinstance(nkey, str):
                     node = node.setdefault(key, Flattening.UnflattenDict)
                 elif isinstance(nkey, int):

omlish/configs/props.py

@@ -19,8 +19,8 @@ def escape(token: str) -> str:
     return _ESCAPE_PATTERN.sub(r'\\\1', token)
 
 
-def parse_line(line: str) -> ta.Optional[ta.Tuple[str, str]]:
-    if line and not (line.startswith('#') or line.startswith('!')):
+def parse_line(line: str) -> tuple[str, str] | None:
+    if line and not line.startswith(('#', '!')):
         match = _SEPARATOR_PATTERN.search(line)
         if match:
             return normalize(line[:match.start()]), normalize(line[match.end():])
@@ -54,7 +54,7 @@ def coalesce_lines(lines: ta.Iterable[str]) -> ta.Generator[str, None, None]:
         pass
 
 
-def parse_lines(lines: ta.Iterable[str]) -> ta.Dict[str, str]:
+def parse_lines(lines: ta.Iterable[str]) -> dict[str, str]:
     props = {}
     for line in coalesce_lines(lines):
         kv_pair = parse_line(line)

omlish/dataclasses/__init__.py

@@ -54,7 +54,7 @@ globals()['make_dataclass'] = xmake_dataclass
 
 
 from .impl.exceptions import (  # noqa
-    CheckException,
+    CheckError,
 )
 
 from .impl.metaclass import (  # noqa

omlish/dataclasses/impl/__init__.py

@@ -3,4 +3,22 @@ TODO:
  - metaclass:
   - cleanup confer
  - descriptors - check_type/validators don't handle setters lol
+ - deep_frozen?
+ - field:
+  - frozen
+  - pickle/transient
+  - mangled
+  - doc
+  - derive
+  - check_type
+ - class
+  - strict_eq
+  - allow_setattr
+  - mangler
+ - observable
+ - c/py gen
+ - iterable
+ - proto/jsonschema gen
+ - enums
+ - nodal
 """

omlish/dataclasses/impl/api.py

@@ -1,4 +1,5 @@
 import collections.abc
+import contextlib
 import dataclasses as dc
 import keyword
 import sys
@@ -12,30 +13,28 @@ from .main import process_class
 from .metadata import METADATA_ATTR
 from .metadata import Metadata
 from .params import FieldExtras
-from .params import Params12
 from .params import ParamsExtras
 
 
 MISSING = dc.MISSING
 
-IS_12 = sys.version_info[1] >= 12
 
-
-def field(
+def field(  # noqa
         default=MISSING,
         *,
         default_factory=MISSING,
         init=True,
-        repr=True,
-        hash=None,
+        repr=True,  # noqa
+        hash=None,  # noqa
         compare=True,
         metadata=None,
         kw_only=MISSING,
 
-        coerce: ta.Optional[ta.Callable[[ta.Any], ta.Any]] = None,
-        check: ta.Optional[ta.Callable[[ta.Any], bool]] = None,
-        check_type: ta.Optional[bool] = None,
+        coerce: ta.Callable[[ta.Any], ta.Any] | None = None,
+        check: ta.Callable[[ta.Any], bool] | None = None,
+        check_type: bool | None = None,
         override: bool = False,
+        repr_fn: ta.Callable[[ta.Any], str | None] | None = None
 ):  # -> dc.Field
     if default is not MISSING and default_factory is not MISSING:
         raise ValueError('cannot specify both default and default_factory')
@@ -45,6 +44,7 @@ def field(
         check=check,
         check_type=check_type,
         override=override,
+        repr_fn=repr_fn,
     )
 
     md: ta.Mapping = {FieldExtras: fx}
@@ -67,12 +67,12 @@ def _strip_missing_values(d):
     return {k: v for k, v in d.items() if v is not MISSING}
 
 
-def dataclass(
+def dataclass(  # noqa
         cls=None,
         /,
         *,
         init=True,
-        repr=True,
+        repr=True,  # noqa
         eq=True,
         order=False,
         unsafe_hash=False,
@@ -96,8 +96,6 @@ def dataclass(
             order=order,
             unsafe_hash=unsafe_hash,
             frozen=frozen,
-        )
-        p12kw = dict(
             match_args=match_args,
             kw_only=kw_only,
             slots=slots,
@@ -118,11 +116,6 @@ def dataclass(
             ParamsExtras: pex,
         }
 
-        if IS_12:
-            pkw.update(p12kw)
-        else:
-            mmd[Params12] = Params12(**p12kw)
-
         md: Metadata = mmd
         cmds = []
         if metadata is not None:
@@ -143,14 +136,14 @@ def dataclass(
     return wrap(cls)
 
 
-def make_dataclass(
+def make_dataclass(  # noqa
         cls_name,
         fields,
         *,
         bases=(),
         namespace=None,
         init=True,
-        repr=True,
+        repr=True,  # noqa
         eq=True,
         order=False,
         unsafe_hash=False,
@@ -203,10 +196,8 @@ def make_dataclass(
         try:
             module = sys._getframemodulename(1) or '__main__'  # type: ignore  # noqa
         except AttributeError:
-            try:
+            with contextlib.suppress(AttributeError, ValueError):
                 module = sys._getframe(1).f_globals.get('__name__', '__main__')  # noqa
-            except (AttributeError, ValueError):
-                pass
     if module is not None:
         cls.__module__ = module
 
@@ -233,7 +224,7 @@ class _ExtraParamsKwargs:
     pass
 
 
-def extra_params(
+def extra_params(  # noqa
         *,
         reorder=MISSING,
         cache_hash=MISSING,

omlish/dataclasses/impl/as_.py

@@ -5,9 +5,9 @@ from .internals import is_dataclass_instance
 from .internals import ATOMIC_TYPES
 
 
-def asdict(obj, *, dict_factory=dict):
+def asdict(obj, *, dict_factory=dict):  # noqa
     if not is_dataclass_instance(obj):  # noqa
-        raise TypeError("asdict() should be called on dataclass instances")
+        raise TypeError('asdict() should be called on dataclass instances')
     return _asdict_inner(obj, dict_factory)
 
 
@@ -40,9 +40,9 @@ def _asdict_inner(obj, dict_factory):
         return copy.deepcopy(obj)
 
 
-def astuple(obj, *, tuple_factory=tuple):
+def astuple(obj, *, tuple_factory=tuple):  # noqa
     if not is_dataclass_instance(obj):
-        raise TypeError("astuple() should be called on dataclass instances")
+        raise TypeError('astuple() should be called on dataclass instances')
     return _astuple_inner(obj, tuple_factory)
 
 

omlish/dataclasses/impl/exceptions.py

@@ -1,2 +1,2 @@
-class CheckException(Exception):
+class CheckError(Exception):
     pass