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

omlish/lang/functions.py

@@ -1,3 +1,4 @@
+import dataclasses as dc
 import functools
 import time
 import typing as ta
@@ -6,6 +7,7 @@ from .descriptors import is_method_descriptor
 
 
 T = ta.TypeVar('T')
+CallableT = ta.TypeVar('CallableT', bound=ta.Callable)
 
 
 def is_lambda(f: ta.Any) -> bool:
@@ -50,8 +52,8 @@ def raise_(o: BaseException) -> ta.NoReturn:
 
 
 def try_(
-        exc: ta.Union[type[Exception], ta.Iterable[type[Exception]]] = Exception,
-        default: ta.Optional[T] = None,
+        exc: type[Exception] | ta.Iterable[type[Exception]] = Exception,
+        default: T | None = None,
 ) -> ta.Callable[..., T]:
     def outer(fn):
         def inner(*args, **kwargs):
@@ -113,14 +115,42 @@ def void(*args, **kwargs) -> ta.NoReturn:
     raise VoidException
 
 
-def ticking_timeout(
-        s: int | float | None,
-        ex: type[BaseException] | BaseException = TimeoutError,
-) -> ta.Callable[[], None]:
-    if s is None:
-        return lambda: None
-    def tick():  # noqa
-        if time.time() >= deadline:
-            raise ex
-    deadline = time.time() + s
-    return tick
+_MISSING = object()
+
+
+def periodically(
+        fn: CallableT,
+        interval_s: float,
+        initial: ta.Any = _MISSING,
+        *,
+        include_runtime: bool = False,
+) -> CallableT:
+    nxt = time.time() + interval_s
+    ret = initial
+
+    @functools.wraps(fn)
+    def inner(*args, **kwargs):
+        nonlocal nxt, ret
+        if time.time() >= nxt or ret is _MISSING:
+            if include_runtime:
+                nxt = time.time() + interval_s
+            ret = fn(*args, **kwargs)
+            if not include_runtime:
+                nxt = time.time() + interval_s
+        return ret
+
+    return inner  # type: ignore
+
+
+@dc.dataclass(init=False)
+class Args:
+    args: ta.Sequence[ta.Any]
+    kwargs: ta.Mapping[str, ta.Any]
+
+    def __init__(self, *args: ta.Any, **kwargs: ta.Any) -> None:
+        super().__init__()
+        self.args = args
+        self.kwargs = kwargs
+
+    def __call__(self, fn: ta.Callable[..., T]) -> T:
+        return fn(*self.args, **self.kwargs)

omlish/lang/imports.py

@@ -10,11 +10,11 @@ from .cached import cached_function
 ##
 
 
-def lazy_import(name: str, package: ta.Optional[str] = None) -> ta.Callable[[], ta.Any]:
+def lazy_import(name: str, package: str | None = None) -> ta.Callable[[], ta.Any]:
     return cached_function(functools.partial(importlib.import_module, name, package=package))
 
 
-def proxy_import(name: str, package: ta.Optional[str] = None) -> types.ModuleType:
+def proxy_import(name: str, package: str | None = None) -> types.ModuleType:
     omod = None
 
     def __getattr__(att):
@@ -65,7 +65,7 @@ def yield_importable(
         package_root: str,
         *,
         recursive: bool = False,
-        filter: ta.Optional[ta.Callable[[str], bool]] = None,
+        filter: ta.Callable[[str], bool] | None = None,
         include_special: bool = False,
 ) -> ta.Iterator[str]:
     def rec(dir):
@@ -112,10 +112,10 @@ def yield_importable(
 def yield_import_all(
         package_root: str,
         *,
-        globals: ta.Optional[dict[str, ta.Any]] = None,
-        locals: ta.Optional[dict[str, ta.Any]] = None,
+        globals: dict[str, ta.Any] | None = None,
+        locals: dict[str, ta.Any] | None = None,
         recursive: bool = False,
-        filter: ta.Optional[ta.Callable[[str], bool]] = None,
+        filter: ta.Callable[[str], bool] | None = None,
         include_special: bool = False,
 ) -> ta.Iterator[str]:
     for import_path in yield_importable(
@@ -132,7 +132,7 @@ def import_all(
         package_root: str,
         *,
         recursive: bool = False,
-        filter: ta.Optional[ta.Callable[[str], bool]] = None,
+        filter: ta.Callable[[str], bool] | None = None,
         include_special: bool = False,
 ) -> None:
     for _ in yield_import_all(
@@ -144,7 +144,7 @@ def import_all(
         pass
 
 
-def try_import(spec: str) -> ta.Optional[types.ModuleType]:
+def try_import(spec: str) -> types.ModuleType | None:
     s = spec.lstrip('.')
     l = len(spec) - len(s)
     try:

omlish/lang/iterables.py

@@ -34,7 +34,7 @@ def peek(vs: ta.Iterable[T]) -> ta.Tuple[T, ta.Iterator[T]]:
     return v, itertools.chain(iter((v,)), it)
 
 
-Rangeable: ta.TypeAlias = ta.Union[int, ta.Tuple[int], ta.Tuple[int, int], ta.Iterable[int]]
+Rangeable: ta.TypeAlias = int | ta.Tuple[int] | ta.Tuple[int, int] | ta.Iterable[int]
 
 
 def asrange(i: Rangeable) -> ta.Iterable[int]:

omlish/lang/maybes.py

@@ -130,7 +130,7 @@ def empty() -> Maybe[T]:
     return _empty  # noqa
 
 
-def maybe(o: ta.Optional[T]) -> Maybe[T]:
+def maybe(o: T | None) -> Maybe[T]:
     if o is None:
         return _empty  # noqa
     return just(o)

omlish/lang/objects.py

@@ -28,7 +28,7 @@ def new_type(
         name: str,
         bases: ta.Sequence[ta.Any],
         namespace: ta.Mapping[str, ta.Any],
-        **kwargs
+        **kwargs,
 ) -> ta.Type:
     return types.new_class(
         name,
@@ -44,7 +44,7 @@ def super_meta(
         name: str,
         bases: ta.Sequence[ta.Any],
         namespace: ta.MutableMapping[str, ta.Any],
-        **kwargs
+        **kwargs,
 ) -> ta.Type:
     """Per types.new_class"""
     resolved_bases = types.resolve_bases(bases)

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
 
 
 ##
@@ -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

@@ -94,7 +94,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 +138,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 +148,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 +164,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 +179,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 +205,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/marshal/base.py

@@ -146,7 +146,7 @@ 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)
@@ -157,7 +157,7 @@ class MarshalContext(BaseContext, lang.Final):
 
 @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)
@@ -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/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/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/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

omlish/marshal/standard.py

@@ -47,9 +47,9 @@ def new_standard_marshaler_factory() -> MarshalerFactory:
     return TypeCacheFactory(  # noqa
         RecursiveMarshalerFactory(
             CompositeFactory(
-                *STANDARD_MARSHALER_FACTORIES
-            )
-        )
+                *STANDARD_MARSHALER_FACTORIES,
+            ),
+        ),
     )
 
 
@@ -74,7 +74,7 @@ def new_standard_unmarshaler_factory() -> UnmarshalerFactory:
     return TypeCacheFactory(  # noqa
         RecursiveUnmarshalerFactory(
             CompositeFactory(
-                *STANDARD_UNMARSHALER_FACTORIES
-            )
-        )
+                *STANDARD_UNMARSHALER_FACTORIES,
+            ),
+        ),
     )

omlish/marshal/utils.py

@@ -5,7 +5,7 @@ T = ta.TypeVar('T')
 
 
 class _Proxy(ta.Generic[T]):
-    __obj: ta.Optional[T] = None
+    __obj: T | None = None
 
     @property
     def _obj(self) -> T:

omlish/os.py

@@ -1,14 +1,23 @@
 import contextlib
+import resource
 import shutil
 import tempfile
 import typing as ta
 
 
+PAGE_SIZE = resource.getpagesize()
+
+
+def round_to_page_size(sz: int) -> int:
+    sz += PAGE_SIZE - 1
+    return sz - (sz % PAGE_SIZE)
+
+
 @contextlib.contextmanager
 def tmp_dir(
-        root_dir: ta.Optional[str] = None,
+        root_dir: str | None = None,
         cleanup: bool = True,
-        **kwargs: ta.Any
+        **kwargs: ta.Any,
 ) -> ta.Iterator[str]:
     path = tempfile.mkdtemp(dir=root_dir, **kwargs)
     try:
@@ -20,9 +29,9 @@ def tmp_dir(
 
 @contextlib.contextmanager
 def tmp_file(
-        root_dir: ta.Optional[str] = None,
+        root_dir: str | None = None,
         cleanup: bool = True,
-        **kwargs: ta.Any
+        **kwargs: ta.Any,
 ) -> ta.Iterator[tempfile._TemporaryFileWrapper]:  # noqa
     with tempfile.NamedTemporaryFile(dir=root_dir, delete=False, **kwargs) as f:
         try: