omlish 0.0.0.dev424__py3-none-any.whl → 0.0.0.dev425__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/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

omlish/logs/color.py

@@ -1,27 +0,0 @@
-# ruff: noqa: ANN201 N802
-import logging
-import typing as ta
-
-from ..term import codes as tc
-from .standard import StandardLogFormatter
-
-
-##
-
-
-class ColorLogFormatter(StandardLogFormatter):
-    LEVEL_COLORS: ta.Mapping[int, tc.SGRs.FG] = {
-        logging.WARNING: tc.SGRs.FG.BRIGHT_YELLOW,
-        logging.ERROR: tc.SGRs.FG.BRIGHT_RED,
-        logging.CRITICAL: tc.SGRs.FG.BRIGHT_RED,
-    }
-
-    def formatMessage(self, record):
-        buf = super().formatMessage(record)
-        try:
-            c = self.LEVEL_COLORS[record.levelno]
-        except KeyError:
-            pass
-        else:
-            buf = tc.SGR(c) + buf + tc.SGR(tc.SGRs.RESET)
-        return buf

omlish/logs/configs.py

@@ -1,29 +0,0 @@
-# ruff: noqa: UP006 UP045
-# @omlish-lite
-"""
-https://docs.python.org/3/howto/logging.html#configuring-logging
-https://docs.python.org/3/library/logging.config.html#logging-config-dictschema
-"""
-import dataclasses as dc
-import typing as ta
-
-
-FilterConfig = ta.Dict[str, ta.Any]  # ta.TypeAlias
-FormatterConfig = ta.Dict[str, ta.Any]  # ta.TypeAlias
-HandlerConfig = ta.Dict[str, ta.Any]  # ta.TypeAlias
-LoggerConfig = ta.Dict[str, ta.Any]  # ta.TypeAlias
-
-
-##
-
-
-@dc.dataclass()
-class DictConfig:
-    version: int = 1
-    incremental: bool = False
-    disable_existing_loggers: bool = False
-    filters: ta.Dict[str, FilterConfig] = dc.field(default_factory=dict)
-    formatters: ta.Dict[str, FormatterConfig] = dc.field(default_factory=dict)
-    handlers: ta.Dict[str, HandlerConfig] = dc.field(default_factory=dict)
-    loggers: ta.Dict[str, LoggerConfig] = dc.field(default_factory=dict)
-    root: ta.Optional[LoggerConfig] = None