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

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev423'
-__revision__ = 'ab3e661e1a48e3d4bb4bacfd9112d4ce25b3359b'
+__version__ = '0.0.0.dev425'
+__revision__ = '92376f181ba36a2d1eda16643d70fd1077e309f1'
 
 
 #
@@ -175,7 +175,7 @@ class SetuptoolsBase:
             '*.g4',
             '*.h',
 
-            '.manifests.json',
+            '.omlish-manifests.json',
 
             'LICENSE',
             'LICENSE.txt',

omlish/dataclasses/impl/configs.py

@@ -24,7 +24,8 @@ def init_package(
         *,
         codegen: bool = False,
 ) -> None:
-    pass
+    if init_globals['__name__'] != init_globals['__package__']:
+        raise NameError('Must call dataclasses.init_package from __init__')
 
 
 ##

omlish/formats/json/stream/lexing.py

@@ -117,9 +117,11 @@ class JsonStreamLexer(GenMachine[str, Token]):
             *,
             include_raw: bool = False,
             include_space: bool = False,
+            allow_comments: bool = False,
     ) -> None:
         self._include_raw = include_raw
         self._include_space = include_space
+        self._allow_comments = allow_comments
 
         self._ofs = 0
         self._line = 1
@@ -200,6 +202,9 @@ class JsonStreamLexer(GenMachine[str, Token]):
             if c in 'tfnIN':
                 return self._do_const(c)
 
+            if self._allow_comments and c == '/':
+                return self._do_comment()
+
             self._raise(f'Unexpected character: {c}')
 
     def _do_string(self):
@@ -321,3 +326,6 @@ class JsonStreamLexer(GenMachine[str, Token]):
         yield self._make_tok(tk, tv, raw, pos)
 
         return self._do_main()
+
+    def _do_comment(self):
+        raise NotImplementedError

omlish/formats/json/stream/utils.py

@@ -15,6 +15,8 @@ class JsonStreamValueParser(lang.ExitStacked):
     include_raw: bool = False
     yield_object_lists: bool = False
 
+    json5: bool = False
+
     #
 
     _lex: JsonStreamLexer = dc.field(init=False)
@@ -24,6 +26,7 @@ class JsonStreamValueParser(lang.ExitStacked):
     def _enter_contexts(self) -> None:
         self._lex = JsonStreamLexer(
             include_raw=self.include_raw,
+            allow_comments=self.json5,
         )
 
         self._parse = JsonStreamParser()

omlish/formats/json5/streams.py

@@ -0,0 +1,22 @@
+"""
+TODO:
+
+Objects:
+ - Object keys may be an ECMAScript 5.1 IdentifierName.
+ - Objects may have a single trailing comma.
+Arrays:
+ - Arrays may have a single trailing comma.
+Strings:
+ - Strings may be single quoted.
+ - Strings may span multiple lines by escaping new line characters.
+ - Strings may include character escapes.
+Numbers:
+ - Numbers may be hexadecimal.
+ - Numbers may have a leading or trailing decimal point.
+ - Numbers may be IEEE 754 positive infinity, negative infinity, and NaN.
+ - Numbers may begin with an explicit plus sign.
+Comments:
+ - Single and multi-line comments are allowed.
+White Space:
+ - Additional white space characters are allowed.
+"""

omlish/lang/__init__.py

@@ -9,6 +9,8 @@ with _auto_proxy_init(
     ##
 
     from .asyncs import (  # noqa
+        as_async,
+
         async_list,
 
         sync_await,
@@ -216,7 +218,6 @@ with _auto_proxy_init(
 
     from .functions import (  # noqa
         VoidError,
-        as_async,
         call_with,
         coalesce,
         cond_kw,
@@ -306,6 +307,7 @@ with _auto_proxy_init(
     )
 
     from .lazyglobals import (  # noqa
+        AmbiguousLazyGlobalsFallbackError,
         LazyGlobals,
     )
 

omlish/lang/asyncs.py

@@ -1,7 +1,19 @@
+import functools
 import typing as ta
 
 
 T = ta.TypeVar('T')
+P = ta.ParamSpec('P')
+
+
+##
+
+
+def as_async(fn: ta.Callable[P, T], *, wrap: bool = False) -> ta.Callable[P, ta.Awaitable[T]]:
+    async def inner(*args, **kwargs):
+        return fn(*args, **kwargs)
+
+    return functools.wraps(fn)(inner) if wrap else inner
 
 
 ##

omlish/lang/functions.py

@@ -167,17 +167,6 @@ def void(*args: ta.Any, **kwargs: ta.Any) -> ta.NoReturn:
 ##
 
 
-def as_async(fn: ta.Callable[P, T]) -> ta.Callable[P, ta.Awaitable[T]]:
-    @functools.wraps(fn)
-    async def inner(*args, **kwargs):
-        return fn(*args, **kwargs)
-
-    return inner
-
-
-##
-
-
 _MISSING = object()
 
 

omlish/lang/lazyglobals.py

@@ -4,6 +4,17 @@ import typing as ta
 ##
 
 
+class AmbiguousLazyGlobalsFallbackError(Exception):
+    def __init__(self, attr: str, fallbacks: list[ta.Callable[[str], ta.Any]]) -> None:
+        super().__init__()
+
+        self.attr = attr
+        self.fallbacks = fallbacks
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({self.attr!r}, {self.fallbacks!r})'
+
+
 class LazyGlobals:
     def __init__(
             self,
@@ -17,6 +28,7 @@ class LazyGlobals:
         self._update_globals = update_globals
 
         self._attr_fns: dict[str, ta.Callable[[], ta.Any]] = {}
+        self._fallback_fns: list[ta.Callable[[str], ta.Callable[[], ta.Any]]] = []
 
     @classmethod
     def install(cls, globals: ta.MutableMapping[str, ta.Any]) -> 'LazyGlobals':  # noqa
@@ -42,13 +54,23 @@ class LazyGlobals:
         self._attr_fns[attr] = fn
         return self
 
+    def add_fallback_fn(self, fn: ta.Callable[[str], ta.Callable[[], ta.Any]]) -> 'LazyGlobals':
+        self._fallback_fns.append(fn)
+        return self
+
     def get(self, attr: str) -> ta.Any:
-        try:
-            fn = self._attr_fns[attr]
-        except KeyError:
-            raise AttributeError(attr) from None
+        val: ta.Any
 
-        val = fn()
+        if (attr_fn := self._attr_fns.get(attr)) is not None:
+            val = attr_fn()
+
+        elif (fallbacks := [(fb_fn, fb_fn(attr)) for fb_fn in self._fallback_fns]):
+            if len(fallbacks) > 1:
+                raise AmbiguousLazyGlobalsFallbackError(attr, [fb_fn for fb_fn, _ in fallbacks])
+            [val] = fallbacks
+
+        else:
+            raise AttributeError(attr)
 
         if self._update_globals and self._globals is not None:
             self._globals[attr] = val

omlish/lang/maysync.py

@@ -3,7 +3,7 @@ import typing as ta
 from ..lite.maysync import MaysyncFn
 from ..lite.maysync import MaysyncGeneratorFn
 from ..lite.maysync import make_maysync as _make_maysync
-from .functions import as_async
+from .asyncs import as_async
 
 
 T = ta.TypeVar('T')
@@ -68,5 +68,5 @@ def make_maysync_from_sync(
 ) -> ta.Callable[P, ta.Awaitable[T]]:
     return _make_maysync(
         s,
-        a if a is not None else as_async(s),
+        a if a is not None else as_async(s, wrap=True),
     )

omlish/lifecycles/contextmanagers.py

@@ -2,7 +2,6 @@ import types
 import typing as ta
 
 from .. import dataclasses as dc
-from .. import defs
 from .. import lang
 from .base import Lifecycle
 from .controller import LifecycleController
@@ -37,7 +36,7 @@ class LifecycleContextManager(ta.Generic[LifecycleT]):
         self._lifecycle = lifecycle
         self._controller = lifecycle if isinstance(lifecycle, LifecycleController) else LifecycleController(lifecycle)
 
-    defs.repr('lifecycle', 'state')
+    __repr__ = lang.AttrRepr(['lifecycle', 'state'])
 
     @property
     def lifecycle(self) -> LifecycleT:

omlish/lifecycles/controller.py

@@ -2,7 +2,6 @@ import abc
 import typing as ta
 
 from .. import check
-from .. import defs
 from .. import lang
 from .base import AnyLifecycle  # noqa
 from .base import Lifecycle  # noqa
@@ -48,7 +47,7 @@ class AnyLifecycleController(AnyLifecycle[R], lang.Abstract, ta.Generic[AnyLifec
         self._state = LifecycleStates.NEW
         self._listeners: list[AnyLifecycleListener[AnyLifecycleT, R]] = []
 
-    defs.repr('lifecycle', 'state')
+    __repr__ = lang.AttrRepr(['lifecycle', 'state'])
 
     @property
     def lifecycle(self) -> AnyLifecycleT:

omlish/lite/asyncs.py

@@ -0,0 +1,15 @@
+import functools
+import typing as ta
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+def as_async(fn: ta.Callable[..., T], *, wrap: bool = False) -> ta.Callable[..., ta.Awaitable[T]]:
+    async def inner(*args, **kwargs):
+        return fn(*args, **kwargs)
+
+    return functools.wraps(fn)(inner) if wrap else inner

omlish/lite/timing.py

@@ -1,5 +1,5 @@
-from ..logs.timing import LogTimingContext
-from ..logs.timing import log_timing_context
+from ..logs.utils import LogTimingContext
+from ..logs.utils import log_timing_context
 from .logs import log
 
 

omlish/logs/all.py

@@ -5,64 +5,53 @@ from .. import lang as _lang
 with _lang.auto_proxy_init(globals()):
     ##
 
-    from .callers import (  # noqa
-        LoggingCaller,
-    )
-
-    from .color import (  # noqa
-        ColorLogFormatter,
+    from .std.filters import (  # noqa
+        TidLoggingFilter,
     )
 
-    from .filters import (  # noqa
-        TidLogFilter,
+    from .std.handlers import (  # noqa
+        ListLoggingHandler,
     )
 
-    from .handlers import (  # noqa
-        ListHandler,
+    from .std.json import (  # noqa
+        JsonLoggingFormatter,
     )
 
-    from .json import (  # noqa
-        JsonLogFormatter,
+    from .std.noisy import (  # noqa
+        silence_noisy_loggers,
     )
 
-    from .levels import (  # noqa
-        LogLevel,
+    from .std.proxy import (  # noqa
+        ProxyLoggingFilterer,
+        ProxyLoggingHandler,
     )
 
-    from .noisy import (  # noqa
-        silence_noisy_loggers,
+    from .callers import (  # noqa
+        LoggingCaller,
     )
 
-    from .protocol import (  # noqa
-        AnyLogging,
-        Logging,
-        AsyncLogging,
-
-        AnyAbstractLogging,
-        AbstractLogging,
-        AbstractAsyncLogging,
-
-        AnyNopLogging,
-        NopLogging,
-        NopAsyncLogging,
+    from .levels import (  # noqa
+        LogLevel,
 
-        StdlibLogging,
+        NamedLogLevel,
     )
 
-    from .proxy import (  # noqa
-        ProxyLogFilterer,
-        ProxyLogHandler,
+    from .protocols import (  # noqa
+        LoggerLike,
     )
 
     from .standard import (  # noqa
         STANDARD_LOG_FORMAT_PARTS,
-        StandardLogFormatter,
+        StandardLoggingFormatter,
 
-        StandardConfiguredLogHandler,
+        StandardConfiguredLoggingHandler,
 
         configure_standard_logging,
     )
 
     from .utils import (  # noqa
+        LogTimingContext,
+        log_timing_context,
+
         error_logging,
     )

omlish/logs/base.py

@@ -0,0 +1,248 @@
+# ruff: noqa: UP006 UP007 UP045 UP046
+# @omlish-lite
+import abc
+import sys
+import time
+import types
+import typing as ta
+
+from ..lite.abstract import Abstract
+from .callers import LoggingCaller
+from .infos import LoggingAsyncioTaskInfo
+from .infos import LoggingMultiprocessingInfo
+from .infos import LoggingProcessInfo
+from .infos import LoggingSourceFileInfo
+from .infos import LoggingThreadInfo
+from .levels import NamedLogLevel
+from .times import LoggingTimeFields
+
+
+T = ta.TypeVar('T')
+
+
+LogLevel = int  # ta.TypeAlias
+
+LoggingExcInfoTuple = ta.Tuple[ta.Type[BaseException], BaseException, ta.Optional[types.TracebackType]]  # ta.TypeAlias
+LoggingExcInfo = ta.Union[BaseException, LoggingExcInfoTuple]  # ta.TypeAlias
+LoggingExcInfoArg = ta.Union[LoggingExcInfo, bool, None]  # ta.TypeAlias
+
+
+##
+
+
+@ta.final
+class LoggingContext:
+    level: NamedLogLevel
+
+    time_ns: int
+
+    exc_info: ta.Optional[LoggingExcInfo] = None
+    exc_info_tuple: ta.Optional[LoggingExcInfoTuple] = None
+
+    @ta.final
+    class NOT_SET:  # noqa
+        def __new__(cls, *args, **kwargs):  # noqa
+            raise TypeError
+
+    #
+
+    def __init__(
+            self,
+            level: LogLevel,
+            *,
+            time_ns: ta.Optional[int] = None,
+
+            exc_info: LoggingExcInfoArg = False,
+
+            caller: ta.Union[LoggingCaller, ta.Type[NOT_SET], None] = NOT_SET,
+            stack_offset: int = 0,
+            stack_info: bool = False,
+    ) -> None:
+        self.level = level if level.__class__ is NamedLogLevel else NamedLogLevel(level)  # type: ignore[assignment]
+
+        #
+
+        if time_ns is None:
+            time_ns = time.time_ns()
+        self.time_ns: int = time_ns
+
+        #
+
+        if exc_info is True:
+            sys_exc_info = sys.exc_info()
+            if sys_exc_info[0] is not None:
+                exc_info = sys_exc_info
+            else:
+                exc_info = None
+        elif exc_info is False:
+            exc_info = None
+
+        if exc_info is not None:
+            self.exc_info = exc_info
+            if isinstance(exc_info, BaseException):
+                self.exc_info_tuple = (type(exc_info), exc_info, exc_info.__traceback__)
+            else:
+                self.exc_info_tuple = exc_info
+
+        #
+
+        if caller is not LoggingContext.NOT_SET:
+            self._caller = caller  # type: ignore[assignment]
+        else:
+            self._stack_offset = stack_offset
+            self._stack_info = stack_info
+
+        #
+
+        self.thread = LoggingThreadInfo.build()
+        self.process = LoggingProcessInfo.build()
+        self.multiprocessing = LoggingMultiprocessingInfo.build()
+        self.asyncio_task = LoggingAsyncioTaskInfo.build()
+
+    #
+
+    _times: LoggingTimeFields
+
+    @property
+    def times(self) -> LoggingTimeFields:
+        try:
+            return self._times
+        except AttributeError:
+            pass
+
+        times = self._times = LoggingTimeFields.build(self.time_ns)
+        return times
+
+    #
+
+    def inc_stack_offset(self, ofs: int = 1) -> 'LoggingContext':
+        if hasattr(self, '_stack_offset'):
+            self._stack_offset += ofs
+        return self
+
+    _caller: ta.Optional[LoggingCaller]
+
+    def build_caller(self) -> ta.Optional[LoggingCaller]:
+        """Must be cooperatively called only from the exact configured _stack_offset."""
+
+        try:
+            return self._caller
+        except AttributeError:
+            pass
+
+        caller = self._caller = LoggingCaller.find(
+            self._stack_offset + 1,
+            stack_info=self._stack_info,
+        )
+        return caller
+
+    def caller(self) -> ta.Optional[LoggingCaller]:
+        try:
+            return self._caller
+        except AttributeError:
+            return None
+
+    _source_file: ta.Optional[LoggingSourceFileInfo]
+
+    def source_file(self) -> ta.Optional[LoggingSourceFileInfo]:
+        try:
+            return self._source_file
+        except AttributeError:
+            pass
+
+        if (caller := self.caller()) is None:
+            return None
+
+        src_file = self._source_file = LoggingSourceFileInfo.build(caller.file_path)
+        return src_file
+
+
+##
+
+
+class AnyLogger(Abstract, ta.Generic[T]):
+    def is_enabled_for(self, level: LogLevel) -> bool:
+        return self.get_effective_level() >= level
+
+    @abc.abstractmethod
+    def get_effective_level(self) -> LogLevel:
+        raise NotImplementedError
+
+    #
+
+    @ta.final
+    def isEnabledFor(self, level: LogLevel) -> bool:  # noqa
+        return self.is_enabled_for(level)
+
+    @ta.final
+    def getEffectiveLevel(self) -> LogLevel:  # noqa
+        return self.get_effective_level()
+
+    #
+
+    @ta.final
+    def debug(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> T:
+        return self._log(LoggingContext(NamedLogLevel.DEBUG, stack_offset=1), msg, *args, **kwargs)
+
+    @ta.final
+    def info(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> T:
+        return self._log(LoggingContext(NamedLogLevel.INFO, stack_offset=1), msg, *args, **kwargs)
+
+    @ta.final
+    def warning(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> T:
+        return self._log(LoggingContext(NamedLogLevel.WARNING, stack_offset=1), msg, *args, **kwargs)
+
+    @ta.final
+    def error(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> T:
+        return self._log(LoggingContext(NamedLogLevel.ERROR, stack_offset=1), msg, *args, **kwargs)
+
+    @ta.final
+    def exception(self, msg: str, *args: ta.Any, exc_info: LoggingExcInfoArg = True, **kwargs: ta.Any) -> T:
+        return self._log(LoggingContext(NamedLogLevel.ERROR, exc_info=exc_info, stack_offset=1), msg, *args, **kwargs)
+
+    @ta.final
+    def critical(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> T:
+        return self._log(LoggingContext(NamedLogLevel.CRITICAL, stack_offset=1), msg, *args, **kwargs)
+
+    @ta.final
+    def log(self, level: LogLevel, msg: str, *args: ta.Any, **kwargs: ta.Any) -> T:
+        return self._log(LoggingContext(level, stack_offset=1), msg, *args, **kwargs)
+
+    #
+
+    @abc.abstractmethod
+    def _log(self, ctx: LoggingContext, msg: str, *args: ta.Any, **kwargs: ta.Any) -> T:
+        raise NotImplementedError
+
+
+class Logger(AnyLogger[None], Abstract):
+    @abc.abstractmethod
+    def _log(self, ctx: LoggingContext, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None:
+        raise NotImplementedError
+
+
+class AsyncLogger(AnyLogger[ta.Awaitable[None]], Abstract):
+    @abc.abstractmethod
+    def _log(self, ctx: LoggingContext, msg: str, *args: ta.Any, **kwargs: ta.Any) -> ta.Awaitable[None]:
+        raise NotImplementedError
+
+
+##
+
+
+class AnyNopLogger(AnyLogger[T], Abstract):
+    @ta.final
+    def get_effective_level(self) -> LogLevel:
+        return 999
+
+
+@ta.final
+class NopLogger(AnyNopLogger[None], Logger):
+    def _log(self, ctx: LoggingContext, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None:
+        pass
+
+
+@ta.final
+class AsyncNopLogger(AnyNopLogger[ta.Awaitable[None]], AsyncLogger):
+    async def _log(self, ctx: LoggingContext, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None:
+        pass