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

omlish/lang/objects.py

@@ -9,18 +9,22 @@ T = ta.TypeVar('T')
 
 
 def attr_repr(obj: ta.Any, *attrs: str) -> str:
-    return '%s(%s)' % (
-        type(obj).__name__,
-        ', '.join('%s=%r' % (attr, getattr(obj, attr)) for attr in attrs))
+    return f'{type(obj).__name__}({", ".join(f"{attr}={getattr(obj, attr)!r}" for attr in attrs)})'
 
 
 def arg_repr(*args, **kwargs) -> str:
     return ', '.join(*(
         list(map(repr, args)) +
-        [f'{k}={repr(v)}' for k, v in kwargs.items()]
+        [f'{k}={v!r}' for k, v in kwargs.items()]
     ))
 
 
+def opt_repr(obj: ta.Any) -> str | None:
+    if obj is None:
+        return None
+    return repr(obj)
+
+
 ##
 
 
@@ -28,8 +32,8 @@ def new_type(
         name: str,
         bases: ta.Sequence[ta.Any],
         namespace: ta.Mapping[str, ta.Any],
-        **kwargs
-) -> ta.Type:
+        **kwargs,
+) -> type:
     return types.new_class(
         name,
         tuple(bases),
@@ -40,12 +44,12 @@ def new_type(
 
 def super_meta(
         super_meta: ta.Any,
-        meta: ta.Type,
+        meta: type,
         name: str,
         bases: ta.Sequence[ta.Any],
         namespace: ta.MutableMapping[str, ta.Any],
-        **kwargs
-) -> ta.Type:
+        **kwargs,
+) -> type:
     """Per types.new_class"""
     resolved_bases = types.resolve_bases(bases)
     if resolved_bases is not bases:
@@ -75,19 +79,21 @@ class SimpleProxy(ta.Generic[T]):
             if instance is None:
                 return self
             setattr(object.__getattribute__(instance, '__wrapped__'), self._attr, value)
+            return None
 
         def __delete__(self, instance):
             if instance is None:
                 return self
             delattr(object.__getattribute__(instance, '__wrapped__'), self._attr)
+            return None
 
-    __wrapped_attrs__: ta.Iterable[str] = set()
+    __wrapped_attrs__: ta.ClassVar[ta.Iterable[str]] = ()
 
     def __init__(self, wrapped: T) -> None:
         super().__init__()
         object.__setattr__(self, '__wrapped__', wrapped)
 
-    def __init_subclass__(cls, **kwargs):
+    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
         super().__init_subclass__(**kwargs)
 
         for attr in cls.__wrapped_attrs__:

omlish/lang/resolving.py

@@ -45,6 +45,6 @@ def get_fqcn_cls(fqcn: str, *, nocheck: bool = False) -> type:
 
 
 class Resolvable:
-    def __init_subclass__(cls, **kwargs):
+    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
         super().__init_subclass__(**kwargs)
         get_cls_fqcn(cls, nocheck=True)

omlish/lang/strings.py

@@ -22,7 +22,7 @@ def camel_case(name: str) -> str:
 
 def snake_case(name: str) -> str:
     uppers: list[int | None] = [i for i, c in enumerate(name) if c.isupper()]
-    return '_'.join([name[l:r].lower() for l, r in zip([None] + uppers, uppers + [None])]).strip('_')
+    return '_'.join([name[l:r].lower() for l, r in zip([None, *uppers], [*uppers, None])]).strip('_')
 
 
 def is_dunder(name: str) -> bool:

omlish/lang/timeouts.py

@@ -0,0 +1,53 @@
+import abc
+import time
+import typing as ta
+
+
+TimeoutLike: ta.TypeAlias = ta.Union['Timeout', float]
+
+
+class Timeout(abc.ABC):
+    @abc.abstractmethod
+    def __call__(self) -> float:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def or_(self, o: ta.Any) -> ta.Any:
+        raise NotImplementedError
+
+
+class DeadlineTimeout(Timeout):
+    def __init__(
+            self,
+            deadline: float,
+            exc: type[BaseException] | BaseException = TimeoutError,
+    ) -> None:
+        super().__init__()
+        self.deadline = deadline
+        self.exc = exc
+
+    def __call__(self) -> float:
+        if (rem := self.deadline - time.time()) > 0:
+            return rem
+        raise self.exc
+
+    def or_(self, o: ta.Any) -> ta.Any:
+        return self()
+
+
+class InfiniteTimeout(Timeout):
+    def __call__(self) -> float:
+        return float('inf')
+
+    def or_(self, o: ta.Any) -> ta.Any:
+        return o
+
+
+def timeout(t: TimeoutLike | None) -> Timeout:
+    if t is None:
+        return InfiniteTimeout()
+    if isinstance(t, Timeout):
+        return t
+    if isinstance(t, (float, int)):
+        return DeadlineTimeout(time.time() + t)
+    raise TypeError(t)

omlish/lang/typing.py

@@ -12,7 +12,7 @@ import typing as ta
 Ty = ta.TypeVar('Ty', bound=type)
 
 
-BytesLike: ta.TypeAlias = ta.Union[bytes, bytearray]
+BytesLike: ta.TypeAlias = bytes | bytearray
 
 
 ##
@@ -37,13 +37,13 @@ def _update_wrapper_no_anns(wrapper, wrapped):
     return wrapper
 
 
-def typed_lambda(ret=_MISSING, **kw):
+def typed_lambda(ret=_MISSING, **kw):  # noqa
     def inner(fn):
         ns = {}
         ns['__fn'] = fn
         proto = ['def __lam(']
         call = ['return __fn(']
-        pkw = {k: v for k, v in kw.items()}
+        pkw = dict(kw)
         for i, (n, t) in enumerate(pkw.items()):
             if i:
                 call.append(', ')
@@ -69,7 +69,7 @@ def typed_lambda(ret=_MISSING, **kw):
     return inner
 
 
-def typed_partial(obj, **kw):
+def typed_partial(obj, **kw):  # noqa
     for k in kw:
         if k.startswith('__'):
             raise NameError(k)
@@ -87,6 +87,6 @@ def typed_partial(obj, **kw):
             for n, p in sig.parameters.items()
             if n not in kw
             and p.annotation is not inspect.Signature.empty
-        }
+        },
     )(inner)
     return _update_wrapper_no_anns(lam, obj)

omlish/libc.py

@@ -1,3 +1,7 @@
+# ruff: noqa: ANN201
+# ruff: noqa: N801
+# ruff: noqa: N802
+
 import ctypes as ct
 import errno
 import platform
@@ -37,14 +41,14 @@ def lasterr() -> tuple[int, str]:
 
 
 # int raise(int sig);
-libc._raise = libc['raise']  # type: ignore
-libc._raise.restype = ct.c_int
-libc._raise.argtypes = [ct.c_int]
-_raise = libc._raise
+libc._raise = libc['raise']  # type: ignore  # noqa
+libc._raise.restype = ct.c_int  # noqa
+libc._raise.argtypes = [ct.c_int]  # noqa
+_raise = libc._raise  # noqa
 
 
 def sigtrap() -> None:
-    libc._raise(signal.SIGTRAP)
+    libc._raise(signal.SIGTRAP)  # noqa
 
 
 ##
@@ -94,7 +98,7 @@ libc.mmap.argtypes = [
     ct.c_int,
     ct.c_int,
     ct.c_int,
-    ct.c_size_t
+    ct.c_size_t,
 ]
 mmap = libc.mmap
 
@@ -138,7 +142,7 @@ elif DARWIN:
 libc.munmap.restype = ct.c_int
 libc.munmap.argtypes = [
     ct.c_void_p,
-    ct.c_size_t
+    ct.c_size_t,
 ]
 munmap = libc.munmap
 
@@ -148,7 +152,7 @@ libc.mprotect.restype = ct.c_int
 libc.mprotect.argtypes = [
     ct.c_void_p,
     ct.c_size_t,
-    ct.c_int
+    ct.c_int,
 ]
 mprotect = libc.mprotect
 
@@ -164,7 +168,7 @@ if LINUX:
         ct.c_void_p,
         ct.c_size_t,
         ct.c_size_t,
-        ct.c_int
+        ct.c_int,
     ]
     mremap = libc.mremap
 
@@ -179,7 +183,7 @@ class Mmap:
             length: int,
             *,
             prot: int = PROT_READ | PROT_WRITE,
-            flags: ta.Optional[int] = None,
+            flags: int | None = None,
             fd: int = -1,
             offset: int = 0,
             desired_base: int = 0,
@@ -205,7 +209,7 @@ class Mmap:
         self._is_mapped = False
 
     @property
-    def base(self) -> ta.Optional[int]:
+    def base(self) -> int | None:
         return self._base
 
     def __enter__(self) -> 'Mmap':

omlish/logs/_abc.py

@@ -1,3 +1,7 @@
+# ruff: noqa: A002
+# ruff: noqa: N802
+# ruff: noqa: N815
+
 import types
 import typing as ta
 
@@ -181,7 +185,7 @@ class Logger(Filterer, ta.Protocol):
 
     def log(self, level: Level, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None: ...
 
-    def findCaller(self, stack_info: bool = False, stacklevel: int = 1) -> Caller: ...  #
+    def findCaller(self, stack_info: bool = False, stacklevel: int = 1) -> Caller: ...
 
     def makeRecord(
         self,

omlish/logs/filters.py

@@ -1,3 +1,5 @@
+# ruff: noqa: ANN201
+
 import logging
 import threading
 

omlish/logs/formatters.py

@@ -1,5 +1,9 @@
+# ruff: noqa: ANN201
+# ruff: noqa: N802
+
 import datetime
 import logging
+import typing as ta
 
 from .. import json
 from .. import term
@@ -20,7 +24,7 @@ class StandardLogFormatter(logging.Formatter):
 
 class ColorLogFormatter(StandardLogFormatter):
 
-    LEVEL_COLORS = {
+    LEVEL_COLORS: ta.Mapping[int, term.SGRs.FG] = {
         logging.WARNING: term.SGRs.FG.BRIGHT_YELLOW,
         logging.ERROR: term.SGRs.FG.BRIGHT_RED,
         logging.CRITICAL: term.SGRs.FG.BRIGHT_RED,
@@ -39,7 +43,7 @@ class ColorLogFormatter(StandardLogFormatter):
 
 class JsonLogFormatter(logging.Formatter):
 
-    KEYS = {
+    KEYS: ta.Mapping[str, bool] = {
         'name': False,
         'msg': False,
         'args': False,

omlish/logs/utils.py

@@ -5,7 +5,7 @@ import logging
 log = logging.getLogger(__name__)
 
 
-def error_logging(log=log):
+def error_logging(log=log):  # noqa
     def outer(fn):
         @functools.wraps(fn)
         def inner(*args, **kwargs):

omlish/marshal/base.py

@@ -81,7 +81,7 @@ from .. import check
 from .. import collections as col
 from .. import lang
 from .. import reflect as rfl
-from .exceptions import UnhandledTypeException
+from .exceptions import UnhandledTypeError
 from .factories import Factory
 from .factories import RecursiveTypeFactory
 from .registries import Registry
@@ -146,24 +146,24 @@ class BaseContext(lang.Abstract):
 
 @dc.dataclass(frozen=True)
 class MarshalContext(BaseContext, lang.Final):
-    factory: ta.Optional[MarshalerFactory] = None
+    factory: MarshalerFactory | None = None
 
     def make(self, o: ta.Any) -> Marshaler:
         rty = rfl.type_(o)
         if (m := check.not_none(self.factory)(self, rty)) is not None:  # noqa
             return m
-        raise UnhandledTypeException(rty)
+        raise UnhandledTypeError(rty)
 
 
 @dc.dataclass(frozen=True)
 class UnmarshalContext(BaseContext, lang.Final):
-    factory: ta.Optional[UnmarshalerFactory] = None
+    factory: UnmarshalerFactory | None = None
 
     def make(self, o: ta.Any) -> Unmarshaler:
         rty = rfl.type_(o)
         if (m := check.not_none(self.factory)(self, rty)) is not None:  # noqa
             return m
-        raise UnhandledTypeException(rty)
+        raise UnhandledTypeError(rty)
 
 
 ##
@@ -194,8 +194,8 @@ class RecursiveUnmarshalerFactory(RecursiveTypeFactory[Unmarshaler, UnmarshalCon
 
 @dc.dataclass(frozen=True)
 class SetType(RegistryItem, lang.Final):
-    marshaler: ta.Optional[Marshaler] = None
-    marshaler_factory: ta.Optional[MarshalerFactory] = None
+    marshaler: Marshaler | None = None
+    marshaler_factory: MarshalerFactory | None = None
 
-    unmarshaler: ta.Optional[Unmarshaler] = None
-    unmarshaler_factory: ta.Optional[UnmarshalerFactory] = None
+    unmarshaler: Unmarshaler | None = None
+    unmarshaler_factory: UnmarshalerFactory | None = None

omlish/marshal/dataclasses.py

@@ -79,7 +79,7 @@ def _make_field_obj(ctx, ty, obj, fac):
 
 
 class DataclassMarshalerFactory(MarshalerFactory):
-    def __call__(self, ctx: MarshalContext, rty: rfl.Type) -> ta.Optional[Marshaler]:
+    def __call__(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler | None:
         if isinstance(rty, type) and dc.is_dataclass(rty):
             dc_md = get_dataclass_metadata(rty)
             fields = [
@@ -97,7 +97,7 @@ class DataclassMarshalerFactory(MarshalerFactory):
 
 
 class DataclassUnmarshalerFactory(UnmarshalerFactory):
-    def __call__(self, ctx: UnmarshalContext, rty: rfl.Type) -> ta.Optional[Unmarshaler]:
+    def __call__(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler | None:
         if isinstance(rty, type) and dc.is_dataclass(rty):
             dc_md = get_dataclass_metadata(rty)
             d: dict[str, tuple[FieldInfo, Unmarshaler]] = {}

omlish/marshal/enums.py

@@ -22,7 +22,7 @@ class EnumMarshaler(Marshaler):
 
 
 class EnumMarshalerFactory(MarshalerFactory):
-    def __call__(self, ctx: MarshalContext, rty: rfl.Type) -> ta.Optional[Marshaler]:
+    def __call__(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler | None:
         if isinstance(rty, type) and issubclass(rty, enum.Enum):
             return EnumMarshaler(rty)
         return None
@@ -37,7 +37,7 @@ class EnumUnmarshaler(Unmarshaler):
 
 
 class EnumUnmarshalerFactory(UnmarshalerFactory):
-    def __call__(self, ctx: UnmarshalContext, rty: rfl.Type) -> ta.Optional[Unmarshaler]:
+    def __call__(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler | None:
         if isinstance(rty, type) and issubclass(rty, enum.Enum):
             return EnumUnmarshaler(rty)
         return None

omlish/marshal/exceptions.py

@@ -1,7 +1,7 @@
 from .. import reflect as rfl
 
 
-class UnhandledTypeException(Exception):
+class UnhandledTypeError(Exception):
     @property
     def rty(self) -> rfl.Type:
         return self.args[0]

omlish/marshal/factories.py

@@ -17,7 +17,7 @@ A = ta.TypeVar('A')
 
 class Factory(abc.ABC, ta.Generic[R, C, A]):
     @abc.abstractmethod
-    def __call__(self, ctx: C, arg: A) -> ta.Optional[R]:
+    def __call__(self, ctx: C, arg: A) -> R | None:
         raise NotImplementedError
 
 
@@ -26,9 +26,9 @@ class Factory(abc.ABC, ta.Generic[R, C, A]):
 
 @dc.dataclass(frozen=True)
 class FuncFactory(ta.Generic[R, C, A]):
-    fn: ta.Callable[[C, A], ta.Optional[R]]
+    fn: ta.Callable[[C, A], R | None]
 
-    def __call__(self, ctx: C, arg: A) -> ta.Optional[R]:
+    def __call__(self, ctx: C, arg: A) -> R | None:
         return self.fn(ctx, arg)
 
 
@@ -39,7 +39,7 @@ class FuncFactory(ta.Generic[R, C, A]):
 class TypeMapFactory(Factory[R, C, rfl.Type]):
     m: ta.Mapping[rfl.Type, R] = dc.field(default_factory=dict)
 
-    def __call__(self, ctx: C, rty: rfl.Type) -> ta.Optional[R]:
+    def __call__(self, ctx: C, rty: rfl.Type) -> R | None:
         return self.m.get(rty)
 
 
@@ -50,10 +50,10 @@ class TypeCacheFactory(Factory[R, C, rfl.Type]):
     def __init__(self, f: Factory[R, C, rfl.Type]) -> None:
         super().__init__()
         self._f = f
-        self._dct: dict[rfl.Type, ta.Optional[R]] = {}
+        self._dct: dict[rfl.Type, R | None] = {}
         self._mtx = threading.RLock()
 
-    def __call__(self, ctx: C, rty: rfl.Type) -> ta.Optional[R]:
+    def __call__(self, ctx: C, rty: rfl.Type) -> R | None:
         try:
             return self._dct[rty]
         except KeyError:
@@ -73,14 +73,14 @@ class RecursiveTypeFactory(Factory[R, C, rfl.Type]):
     def __init__(
             self,
             f: Factory[R, C, rfl.Type],
-            prx: ta.Callable[[], tuple[ta.Optional[R], ta.Callable[[ta.Optional[R]], None]]],
+            prx: ta.Callable[[], tuple[R | None, ta.Callable[[R | None], None]]],
     ) -> None:
         super().__init__()
         self._f = f
         self._prx = prx
-        self._dct: dict[rfl.Type, ta.Optional[R]] = {}
+        self._dct: dict[rfl.Type, R | None] = {}
 
-    def __call__(self, ctx: C, rty: rfl.Type) -> ta.Optional[R]:
+    def __call__(self, ctx: C, rty: rfl.Type) -> R | None:
         try:
             return self._dct[rty]
         except KeyError:
@@ -108,7 +108,7 @@ class CompositeFactory(Factory[R, C, A]):
         self._fs = fs
         self._st = strategy
 
-    def __call__(self, ctx: C, arg: A) -> ta.Optional[R]:
+    def __call__(self, ctx: C, arg: A) -> R | None:
         w: list[R] = []
         for c in self._fs:
             if (r := c(ctx, arg)) is None:

omlish/marshal/global_.py

@@ -1,8 +1,14 @@
-from .registries import Registry
-from .standard import new_standard_marshaler_factory
+import typing as ta
+
 from .base import MarshalContext
 from .base import UnmarshalContext
+from .registries import Registry
+from .standard import new_standard_marshaler_factory
 from .standard import new_standard_unmarshaler_factory
+from .values import Value
+
+
+T = ta.TypeVar('T')
 
 
 ##
@@ -17,7 +23,7 @@ GLOBAL_REGISTRY = Registry()
 GLOBAL_MARSHALER_FACTORY = new_standard_marshaler_factory()
 
 
-def marshal(obj, ty=None, **kwargs):
+def marshal(obj: ta.Any, ty: type | None = None, **kwargs: ta.Any) -> Value:
     mc = MarshalContext(GLOBAL_REGISTRY, factory=GLOBAL_MARSHALER_FACTORY, **kwargs)
     return mc.make(ty if ty is not None else type(obj)).marshal(mc, obj)
 
@@ -28,6 +34,6 @@ def marshal(obj, ty=None, **kwargs):
 GLOBAL_UNMARSHALER_FACTORY = new_standard_unmarshaler_factory()
 
 
-def unmarshal(v, ty, **kwargs):
+def unmarshal(v: Value, ty: type[T], **kwargs: ta.Any) -> T:
     uc = UnmarshalContext(GLOBAL_REGISTRY, factory=GLOBAL_UNMARSHALER_FACTORY, **kwargs)
     return uc.make(ty).unmarshal(uc, v)

omlish/marshal/iterables.py

@@ -23,7 +23,7 @@ class IterableMarshaler(Marshaler):
 
 
 class IterableMarshalerFactory(MarshalerFactory):
-    def __call__(self, ctx: MarshalContext, rty: rfl.Type) -> ta.Optional[Marshaler]:
+    def __call__(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler | None:
         if isinstance(rty, rfl.Generic) and issubclass(rty.cls, collections.abc.Iterable):
             if (e := ctx.make(check.single(rty.args))) is None:
                 return None  # type: ignore
@@ -45,7 +45,7 @@ class IterableUnmarshaler(Unmarshaler):
 
 
 class IterableUnmarshalerFactory(UnmarshalerFactory):
-    def __call__(self, ctx: UnmarshalContext, rty: rfl.Type) -> ta.Optional[Unmarshaler]:
+    def __call__(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler | None:
         if isinstance(rty, rfl.Generic) and issubclass(rty.cls, collections.abc.Iterable):
             if (e := ctx.make(check.single(rty.args))) is None:
                 return None  # type: ignore

omlish/marshal/mappings.py

@@ -26,7 +26,7 @@ class MappingMarshaler(Marshaler):
 
 
 class MappingMarshalerFactory(MarshalerFactory):
-    def __call__(self, ctx: MarshalContext, rty: rfl.Type) -> ta.Optional[Marshaler]:
+    def __call__(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler | None:
         if isinstance(rty, rfl.Generic) and issubclass(rty.cls, collections.abc.Mapping):
             kt, vt = rty.args
             if (ke := ctx.make(kt)) is None or (ve := ctx.make(vt)) is None:
@@ -53,7 +53,7 @@ class MappingUnmarshaler(Unmarshaler):
 
 
 class MappingUnmarshalerFactory(UnmarshalerFactory):
-    def __call__(self, ctx: UnmarshalContext, rty: rfl.Type) -> ta.Optional[Unmarshaler]:
+    def __call__(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler | None:
         if isinstance(rty, rfl.Generic) and issubclass(rty.cls, collections.abc.Mapping):
             kt, vt = rty.args
             if (ke := ctx.make(kt)) is None or (ve := ctx.make(vt)) is None:

omlish/marshal/objects.py

@@ -98,8 +98,7 @@ class ObjectUnmarshaler(Unmarshaler):
                 if ukf is not None:
                     ukf[ks] = mv  # FIXME: unmarshal?
                     continue
-                else:
-                    raise
+                raise
             if fi.name in kw:
                 raise KeyError(f'Duplicate keys for field {fi.name!r}: {ks!r}')
             kw[fi.name] = u.unmarshal(ctx, mv)

omlish/marshal/optionals.py

@@ -15,14 +15,14 @@ from .values import Value
 class OptionalMarshaler(Marshaler):
     e: Marshaler
 
-    def marshal(self, ctx: MarshalContext, o: ta.Optional[ta.Any]) -> Value:
+    def marshal(self, ctx: MarshalContext, o: ta.Any | None) -> Value:
         if o is None:
             return None
         return self.e.marshal(ctx, o)
 
 
 class OptionalMarshalerFactory(MarshalerFactory):
-    def __call__(self, ctx: MarshalContext, rty: rfl.Type) -> ta.Optional[Marshaler]:
+    def __call__(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler | None:
         if isinstance(rty, rfl.Union) and rty.is_optional:
             if (e := ctx.make(rty.without_none())) is None:
                 return None  # type: ignore
@@ -34,14 +34,14 @@ class OptionalMarshalerFactory(MarshalerFactory):
 class OptionalUnmarshaler(Unmarshaler):
     e: Unmarshaler
 
-    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Optional[ta.Any]:
+    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Any | None:
         if v is None:
             return None
         return self.e.unmarshal(ctx, v)
 
 
 class OptionalUnmarshalerFactory(UnmarshalerFactory):
-    def __call__(self, ctx: UnmarshalContext, rty: rfl.Type) -> ta.Optional[Unmarshaler]:
+    def __call__(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler | None:
         if isinstance(rty, rfl.Union) and rty.is_optional:
             if (e := ctx.make(rty.without_none())) is None:
                 return None  # type: ignore

omlish/marshal/polymorphism.py

@@ -100,7 +100,7 @@ def polymorphism_from_subclasses(ty: type, *, naming: Naming | None = None) -> P
 class PolymorphismMarshaler(Marshaler):
     m: ta.Mapping[type, tuple[str, Marshaler]]
 
-    def marshal(self, ctx: MarshalContext, o: ta.Optional[ta.Any]) -> Value:
+    def marshal(self, ctx: MarshalContext, o: ta.Any | None) -> Value:
         tag, m = self.m[type(o)]
         return {tag: m.marshal(ctx, o)}
 
@@ -109,7 +109,7 @@ class PolymorphismMarshaler(Marshaler):
 class PolymorphismMarshalerFactory(MarshalerFactory):
     p: Polymorphism
 
-    def __call__(self, ctx: MarshalContext, rty: rfl.Type) -> ta.Optional[Marshaler]:
+    def __call__(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler | None:
         if rty is self.p.ty:
             return PolymorphismMarshaler({
                 i.ty: (i.tag, ctx.make(i.ty))
@@ -125,7 +125,7 @@ class PolymorphismMarshalerFactory(MarshalerFactory):
 class PolymorphismUnmarshaler(Unmarshaler):
     m: ta.Mapping[str, Unmarshaler]
 
-    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Optional[ta.Any]:
+    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Any | None:
         ma = check.isinstance(v, collections.abc.Mapping)
         [(tag, iv)] = ma.items()
         u = self.m[tag]  # type: ignore
@@ -136,7 +136,7 @@ class PolymorphismUnmarshaler(Unmarshaler):
 class PolymorphismUnmarshalerFactory(UnmarshalerFactory):
     p: Polymorphism
 
-    def __call__(self, ctx: UnmarshalContext, rty: rfl.Type) -> ta.Optional[Unmarshaler]:
+    def __call__(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler | None:
         if rty is self.p.ty:
             return PolymorphismUnmarshaler({
                 t: u