omlish 0.0.0.dev424__py3-none-any.whl → 0.0.0.dev426__py3-none-any.whl

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)

omlish/lite/logs.py

@@ -1,4 +0,0 @@
-import logging
-
-
-log = logging.getLogger(__name__)

omlish/lite/reprs.py

@@ -1,85 +0,0 @@
-# ruff: noqa: UP007 UP045
-import dataclasses as dc
-import typing as ta
-
-
-##
-
-
-@dc.dataclass(frozen=True)
-class AttrRepr:
-    attrs: ta.Sequence[str]
-
-    # _: dc.KW_ONLY
-
-    with_module: bool = False
-    use_qualname: bool = False
-    with_id: bool = False
-    value_filter: ta.Optional[ta.Callable[[ta.Any], bool]] = None
-    recursive: bool = False
-
-    @classmethod
-    def of(cls, *attrs: str, **kwargs: ta.Any) -> 'AttrRepr':
-        return cls(attrs, **kwargs)
-
-    #
-
-    def _build_(self, obj: ta.Any) -> str:
-        vs = ', '.join(
-            f'{attr}={v!r}'
-            for attr in self.attrs
-            for v in [getattr(obj, attr)]
-            if self.value_filter is None or self.value_filter(v)
-        )
-
-        return (
-            f'{obj.__class__.__module__ + "." if self.with_module else ""}'
-            f'{obj.__class__.__qualname__ if self.use_qualname else obj.__class__.__name__}'
-            f'{("@" + hex(id(obj))[2:]) if self.with_id else ""}'
-            f'({vs})'
-        )
-
-    _build: ta.ClassVar[ta.Callable[[ta.Any], str]]
-
-    def __call__(self, obj: ta.Any) -> str:
-        try:
-            build: ta.Any = self._build
-
-        except AttributeError:
-            build = self._build_
-            if self.recursive:
-                build = self._reprlib().recursive_repr()(build)
-            object.__setattr__(self, '_build', build)
-
-        return build(obj)
-
-    #
-
-    def __get__(self, instance, owner):
-        if instance is None:
-            return self
-
-        def __repr__(other):  # noqa
-            return self(other)
-
-        return __repr__.__get__(instance, owner)
-
-    #
-
-    _reprlib_: ta.ClassVar[ta.Any]
-
-    @classmethod
-    def _reprlib(cls) -> ta.Any:
-        try:
-            return cls._reprlib_
-        except AttributeError:
-            pass
-
-        import reprlib  # noqa
-
-        cls._reprlib_ = reprlib
-        return reprlib
-
-
-def attr_repr(obj: ta.Any, *attrs: str, **kwargs: ta.Any) -> str:
-    return AttrRepr(attrs, **kwargs)(obj)

omlish/logs/abc.py

@@ -1,319 +0,0 @@
-# ruff: noqa: A002 N802 N815
-import types
-import typing as ta
-
-
-##
-
-
-Level: ta.TypeAlias = int
-
-
-ExceptionInfo: ta.TypeAlias = tuple[type[BaseException], BaseException, types.TracebackType]
-
-
-class LogRecord:
-    """https://docs.python.org/3/library/logging.html#logrecord-attributes"""
-
-    # Name of the logger used to log the call.
-    name: str
-
-    # Human-readable time when the LogRecord was created. By default this is of the form '2003-07-08 16:49:45,896' (the
-    # numbers after the comma are millisecond portion of the time).
-    asctime: str
-
-    # The logged message, computed as msg % args. This is set when Formatter.format() is invoked.
-    message: str
-
-    # The format string passed in the original logging call. Merged with args to produce message, or an arbitrary object
-    # (see Using arbitrary objects as messages).
-    msg: str
-
-    # The tuple of arguments merged into msg to produce message, or a dict whose values are used for the merge (when
-    # there is only one argument, and it is a dictionary).
-    args: tuple
-
-    # Text logging level for the message ('DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL').
-    levelname: str
-
-    # # Numeric logging level for the message (DEBUG, INFO, WARNING, ERROR, CRITICAL).
-    levelno: Level
-
-    # Full pathname of the source file where the logging call was issued (if available).
-    pathname: str
-
-    # Filename portion of pathname.
-    filename: str
-
-    # Module (name portion of filename).
-    module: str
-
-    # Exception tuple (à la sys.exc_info) or, if no exception has occurred, None.
-    exc_info: ExceptionInfo | None
-
-    exc_text: str | None
-
-    # Stack frame information (where available) from the bottom of the stack in the current thread, up to and including
-    # the stack frame of the logging call which resulted in the creation of this record.
-    stack_info: str | None
-
-    # Source line number where the logging call was issued (if available).
-    lineno: int
-
-    # Name of function containing the logging call.
-    funcName: str
-
-    # Time when the LogRecord was created (as returned by time.time_ns() / 1e9).
-    created: float
-
-    # Millisecond portion of the time when the LogRecord was created.
-    msecs: float
-
-    # Time in milliseconds when the LogRecord was created, relative to the time the logging module was loaded.
-    relativeCreated: float
-
-    # Thread ID (if available).
-    thread: int
-
-    # Thread name (if available).
-    threadName: str
-
-    # Process name (if available).
-    processName: str
-
-    # Process ID (if available).
-    process: int
-
-    # asyncio.Task name (if available).
-    taskName: str
-
-
-##
-
-
-class Formatter(ta.Protocol):
-    """https://docs.python.org/3/library/logging.html#formatter-objects"""
-
-    default_time_format: ta.ClassVar[str]
-    default_msec_format: ta.ClassVar[str]
-
-    def formatTime(self, record: LogRecord, datefmt: str | None = None) -> str: ...
-
-    def formatException(self, ei: ExceptionInfo) -> str: ...
-
-    def usesTime(self) -> bool: ...
-
-    def formatMessage(self, record: LogRecord) -> str: ...
-
-    def formatStack(self, stack_info: str) -> str: ...
-
-    def format(self, record: LogRecord) -> str: ...
-
-
-class BufferingFormatter(ta.Protocol):
-    """https://docs.python.org/3/library/logging.html#logging.BufferingFormatter"""
-
-    def formatHeader(self, records: ta.Sequence[LogRecord]) -> str: ...
-
-    def formatFooter(self, records: ta.Sequence[LogRecord]) -> str: ...
-
-    def format(self, records: ta.Sequence[LogRecord]) -> str: ...
-
-
-##
-
-
-class Filter(ta.Protocol):
-    """https://docs.python.org/3/library/logging.html#filter-objects"""
-
-    def filter(self, record: LogRecord) -> bool: ...
-
-
-class Filterer(ta.Protocol):
-    """A base class for loggers and handlers which allows them to share common code."""
-
-    def addFilter(self, filter: Filter) -> None: ...
-
-    def removeFilter(self, filter: Filter) -> None: ...
-
-    def filter(self, record: LogRecord) -> bool: ...
-
-
-##
-
-
-class Handler(Filterer, ta.Protocol):
-    """https://docs.python.org/3/library/logging.html#handler-objects"""
-
-    level: Level
-
-    def get_name(self) -> str: ...
-
-    def set_name(self, name: str) -> None: ...
-
-    name: str
-
-    def createLock(self) -> None: ...
-
-    def acquire(self) -> None: ...
-
-    def release(self) -> None: ...
-
-    def setLevel(self, level: Level) -> None: ...
-
-    def format(self, record: LogRecord) -> str: ...
-
-    def emit(self, record: LogRecord) -> None: ...
-
-    def handle(self, record: LogRecord) -> bool: ...
-
-    def setFormatter(self, fmt: Formatter) -> None: ...
-
-    def flush(self) -> None: ...
-
-    def close(self) -> None: ...
-
-    def handleError(self, record: LogRecord) -> None: ...
-
-
-class Stream(ta.Protocol):
-    def write(self, s: str) -> None: ...
-
-    def flush(self) -> None: ...  # OPTIONAL METHOD
-
-    def close(self) -> None: ...  # OPTIONAL METHOD
-
-
-class StreamHandler(Handler, ta.Protocol):
-    """https://docs.python.org/3/library/logging.handlers.html#logging.StreamHandler"""
-
-    terminator: ta.ClassVar[str]
-
-    stream: Stream
-
-    def flush(self) -> None: ...
-
-    def emit(self, record: LogRecord) -> None: ...
-
-    def setStream(self, stream: Stream) -> None: ...
-
-
-##
-
-
-class Manager(ta.Protocol):
-    """There is [under normal circumstances] just one Manager instance, which holds the hierarchy of loggers."""
-
-    root: 'Logger'
-
-    disable: Level
-
-    def getLogger(self, name: str) -> 'Logger': ...
-
-    def setLoggerClass(self, klass: type['Logger']) -> None: ...
-
-    def setLogRecordFactory(self, factory: ta.Callable[..., LogRecord]) -> None: ...  # UNREFERENCED?
-
-
-##
-
-
-Caller: ta.TypeAlias = tuple[
-    str,  # filename
-    int,  # lineno
-    str,  # name
-    str,  # formatted
-]
-
-
-class Logger(Filterer, ta.Protocol):
-    """https://docs.python.org/3/library/logging.html#logger-objects"""
-
-    name: str
-    level: Level
-    parent: ta.Optional['Logger']
-    propagate: bool
-    handlers: list[Handler]
-    disabled: bool
-
-    manager: Manager
-
-    def setLevel(self, level: Level) -> None: ...
-
-    def debug(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None: ...
-    def info(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None: ...
-    def warning(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None: ...
-    def warn(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None: ...
-    def error(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None: ...
-    def exception(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None: ...
-    def critical(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None: ...
-    def fatal(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None: ...
-
-    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 makeRecord(
-        self,
-        name,
-        level,
-        fn,
-        lno,
-        msg,
-        args,
-        exc_info,
-        func: str | None = None,
-        extra: ta.Mapping[str, ta.Any] | None = None,
-        sinfo: str | None = None,
-    ) -> LogRecord: ...
-
-    def handle(self, record: LogRecord) -> None: ...
-
-    def addHandler(self, hdlr: Handler) -> None: ...
-
-    def removeHandler(self, hdlr: Handler) -> None: ...
-
-    def hasHandlers(self) -> bool: ...
-
-    def callHandlers(self, record: LogRecord) -> None: ...
-
-    def getEffectiveLevel(self) -> Level: ...
-
-    def isEnabledFor(self, level: Level) -> bool: ...
-
-    def getChild(self, suffix: str) -> 'Logger': ...
-
-
-##
-
-
-class LoggerAdapter(ta.Protocol):
-    """https://docs.python.org/3/library/logging.html#loggeradapter-objects"""
-
-    logger: Logger
-    extra: ta.Mapping[str, ta.Any]
-
-    def process(self, msg: str, kwargs: dict[str, ta.Any]) -> tuple[str, dict[str, ta.Any]]: ...
-
-    def debug(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None: ...
-    def info(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None: ...
-    def warning(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None: ...
-    def warn(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None: ...
-    def error(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None: ...
-    def exception(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None: ...
-    def critical(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None: ...
-    def fatal(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None: ...
-
-    def log(self, level: Level, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None: ...
-
-    def isEnabledFor(self, level: Level) -> bool: ...
-
-    def setLevel(self, level: Level) -> None: ...
-
-    def getEffectiveLevel(self) -> Level: ...
-
-    def hasHandlers(self) -> bool: ...
-
-    manager: Manager
-
-    name: str