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

omlish/collections/coerce.py

@@ -39,8 +39,8 @@ def seq(
 
 
 def opt_seq(
-        it: ta.Optional[ta.Iterable[T]],
-) -> ta.Optional[ta.Sequence[T]]:
+        it: ta.Iterable[T] | None,
+) -> ta.Sequence[T] | None:
     if it is None:
         return None
     else:
@@ -48,8 +48,8 @@ def opt_seq(
 
 
 def seq_or_none(
-        it: ta.Optional[ta.Iterable[T]],
-) -> ta.Optional[ta.Sequence[T]]:
+        it: ta.Iterable[T] | None,
+) -> ta.Sequence[T] | None:
     ret = opt_seq(it)
     if ret:
         return ret
@@ -58,7 +58,7 @@ def seq_or_none(
 
 
 def seq_of(
-        fn: ta.Union[ta.Callable[[T], T2], tuple],
+        fn: ta.Callable[[T], T2] | tuple,
 ) -> ta.Callable[[ta.Iterable[T]], ta.Sequence[T2]]:
     def inner(it):
         return seq(fn(e) for e in it)  # type: ignore
@@ -68,8 +68,8 @@ def seq_of(
 
 
 def opt_seq_of(
-        fn: ta.Union[ta.Callable[[T], T2], tuple],
-) -> ta.Callable[[ta.Optional[ta.Iterable[T]]], ta.Optional[ta.Sequence[T2]]]:
+        fn: ta.Callable[[T], T2] | tuple,
+) -> ta.Callable[[ta.Iterable[T] | None], ta.Sequence[T2] | None]:
     def inner(it):
         if it is None:
             return None
@@ -81,8 +81,8 @@ def opt_seq_of(
 
 
 def seq_of_or_none(
-        fn: ta.Union[ta.Callable[[T], T2], tuple],
-) -> ta.Callable[[ta.Optional[ta.Iterable[T]]], ta.Optional[ta.Sequence[T2]]]:
+        fn: ta.Callable[[T], T2] | tuple,
+) -> ta.Callable[[ta.Iterable[T] | None], ta.Sequence[T2] | None]:
     def inner(it):
         if it is None:
             return None
@@ -115,8 +115,8 @@ def abs_set(
 
 
 def opt_abs_set(
-        it: ta.Optional[ta.Iterable[T]],
-) -> ta.Optional[ta.AbstractSet[T]]:
+        it: ta.Iterable[T] | None,
+) -> ta.AbstractSet[T] | None:
     if it is None:
         return None
     else:
@@ -124,8 +124,8 @@ def opt_abs_set(
 
 
 def abs_set_or_none(
-        it: ta.Optional[ta.Iterable[T]],
-) -> ta.Optional[ta.AbstractSet[T]]:
+        it: ta.Iterable[T] | None,
+) -> ta.AbstractSet[T] | None:
     ret = opt_abs_set(it)
     if ret:
         return ret
@@ -134,7 +134,7 @@ def abs_set_or_none(
 
 
 def abs_set_of(
-        fn: ta.Union[ta.Callable[[T], T2], tuple],
+        fn: ta.Callable[[T], T2] | tuple,
 ) -> ta.Callable[[ta.Iterable[T]], ta.AbstractSet[T2]]:
     def inner(it):
         return abs_set(fn(e) for e in it)  # type: ignore
@@ -144,8 +144,8 @@ def abs_set_of(
 
 
 def opt_abs_set_of(
-        fn: ta.Union[ta.Callable[[T], T2], tuple],
-) -> ta.Callable[[ta.Optional[ta.Iterable[T]]], ta.Optional[ta.AbstractSet[T2]]]:
+        fn: ta.Callable[[T], T2] | tuple,
+) -> ta.Callable[[ta.Iterable[T] | None], ta.AbstractSet[T2] | None]:
     def inner(it):
         if it is None:
             return None
@@ -157,8 +157,8 @@ def opt_abs_set_of(
 
 
 def abs_set_of_or_none(
-        fn: ta.Union[ta.Callable[[T], T2], tuple],
-) -> ta.Callable[[ta.Optional[ta.Iterable[T]]], ta.Optional[ta.AbstractSet[T2]]]:
+        fn: ta.Callable[[T], T2] | tuple,
+) -> ta.Callable[[ta.Iterable[T] | None], ta.AbstractSet[T2] | None]:
     def inner(it):
         if it is None:
             return None
@@ -191,8 +191,8 @@ def frozenset_(
 
 
 def opt_frozenset(
-        it: ta.Optional[ta.Iterable[T]],
-) -> ta.Optional[frozenset[T]]:
+        it: ta.Iterable[T] | None,
+) -> frozenset[T] | None:
     if it is None:
         return None
     else:
@@ -200,8 +200,8 @@ def opt_frozenset(
 
 
 def frozenset_or_none(
-        it: ta.Optional[ta.Iterable[T]],
-) -> ta.Optional[frozenset[T]]:
+        it: ta.Iterable[T] | None,
+) -> frozenset[T] | None:
     ret = opt_frozenset(it)
     if ret:
         return ret
@@ -210,7 +210,7 @@ def frozenset_or_none(
 
 
 def frozenset_of(
-        fn: ta.Union[ta.Callable[[T], T2], tuple],
+        fn: ta.Callable[[T], T2] | tuple,
 ) -> ta.Callable[[ta.Iterable[T]], frozenset[T2]]:
     def inner(it):
         return frozenset_(fn(e) for e in it)  # type: ignore
@@ -220,8 +220,8 @@ def frozenset_of(
 
 
 def opt_frozenset_of(
-        fn: ta.Union[ta.Callable[[T], T2], tuple],
-) -> ta.Callable[[ta.Optional[ta.Iterable[T]]], ta.Optional[frozenset[T2]]]:
+        fn: ta.Callable[[T], T2] | tuple,
+) -> ta.Callable[[ta.Iterable[T] | None], frozenset[T2] | None]:
     def inner(it):
         if it is None:
             return None
@@ -233,8 +233,8 @@ def opt_frozenset_of(
 
 
 def frozenset_of_or_none(
-        fn: ta.Union[ta.Callable[[T], T2], tuple],
-) -> ta.Callable[[ta.Optional[ta.Iterable[T]]], ta.Optional[frozenset[T2]]]:
+        fn: ta.Callable[[T], T2] | tuple,
+) -> ta.Callable[[ta.Iterable[T] | None], frozenset[T2] | None]:
     def inner(it):
         if it is None:
             return None
@@ -256,14 +256,14 @@ def frozenset_of_or_none(
 
 
 def map(
-        src: ta.Union[ta.Mapping[K, V], ta.Iterable[tuple[K, V]]],
+        src: ta.Mapping[K, V] | ta.Iterable[tuple[K, V]],
 ) -> ta.Mapping[K, V]:
     return FrozenDict(src)
 
 
 def opt_map(
-        src: ta.Optional[ta.Union[ta.Mapping[K, V], ta.Iterable[tuple[K, V]]]],
-) -> ta.Optional[ta.Mapping[K, V]]:
+        src: ta.Mapping[K, V] | ta.Iterable[tuple[K, V]] | None,
+) -> ta.Mapping[K, V] | None:
     if src is None:
         return None
     else:
@@ -271,8 +271,8 @@ def opt_map(
 
 
 def map_or_none(
-        src: ta.Optional[ta.Union[ta.Mapping[K, V], ta.Iterable[tuple[K, V]]]],
-) -> ta.Optional[ta.Mapping[K, V]]:
+        src: ta.Mapping[K, V] | ta.Iterable[tuple[K, V]] | None,
+) -> ta.Mapping[K, V] | None:
     ret = opt_map(src)
     if ret:
         return ret
@@ -281,10 +281,10 @@ def map_or_none(
 
 
 def map_of(
-        key_fn: ta.Union[ta.Callable[[K], K2], tuple],
-        value_fn: ta.Union[ta.Callable[[V], V2], tuple],
+        key_fn: ta.Callable[[K], K2] | tuple,
+        value_fn: ta.Callable[[V], V2] | tuple,
 ) -> ta.Callable[
-    [ta.Union[ta.Mapping[K, V], ta.Iterable[tuple[K, V]]]],
+    [ta.Mapping[K, V] | ta.Iterable[tuple[K, V]]],
     ta.Mapping[K2, V2],
 ]:
     def inner(src):
@@ -296,11 +296,11 @@ def map_of(
 
 
 def opt_map_of(
-        key_fn: ta.Union[ta.Callable[[K], K2], tuple],
-        value_fn: ta.Union[ta.Callable[[V], V2], tuple],
+        key_fn: ta.Callable[[K], K2] | tuple,
+        value_fn: ta.Callable[[V], V2] | tuple,
 ) -> ta.Callable[
-    [ta.Optional[ta.Union[ta.Mapping[K, V], ta.Iterable[tuple[K, V]]]]],
-    ta.Optional[ta.Mapping[K2, V2]],
+    [ta.Mapping[K, V] | ta.Iterable[tuple[K, V]] | None],
+    ta.Mapping[K2, V2] | None,
 ]:
     def inner(src):
         if src is None:
@@ -314,11 +314,11 @@ def opt_map_of(
 
 
 def map_of_or_none(
-        key_fn: ta.Union[ta.Callable[[K], K2], tuple],
-        value_fn: ta.Union[ta.Callable[[V], V2], tuple],
+        key_fn: ta.Callable[[K], K2] | tuple,
+        value_fn: ta.Callable[[V], V2] | tuple,
 ) -> ta.Callable[
-    [ta.Optional[ta.Union[ta.Mapping[K, V], ta.Iterable[tuple[K, V]]]]],
-    ta.Optional[ta.Mapping[K2, V2]],
+    [ta.Mapping[K, V] | ta.Iterable[tuple[K, V]] | None],
+    ta.Mapping[K2, V2] | None,
 ]:
     def inner(src):
         if src is None:

omlish/collections/frozen.py

@@ -74,11 +74,11 @@ class FrozenDict(ta.Mapping[K, V], Frozen):
 
 class FrozenList(ta.Sequence[T], Frozen):
 
-    def __init__(self, it: ta.Optional[ta.Iterable[T]] = None) -> None:
+    def __init__(self, it: ta.Iterable[T] | None = None) -> None:
         super().__init__()
 
         self._tup: tuple = tuple(it) if it is not None else ()
-        self._hash: ta.Optional[int] = None
+        self._hash: int | None = None
 
     @property
     def debug(self) -> ta.Sequence[T]:
@@ -111,7 +111,7 @@ class FrozenList(ta.Sequence[T], Frozen):
             self._hash = hash(self._tup)
         return self._hash
 
-    def __getitem__(self, idx: ta.Union[int, slice]) -> 'FrozenList[T]':  # type: ignore
+    def __getitem__(self, idx: int | slice) -> 'FrozenList[T]':  # type: ignore
         if isinstance(idx, int):
             return self._tup[idx]
         else:

omlish/collections/identity.py

@@ -69,7 +69,7 @@ class IdentityKeyDict(ta.MutableMapping[K, V]):
 
 class IdentitySet(ta.MutableSet[T]):
 
-    def __init__(self, init: ta.Optional[ta.Iterable[T]] = None) -> None:
+    def __init__(self, init: ta.Iterable[T] | None = None) -> None:
         super().__init__()
         self._dict: dict[int, T] = {}
         if init is not None:

omlish/collections/mappings.py

@@ -8,7 +8,7 @@ K = ta.TypeVar('K')
 V = ta.TypeVar('V')
 
 
-def multikey_dict(dct: ta.Mapping[ta.Union[ta.Iterable[K], K], V], *, deep: bool = False) -> dict[K, V]:
+def multikey_dict(dct: ta.Mapping[ta.Iterable[K] | K, V], *, deep: bool = False) -> dict[K, V]:
     ret = {}
     for k, v in dct.items():
         if deep and isinstance(v, dict):
@@ -23,7 +23,7 @@ def multikey_dict(dct: ta.Mapping[ta.Union[ta.Iterable[K], K], V], *, deep: bool
 
 def guarded_map_update(
         dst: ta.MutableMapping[ta.Any, ta.Any],
-        *srcs: ta.Mapping[ta.Any, ta.Any]
+        *srcs: ta.Mapping[ta.Any, ta.Any],
 ) -> ta.MutableMapping[ta.Any, ta.Any]:
     for src in srcs:
         for k, v in src.items():
@@ -71,7 +71,7 @@ class TypeMap(ta.Generic[T]):
     def __iter__(self) -> ta.Iterable[T]:
         return iter(self._items)
 
-    def get(self, ty: type[T]) -> ta.Optional[T]:
+    def get(self, ty: type[T]) -> T | None:
         return self._dct.get(ty)
 
     def __getitem__(self, ty: type[T]) -> ta.Sequence[T]:

omlish/collections/ordered.py

@@ -6,7 +6,7 @@ T = ta.TypeVar('T')
 
 class OrderedSet(ta.MutableSet[T]):
 
-    def __init__(self, iterable: ta.Optional[ta.Iterable[T]] = None) -> None:
+    def __init__(self, iterable: ta.Iterable[T] | None = None) -> None:
         super().__init__()
         self._dct: dict[T, ta.Any] = {}
         if iterable is not None:

omlish/collections/skiplist.py

@@ -27,7 +27,7 @@ class SkipList(SortedCollection[T]):
         def __init__(
                 self,
                 value: T,
-                level: int
+                level: int,
         ) -> None:
             super().__init__()
 
@@ -46,7 +46,7 @@ class SkipList(SortedCollection[T]):
             self,
             *,
             max_height: int = 16,
-            comparator: ta.Optional[SortedCollection.Comparator[T]] = None,
+            comparator: SortedCollection.Comparator[T] | None = None,
     ) -> None:
         super().__init__()
 
@@ -108,7 +108,7 @@ class SkipList(SortedCollection[T]):
         self._length += 1
         return True
 
-    def _find(self, value: T) -> ta.Optional[_Node]:
+    def _find(self, value: T) -> _Node | None:
         if value is None:
             raise TypeError(value)
 
@@ -120,7 +120,7 @@ class SkipList(SortedCollection[T]):
 
         return cur.next[0]
 
-    def find(self, value: T) -> ta.Optional[T]:
+    def find(self, value: T) -> T | None:
         node = self._find(value)
         if node is None:
             return None
@@ -157,7 +157,7 @@ class SkipList(SortedCollection[T]):
         self._length -= 1
         return True
 
-    def iter(self, base: ta.Optional[T] = None) -> ta.Iterable[T]:
+    def iter(self, base: T | None = None) -> ta.Iterable[T]:
         if base is not None:
             cur = self._find(base)
             while cur is not None and self._compare(base, cur.value) > 0:  # type: ignore
@@ -169,7 +169,7 @@ class SkipList(SortedCollection[T]):
             yield cur.value  # type: ignore
             cur = cur.next[0]
 
-    def riter(self, base: ta.Optional[T] = None) -> ta.Iterable[T]:
+    def riter(self, base: T | None = None) -> ta.Iterable[T]:
         if base is not None:
             cur = self._find(base)
             while cur is not self._head and self._compare(base, cur.value) < 0:  # type: ignore

omlish/collections/sorted.py

@@ -38,7 +38,7 @@ class SortedCollection(lang.Abstract, ta.Collection[T]):
         raise NotImplementedError
 
     @abc.abstractmethod
-    def find(self, value: T) -> ta.Optional[T]:
+    def find(self, value: T) -> T | None:
         raise NotImplementedError
 
     @abc.abstractmethod
@@ -46,11 +46,11 @@ class SortedCollection(lang.Abstract, ta.Collection[T]):
         raise NotImplementedError
 
     @abc.abstractmethod
-    def iter(self, base: ta.Optional[T] = None) -> ta.Iterable[T]:
+    def iter(self, base: T | None = None) -> ta.Iterable[T]:
         raise NotImplementedError
 
     @abc.abstractmethod
-    def riter(self, base: ta.Optional[T] = None) -> ta.Iterable[T]:
+    def riter(self, base: T | None = None) -> ta.Iterable[T]:
         raise NotImplementedError
 
 

omlish/collections/treap.py

@@ -65,7 +65,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
@@ -79,11 +79,11 @@ def find(n: ta.Optional[TreapNode[T]], v: T, c: Comparer[T]) -> ta.Optional[Trea
 
 
 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 +100,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 +120,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 +146,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 +167,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 +190,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 +206,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

@@ -33,7 +33,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__()
@@ -115,7 +115,7 @@ class TreapMapIterator(ta.Generic[K, V]):
             self,
             *,
             _st: list[treap.TreapNode[tuple[K, V]]],
-            _n: ta.Optional[treap.TreapNode[tuple[K, V]]],
+            _n: treap.TreapNode[tuple[K, V]] | None,
             _b: bool,
     ) -> None:
         super().__init__()

omlish/collections/unmodifiable.py

@@ -24,34 +24,34 @@ class UnmodifiableSequence(ta.Sequence[T], Unmodifiable, lang.Final):
     def __repr__(self) -> str:
         return '%s(%r)' % (type(self).__name__, self._target)
 
-    def __contains__(self, x: object) -> bool:
+    def __contains__(self, x: ta.Any) -> bool:
         return x in self._target
 
-    def __eq__(self, o: object) -> bool:
+    def __eq__(self, o: ta.Any) -> 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:
+    def __ne__(self, o: ta.Any) -> bool:
         return self._target != o
 
     def __reversed__(self) -> ta.Iterator[T]:
@@ -79,10 +79,10 @@ class UnmodifiableSet(ta.AbstractSet[T], Unmodifiable, lang.Final):
     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:
+    def __eq__(self, o: ta.Any) -> 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: object) -> bool:
+    def __ne__(self, o: ta.Any) -> bool:
         return self._target != o
 
     def __or__(self, s: ta.AbstractSet[T]) -> ta.AbstractSet[T]:  # type: ignore
@@ -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__()
@@ -131,37 +132,37 @@ class UnmodifiableMapping(ta.Mapping[K, V], Unmodifiable, lang.Final):
     def __repr__(self) -> str:
         return '%s(%r)' % (type(self).__name__, self._target)
 
-    def __contains__(self, o: object) -> bool:
+    def __contains__(self, o: ta.Any) -> bool:
         return o in self._target
 
-    def __eq__(self, o: object) -> bool:
+    def __eq__(self, o: ta.Any) -> 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:
+    def __ne__(self, o: ta.Any) -> 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/configs/flattening.py

@@ -119,7 +119,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))

omlish/configs/props.py

@@ -19,7 +19,7 @@ def escape(token: str) -> str:
     return _ESCAPE_PATTERN.sub(r'\\\1', token)
 
 
-def parse_line(line: str) -> ta.Optional[ta.Tuple[str, str]]:
+def parse_line(line: str) -> ta.Tuple[str, str] | None:
     if line and not (line.startswith('#') or line.startswith('!')):
         match = _SEPARATOR_PATTERN.search(line)
         if match:

omlish/dataclasses/impl/__init__.py

@@ -3,4 +3,6 @@ TODO:
  - metaclass:
   - 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?
 """