omlish 0.0.0.dev423__py3-none-any.whl → 0.0.0.dev484__py3-none-any.whl

omlish/funcs/match.py

@@ -1,227 +0,0 @@
-"""
-Analogous to scala's partial functions ( https://www.scala-lang.org/api/current/scala/PartialFunction.html ).
-
-TODO:
- - unify MatchFnClass with dispatch.method?
-  - __call__ = mfs.method(); @__call__.register(lambda: ...) def _call_... ?
-  - not really the same thing, dispatch is unordered this is necessarily ordered
-"""
-import abc
-import dataclasses as dc
-import typing as ta
-
-from .. import lang
-
-
-T = ta.TypeVar('T')
-P = ta.ParamSpec('P')
-
-
-##
-
-
-class MatchGuardError(Exception):
-    pass
-
-
-class MatchFn(lang.Abstract, ta.Generic[P, T]):
-    @abc.abstractmethod
-    def guard(self, *args: P.args, **kwargs: P.kwargs) -> bool:
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def fn(self, *args: P.args, **kwargs: P.kwargs) -> T:
-        raise NotImplementedError
-
-    def __get__(self, instance, owner=None):
-        return self
-
-    @ta.final
-    def __call__(self, *args: P.args, **kwargs: P.kwargs) -> T:
-        if not self.guard(*args, **kwargs):
-            raise MatchGuardError(*args, **kwargs)
-        return self.fn(*args, **kwargs)
-
-
-##
-
-
-@dc.dataclass(frozen=True)
-class SimpleMatchFn(MatchFn[P, T]):
-    _guard: ta.Callable[P, bool]
-    _fn: ta.Callable[P, T]
-
-    def guard(self, *args: P.args, **kwargs: P.kwargs) -> bool:
-        return self._guard(*args, **kwargs)
-
-    def fn(self, *args: P.args, **kwargs: P.kwargs) -> T:
-        return self._fn(*args, **kwargs)
-
-    def __get__(self, instance, owner=None):
-        return self.__class__(
-            self._guard.__get__(instance, owner),  # noqa
-            self._fn.__get__(instance, owner),  # noqa
-        )
-
-
-@ta.overload
-def simple(guard: ta.Callable[..., bool], fn: ta.Callable[P, T]) -> SimpleMatchFn[P, T]:
-    ...
-
-
-@ta.overload
-def simple(guard: ta.Callable[..., bool]) -> ta.Callable[[ta.Callable[P, T]], SimpleMatchFn[P, T]]:
-    ...
-
-
-def simple(guard, fn=None):
-    def inner(fn):  # noqa
-        return SimpleMatchFn(guard, fn)
-    if fn is not None:
-        return inner(fn)
-    else:
-        return inner
-
-
-##
-
-
-class AmbiguousMatchesError(Exception):
-    pass
-
-
-@dc.dataclass(frozen=True)
-class MultiMatchFn(MatchFn[P, T]):
-    children: ta.Sequence[MatchFn[P, T]]
-    strict: bool = False
-
-    def match(self, *args: P.args, **kwargs: P.kwargs) -> MatchFn[P, T] | None:
-        matches = []
-        for cur in self.children:
-            if cur.guard(*args, **kwargs):
-                if self.strict:
-                    matches.append(cur)
-                else:
-                    return cur
-        if not matches:
-            return None
-        elif len(matches) > 1:
-            raise AmbiguousMatchesError
-        else:
-            return matches[0]
-
-    def guard(self, *args: P.args, **kwargs: P.kwargs) -> bool:
-        return self.match(*args, **kwargs) is not None
-
-    def fn(self, *args: P.args, **kwargs: P.kwargs) -> T:
-        if (m := self.match(*args, **kwargs)) is None:
-            raise MatchGuardError(*args, **kwargs)
-        return m.fn(*args, **kwargs)
-
-    def __get__(self, instance, owner=None):
-        return self.__class__(
-            [c.__get__(instance, owner) for c in self.children],
-            strict=self.strict,
-        )
-
-
-def multi(*children: MatchFn[P, T], strict: bool = False) -> MultiMatchFn:  # MultiMatchFn[P[0], T[-1]]
-    return MultiMatchFn(children, strict=strict)  # noqa
-
-
-##
-
-
-class CachedMatchFn(MatchFn[P, T]):
-    @staticmethod
-    def _default_key(*args, **kwargs):
-        return (args, tuple(sorted(kwargs.items(), key=lambda t: t[0])))
-
-    def __init__(
-            self,
-            f: MatchFn[P, T],
-            *,
-            key: ta.Callable[P, ta.Any] = _default_key,
-            lock: lang.DefaultLockable = None,
-    ) -> None:
-        super().__init__()
-
-        self._f = f
-        self._key = key
-        self._lock = lock
-        self._lock_impl = lang.default_lock(lock)()
-        self._dct: dict[ta.Any, lang.Maybe[ta.Any]] = {}
-
-    def guard(self, *args: P.args, **kwargs: P.kwargs) -> bool:
-        with self._lock_impl:
-            k = self._key(*args, **kwargs)
-            try:
-                e = self._dct[k]
-            except KeyError:
-                if self._f.guard(*args, **kwargs):
-                    return True
-                else:
-                    self._dct[k] = lang.empty()
-                    return False
-            else:
-                return e.present
-
-    def fn(self, *args: P.args, **kwargs: P.kwargs) -> T:
-        with self._lock_impl:
-            k = self._key(*args, **kwargs)
-            try:
-                e = self._dct[k]
-            except KeyError:
-                try:
-                    ret = self._f(*args, **kwargs)
-                except MatchGuardError:
-                    self._dct[k] = lang.empty()
-                    raise
-                else:
-                    self._dct[k] = lang.just(ret)
-                    return ret
-            else:
-                if e.present:
-                    return e.must()
-                else:
-                    raise MatchGuardError(*args, **kwargs)
-
-    def __get__(self, instance, owner=None):
-        return self.__class__(self._f.__get__(instance, owner), key=self._key)  # noqa
-
-
-cached = CachedMatchFn
-
-
-##
-
-
-class MatchFnClass(MatchFn[P, T]):
-    _cls_match_fn: ta.ClassVar[MultiMatchFn]
-
-    __match_fn: MatchFn[P, T] | None = None
-
-    @property
-    def _match_fn(self) -> MatchFn[P, T]:
-        if (mf := self.__match_fn) is None:
-            mf = self.__match_fn = self._cls_match_fn.__get__(self)
-        return mf
-
-    def __init_subclass__(cls, strict: bool = False, **kwargs: ta.Any) -> None:
-        super().__init_subclass__()
-
-        if '_cls_match_fn' in cls.__dict__:
-            raise AttributeError('_cls_match_fn')
-
-        d = {}
-        for c in cls.__mro__:
-            for a, o in c.__dict__.items():
-                if isinstance(o, MatchFn) and a not in d:
-                    d[a] = o
-        cls._cls_match_fn = MultiMatchFn(list(d.values()), strict=strict)
-
-    def guard(self, *args: P.args, **kwargs: P.kwargs) -> bool:
-        return self._match_fn.guard(*args, **kwargs)
-
-    def fn(self, *args: P.args, **kwargs: P.kwargs) -> T:
-        return self._match_fn.fn(*args, **kwargs)

omlish/io/trampoline.py

@@ -1,289 +0,0 @@
-import abc
-import contextlib
-import io
-import typing as ta
-
-from .. import check
-from .. import lang
-from ..concurrent import threadlets as tls
-from ..sync import ConditionDeque
-
-
-if ta.TYPE_CHECKING:
-    import threading
-
-    from . import pyio  # noqa
-
-else:
-    threading = lang.proxy_import('threading')
-
-    pyio = lang.proxy_import('.pyio', __package__)
-
-
-T = ta.TypeVar('T')
-
-BytesLike: ta.TypeAlias = ta.Any
-
-BufferedReader: ta.TypeAlias = io.BufferedReader
-# BufferedReader: ta.TypeAlias = pyio.BufferedReader
-
-
-##
-
-
-class ProxyReadFile:
-    def __init__(self, read: ta.Callable[[int], bytes | BaseException]) -> None:
-        super().__init__()
-
-        self._read = read
-        self._eof = False
-        self._closed = False
-
-    #
-
-    def read(self, n: int, /) -> bytes:
-        if self._closed:
-            raise RuntimeError('Closed')
-        if self._eof:
-            return b''
-        d = self._read(n)
-        if isinstance(d, BaseException):
-            raise d
-        if not d:
-            self._eof = True
-        return d
-
-    def readall(self, *args, **kwargs):
-        raise TypeError  # FIXME
-
-    def readinto(self, b: BytesLike) -> int | None:
-        d = self.read(len(b))
-        if d:
-            b[:len(d)] = d
-        return len(d)
-
-    #
-
-    def readable(self) -> bool:
-        return not (self._eof or self._closed)
-
-    @property
-    def closed(self) -> bool:
-        return self._closed
-
-    def close(self) -> None:
-        self._closed = True
-
-    #
-
-    def flush(self) -> None:
-        pass
-
-    def seekable(self) -> bool:
-        return False
-
-    def seek(self, n: int, /) -> ta.Any:
-        raise TypeError
-
-
-##
-
-
-class NeedMore(lang.Marker):
-    pass
-
-
-class Exited(lang.Marker):
-    pass
-
-
-class Shutdown(BaseException):  # noqa
-    pass
-
-
-IoTrampolineTarget: ta.TypeAlias = ta.Callable[[io.BufferedReader], ta.ContextManager[ta.Callable[[], bytes]]]
-
-
-class IoTrampoline(lang.Abstract):
-    def __init__(
-            self,
-            target: IoTrampolineTarget,
-            *,
-            buffer_size: int | None = None,
-    ) -> None:
-        super().__init__()
-
-        self._target = target
-        self._buffer_size = buffer_size
-
-    def _make_buffered_reader(self, raw: ta.Any) -> io.BufferedReader:
-        return io.BufferedReader(
-            raw,
-            **(dict(buffer_size=self._buffer_size) if self._buffer_size is not None else {}),
-        )
-
-    @abc.abstractmethod
-    def close(self, timeout: float | None = None) -> None:
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def __enter__(self) -> ta.Self:
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def feed(self, *data: bytes) -> ta.Iterable[bytes]:
-        raise NotImplementedError
-
-
-#
-
-
-class ThreadIoTrampoline(IoTrampoline):
-    def __init__(self, target: IoTrampolineTarget, **kwargs: ta.Any) -> None:
-        super().__init__(target, **kwargs)
-
-        self._in: ConditionDeque[bytes | BaseException] = ConditionDeque()
-        self._out: ConditionDeque[
-            bytes |  # noqa
-            type[NeedMore] |
-            type[Exited] |
-            BaseException
-        ] = ConditionDeque()
-
-        self._proxy = ProxyReadFile(self._read)
-
-        self._thread = threading.Thread(target=self._thread_proc, daemon=True)
-
-    #
-
-    def close(self, timeout: float | None = None) -> None:
-        if not self._thread.is_alive():
-            return
-        self._out.push(Shutdown())
-        self._thread.join(timeout)
-        if self._thread.is_alive():
-            if timeout is not None:
-                raise TimeoutError
-            else:
-                raise RuntimeError('Failed to join thread')
-
-    #
-
-    def __enter__(self) -> ta.Self:
-        self._thread.start()
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        self.close()
-
-    #
-
-    def _read(self, n: int, /) -> bytes | BaseException:
-        return self._in.pop(if_empty=lambda: self._out.push(NeedMore))
-
-    def _thread_proc(self) -> None:
-        try:
-            with contextlib.closing(self._make_buffered_reader(self._proxy)) as bf:  # noqa
-                with self._target(bf) as read:
-                    while out := read():
-                        self._out.push(out)
-                    self._out.push(out)
-        except BaseException as e:
-            self._out.push(e)
-            raise
-        finally:
-            self._out.push(Exited)
-
-    def feed(self, *data: bytes) -> ta.Iterable[bytes]:
-        self._in.push(*data)
-        while True:
-            e = self._out.pop()
-            if e is NeedMore:
-                break
-            elif isinstance(e, BaseException):
-                raise e
-            elif e is Exited:
-                raise RuntimeError('IO thread exited')
-            elif isinstance(e, bytes):
-                yield e
-                if not e:
-                    return
-            else:
-                raise TypeError(e)
-
-
-#
-
-
-class ThreadletIoTrampoline(IoTrampoline):
-    def __init__(
-            self,
-            target: IoTrampolineTarget,
-            threadlets: tls.Threadlets = tls.GREENLET_THREADLETS,
-            ** kwargs: ta.Any,
-    ) -> None:
-        super().__init__(target, **kwargs)
-
-        self._proxy = ProxyReadFile(self._read)
-        self._tl: tls.Threadlet = threadlets.spawn(self._g_proc)
-
-    #
-
-    def close(self, timeout: float | None = None) -> None:
-        if self._tl.dead:
-            return
-        out = self._tl.switch(Shutdown())
-        if out is not Exited or not self._tl.dead:
-            raise RuntimeError
-
-    #
-
-    def __enter__(self) -> ta.Self:
-        out = self._tl.switch()
-        if out is not NeedMore:
-            raise RuntimeError
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        self.close()
-
-    #
-
-    def _read(self, n: int, /) -> bytes:
-        out = check.not_none(self._tl.parent).switch(NeedMore)
-        return out
-
-    def _g_proc(self) -> ta.Any:
-        try:
-            with contextlib.closing(self._make_buffered_reader(self._proxy)) as bf:  # noqa
-                with self._target(bf) as read:
-                    while out := read():
-                        e = check.not_none(self._tl.parent).switch(out)
-                        if e is not NeedMore:
-                            raise TypeError(e)  # noqa
-                    e = check.not_none(self._tl.parent).switch(out)
-                    if not isinstance(e, Shutdown):
-                        raise TypeError(e)  # noqa
-            return Exited
-        except BaseException as e:
-            check.not_none(self._tl.parent).throw(e)
-            raise
-
-    def feed(self, *data: bytes) -> ta.Iterable[bytes]:
-        i: bytes | type[NeedMore]
-        for i in data:
-            while True:
-                e = self._tl.switch(i)
-                i = NeedMore
-                if e is NeedMore:
-                    break
-                elif isinstance(e, bytes):
-                    yield e
-                    if not e:
-                        return
-                else:
-                    raise TypeError(e)