omlish 0.0.0.dev132__py3-none-any.whl → 0.0.0.dev177__py3-none-any.whl

omlish/lang/generators.py

@@ -0,0 +1,243 @@
+import abc
+import functools
+import typing as ta
+
+from .maybes import Maybe
+from .maybes import empty
+from .maybes import just
+
+
+T = ta.TypeVar('T')
+I = ta.TypeVar('I')
+O = ta.TypeVar('O')
+R = ta.TypeVar('R')
+I_contra = ta.TypeVar('I_contra', contravariant=True)
+O_co = ta.TypeVar('O_co', covariant=True)
+R_co = ta.TypeVar('R_co', covariant=True)
+
+
+##
+
+
+def nextgen(g: T) -> T:
+    next(g)  # type: ignore
+    return g
+
+
+def autostart(fn):
+    @functools.wraps(fn)
+    def inner(*args, **kwargs):
+        g = fn(*args, **kwargs)
+        if (o := next(g)) is not None:
+            raise TypeError(o)
+        return g
+    return inner
+
+
+##
+
+
+@ta.runtime_checkable
+class GeneratorLike(ta.Protocol[O_co, I_contra, R_co]):
+    def send(self, i: I_contra) -> O_co:  # Raises[StopIteration[R_co]]
+        ...
+
+    def close(self) -> None:
+        ...
+
+
+class GeneratorLike_(abc.ABC, ta.Generic[O, I, R]):  # noqa
+    @abc.abstractmethod
+    def send(self, i: I) -> O:  # Raises[StopIteration[R]]
+        raise NotImplementedError
+
+    def close(self) -> None:
+        pass
+
+
+@ta.overload
+def adapt_generator_like(gl: GeneratorLike_[O, I, R]) -> ta.Generator[O, I, R]:
+    ...
+
+
+@ta.overload
+def adapt_generator_like(gl: GeneratorLike[O, I, R]) -> ta.Generator[O, I, R]:
+    ...
+
+
+def adapt_generator_like(gl):
+    try:
+        i = yield
+        while True:
+            i = yield gl.send(i)
+    except StopIteration as e:
+        return e.value
+    finally:
+        gl.close()
+
+
+##
+
+
+class Generator(ta.Generator[O, I, R]):
+    def __init__(self, g: ta.Generator[O, I, R]) -> None:
+        super().__init__()
+        self._g = g
+
+    @property
+    def g(self) -> ta.Generator[O, I, R]:
+        return self._g
+
+    value: R
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        try:
+            return next(self._g)
+        except StopIteration as e:
+            self.value = e.value
+            raise
+
+    def send(self, v):
+        try:
+            return self._g.send(v)
+        except StopIteration as e:
+            self.value = e.value
+            raise
+
+    def throw(self, *args):
+        try:
+            return self._g.throw(*args)
+        except StopIteration as e:
+            self.value = e.value
+            raise
+
+    def close(self):
+        self._g.close()
+
+
+##
+
+
+class CoroutineGenerator(ta.Generic[O, I, R]):
+    def __init__(self, g: ta.Generator[O, I, R]) -> None:
+        super().__init__()
+        self._g = g
+
+    @property
+    def g(self) -> ta.Generator[O, I, R]:
+        return self._g
+
+    #
+
+    def close(self) -> None:
+        self._g.close()
+
+    def __enter__(self) -> ta.Self:
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self._g.close()
+
+    #
+
+    class Output(ta.NamedTuple, ta.Generic[T]):
+        v: T
+
+        @property
+        def is_return(self) -> bool:
+            raise NotImplementedError
+
+    class Yield(Output[T]):
+        @property
+        def is_return(self) -> bool:
+            return False
+
+    class Return(Output[T]):
+        @property
+        def is_return(self) -> bool:
+            return True
+
+    class Nothing:
+        def __new__(cls):
+            raise TypeError
+
+    #
+
+    def send(self, /, v: I | type[Nothing] = Nothing) -> Yield[O] | Return[R]:
+        try:
+            if v is self.Nothing:
+                o = next(self._g)
+            else:
+                o = self._g.send(v)  # type: ignore[arg-type]
+        except StopIteration as e:
+            return self.Return(e.value)
+        else:
+            return self.Yield(o)
+
+    def send_opt(self, v: I | None) -> Yield[O] | Return[R]:
+        return self.send(v if v is not None else self.Nothing)
+
+    def send_maybe(self, v: Maybe[I]) -> Yield[O] | Return[R]:
+        return self.send(v.or_else(self.Nothing))
+
+    def throw(self, v: BaseException) -> Yield[O] | Return[R]:
+        try:
+            o = self._g.throw(v)
+        except StopIteration as e:
+            return self.Return(e.value)
+        else:
+            return self.Yield(o)
+
+
+corogen = CoroutineGenerator
+
+
+##
+
+
+class GeneratorMappedIterator(ta.Generic[O, I, R]):
+    """
+    Like a `map` iterator but takes a generator instead of a function. Provided generator *must* yield outputs 1:1 with
+    inputs.
+
+    Generator return value will be captured on `value` property - if present generator stopped, it absent iterator
+    stopped.
+    """
+
+    def __init__(self, g: ta.Generator[O, I, R], it: ta.Iterator[I]) -> None:
+        super().__init__()
+
+        self._g = g
+        self._it = it
+        self._value: Maybe[R] = empty()
+
+    @property
+    def g(self) -> ta.Generator[O, I, R]:
+        return self._g
+
+    @property
+    def it(self) -> ta.Iterator[I]:
+        return self._it
+
+    @property
+    def value(self) -> Maybe[R]:
+        return self._value
+
+    def __iter__(self) -> ta.Iterator[O]:
+        return self
+
+    def __next__(self) -> O:
+        i = next(self._it)
+        try:
+            o = self._g.send(i)
+        except StopIteration as e:
+            self._value = just(e.value)
+            raise StopIteration from e
+        return o
+
+
+def genmap(g: ta.Generator[O, I, R], it: ta.Iterable[I]) -> GeneratorMappedIterator[O, I, R]:
+    return GeneratorMappedIterator(g, iter(it))

omlish/lang/iterables.py

@@ -1,10 +1,10 @@
 import dataclasses as dc
+import functools
 import itertools
 import typing as ta
 
 
 T = ta.TypeVar('T')
-S = ta.TypeVar('S')
 R = ta.TypeVar('R')
 
 
@@ -15,6 +15,9 @@ BUILTIN_SCALAR_ITERABLE_TYPES: tuple[type, ...] = (
 )
 
 
+##
+
+
 def ilen(it: ta.Iterable) -> int:
     c = 0
     for _ in it:
@@ -44,40 +47,36 @@ def interleave(vs: ta.Iterable[T], d: T) -> ta.Iterable[T]:
         yield v
 
 
-Rangeable: ta.TypeAlias = ta.Union[  # noqa
-    int,
-    tuple[int],
-    tuple[int, int],
-    tuple[int, int, int],
-    ta.Iterable[int],
-]
+@ta.overload
+def readiter(f: ta.TextIO, sz: int) -> ta.Iterator[str]:
+    ...
 
 
-def asrange(i: Rangeable) -> ta.Iterable[int]:
-    if isinstance(i, int):
-        return range(i)
-    elif isinstance(i, tuple):
-        return range(*i)
-    elif isinstance(i, ta.Iterable):
-        return i
-    else:
-        raise TypeError(i)
+@ta.overload
+def readiter(f: ta.BinaryIO, sz: int) -> ta.Iterator[bytes]:
+    ...
 
 
-def prodrange(*dims: Rangeable) -> ta.Iterable[ta.Sequence[int]]:
-    if not dims:
-        return []
-    return itertools.product(*map(asrange, dims))
+@ta.overload
+def readiter(f: ta.IO, sz: int) -> ta.Iterator[ta.AnyStr]:
+    ...
+
+
+def readiter(f, sz):
+    return iter(functools.partial(f.read, sz), None)
 
 
 @dc.dataclass(frozen=True)
-class itergen(ta.Generic[T]):  # noqa
+class IterGen(ta.Generic[T]):
     fn: ta.Callable[[], ta.Iterable[T]]
 
     def __iter__(self):
         return iter(self.fn())
 
 
+itergen = IterGen
+
+
 def renumerate(it: ta.Iterable[T]) -> ta.Iterable[tuple[T, int]]:
     return ((e, i) for i, e in enumerate(it))
 
@@ -89,32 +88,30 @@ def flatmap(fn: ta.Callable[[T], ta.Iterable[R]], it: ta.Iterable[T]) -> ta.Iter
     return flatten(map(fn, it))
 
 
-class Generator(ta.Generator[T, S, R]):
-    def __init__(self, gen: ta.Generator[T, S, R]) -> None:
-        super().__init__()
-        self.gen = gen
+##
 
-    value: R
 
-    def __iter__(self):
-        return self
-
-    def __next__(self):
-        return self.send(None)
-
-    def send(self, v):
-        try:
-            return self.gen.send(v)
-        except StopIteration as e:
-            self.value = e.value
-            raise
-
-    def throw(self, *args):
-        try:
-            return self.gen.throw(*args)
-        except StopIteration as e:
-            self.value = e.value
-            raise
-
-    def close(self):
-        self.gen.close()
+Rangeable: ta.TypeAlias = ta.Union[  # noqa
+    int,
+    tuple[int],
+    tuple[int, int],
+    tuple[int, int, int],
+    ta.Iterable[int],
+]
+
+
+def asrange(i: Rangeable) -> ta.Iterable[int]:
+    if isinstance(i, int):
+        return range(i)
+    elif isinstance(i, tuple):
+        return range(*i)
+    elif isinstance(i, ta.Iterable):
+        return i
+    else:
+        raise TypeError(i)
+
+
+def prodrange(*dims: Rangeable) -> ta.Iterable[ta.Sequence[int]]:
+    if not dims:
+        return []
+    return itertools.product(*map(asrange, dims))

omlish/lang/maybes.py

@@ -50,11 +50,11 @@ class Maybe(abc.ABC, ta.Generic[T]):
         raise NotImplementedError
 
     @abc.abstractmethod
-    def or_else(self, other: T) -> T:
+    def or_else(self, other: T | U) -> T | U:
         raise NotImplementedError
 
     @abc.abstractmethod
-    def or_else_get(self, supplier: ta.Callable[[], T]) -> T:
+    def or_else_get(self, supplier: ta.Callable[[], U]) -> T | U:
         raise NotImplementedError
 
     @abc.abstractmethod
@@ -109,10 +109,10 @@ class _Maybe(Maybe[T], tuple):
             return value
         return _empty  # noqa
 
-    def or_else(self, other: T) -> T:
+    def or_else(self, other: T | U) -> T | U:
         return self.must() if self else other
 
-    def or_else_get(self, supplier: ta.Callable[[], T]) -> T:
+    def or_else_get(self, supplier: ta.Callable[[], T | U]) -> T | U:
         return self.must() if self else supplier()
 
     def or_else_raise(self, exception_supplier: ta.Callable[[], Exception]) -> T:

omlish/lite/cached.py

@@ -4,8 +4,13 @@ import typing as ta
 
 T = ta.TypeVar('T')
 
+CallableT = ta.TypeVar('CallableT', bound=ta.Callable)
 
-class _cached_nullary:  # noqa
+
+##
+
+
+class _AbstractCachedNullary:
     def __init__(self, fn):
         super().__init__()
         self._fn = fn
@@ -13,14 +18,42 @@ class _cached_nullary:  # noqa
         functools.update_wrapper(self, fn)
 
     def __call__(self, *args, **kwargs):  # noqa
-        if self._value is self._missing:
-            self._value = self._fn()
-        return self._value
+        raise TypeError
 
     def __get__(self, instance, owner):  # noqa
         bound = instance.__dict__[self._fn.__name__] = self.__class__(self._fn.__get__(instance, owner))
         return bound
 
 
-def cached_nullary(fn):  # ta.Callable[..., T]) -> ta.Callable[..., T]:
-    return _cached_nullary(fn)
+##
+
+
+class _CachedNullary(_AbstractCachedNullary):
+    def __call__(self, *args, **kwargs):  # noqa
+        if self._value is self._missing:
+            self._value = self._fn()
+        return self._value
+
+
+def cached_nullary(fn: CallableT) -> CallableT:
+    return _CachedNullary(fn)  # type: ignore
+
+
+def static_init(fn: CallableT) -> CallableT:
+    fn = cached_nullary(fn)
+    fn()
+    return fn
+
+
+##
+
+
+class _AsyncCachedNullary(_AbstractCachedNullary):
+    async def __call__(self, *args, **kwargs):
+        if self._value is self._missing:
+            self._value = await self._fn()
+        return self._value
+
+
+def async_cached_nullary(fn):  # ta.Callable[..., T]) -> ta.Callable[..., T]:
+    return _AsyncCachedNullary(fn)