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

omlish/logs/protocol.py

@@ -1,218 +0,0 @@
-# ruff: noqa: UP006 UP007 UP045
-# @omlish-lite
-import abc
-import logging
-import sys
-import typing as ta
-
-from .callers import LoggingCaller
-from .levels import LogLevel
-
-
-T = ta.TypeVar('T')
-T_co = ta.TypeVar('T_co', covariant=True)
-
-
-##
-
-
-class AnyLogging(ta.Protocol[T_co]):
-    def isEnabledFor(self, level: LogLevel) -> bool: ...  # noqa
-
-    def getEffectiveLevel(self) -> LogLevel: ...  # noqa
-
-    #
-
-    def debug(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> T_co: ...
-
-    def info(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> T_co: ...
-
-    def warning(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> T_co: ...
-
-    def error(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> T_co: ...
-
-    def exception(self, msg: str, *args: ta.Any, exc_info: bool = True, **kwargs: ta.Any) -> T_co: ...
-
-    def critical(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> T_co: ...
-
-    def log(self, level: LogLevel, msg: str, *args: ta.Any, **kwargs: ta.Any) -> T_co: ...
-
-
-class Logging(AnyLogging[None], ta.Protocol):
-    pass
-
-
-class AsyncLogging(AnyLogging[ta.Awaitable[None]], ta.Protocol):
-    pass
-
-
-##
-
-
-class AnyAbstractLogging(abc.ABC, ta.Generic[T]):
-    @ta.final
-    def isEnabledFor(self, level: LogLevel) -> bool:  # noqa
-        return self.is_enabled_for(level)
-
-    def is_enabled_for(self, level: LogLevel) -> bool:  # noqa
-        return level >= self.getEffectiveLevel()
-
-    @ta.final
-    def getEffectiveLevel(self) -> LogLevel:  # noqa
-        return self.get_effective_level()
-
-    @abc.abstractmethod
-    def get_effective_level(self) -> LogLevel:  # noqa
-        raise NotImplementedError
-
-    #
-
-    def debug(self, msg: str, *args: ta.Any, _logging_stack_offset: int = 0, **kwargs: ta.Any) -> T:
-        return self.log(logging.DEBUG, msg, *args, _logging_stack_offset=_logging_stack_offset + 1, **kwargs)
-
-    def info(self, msg: str, *args: ta.Any, _logging_stack_offset: int = 0, **kwargs: ta.Any) -> T:
-        return self.log(logging.INFO, msg, *args, _logging_stack_offset=_logging_stack_offset + 1, **kwargs)
-
-    def warning(self, msg: str, *args: ta.Any, _logging_stack_offset: int = 0, **kwargs: ta.Any) -> T:
-        return self.log(logging.WARNING, msg, *args, _logging_stack_offset=_logging_stack_offset + 1, **kwargs)
-
-    def error(self, msg: str, *args: ta.Any, _logging_stack_offset: int = 0, **kwargs: ta.Any) -> T:
-        return self.log(logging.ERROR, msg, *args, _logging_stack_offset=_logging_stack_offset + 1, **kwargs)
-
-    def exception(self, msg: str, *args: ta.Any, exc_info: bool = True, _logging_stack_offset: int = 0, **kwargs: ta.Any) -> T:  # noqa
-        return self.error(msg, *args, exc_info=exc_info, _logging_stack_offset=_logging_stack_offset + 1, **kwargs)  # noqa
-
-    def critical(self, msg: str, *args: ta.Any, _logging_stack_offset: int = 0, **kwargs: ta.Any) -> T:
-        return self.log(logging.CRITICAL, msg, *args, _logging_stack_offset=_logging_stack_offset + 1, **kwargs)
-
-    @abc.abstractmethod
-    def log(
-            self,
-            level: int,
-            msg: str,
-            *args: ta.Any,
-            exc_info: ta.Any = None,
-            extra: ta.Any = None,
-            stack_info: bool = False,
-            _logging_stack_offset: int = 0,
-    ) -> T:
-        raise NotImplementedError
-
-
-class AbstractLogging(AnyAbstractLogging[None], abc.ABC):
-    def log(self, level: LogLevel, msg: str, *args: ta.Any, _logging_stack_offset: int = 0, **kwargs: ta.Any) -> None:
-        if not isinstance(level, int):
-            raise TypeError('Level must be an integer.')
-        if self.is_enabled_for(level):
-            self._log(level, msg, args, _logging_stack_offset=_logging_stack_offset + 1, **kwargs)
-
-    @abc.abstractmethod
-    def _log(
-            self,
-            level: int,
-            msg: str,
-            args: ta.Any,
-            *,
-            exc_info: ta.Any = None,
-            extra: ta.Any = None,
-            stack_info: bool = False,
-            _logging_stack_offset: int = 0,
-    ) -> None:
-        raise NotImplementedError
-
-
-class AbstractAsyncLogging(AnyAbstractLogging[ta.Awaitable[None]], abc.ABC):
-    async def log(self, level: LogLevel, msg: str, *args: ta.Any, _logging_stack_offset: int = 0, **kwargs: ta.Any) -> None:  # noqa
-        if not isinstance(level, int):
-            raise TypeError('Level must be an integer.')
-        if self.is_enabled_for(level):
-            await self._log(level, msg, args, _logging_stack_offset=_logging_stack_offset + 1, **kwargs)
-
-    @abc.abstractmethod
-    def _log(
-            self,
-            level: int,
-            msg: str,
-            args: ta.Any,
-            *,
-            exc_info: ta.Any = None,
-            extra: ta.Any = None,
-            stack_info: bool = False,
-            _logging_stack_offset: int = 0,
-    ) -> ta.Awaitable[None]:
-        raise NotImplementedError
-
-
-##
-
-
-class AnyNopLogging(AnyAbstractLogging[T], abc.ABC):
-    def get_effective_level(self) -> LogLevel:
-        return logging.CRITICAL + 1
-
-
-class NopLogging(AnyNopLogging[None], AbstractLogging):
-    def _log(self, *args: ta.Any, **kwargs: ta.Any) -> None:
-        pass
-
-
-class NopAsyncLogging(AnyNopLogging[ta.Awaitable[None]], AbstractAsyncLogging):
-    async def _log(self, *args: ta.Any, **kwargs: ta.Any) -> None:
-        pass
-
-
-##
-
-
-class StdlibLogging(AbstractLogging):
-    def __init__(self, underlying: logging.Logger) -> None:
-        super().__init__()
-
-        if not isinstance(underlying, logging.Logger):
-            raise TypeError(underlying)
-
-        self._underlying = underlying
-
-    #
-
-    def is_enabled_for(self, level: int) -> bool:  # noqa
-        return self._underlying.isEnabledFor(level)
-
-    def get_effective_level(self) -> int:  # noqa
-        return self._underlying.getEffectiveLevel()
-
-    #
-
-    def _log(
-            self,
-            level: int,
-            msg: str,
-            args: ta.Any,
-            *,
-            exc_info: ta.Any = None,
-            extra: ta.Any = None,
-            stack_info: bool = False,
-            _logging_stack_offset: int = 0,
-    ) -> None:
-        caller = LoggingCaller.find(_logging_stack_offset, stack_info=stack_info)
-
-        if exc_info:
-            if isinstance(exc_info, BaseException):
-                exc_info = (type(exc_info), exc_info, exc_info.__traceback__)
-            elif not isinstance(exc_info, tuple):
-                exc_info = sys.exc_info()
-
-        record = self._underlying.makeRecord(
-            name=self._underlying.name,
-            level=level,
-            fn=caller.filename,
-            lno=caller.lineno,
-            msg=msg,
-            args=args,
-            exc_info=exc_info,
-            func=caller.func,
-            extra=extra,
-            sinfo=caller.sinfo,
-        )
-
-        self._underlying.handle(record)

omlish/logs/timing.py

@@ -1,58 +0,0 @@
-# ruff: noqa: UP006 UP007 UP045
-# @omlish-lite
-import logging
-import time
-import typing as ta
-
-
-##
-
-
-class LogTimingContext:
-    DEFAULT_LOG: ta.ClassVar[ta.Optional[logging.Logger]] = None
-
-    class _NOT_SPECIFIED:  # noqa
-        def __new__(cls, *args, **kwargs):  # noqa
-            raise TypeError
-
-    def __init__(
-            self,
-            description: str,
-            *,
-            log: ta.Union[logging.Logger, ta.Type[_NOT_SPECIFIED], None] = _NOT_SPECIFIED,  # noqa
-            level: int = logging.DEBUG,
-    ) -> None:
-        super().__init__()
-
-        self._description = description
-        if log is self._NOT_SPECIFIED:
-            log = self.DEFAULT_LOG  # noqa
-        self._log: ta.Optional[logging.Logger] = log  # type: ignore
-        self._level = level
-
-    def set_description(self, description: str) -> 'LogTimingContext':
-        self._description = description
-        return self
-
-    _begin_time: float
-    _end_time: float
-
-    def __enter__(self) -> 'LogTimingContext':
-        self._begin_time = time.time()
-
-        if self._log is not None:
-            self._log.log(self._level, f'Begin : {self._description}')  # noqa
-
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        self._end_time = time.time()
-
-        if self._log is not None:
-            self._log.log(
-                self._level,
-                f'End : {self._description} - {self._end_time - self._begin_time:0.2f} s elapsed',
-            )
-
-
-log_timing_context = LogTimingContext

omlish/marshal/factories/match.py

@@ -1,34 +0,0 @@
-from ... import lang
-from ... import reflect as rfl
-from ...funcs import match as mfs
-from ..base.contexts import MarshalContext
-from ..base.contexts import UnmarshalContext
-from ..base.types import Marshaler
-from ..base.types import MarshalerFactory
-from ..base.types import MarshalerMaker
-from ..base.types import Unmarshaler
-from ..base.types import UnmarshalerFactory
-from ..base.types import UnmarshalerMaker
-
-
-##
-
-
-class MarshalerFactoryMatchClass(
-    MarshalerFactory,
-    mfs.MatchFnClass[[MarshalContext, rfl.Type], Marshaler],
-    lang.Abstract,
-):
-    @property
-    def make_marshaler(self) -> MarshalerMaker:
-        return self  # noqa
-
-
-class UnmarshalerFactoryMatchClass(
-    UnmarshalerFactory,
-    mfs.MatchFnClass[[UnmarshalContext, rfl.Type], Unmarshaler],
-    lang.Abstract,
-):
-    @property
-    def make_unmarshaler(self) -> UnmarshalerMaker:
-        return self  # noqa

omlish/marshal/factories/simple.py

@@ -1,28 +0,0 @@
-from ... import lang
-from ..base.types import MarshalerFactory
-from ..base.types import MarshalerMaker
-from ..base.types import UnmarshalerFactory
-from ..base.types import UnmarshalerMaker
-
-
-##
-
-
-class SimpleMarshalerFactory(
-    MarshalerFactory,
-    MarshalerMaker,
-    lang.Abstract,
-):
-    @property
-    def make_marshaler(self) -> MarshalerMaker:
-        return self  # noqa
-
-
-class SimpleUnmarshalerFactory(
-    UnmarshalerFactory,
-    UnmarshalerMaker,
-    lang.Abstract,
-):
-    @property
-    def make_unmarshaler(self) -> UnmarshalerMaker:
-        return self  # noqa

omlish/specs/irc/messages/base.py

@@ -1,49 +0,0 @@
-import typing as ta
-
-from .... import check
-from .... import dataclasses as dc
-from ....funcs import pairs as fps
-from ..numerics import numerics as nr
-from .formats import MessageFormat
-from .formats import MessageParamsUnpacker
-
-
-##
-
-
-class Message(dc.Case):
-    FORMAT: ta.ClassVar[MessageFormat]
-    REPLIES: ta.ClassVar[ta.Collection[nr.NumericReply]] = ()
-
-
-##
-
-
-def list_pair_params_unpacker(
-        kwarg: str,
-        key_param: str,
-        value_param: str,
-) -> MessageParamsUnpacker:
-    def forward(params: ta.Mapping[str, str]) -> ta.Mapping[str, ta.Any]:
-        out: dict = dict(params)
-        ks = out.pop(key_param)
-        vs = out.pop(value_param, None)
-        if vs is not None:
-            out[kwarg] = list(zip(ks, vs, strict=True))
-        else:
-            out[kwarg] = ks
-        return out
-
-    def backward(kwargs: ta.Mapping[str, ta.Any]) -> ta.Mapping[str, str]:
-        out: dict = dict(kwargs)
-        ts = out.pop(kwarg)
-        is_ts = check.single({isinstance(e, tuple) for e in ts})
-        if is_ts:
-            ks, vs = zip(*ts)
-            out[key_param] = ks
-            out[value_param] = vs
-        else:
-            out[key_param] = ts
-        return out
-
-    return fps.of(forward, backward)

omlish/specs/irc/messages/formats.py

@@ -1,92 +0,0 @@
-import enum
-import typing as ta
-
-from .... import check
-from .... import dataclasses as dc
-from .... import lang
-from ....funcs import pairs as fps
-
-
-MessageParamsUnpacker: ta.TypeAlias = fps.FnPair[
-    ta.Mapping[str, str],  # params
-    ta.Mapping[str, ta.Any],  # kwargs
-]
-
-
-##
-
-
-class MessageFormat(dc.Frozen, final=True):
-    name: str
-
-    class Param(dc.Case):
-        @classmethod
-        def of(cls, obj: ta.Any) -> 'MessageFormat.Param':
-            if isinstance(obj, MessageFormat.Param):
-                return obj
-
-            elif isinstance(obj, str):
-                s = check.non_empty_str(obj)
-
-                optional = False
-                if s.startswith('?'):
-                    optional = True
-                    s = s[1:]
-
-                arity = MessageFormat.KwargParam.Arity.SINGLE
-                if s.startswith('*'):
-                    arity = MessageFormat.KwargParam.Arity.VARIADIC
-                    s = s[1:]
-
-                elif s.startswith(','):
-                    arity = MessageFormat.KwargParam.Arity.COMMA_LIST
-                    s = s[1:]
-
-                return MessageFormat.KwargParam(
-                    s,
-                    optional=optional,
-                    arity=arity,
-                )
-
-            else:
-                raise TypeError(obj)
-
-    class KwargParam(Param):
-        name: str = dc.xfield(validate=lang.is_ident)
-
-        optional: bool = False
-
-        class Arity(enum.Enum):
-            SINGLE = enum.auto()  # <foo>
-            VARIADIC = enum.auto()  # <foo>{ <foo>}
-            COMMA_LIST = enum.auto()  # <foo>{,<foo>}
-
-        arity: Arity = Arity.SINGLE
-
-    class LiteralParam(Param):
-        text: str
-
-    params: ta.Sequence[Param]
-
-    _: dc.KW_ONLY
-
-    unpack_params: MessageParamsUnpacker | None = None
-
-    @dc.init
-    def _validate_params(self) -> None:
-        kws = [p for p in self.params if isinstance(p, MessageFormat.KwargParam)]
-        check.unique(p.name for p in kws)
-        check.state(all(p.arity is not MessageFormat.KwargParam.Arity.VARIADIC for p in kws[:-1]))
-
-    @classmethod
-    def of(
-            cls,
-            name: str,
-            *params: ta.Any,
-            **kwargs: ta.Any,
-    ) -> 'MessageFormat':
-        return cls(
-            name,
-            [MessageFormat.Param.of(p) for p in params],
-            **kwargs,
-        )