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

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
 
@@ -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: treap.TreapNode[tuple[K, V]] | None,
-            _b: bool,
     ) -> 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,12 +22,12 @@ 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: ta.Any) -> bool:
         return x in self._target
 
-    def __eq__(self, o: ta.Any) -> bool:
+    def __eq__(self, o: object) -> bool:
         return self._target == o
 
     def __ge__(self, other: ta.Any) -> bool:
@@ -51,7 +51,7 @@ class UnmodifiableSequence(ta.Sequence[T], Unmodifiable, lang.Final):
     def __lt__(self, other: ta.Any) -> bool:
         return self._target < other
 
-    def __ne__(self, o: ta.Any) -> bool:
+    def __ne__(self, o: object) -> bool:
         return self._target != o
 
     def __reversed__(self) -> ta.Iterator[T]:
@@ -74,7 +74,7 @@ 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
@@ -82,7 +82,7 @@ class UnmodifiableSet(ta.AbstractSet[T], Unmodifiable, lang.Final):
     def __contains__(self, x: ta.Any) -> bool:
         return x in self._target
 
-    def __eq__(self, o: ta.Any) -> bool:
+    def __eq__(self, o: object) -> bool:
         return self._target == o
 
     def __ge__(self, s: ta.AbstractSet[ta.Any]) -> bool:
@@ -103,7 +103,7 @@ class UnmodifiableSet(ta.AbstractSet[T], Unmodifiable, lang.Final):
     def __lt__(self, s: ta.AbstractSet[ta.Any]) -> bool:
         return self._target > s
 
-    def __ne__(self, o: ta.Any) -> bool:
+    def __ne__(self, o: object) -> bool:
         return self._target != o
 
     def __or__(self, s: ta.AbstractSet[T]) -> ta.AbstractSet[T]:  # type: ignore
@@ -130,12 +130,12 @@ 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: ta.Any) -> bool:
         return o in self._target
 
-    def __eq__(self, o: ta.Any) -> bool:
+    def __eq__(self, o: object) -> bool:
         return self._target == o
 
     def __ge__(self, other: ta.Any) -> bool:
@@ -159,7 +159,7 @@ class UnmodifiableMapping(ta.Mapping[K, V], Unmodifiable, lang.Final):
     def __lt__(self, other: ta.Any) -> bool:
         return self._target < other
 
-    def __ne__(self, o: ta.Any) -> bool:
+    def __ne__(self, o: object) -> bool:
         return self._target != o
 
     def get(self, k: K, default=None) -> V | None:  # type: ignore

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)
@@ -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.Tuple[str, str] | None:
-    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

@@ -4,5 +4,21 @@ TODO:
   - cleanup confer
  - descriptors - check_type/validators don't handle setters lol
  - deep_frozen?
- - repr='redact', 'if_not_none', 'if_truthy', dc.if_(lambda v: ...)? just a lambda returning str | None?
+ - 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
@@ -18,13 +19,13 @@ from .params import ParamsExtras
 MISSING = dc.MISSING
 
 
-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,
@@ -66,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,
@@ -135,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,
@@ -195,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
 
@@ -225,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

omlish/dataclasses/impl/fields.py

@@ -55,7 +55,7 @@ def preprocess_field(
     if ft in (FieldType.CLASS, FieldType.INIT):
         if f.default_factory is not MISSING:
             raise TypeError(f'field {f.name} cannot have a default factory')
-    f._field_type = ft.value  # type: ignore
+    f._field_type = ft.value  # type: ignore  # noqa
 
     if ft in (FieldType.INSTANCE, FieldType.INIT):
         if f.kw_only is MISSING:
@@ -88,7 +88,7 @@ def field_assign(
 def field_init(
         f: dc.Field,
         frozen: bool,
-        locals: dict[str, ta.Any],
+        locals: dict[str, ta.Any],  # noqa
         self_name: str,
         slots: bool,
 ) -> ta.Sequence[str]:
@@ -135,12 +135,12 @@ def field_init(
             locals[default_name] = f.default
             value = f.name
 
+    elif slots and f.default is not MISSING:
+        locals[default_name] = f.default
+        value = default_name
+
     else:
-        if slots and f.default is not MISSING:
-            locals[default_name] = f.default
-            value = default_name
-        else:
-            pass
+        pass
 
     if value is not None and field_type(f) is not FieldType.INIT:
         lines.append(field_assign(frozen, f.name, value, self_name, fx.override))  # noqa

omlish/dataclasses/impl/frozen.py

@@ -10,9 +10,9 @@ from .utils import set_new_attribute
 def frozen_get_del_attr(
         cls: type,
         fields: ta.Sequence[dc.Field],
-        globals: Namespace,
+        globals: Namespace,  # noqa
 ) -> tuple[ta.Callable, ta.Callable]:
-    locals = {
+    locals = {  # noqa
         'cls': cls,
         'FrozenInstanceError': dc.FrozenInstanceError,
     }

omlish/dataclasses/impl/init.py

@@ -3,7 +3,7 @@ import inspect
 import typing as ta
 
 from ... import lang
-from .exceptions import CheckException
+from .exceptions import CheckError
 from .fields import field_init
 from .fields import field_type
 from .fields import has_default
@@ -64,7 +64,7 @@ class InitBuilder:
             fields: ta.Mapping[str, dc.Field],
             has_post_init: bool,
             self_name: str,
-            globals: Namespace,
+            globals: Namespace,  # noqa
     ) -> None:
         super().__init__()
 
@@ -86,7 +86,7 @@ class InitBuilder:
                 elif seen_default:
                     raise TypeError(f'non-default argument {f.name!r} follows default argument {seen_default.name!r}')
 
-        locals: dict[str, ta.Any] = {}
+        locals: dict[str, ta.Any] = {}  # noqa
 
         if self._info.params_extras.generic_init:
             get_fty = lambda f: self._info.generic_replaced_field_annotations[f.name]
@@ -99,7 +99,7 @@ class InitBuilder:
             '__dataclass_builtins_object__': object,
             '__dataclass_builtins_isinstance__': isinstance,
             '__dataclass_builtins_TypeError__': TypeError,
-            '__dataclass_CheckException__': CheckException,
+            '__dataclass_CheckException__': CheckError,
         })
 
         body_lines: list[str] = []
@@ -143,7 +143,7 @@ class InitBuilder:
 
         return create_fn(
             '__init__',
-            [self._self_name] + _init_params,
+            [self._self_name, *_init_params],
             body_lines,
             locals=locals,
             globals=self._globals,

omlish/dataclasses/impl/internals.py

@@ -42,7 +42,7 @@ is_dataclass_instance = dc._is_dataclass_instance  # type: ignore  # noqa
 ##
 
 
-ATOMIC_TYPES: ta.FrozenSet[type]
+ATOMIC_TYPES: frozenset[type]
 
 if hasattr(dc, '_ATOMIC_TYPES'):
     ATOMIC_TYPES = getattr(dc, '_ATOMIC_TYPES')

omlish/dataclasses/impl/metaclass.py

@@ -97,7 +97,7 @@ class Data(metaclass=DataMeta):
             spi = super().__post_init__  # type: ignore  # noqa
         except AttributeError:
             if args or kwargs:
-                raise TypeError(args, kwargs)
+                raise TypeError(args, kwargs) from None
         else:
             spi(*args, **kwargs)
 

omlish/dataclasses/impl/order.py

@@ -12,7 +12,7 @@ def cmp_fn(
         op: str,
         self_tuple: str,
         other_tuple: str,
-        globals: Namespace,
+        globals: Namespace,  # noqa
 ) -> ta.Callable:
     return create_fn(
         name,

omlish/dataclasses/impl/replace.py

@@ -11,7 +11,7 @@ from .utils import set_new_attribute
 MISSING = dc.MISSING
 
 
-def replace(obj, /, **changes):
+def replace(obj, /, **changes):  # noqa
     if not is_dataclass_instance(obj):
         raise TypeError('replace() should be called on dataclass instances')
     return _replace(obj, **changes)

omlish/dataclasses/impl/repr.py

@@ -11,9 +11,9 @@ from .utils import set_new_attribute
 
 def repr_fn(
         fields: ta.Sequence[dc.Field],
-        globals: Namespace,
+        globals: Namespace,  # noqa
 ) -> ta.Callable:
-    locals: dict[str, ta.Any] = {}
+    locals: dict[str, ta.Any] = {}  # noqa
     if any(get_field_extras(f).repr_fn is not None for f in fields):
         lst: list[str] = []
         for f in fields:
@@ -25,12 +25,12 @@ def repr_fn(
         src = [
             'l = []',
             *lst,
-            'return f"{self.__class__.__qualname__}({\", \".join(l)})"',
+            'return f"{self.__class__.__qualname__}({", ".join(l)})"',
         ]
     else:
         src = [
             'return f"{self.__class__.__qualname__}(' +
-            ', '.join([f"{f.name}={{self.{f.name}!r}}" for f in fields]) +
+            ', '.join([f'{f.name}={{self.{f.name}!r}}' for f in fields]) +
             ')"',
         ]
     fn = create_fn(

omlish/dataclasses/impl/utils.py

@@ -16,15 +16,15 @@ def create_fn(
         args: ta.Sequence[str],
         body: ta.Sequence[str],
         *,
-        globals: Namespace | None = None,
-        locals: Namespace | None = None,
+        globals: Namespace | None = None,  # noqa
+        locals: Namespace | None = None,  # noqa
         return_type: lang.Maybe[ta.Any] = lang.empty(),
 ) -> ta.Callable:
     check.not_isinstance(args, str)
     check.not_isinstance(body, str)
 
     if locals is None:
-        locals = {}
+        locals = {}  # noqa
     return_annotation = ''
     if return_type.present:
         locals['__dataclass_return_type__'] = return_type()
@@ -43,7 +43,7 @@ def create_fn(
 
 # TODO: https://github.com/python/cpython/commit/8945b7ff55b87d11c747af2dad0e3e4d631e62d6
 class FuncBuilder:
-    def __init__(self, globals: Namespace) -> None:
+    def __init__(self, globals: Namespace) -> None:  # noqa
         super().__init__()
 
         self.names: list[str] = []
@@ -59,7 +59,7 @@ class FuncBuilder:
             args: ta.Sequence[str],
             body: ta.Sequence[str],
             *,
-            locals: Namespace | None = None,
+            locals: Namespace | None = None,  # noqa
             return_type: lang.Maybe[ta.Any] = lang.empty(),
             overwrite_error: bool = False,
             unconditional_add: bool = False,
@@ -91,7 +91,7 @@ class FuncBuilder:
         body = textwrap.indent('\n'.join(body), '    ')
 
         # Compute the text of the entire function, add it to the text we're generating.
-        deco_str = "  {decorator}\n" if decorator else ""
+        deco_str = '  {decorator}\n' if decorator else ''
         self.src.append(f'{deco_str}  def {name}({args}){return_annotation}:\n{body}')
 
     def add_fns_to_class(self, cls: type) -> None: