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

omlish/dataclasses/impl/api.py

@@ -12,14 +12,11 @@ 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(
         default=MISSING,
@@ -32,10 +29,11 @@ def field(
         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 +43,7 @@ def field(
         check=check,
         check_type=check_type,
         override=override,
+        repr_fn=repr_fn,
     )
 
     md: ta.Mapping = {FieldExtras: fx}
@@ -96,8 +95,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 +115,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:

omlish/dataclasses/impl/fields.py

@@ -112,7 +112,7 @@ def field_init(
         locals[cn] = f.type
         lines.append(
             f'if not __dataclass_builtins_isinstance__({f.name}, {cn}): '
-            f'raise __dataclass_builtins_TypeError__({f.name}, {cn})'
+            f'raise __dataclass_builtins_TypeError__({f.name}, {cn})',
         )
 
     value: str | None = None

omlish/dataclasses/impl/init.py

@@ -109,7 +109,7 @@ class InitBuilder:
                 self._info.params.frozen,
                 locals,
                 self._self_name,
-                self._info.params12.slots,
+                self._info.params.slots,
             )
 
             if f_lines:

omlish/dataclasses/impl/internals.py

@@ -17,6 +17,21 @@ POST_INIT_NAME = dc._POST_INIT_NAME  # type: ignore  # noqa
 
 Params = dc._DataclassParams  # type: ignore  # noqa
 
+"""
+@dc.dataclass(frozen=True)
+class Params:
+    init = True
+    repr = True
+    eq = True
+    order = False
+    unsafe_hash = False
+    frozen = False
+    match_args = True
+    kw_only = False
+    slots = False
+    weakref_slot = False
+"""
+
 
 ##
 

omlish/dataclasses/impl/main.py

@@ -84,7 +84,7 @@ class MainProcessor:
 
         cls_fields: list[dc.Field] = []
 
-        kw_only = self._info.params12.kw_only
+        kw_only = self._info.params.kw_only
         kw_only_seen = False
         for name, ann in self._info.cls_annotations.items():
             if is_kw_only(self._cls, ann):
@@ -111,11 +111,11 @@ class MainProcessor:
 
     @lang.cached_function
     def _transform_slots(self) -> None:
-        if self._info.params12.weakref_slot and not self._info.params12.slots:
+        if self._info.params.weakref_slot and not self._info.params.slots:
             raise TypeError('weakref_slot is True but slots is False')
-        if not self._info.params12.slots:
+        if not self._info.params.slots:
             return
-        self._cls = add_slots(self._cls, self._info.params.frozen, self._info.params12.weakref_slot)
+        self._cls = add_slots(self._cls, self._info.params.frozen, self._info.params.weakref_slot)
 
     @lang.cached_function
     def process(self) -> type:

omlish/dataclasses/impl/metaclass.py

@@ -59,7 +59,7 @@ class DataMeta(abc.ABCMeta):
             # confer=frozenset(),
 
             metadata=None,
-            **kwargs
+            **kwargs,
     ):
         cls = lang.super_meta(
             super(),

omlish/dataclasses/impl/metadata.py

@@ -58,7 +58,7 @@ class Check(lang.Marker):
     pass
 
 
-def check(fn: ta.Union[ta.Callable[..., bool], staticmethod]) -> None:
+def check(fn: ta.Callable[..., bool] | staticmethod) -> None:
     _append_cls_md(Check, fn)
 
 

omlish/dataclasses/impl/order.py

@@ -43,5 +43,5 @@ class OrderProcessor(Processor):
             if set_new_attribute(self._cls, name, cmp_fn(name, op, self_tuple, other_tuple, globals=self._info.globals)):  # noqa
                 raise TypeError(
                     f'Cannot overwrite attribute {name} in class {self._cls.__name__}. '
-                    f'Consider using functools.total_ordering'
+                    f'Consider using functools.total_ordering',
                 )

omlish/dataclasses/impl/params.py

@@ -28,7 +28,6 @@ Params:
     weakref_slot: bool = False
 """
 import dataclasses as dc
-import sys
 import typing as ta
 
 from ... import lang
@@ -38,18 +37,16 @@ from .metadata import EMPTY_METADATA
 from .metadata import METADATA_ATTR
 
 
-IS_12 = sys.version_info[1] >= 12
-
-
 ##
 
 
 @dc.dataclass(frozen=True)
 class FieldExtras(lang.Final):
-    coerce: ta.Optional[ta.Union[bool, ta.Callable[[ta.Any], ta.Any]]] = None
-    check: ta.Optional[ta.Callable[[ta.Any], bool]] = None
-    check_type: ta.Optional[bool] = None
+    coerce: bool | 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
 
 
 DEFAULT_FIELD_EXTRAS = FieldExtras()
@@ -82,37 +79,6 @@ def get_params(obj: ta.Any) -> Params:
 ##
 
 
-@dc.dataclass(frozen=True)
-class Params12(lang.Final):
-    match_args: bool = True
-    kw_only: bool = False
-    slots: bool = False
-    weakref_slot: bool = False
-
-
-DEFAULT_PARAMS12 = Params12()
-
-
-def get_params12(obj: ta.Any) -> Params12:
-    if IS_12:
-        p = get_params(obj)
-        return Params12(
-            match_args=p.match_args,
-            kw_only=p.kw_only,
-            slots=p.slots,
-            weakref_slot=p.weakref_slot,
-        )
-
-    if (pcls := get_params_cls(obj)) is None:
-        raise TypeError(pcls)
-
-    md = pcls.__dict__.get(METADATA_ATTR, EMPTY_METADATA)
-    return md.get(Params12, DEFAULT_PARAMS12)
-
-
-##
-
-
 @dc.dataclass(frozen=True)
 class ParamsExtras(lang.Final):
     reorder: bool = False

omlish/dataclasses/impl/reflect.py

@@ -22,10 +22,8 @@ from .metadata import METADATA_ATTR
 from .metadata import Metadata
 from .metadata import get_merged_metadata
 from .params import PARAMS_ATTR
-from .params import Params12
 from .params import ParamsExtras
 from .params import get_params
-from .params import get_params12
 from .params import get_params_extras
 from .utils import Namespace
 
@@ -55,7 +53,7 @@ class ClassInfo:
             return {}
 
     @cached.property
-    def cls_annotations(self) -> dict[str, ta.Any]:
+    def cls_annotations(self) -> ta.Mapping[str, ta.Any]:
         return inspect.get_annotations(self._cls)
 
     ##
@@ -68,10 +66,6 @@ class ClassInfo:
     def cls_params(self) -> Params | None:
         return self._cls.__dict__.get(PARAMS_ATTR)
 
-    @cached.property
-    def params12(self) -> Params12:
-        return get_params12(self._cls)
-
     @cached.property
     def params_extras(self) -> ParamsExtras:
         return get_params_extras(self._cls)

omlish/dataclasses/impl/repr.py

@@ -2,6 +2,7 @@ import dataclasses as dc
 import reprlib
 import typing as ta
 
+from .params import get_field_extras
 from .processing import Processor
 from .utils import Namespace
 from .utils import create_fn
@@ -12,15 +13,32 @@ def repr_fn(
         fields: ta.Sequence[dc.Field],
         globals: Namespace,
 ) -> ta.Callable:
+    locals: dict[str, ta.Any] = {}
+    if any(get_field_extras(f).repr_fn is not None for f in fields):
+        lst: list[str] = []
+        for f in fields:
+            if (fex := get_field_extras(f)).repr_fn is not None:
+                locals[fn_name := f'__repr_fn__{f.name}'] = fex.repr_fn
+                lst.append(f"if (r := {fn_name}(self.{f.name})) is not None: l.append(f'{f.name}={{r}}')")
+            else:
+                lst.append(f"l.append(f'{f.name}={{self.{f.name}!r}}')")
+        src = [
+            'l = []',
+            *lst,
+            '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]) +
+            ')"',
+        ]
     fn = create_fn(
         '__repr__',
         ('self',),
-        [
-            'return f"{self.__class__.__qualname__}(' +
-            ', '.join([f"{f.name}={{self.{f.name}!r}}" for f in fields]) +
-            ')"'
-        ],
+        src,
         globals=globals,
+        locals=locals,
     )
     return reprlib.recursive_repr()(fn)
 

omlish/dataclasses/impl/simple.py

@@ -16,7 +16,7 @@ class OverridesProcessor(Processor):
             if not fx.override:
                 continue
 
-            if self._info.params12.slots:
+            if self._info.params.slots:
                 raise TypeError
 
             self_name = '__dataclass_self__' if 'self' in self._info.fields else 'self'
@@ -85,7 +85,7 @@ class DocProcessor(Processor):
 
 class MatchArgsProcessor(Processor):
     def _process(self) -> None:
-        if not self._info.params12.match_args:
+        if not self._info.params.match_args:
             return
 
         ifs = get_init_fields(self._info.fields.values())

omlish/dataclasses/impl/slots.py

@@ -55,8 +55,8 @@ def add_slots(
             inherited_slots.__contains__,
             itertools.chain(
                 field_names,
-                ('__weakref__',) if weakref_slot else ()
-            )
+                ('__weakref__',) if weakref_slot else (),
+            ),
         ),
     )
 

omlish/dataclasses/impl/utils.py

@@ -16,8 +16,8 @@ def create_fn(
         args: ta.Sequence[str],
         body: ta.Sequence[str],
         *,
-        globals: ta.Optional[Namespace] = None,
-        locals: ta.Optional[Namespace] = None,
+        globals: Namespace | None = None,
+        locals: Namespace | None = None,
         return_type: lang.Maybe[ta.Any] = lang.empty(),
 ) -> ta.Callable:
     check.not_isinstance(args, str)
@@ -59,11 +59,11 @@ class FuncBuilder:
             args: ta.Sequence[str],
             body: ta.Sequence[str],
             *,
-            locals: ta.Optional[Namespace] = None,
+            locals: Namespace | None = None,
             return_type: lang.Maybe[ta.Any] = lang.empty(),
             overwrite_error: bool = False,
             unconditional_add: bool = False,
-            decorator: ta.Optional[str] = None,
+            decorator: str | None = None,
     ) -> None:
         if locals is not None:
             self.locals.update(locals)

omlish/dispatch/dispatch.py

@@ -27,19 +27,20 @@ def get_impl_func_cls_set(func: ta.Callable) -> ta.FrozenSet[type]:
         raise TypeError(f'Invalid impl func: {func!r}')
 
     _, cls = next(iter(ta.get_type_hints(func).items()))
-    if rfl.is_union_type(cls):
-        ret = frozenset(check.isinstance(arg, type) for arg in ta.get_args(cls))
+    rty = rfl.type_(cls)
+    if isinstance(rty, rfl.Union):
+        ret = frozenset(check.isinstance(arg, type) for arg in rty.args)
     else:
-        ret = frozenset([check.isinstance(cls, type)])
+        ret = frozenset([check.isinstance(rty, type)])
 
     _IMPL_FUNC_CLS_SET_CACHE[func] = ret
     return ret
 
 
-def find_impl(cls: type, registry: ta.Mapping[type, T]) -> ta.Optional[T]:
+def find_impl(cls: type, registry: ta.Mapping[type, T]) -> T | None:
     mro = c3.compose_mro(cls, registry.keys())
 
-    match: ta.Optional[type] = None
+    match: type | None = None
     for t in mro:
         if match is not None:
             # If *match* is an implicit ABC but there is another unrelated, equally matching implicit ABC, refuse the
@@ -71,7 +72,7 @@ class Dispatcher(ta.Generic[T]):
         impls_by_arg_cls: dict[type, T] = {}
         self._impls_by_arg_cls = impls_by_arg_cls
 
-        dispatch_cache: dict[ta.Any, ta.Optional[T]] = {}
+        dispatch_cache: dict[ta.Any, T | None] = {}
         self._get_dispatch_cache = lambda: dispatch_cache
 
         def cache_remove(k, self_ref=weakref.ref(self)):
@@ -87,7 +88,7 @@ class Dispatcher(ta.Generic[T]):
 
         weakref_ref_ = weakref.ref
 
-        def dispatch(cls: type) -> ta.Optional[T]:
+        def dispatch(cls: type) -> T | None:
             nonlocal cache_token
 
             if cache_token is not None and (current_token := abc.get_cache_token()) != cache_token:
@@ -132,6 +133,6 @@ class Dispatcher(ta.Generic[T]):
     def cache_size(self) -> int:
         return len(self._get_dispatch_cache())
 
-    dispatch: ta.Callable[[type], ta.Optional[T]]
+    dispatch: ta.Callable[[type], T | None]
 
     register: ta.Callable[[T, ta.Iterable[type]], T]

omlish/dispatch/methods.py

@@ -16,7 +16,7 @@ from .dispatch import get_impl_func_cls_set
 T = ta.TypeVar('T')
 
 
-def build_mro_dct(instance_cls: type, owner_cls: ta.Optional[type] = None) -> ta.Mapping[str, ta.Any]:
+def build_mro_dct(instance_cls: type, owner_cls: type | None = None) -> ta.Mapping[str, ta.Any]:
     if owner_cls is None:
         owner_cls = instance_cls
     mro = instance_cls.__mro__[-2::-1]
@@ -89,7 +89,7 @@ class Method:
 
         return impl
 
-    def build_attr_dispatcher(self, instance_cls: type, owner_cls: ta.Optional[type] = None) -> Dispatcher[str]:
+    def build_attr_dispatcher(self, instance_cls: type, owner_cls: type | None = None) -> Dispatcher[str]:
         disp: Dispatcher[str] = Dispatcher()
 
         mro_dct = build_mro_dct(instance_cls, owner_cls)

omlish/docker.py

@@ -118,28 +118,30 @@ class ComposeConfig:
             self,
             prefix: str,
             *,
-            compose_path: str | None = None,
+            file_path: str | None = None,
     ) -> None:
         super().__init__()
 
         self._prefix = prefix
-        self._compose_path = compose_path
+        self._file_path = file_path
 
     @lang.cached_function
     def get_config(self) -> ta.Mapping[str, ta.Any]:
-        with open(check.not_none(self._compose_path), 'r') as f:
+        with open(check.not_none(self._file_path), 'r') as f:
             buf = f.read()
-        dct = yaml.safe_load(buf)
+        return yaml.safe_load(buf)
 
+    @lang.cached_function
+    def get_services(self) -> ta.Mapping[str, ta.Any]:
         ret = {}
-        for n, c in dct['services'].items():
+        for n, c in self.get_config()['services'].items():
             check.state(n.startswith(self._prefix))
             ret[n[len(self._prefix):]] = c
 
         return ret
 
 
-def timebomb_payload(delay_s: int | float, name: str = 'omlish-timebomb') -> str:
+def timebomb_payload(delay_s: float, name: str = 'omlish-docker-timebomb') -> str:
     return (
         '('
         f'echo {shlex.quote(name)} && '

omlish/dynamic.py

@@ -49,10 +49,10 @@ class Var(ta.Generic[T]):
 
     def __init__(
             self,
-            default: ta.Union[type[MISSING], T] = MISSING,  # type: ignore
+            default: type[MISSING] | T = MISSING,  # type: ignore
             *,
-            new: ta.Union[ta.Callable[[], T], type[MISSING]] = MISSING,
-            validate: ta.Optional[ta.Callable[[T], None]] = None,
+            new: ta.Callable[[], T] | type[MISSING] = MISSING,
+            validate: ta.Callable[[T], None] | None = None,
     ) -> None:
         super().__init__()
 
@@ -60,7 +60,7 @@ class Var(ta.Generic[T]):
             raise TypeError('Cannot set both default and new')
         elif default is not MISSING:
             new = lambda: default  # type: ignore
-        self._new: ta.Union[type[MISSING], ta.Callable[[], T]] = new
+        self._new: type[MISSING] | ta.Callable[[], T] = new
         self._validate = validate
         self._bindings_by_frame: ta.MutableMapping[types.FrameType, ta.MutableMapping[int, Binding]] = weakref.WeakValueDictionary()  # noqa
 
@@ -166,7 +166,7 @@ class Binding(ta.Generic[T]):
 
     def __enter__(self) -> T:
         frame = sys._getframe(self._offset).f_back  # noqa
-        lag_frame: ta.Optional[types.FrameType] = frame
+        lag_frame: types.FrameType | None = frame
         while lag_frame is not None:
             for cur_depth in range(_MAX_HOIST_DEPTH + 1):
                 if lag_frame is None:

omlish/graphs/dot/items.py

@@ -115,7 +115,7 @@ class Attrs(Item):
         coerce=lambda o: col.frozendict(
             (check.not_empty(check.isinstance(k, str)), Value.of(v))  # type: ignore
             for k, v in check.isinstance(o, ta.Mapping).items()
-        )
+        ),
     )
 
     @classmethod

omlish/graphs/trees.py

@@ -57,7 +57,7 @@ class BasicTreeAnalysis(ta.Generic[NodeT]):
         self._dict_fac: ta.Callable[..., ta.MutableMapping[NodeT, ta.Any]] = col.IdentityKeyDict if identity else dict
         self._idx_seq_fac: ta.Callable[..., col.IndexedSeq[NodeT]] = functools.partial(col.IndexedSeq, identity=identity)  # noqa
 
-        def walk(cur: NodeT, parent: ta.Optional[NodeT]) -> None:
+        def walk(cur: NodeT, parent: NodeT | None) -> None:
             check.not_none(cur)
             if cur in node_set:
                 raise DuplicateNodeException(cur)
@@ -78,9 +78,9 @@ class BasicTreeAnalysis(ta.Generic[NodeT]):
 
         nodes: list[NodeT] = []
         node_set: ta.MutableSet[NodeT] = self._set_fac()  # type: ignore
-        children_by_node: ta.MutableMapping[ta.Optional[NodeT], ta.Sequence[NodeT]] = self._dict_fac()  # type: ignore
+        children_by_node: ta.MutableMapping[NodeT | None, ta.Sequence[NodeT]] = self._dict_fac()  # type: ignore
         child_sets_by_node: ta.MutableMapping[ta.Optional[NodeT], ta.AbstractSet[NodeT]] = self._dict_fac()  # type: ignore  # noqa
-        parents_by_node: ta.MutableMapping[NodeT, ta.Optional[NodeT]] = self._dict_fac()  # type: ignore
+        parents_by_node: ta.MutableMapping[NodeT, NodeT | None] = self._dict_fac()  # type: ignore
 
         children_by_node[None] = [root]
         child_sets_by_node[None] = self._set_fac([root])  # type: ignore
@@ -89,10 +89,10 @@ class BasicTreeAnalysis(ta.Generic[NodeT]):
 
         self._nodes = self._idx_seq_fac(nodes)  # type: ignore
         self._node_set: ta.AbstractSet[NodeT] = node_set
-        self._children_by_node: ta.Mapping[ta.Optional[NodeT], col.IndexedSeq[NodeT]] = self._dict_fac(  # type: ignore
+        self._children_by_node: ta.Mapping[NodeT | None, col.IndexedSeq[NodeT]] = self._dict_fac(  # type: ignore
             [(n, self._idx_seq_fac(cs)) for n, cs in children_by_node.items()])
-        self._child_sets_by_node: ta.Mapping[ta.Optional[NodeT], ta.AbstractSet[NodeT]] = child_sets_by_node
-        self._parents_by_node: ta.Mapping[NodeT, ta.Optional[NodeT]] = parents_by_node
+        self._child_sets_by_node: ta.Mapping[NodeT | None, ta.AbstractSet[NodeT]] = child_sets_by_node
+        self._parents_by_node: ta.Mapping[NodeT, NodeT | None] = parents_by_node
 
     @property
     def root(self) -> NodeT:
@@ -115,27 +115,24 @@ class BasicTreeAnalysis(ta.Generic[NodeT]):
         return self._node_set
 
     @property
-    def children_by_node(self) -> ta.Mapping[ta.Optional[NodeT], col.IndexedSeq[NodeT]]:
+    def children_by_node(self) -> ta.Mapping[NodeT | None, col.IndexedSeq[NodeT]]:
         return self._children_by_node
 
     @property
-    def child_sets_by_node(self) -> ta.Mapping[ta.Optional[NodeT], ta.AbstractSet[NodeT]]:
+    def child_sets_by_node(self) -> ta.Mapping[NodeT | None, ta.AbstractSet[NodeT]]:
         return self._child_sets_by_node
 
     @property
-    def parents_by_node(self) -> ta.Mapping[NodeT, ta.Optional[NodeT]]:
+    def parents_by_node(self) -> ta.Mapping[NodeT, NodeT | None]:
         return self._parents_by_node
 
     @classmethod
     def from_parents(
             cls,
-            src: ta.Union[
-                ta.Mapping[NodeT, ta.Optional[NodeT]],
-                ta.Iterable[tuple[NodeT, ta.Optional[NodeT]]],
-            ],
+            src: ta.Mapping[NodeT, NodeT | None] | ta.Iterable[tuple[NodeT, NodeT | None]],
             *,
             identity: bool = False,
-            **kwargs
+            **kwargs,
     ) -> 'BasicTreeAnalysis[NodeT]':
         pairs: ta.Sequence[tuple[NodeT, NodeT]]
         if isinstance(src, ta.Mapping):
@@ -166,13 +163,10 @@ class BasicTreeAnalysis(ta.Generic[NodeT]):
     @classmethod
     def from_children(
             cls,
-            src: ta.Union[
-                ta.Mapping[NodeT, ta.Iterable[NodeT]],
-                ta.Iterable[tuple[NodeT, ta.Iterable[NodeT]]],
-            ],
+            src: ta.Mapping[NodeT, ta.Iterable[NodeT]] | ta.Iterable[tuple[NodeT, ta.Iterable[NodeT]]],
             *,
             identity: bool = False,
-            **kwargs
+            **kwargs,
     ) -> 'BasicTreeAnalysis[NodeT]':
         pairs: ta.Sequence[tuple[NodeT, ta.Sequence[NodeT]]]
         if isinstance(src, ta.Mapping):
@@ -222,7 +216,7 @@ class BasicTreeAnalysis(ta.Generic[NodeT]):
             return ret  # type: ignore
 
     def iter_ancestors(self, node: NodeT) -> NodeGenerator[NodeT]:
-        cur: ta.Optional[NodeT] = node
+        cur: NodeT | None = node
         while True:
             cur = self.parents_by_node.get(cur)  # type: ignore
             if cur is None:
@@ -232,7 +226,7 @@ class BasicTreeAnalysis(ta.Generic[NodeT]):
     def get_lineage(self, node: NodeT) -> col.IndexedSeq[NodeT]:
         return self._idx_seq_fac(reversed([node, *self.iter_ancestors(node)]))
 
-    def get_first_parent_of_type(self, node: NodeT, ty: type[T]) -> ta.Optional[T]:
+    def get_first_parent_of_type(self, node: NodeT, ty: type[T]) -> T | None:
         for cur in self.iter_ancestors(node):
             if isinstance(cur, ty):
                 return cur

omlish/inject/elements.py

@@ -25,7 +25,7 @@ class Elements(lang.Final):
                 yield from c
 
 
-def as_elements(*args: ta.Union[Element, Elements]) -> Elements:
+def as_elements(*args: Element | Elements) -> Elements:
     es: set[Element] = set()
     cs: set['Elements'] = set()
     for a in args:

omlish/inject/exceptions.py

@@ -13,7 +13,7 @@ class KeyException(Exception):
     key: Key
 
     source: ta.Any = None
-    name: ta.Optional[str] = None
+    name: str | None = None
 
 
 @dc.dataclass()

omlish/inject/impl/injector.py

@@ -45,7 +45,7 @@ class InjectorImpl(Injector, lang.Final):
         super().__init__()
 
         self._ec = check.isinstance(ec, ElementCollection)
-        self._p: ta.Optional[InjectorImpl] = check.isinstance(p, (InjectorImpl, None))
+        self._p: InjectorImpl | None = check.isinstance(p, (InjectorImpl, None))
 
         self._internal_consts: dict[Key, ta.Any] = {
             Key(Injector): self,

omlish/inject/impl/inspect.py

@@ -52,7 +52,7 @@ def build_kwargs_target(
         obj: ta.Any,
         *,
         skip_args: int = 0,
-        skip_kwargs: ta.Optional[ta.Iterable[ta.Any]] = None,
+        skip_kwargs: ta.Iterable[ta.Any] | None = None,
         raw_optional: bool = False,
 ) -> KwargsTarget:
     sig = signature(obj)

omlish/inject/injector.py

@@ -31,7 +31,7 @@ class Injector(lang.Abstract):
 
     def __getitem__(
             self,
-            target: ta.Union[Key[T], type[T]],
+            target: Key[T] | type[T],
     ) -> T:
         return self.provide(target)