omlish 0.0.0.dev1__tar.gz → 0.0.0.dev2__tar.gz

omlish-0.0.0.dev2/PKG-INFO

@@ -0,0 +1,30 @@
+Metadata-Version: 2.1
+Name: omlish
+Version: 0.0.0.dev2
+Summary: omlish
+Author: wrmsr
+License: BSD-3-Clause
+Project-URL: source, https://github.com/wrmsr/omlish
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.12
+License-File: LICENSE
+Provides-Extra: async
+Requires-Dist: anyio; extra == "async"
+Provides-Extra: http
+Requires-Dist: httpx; extra == "http"
+Provides-Extra: sql
+Requires-Dist: sqlalchemy; extra == "sql"
+Provides-Extra: wrapt
+Requires-Dist: wrapt; extra == "wrapt"
+Provides-Extra: yaml
+Requires-Dist: pyyaml; extra == "yaml"
+Provides-Extra: server
+Requires-Dist: h11; extra == "server"
+Requires-Dist: h2; extra == "server"
+Requires-Dist: priority; extra == "server"
+Requires-Dist: wsproto; extra == "server"
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"

{omlish-0.0.0.dev1 → omlish-0.0.0.dev2}/omlish/__about__.py

@@ -2,6 +2,6 @@ __name__ = 'omlish'
 __author__ = 'wrmsr'
 __url__ = 'https://github.com/wrmsr/omlish'
 __license__ = 'BSD-3-Clause'
-__requires_python__ = '>=3.11'
+__requires_python__ = '>=3.12'
 
-__version__ = '0.0.0.dev1'
+__version__ = '0.0.0.dev2'

{omlish-0.0.0.dev1 → omlish-0.0.0.dev2}/omlish/argparse.py

@@ -48,7 +48,7 @@ ArgumentParser = argparse.ArgumentParser
 class Arg:
     args: ta.Sequence[ta.Any]
     kwargs: ta.Mapping[str, ta.Any]
-    dest: ta.Optional[str] = None
+    dest: str | None = None
 
     def __get__(self, instance, owner=None):
         if instance is None:
@@ -92,8 +92,8 @@ class Command:
 
 def command(
         *args: Arg,
-        name: ta.Optional[str] = None,
-        parent: ta.Optional[Command] = None,
+        name: str | None = None,
+        parent: Command | None = None,
 ) -> ta.Any:  # ta.Callable[[CommandFn], Command]:  # FIXME
     for arg in args:
         check.isinstance(arg, Arg)
@@ -192,7 +192,7 @@ class _CliMeta(type):
 
 class Cli(metaclass=_CliMeta):
 
-    def __init__(self, argv: ta.Optional[ta.Sequence[str]] = None) -> None:
+    def __init__(self, argv: ta.Sequence[str] | None = None) -> None:
         super().__init__()
 
         self._argv = argv if argv is not None else sys.argv[1:]

omlish-0.0.0.dev2/omlish/asyncs/anyio.py

@@ -0,0 +1,84 @@
+"""
+lookit:
+ - https://github.com/davidbrochart/sqlite-anyio/blob/a3ba4c6ef0535b14a5a60071fcd6ed565a514963/sqlite_anyio/sqlite.py
+ - https://github.com/rafalkrupinski/ratelimit-anyio/blob/2910a8a3d6fa54ed17ee6ba457686c9f7a4c4beb/src/ratelimit_anyio/__init__.py
+ - https://github.com/nekitdev/async-extensions/tree/main/async_extensions
+ - https://github.com/kinnay/anynet/tree/master/anynet
+ - https://github.com/M-o-a-T/asyncscope
+ - https://github.com/M-o-a-T/aevent
+ - https://github.com/florimondmanca/aiometer
+ - https://github.com/sanitizers/octomachinery/blob/b36c3d3d49da813ac46e361424132955a4e99ac8/octomachinery/utils/asynctools.py
+"""  # noqa
+import typing as ta
+
+import anyio.streams.memory
+import anyio.streams.stapled
+
+from .. import check
+from .. import lang
+
+
+T = ta.TypeVar('T')
+
+
+async def anyio_eof_to_empty(fn: ta.Callable[..., ta.Awaitable[T]], *args: ta.Any, **kwargs: ta.Any) -> T | bytes:
+    try:
+        return await fn(*args, **kwargs)
+    except anyio.EndOfStream:
+        return b''
+
+
+def split_memory_object_streams(
+        *args: anyio.create_memory_object_stream[T],
+) -> tuple[
+    anyio.streams.memory.MemoryObjectSendStream[T],
+    anyio.streams.memory.MemoryObjectReceiveStream[T],
+]:
+    [tup] = args
+    return tup
+
+
+# FIXME: https://github.com/python/mypy/issues/15238
+# def create_memory_object_stream[T](max_buffer_size: float = 0) -> tuple[
+#     anyio.streams.memory.MemoryObjectSendStream[T],
+#     anyio.streams.memory.MemoryObjectReceiveStream[T],
+# ]:
+#     return anyio.create_memory_object_stream[T](max_buffer_size)
+
+
+def staple_memory_object_stream(
+        *args: anyio.create_memory_object_stream[T],
+) -> anyio.streams.stapled.StapledObjectStream[T]:
+    send, receive = args
+    return anyio.streams.stapled.StapledObjectStream(
+        check.isinstance(send, anyio.streams.memory.MemoryObjectSendStream),  # type: ignore
+        check.isinstance(receive, anyio.streams.memory.MemoryObjectReceiveStream),  # type: ignore
+    )
+
+
+# FIXME: https://github.com/python/mypy/issues/15238
+# def staple_memory_object_stream2[T](max_buffer_size: float = 0) -> anyio.streams.stapled.StapledObjectStream[T]:
+#     send, receive = anyio.create_memory_object_stream[T](max_buffer_size)
+#     return anyio.streams.stapled.StapledObjectStream(
+#         check.isinstance(send, anyio.streams.memory.MemoryObjectSendStream),  # type: ignore
+#         check.isinstance(receive, anyio.streams.memory.MemoryObjectReceiveStream),  # type: ignore
+#     )
+
+
+async def gather(*fns: ta.Callable[..., ta.Awaitable[T]], take_first: bool = False) -> list[lang.Maybe[T]]:
+    results: list[lang.Maybe[T]] = [lang.empty()] * len(fns)
+
+    async def inner(fn, i):
+        results[i] = lang.just(await fn())
+        if take_first:
+            tg.cancel_scope.cancel()
+
+    async with anyio.create_task_group() as tg:
+        for i, fn in enumerate(fns):
+            tg.start_soon(inner, fn, i)
+
+    return results
+
+
+async def first(*fns: ta.Callable[..., ta.Awaitable[T]], **kwargs: ta.Any) -> list[lang.Maybe[T]]:
+    return await gather(*fns, take_first=True, **kwargs)

{omlish-0.0.0.dev1 → omlish-0.0.0.dev2}/omlish/asyncs/futures.py

@@ -12,7 +12,7 @@ T = ta.TypeVar('T')
 
 class FutureException(Exception, ta.Generic[T]):
 
-    def __init__(self, future: cf.Future, target: ta.Optional[T] = None) -> None:
+    def __init__(self, future: cf.Future, target: T | None = None) -> None:
         super().__init__()
 
         self._future = future
@@ -23,7 +23,7 @@ class FutureException(Exception, ta.Generic[T]):
         return self._future
 
     @property
-    def target(self) -> ta.Optional[T]:
+    def target(self) -> T | None:
         return self._target
 
     def __repr__(self) -> str:
@@ -44,8 +44,8 @@ class FutureTimeoutException(Exception):
 def wait_futures(
         futures: ta.Sequence[cf.Future],
         *,
-        timeout_s: ta.Union[int, float] = 60,
-        tick_interval_s: ta.Union[int, float] = 0.5,
+        timeout_s: float = 60,
+        tick_interval_s: float = .5,
         tick_fn: ta.Callable[..., bool] = lambda: True,
         raise_exceptions: bool = False,
         cancel_on_exception: bool = False,
@@ -78,8 +78,8 @@ def wait_dependent_futures(
         executor: cf.Executor,
         dependency_sets_by_fn: ta.Mapping[ta.Callable, ta.AbstractSet[ta.Callable]],
         *,
-        timeout_s: ta.Union[int, float] = 60,
-        tick_interval_s: ta.Union[int, float] = 0.5,
+        timeout_s: float = 60,
+        tick_interval_s: float = .5,
         tick_fn: ta.Callable[..., bool] = lambda: True,
 ) -> ta.Mapping[ta.Callable, cf.Future]:
     for fn, deps in dependency_sets_by_fn.items():

{omlish-0.0.0.dev1 → omlish-0.0.0.dev2}/omlish/c3.py

@@ -49,7 +49,7 @@ def merge(seqs: ta.MutableSequence[list[T]]) -> list[T]:
     """
 
     result: list[T] = []
-    candidate: ta.Optional[T] = None
+    candidate: T | None = None
     while True:
         seqs = [s for s in seqs if s]  # purge empty sequences
         if not seqs:
@@ -73,7 +73,7 @@ def merge(seqs: ta.MutableSequence[list[T]]) -> list[T]:
 
 def mro(
         cls: T,
-        abcs: ta.Optional[ta.Sequence[T]] = None,
+        abcs: ta.Sequence[T] | None = None,
         *,
         get_bases: ta.Callable[[T], ta.Sequence[T]] = operator.attrgetter('__bases__'),
         is_subclass: ta.Callable[[T, T], bool] = issubclass,  # type: ignore
@@ -115,7 +115,7 @@ def mro(
     return merge(
         [[cls]] +
         explicit_c3_mros + abstract_c3_mros + other_c3_mros +
-        [explicit_bases] + [abstract_bases] + [other_bases]
+        [explicit_bases] + [abstract_bases] + [other_bases],
     )
 
 
@@ -123,7 +123,7 @@ def compose_mro(
         cls: T,
         types: ta.Iterable[T],
         *,
-        get_mro: ta.Callable[[T], ta.Optional[ta.Sequence[T]]] = operator.attrgetter('__mro__'),
+        get_mro: ta.Callable[[T], ta.Sequence[T] | None] = operator.attrgetter('__mro__'),
         get_bases: ta.Callable[[T], ta.Sequence[T]] = operator.attrgetter('__bases__'),
         is_subclass: ta.Callable[[T, T], bool] = issubclass,  # type: ignore
         get_subclasses: ta.Callable[[T], ta.Iterable[T]] = operator.methodcaller('__subclasses__'),

{omlish-0.0.0.dev1 → omlish-0.0.0.dev2}/omlish/check.py

@@ -9,7 +9,7 @@ import typing as ta
 T = ta.TypeVar('T')
 SizedT = ta.TypeVar('SizedT', bound=ta.Sized)
 
-Message = ta.Union[str, ta.Callable[..., ta.Optional[str]], None]
+Message = ta.Union[str, ta.Callable[..., str | None], None]
 
 _NONE_TYPE = type(None)
 
@@ -33,7 +33,7 @@ def _raise(
         default_message: str,
         message: Message,
         *args: ta.Any,
-        **kwargs: ta.Any
+        **kwargs: ta.Any,
 ) -> ta.NoReturn:
     if _callable(message):
         message = ta.cast(ta.Callable, message)(*args, **kwargs)
@@ -64,7 +64,7 @@ def isinstance(v: ta.Any, spec: ta.Union[type[T], tuple], msg: Message = None) -
     return v
 
 
-def of_isinstance(spec: ta.Union[type[T], tuple], msg: Message = None) -> ta.Callable[[ta.Any], T]:
+def of_isinstance(spec: type[T] | tuple, msg: Message = None) -> ta.Callable[[ta.Any], T]:
     def inner(v):
         return isinstance(v, _unpack_isinstance_spec(spec), msg)
 
@@ -155,7 +155,7 @@ def single(obj: ta.Iterable[T], message: Message = None) -> T:
         return value
 
 
-def optional_single(obj: ta.Iterable[T], message: Message = None) -> ta.Optional[T]:
+def optional_single(obj: ta.Iterable[T], message: Message = None) -> T | None:
     it = iter(obj)
     try:
         value = next(it)
@@ -176,7 +176,7 @@ def none(v: ta.Any, msg: Message = None) -> None:
         _raise(ValueError, 'Must be None', msg, v)
 
 
-def not_none(v: ta.Optional[T], msg: Message = None) -> T:
+def not_none(v: T | None, msg: Message = None) -> T:
     if v is None:
         _raise(ValueError, 'Must not be None', msg, v)
     return v
@@ -212,7 +212,7 @@ def callable(v: T, msg: Message = None) -> T:
     return v  # type: ignore
 
 
-def non_empty_str(v: ta.Optional[str], msg: Message = None) -> str:
+def non_empty_str(v: str | None, msg: Message = None) -> str:
     if not _isinstance(v, str) or not v:
         _raise(ValueError, 'Must be non-empty str', msg, v)
     return v

omlish-0.0.0.dev2/omlish/collections/__init__.py

@@ -0,0 +1,98 @@
+from .coerce import (  # noqa
+    abs_set,
+    abs_set_of,
+    abs_set_of_or_none,
+    abs_set_or_none,
+    frozenset_,
+    frozenset_of,
+    frozenset_of_or_none,
+    frozenset_or_none,
+    map,
+    map_of,
+    map_of_or_none,
+    map_or_none,
+    opt_abs_set,
+    opt_abs_set_of,
+    opt_frozenset,
+    opt_frozenset_of,
+    opt_map,
+    opt_map_of,
+    opt_seq,
+    opt_seq_of,
+    seq,
+    seq_of,
+    seq_of_or_none,
+    seq_or_none,
+)
+
+from .frozen import (  # noqa
+    Frozen,
+    FrozenDict,
+    FrozenList,
+    frozendict,
+    frozenlist,
+)
+
+from .identity import (  # noqa
+    IdentityKeyDict,
+    IdentitySet,
+    IdentityWrapper,
+)
+
+from .indexed import (  # noqa
+    IndexedSeq,
+    IndexedSetSeq,
+)
+
+from .mappings import (  # noqa
+    MissingDict,
+    TypeMap,
+    TypeMultiMap,
+    guarded_map_update,
+    multikey_dict,
+    yield_dict_init,
+)
+
+from .ordered import (  # noqa
+    OrderedFrozenSet,
+    OrderedSet,
+)
+
+from .persistent import (  # noqa
+    PersistentMap,
+)
+
+from .skiplist import (  # noqa
+    SkipList,
+    SkipListDict,
+)
+
+from .sorted import (  # noqa
+    SortedCollection,
+    SortedListDict,
+    SortedMapping,
+    SortedMutableMapping,
+)
+
+from .treapmap import (  # noqa
+    new_treap_map,
+)
+
+from .unmodifiable import (  # noqa
+    Unmodifiable,
+    UnmodifiableMapping,
+    UnmodifiableSequence,
+    UnmodifiableSet,
+)
+
+from .utils import (  # noqa
+    all_equal,
+    all_not_equal,
+    indexes,
+    key_cmp,
+    mut_toposort,
+    partition,
+    toposort,
+    unique,
+    unique_dict,
+)

{omlish-0.0.0.dev1 → omlish-0.0.0.dev2}/omlish/collections/cache/descriptor.py

@@ -27,7 +27,7 @@ class _HashedSeq(list):
     def __init__(
             self,
             tup: ta.Tuple,
-            hasher: ta.Callable[[ta.Any], int] = hash
+            hasher: ta.Callable[[ta.Any], int] = hash,
     ) -> None:
         super().__init__()
 
@@ -46,7 +46,7 @@ def _make_key(
         fasttypes=frozenset([int, str, frozenset, type(None)]),
         tuple=tuple,
         type=type,
-        len=len
+        len=len,
 ) -> ta.Any:
     key = args
     if kwargs:
@@ -81,7 +81,7 @@ class _CacheDescriptor:
             fn: ta.Callable,
             scope: Scope,
             typed: bool,
-            **kwargs: ta.Any
+            **kwargs: ta.Any,
     ) -> None:
         super().__init__()
 
@@ -175,9 +175,9 @@ class _CacheDescriptor:
 
 
 def cache(
-        scope: ta.Union[Scope, str] = Scope.INSTANCE,
+        scope: Scope | str = Scope.INSTANCE,
         typed: bool = False,
-        **kwargs
+        **kwargs,
 ) -> CC:
     if not isinstance(scope, Scope):
         scope = getattr(Scope, scope.upper())  # noqa

{omlish-0.0.0.dev1 → omlish-0.0.0.dev2}/omlish/collections/cache/impl.py

@@ -82,8 +82,8 @@ class CacheImpl(Cache[K, V]):
             lru_next: 'CacheImpl.Link'
             lfu_prev: 'CacheImpl.Link'
             lfu_next: 'CacheImpl.Link'
-            key: ta.Union[ta.Any, weakref.ref]
-            value: ta.Union[ta.Any, weakref.ref]
+            key: ta.Any | weakref.ref
+            value: ta.Any | weakref.ref
             weight: float
             written: float
             accessed: float
@@ -120,7 +120,7 @@ class CacheImpl(Cache[K, V]):
             identity_keys: bool = False,
             expire_after_access: float | None = None,
             expire_after_write: float | None = None,
-            removal_listener: ta.Callable[[ta.Union[K, weakref.ref], ta.Union[V, weakref.ref]], None] | None = None,
+            removal_listener: ta.Callable[[K | weakref.ref, V | weakref.ref], None] | None = None,
             clock: ta.Callable[[], float] | None = None,
             weak_keys: bool = False,
             weak_values: bool = False,
@@ -165,7 +165,7 @@ class CacheImpl(Cache[K, V]):
         if self._track_frequency:
             self._root.lfu_next = self._root.lfu_prev = self._root
 
-        weak_dead: ta.Optional[ta.Deque[CacheImpl.Link]]
+        weak_dead: ta.Deque[CacheImpl.Link] | None
         if weak_keys or weak_values:
             weak_dead = collections.deque()
             weak_dead_ref = weakref.ref(weak_dead)

{omlish-0.0.0.dev1 → omlish-0.0.0.dev2}/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: