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

omlish/logs/contexts.py

@@ -0,0 +1,276 @@
+# 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 LogLevel
+from .levels import NamedLogLevel
+from .times import LoggingTimeFields
+
+
+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
+
+
+##
+
+
+class LoggingContext(Abstract):
+    @property
+    @abc.abstractmethod
+    def level(self) -> NamedLogLevel:
+        raise NotImplementedError
+
+    #
+
+    @property
+    @abc.abstractmethod
+    def time_ns(self) -> int:
+        raise NotImplementedError
+
+    @property
+    @abc.abstractmethod
+    def times(self) -> LoggingTimeFields:
+        raise NotImplementedError
+
+    #
+
+    @property
+    @abc.abstractmethod
+    def exc_info(self) -> ta.Optional[LoggingExcInfo]:
+        raise NotImplementedError
+
+    @property
+    @abc.abstractmethod
+    def exc_info_tuple(self) -> ta.Optional[LoggingExcInfoTuple]:
+        raise NotImplementedError
+
+    #
+
+    @abc.abstractmethod
+    def caller(self) -> ta.Optional[LoggingCaller]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def source_file(self) -> ta.Optional[LoggingSourceFileInfo]:
+        raise NotImplementedError
+
+    #
+
+    @abc.abstractmethod
+    def thread(self) -> ta.Optional[LoggingThreadInfo]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def process(self) -> ta.Optional[LoggingProcessInfo]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def multiprocessing(self) -> ta.Optional[LoggingMultiprocessingInfo]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def asyncio_task(self) -> ta.Optional[LoggingAsyncioTaskInfo]:
+        raise NotImplementedError
+
+
+##
+
+
+class CaptureLoggingContext(LoggingContext, Abstract):
+    class AlreadyCapturedError(Exception):
+        pass
+
+    class NotCapturedError(Exception):
+        pass
+
+    @abc.abstractmethod
+    def capture(self) -> None:
+        """Must be cooperatively called only from the expected locations."""
+
+        raise NotImplementedError
+
+
+@ta.final
+class CaptureLoggingContextImpl(CaptureLoggingContext):
+    @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: NamedLogLevel = level if level.__class__ is NamedLogLevel else NamedLogLevel(level)  # type: ignore[assignment]  # noqa
+
+        #
+
+        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: ta.Optional[LoggingExcInfo] = exc_info
+            if isinstance(exc_info, BaseException):
+                self._exc_info_tuple: ta.Optional[LoggingExcInfoTuple] = (type(exc_info), exc_info, exc_info.__traceback__)  # noqa
+            else:
+                self._exc_info_tuple = exc_info
+
+        #
+
+        if caller is not CaptureLoggingContextImpl.NOT_SET:
+            self._caller = caller  # type: ignore[assignment]
+        else:
+            self._stack_offset = stack_offset
+            self._stack_info = stack_info
+
+    ##
+
+    @property
+    def level(self) -> NamedLogLevel:
+        return self._level
+
+    #
+
+    @property
+    def time_ns(self) -> int:
+        return self._time_ns
+
+    _times: LoggingTimeFields
+
+    @property
+    def times(self) -> LoggingTimeFields:
+        try:
+            return self._times
+        except AttributeError:
+            pass
+
+        times = self._times = LoggingTimeFields.build(self.time_ns)
+        return times
+
+    #
+
+    _exc_info: ta.Optional[LoggingExcInfo] = None
+    _exc_info_tuple: ta.Optional[LoggingExcInfoTuple] = None
+
+    @property
+    def exc_info(self) -> ta.Optional[LoggingExcInfo]:
+        return self._exc_info
+
+    @property
+    def exc_info_tuple(self) -> ta.Optional[LoggingExcInfoTuple]:
+        return self._exc_info_tuple
+
+    ##
+
+    _stack_offset: int
+    _stack_info: bool
+
+    def inc_stack_offset(self, ofs: int = 1) -> 'CaptureLoggingContext':
+        if hasattr(self, '_stack_offset'):
+            self._stack_offset += ofs
+        return self
+
+    _has_captured: bool = False
+
+    _caller: ta.Optional[LoggingCaller]
+    _source_file: ta.Optional[LoggingSourceFileInfo]
+
+    _thread: ta.Optional[LoggingThreadInfo]
+    _process: ta.Optional[LoggingProcessInfo]
+    _multiprocessing: ta.Optional[LoggingMultiprocessingInfo]
+    _asyncio_task: ta.Optional[LoggingAsyncioTaskInfo]
+
+    def capture(self) -> None:
+        if self._has_captured:
+            raise CaptureLoggingContextImpl.AlreadyCapturedError
+        self._has_captured = True
+
+        if not hasattr(self, '_caller'):
+            self._caller = LoggingCaller.find(
+                self._stack_offset + 1,
+                stack_info=self._stack_info,
+            )
+
+        if (caller := self._caller) is not None:
+            self._source_file = LoggingSourceFileInfo.build(caller.file_path)
+        else:
+            self._source_file = None
+
+        self._thread = LoggingThreadInfo.build()
+        self._process = LoggingProcessInfo.build()
+        self._multiprocessing = LoggingMultiprocessingInfo.build()
+        self._asyncio_task = LoggingAsyncioTaskInfo.build()
+
+    #
+
+    def caller(self) -> ta.Optional[LoggingCaller]:
+        try:
+            return self._caller
+        except AttributeError:
+            raise CaptureLoggingContext.NotCapturedError from None
+
+    def source_file(self) -> ta.Optional[LoggingSourceFileInfo]:
+        try:
+            return self._source_file
+        except AttributeError:
+            raise CaptureLoggingContext.NotCapturedError from None
+
+    #
+
+    def thread(self) -> ta.Optional[LoggingThreadInfo]:
+        try:
+            return self._thread
+        except AttributeError:
+            raise CaptureLoggingContext.NotCapturedError from None
+
+    def process(self) -> ta.Optional[LoggingProcessInfo]:
+        try:
+            return self._process
+        except AttributeError:
+            raise CaptureLoggingContext.NotCapturedError from None
+
+    def multiprocessing(self) -> ta.Optional[LoggingMultiprocessingInfo]:
+        try:
+            return self._multiprocessing
+        except AttributeError:
+            raise CaptureLoggingContext.NotCapturedError from None
+
+    def asyncio_task(self) -> ta.Optional[LoggingAsyncioTaskInfo]:
+        try:
+            return self._asyncio_task
+        except AttributeError:
+            raise CaptureLoggingContext.NotCapturedError from None

omlish/logs/infos.py

@@ -9,8 +9,19 @@ import typing as ta
 ##
 
 
+class _LoggingContextInfo:
+    def __mro_entries__(self, bases):
+        return ()
+
+
+LoggingContextInfo: type = ta.cast(ta.Any, _LoggingContextInfo())
+
+
+##
+
+
 @ta.final
-class LoggingSourceFileInfo(ta.NamedTuple):
+class LoggingSourceFileInfo(LoggingContextInfo, ta.NamedTuple):  # type: ignore[misc]
     file_name: str
     module: str
 
@@ -36,7 +47,7 @@ class LoggingSourceFileInfo(ta.NamedTuple):
 
 
 @ta.final
-class LoggingThreadInfo(ta.NamedTuple):
+class LoggingThreadInfo(LoggingContextInfo, ta.NamedTuple):  # type: ignore[misc]
     ident: int
     native_id: ta.Optional[int]
     name: str
@@ -54,7 +65,7 @@ class LoggingThreadInfo(ta.NamedTuple):
 
 
 @ta.final
-class LoggingProcessInfo(ta.NamedTuple):
+class LoggingProcessInfo(LoggingContextInfo, ta.NamedTuple):  # type: ignore[misc]
     pid: int
 
     @classmethod
@@ -68,7 +79,7 @@ class LoggingProcessInfo(ta.NamedTuple):
 
 
 @ta.final
-class LoggingMultiprocessingInfo(ta.NamedTuple):
+class LoggingMultiprocessingInfo(LoggingContextInfo, ta.NamedTuple):  # type: ignore[misc]
     process_name: str
 
     @classmethod
@@ -86,7 +97,7 @@ class LoggingMultiprocessingInfo(ta.NamedTuple):
 
 
 @ta.final
-class LoggingAsyncioTaskInfo(ta.NamedTuple):
+class LoggingAsyncioTaskInfo(LoggingContextInfo, ta.NamedTuple):  # type: ignore[misc]
     name: str
 
     @classmethod
@@ -100,6 +111,9 @@ class LoggingAsyncioTaskInfo(ta.NamedTuple):
         except Exception:  # noqa
             return None
 
+        if task is None:
+            return None
+
         return cls(
             task.get_name(),  # Always non-None
         )

omlish/logs/modules.py

@@ -2,9 +2,12 @@
 import logging
 import typing as ta
 
+from .base import Logger
+from .std.adapters import StdLogger
+
 
 ##
 
 
-def get_module_logger(mod_globals: ta.Mapping[str, ta.Any]) -> logging.Logger:
-    return logging.getLogger(mod_globals.get('__name__'))
+def get_module_logger(mod_globals: ta.Mapping[str, ta.Any]) -> Logger:
+    return StdLogger(logging.getLogger(mod_globals.get('__name__')))  # noqa

omlish/logs/protocols.py

@@ -16,16 +16,16 @@ class LoggerLike(ta.Protocol):
 
     #
 
-    def debug(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None: ...  # noqa
+    def log(self, level: LogLevel, msg: str, /, *args: ta.Any, **kwargs: ta.Any) -> None: ...  # noqa
 
-    def info(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None: ...  # noqa
+    def debug(self, msg: str, /, *args: ta.Any, **kwargs: ta.Any) -> None: ...  # noqa
 
-    def warning(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None: ...  # noqa
+    def info(self, msg: str, /, *args: ta.Any, **kwargs: ta.Any) -> None: ...  # noqa
 
-    def error(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None: ...  # noqa
+    def warning(self, msg: str, /, *args: ta.Any, **kwargs: ta.Any) -> None: ...  # noqa
 
-    def exception(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None: ...  # noqa
+    def error(self, msg: str, /, *args: ta.Any, **kwargs: ta.Any) -> None: ...  # noqa
 
-    def critical(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None: ...  # noqa
+    def exception(self, msg: str, /, *args: ta.Any, **kwargs: ta.Any) -> None: ...  # noqa
 
-    def log(self, level: LogLevel, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None: ...  # noqa
+    def critical(self, msg: str, /, *args: ta.Any, **kwargs: ta.Any) -> None: ...  # noqa

omlish/logs/std/adapters.py

@@ -1,10 +1,12 @@
+# ruff: noqa: UP007
 # @omlish-lite
 import logging
 import typing as ta
 
 from ..base import Logger
-from ..base import LoggingContext
-from ..base import LogLevel
+from ..base import LoggingMsgFn
+from ..contexts import CaptureLoggingContext
+from ..levels import LogLevel
 from .records import LoggingContextLogRecord
 
 
@@ -24,15 +26,17 @@ class StdLogger(Logger):
     def get_effective_level(self) -> LogLevel:
         return self._std.getEffectiveLevel()
 
-    def _log(self, ctx: LoggingContext, msg: str, *args: ta.Any) -> None:
+    def _log(self, ctx: CaptureLoggingContext, msg: ta.Union[str, tuple, LoggingMsgFn], *args: ta.Any) -> None:
         if not self.is_enabled_for(ctx.level):
             return
 
-        ctx.build_caller()
+        ctx.capture()
+
+        ms, args = self._prepare_msg_args(msg, *args)
 
         rec = LoggingContextLogRecord(
             name=self._std.name,
-            msg=msg,
+            msg=ms,
             args=args,
 
             _logging_context=ctx,

omlish/logs/std/handlers.py

@@ -8,10 +8,12 @@ import typing as ta
 
 
 class ListLoggingHandler(logging.Handler):
-    def __init__(self) -> None:
+    def __init__(self, record_list: ta.Optional[ta.List[logging.LogRecord]] = None) -> None:
         super().__init__()
 
-        self.records: ta.List[logging.LogRecord] = []
+        if record_list is None:
+            record_list = []
+        self.records: ta.List[logging.LogRecord] = record_list
 
     def emit(self, record: logging.LogRecord) -> None:
         self.records.append(record)

omlish/logs/std/records.py

@@ -5,8 +5,9 @@ import logging
 import sys
 import typing as ta
 
-from ..base import LoggingContext
-from ..base import LoggingExcInfoTuple
+from ...lite.check import check
+from ..contexts import LoggingContext
+from ..contexts import LoggingExcInfoTuple
 from ..warnings import LoggingSetupWarning
 
 
@@ -268,19 +269,33 @@ class LoggingContextLogRecord(logging.LogRecord):
         self.msecs: float = times.msecs
         self.relativeCreated: float = times.relative_created
 
-        thread = ctx.thread
-        self.thread: ta.Optional[int] = thread.ident
-        self.threadName: ta.Optional[str] = thread.name
+        if logging.logThreads:
+            thread = check.not_none(ctx.thread())
+            self.thread: ta.Optional[int] = thread.ident
+            self.threadName: ta.Optional[str] = thread.name
+        else:
+            self.thread = None
+            self.threadName = None
 
-        process = ctx.process
-        self.process: ta.Optional[int] = process.pid
+        if logging.logProcesses:
+            process = check.not_none(ctx.process())
+            self.process: ta.Optional[int] = process.pid
+        else:
+            self.process = None
 
-        if (mp := ctx.multiprocessing) is not None:
-            self.processName: ta.Optional[str] = mp.process_name
+        if logging.logMultiprocessing:
+            if (mp := ctx.multiprocessing()) is not None:
+                self.processName: ta.Optional[str] = mp.process_name
+            else:
+                self.processName = None
         else:
             self.processName = None
 
-        if (at := ctx.asyncio_task) is not None:
-            self.taskName: ta.Optional[str] = at.name
+        # Absent <3.12
+        if getattr(logging, 'logAsyncioTasks', None):
+            if (at := ctx.asyncio_task()) is not None:
+                self.taskName: ta.Optional[str] = at.name
+            else:
+                self.taskName = None
         else:
             self.taskName = None

omlish/logs/times.py

@@ -4,13 +4,14 @@ import logging
 import time
 import typing as ta
 
+from .infos import LoggingContextInfo
 from .warnings import LoggingSetupWarning
 
 
 ##
 
 
-class LoggingTimeFields(ta.NamedTuple):
+class LoggingTimeFields(LoggingContextInfo, ta.NamedTuple):  # type: ignore[misc]
     """Maps directly to stdlib `logging.LogRecord` fields, and must be kept in sync with it."""
 
     created: float

omlish/manifests/loading.py

@@ -8,6 +8,12 @@ TODO:
  - TypeMap style weak cache of issubclass queries
   - wait.. lazily load the class for virtual subclass queries? xor support virtual bases?
  - weakref class dict keys?
+ - cheap_discover_package_root_dirs: Seq[str] | None = None or smth
+ - maaaybe.. add an EnvVar? OMLISH_MANIFEST_ROOT_DIRS? if set to : delimited, turns off package disco and overrides
+   scan_root_dirs
+  - currently the cli cant subprocess itself and keep manifests working
+  - EnvVar cls is already lite
+
 """
 import dataclasses as dc
 import importlib.machinery

omlish/secrets/secrets.py

@@ -11,7 +11,6 @@ TODO:
 """
 import abc
 import collections
-import logging
 import os
 import sys
 import time
@@ -21,12 +20,13 @@ import typing as ta
 from .. import dataclasses as dc
 from .. import lang
 from .. import marshal as msh
+from ..logs import all as logs
 
 
 msh.register_global_module_import('.marshal', __package__)
 
 
-log = logging.getLogger(__name__)
+log = logs.get_module_logger(globals())
 
 
 ##
@@ -269,7 +269,7 @@ class LoggingSecrets(Secrets):
             self,
             child: Secrets,
             *,
-            log: logging.Logger | None = None,  # noqa
+            log: logs.LoggerLike | None = None,  # noqa
     ) -> None:
         super().__init__()
 

omlish/sockets/server/handlers.py

@@ -3,11 +3,11 @@
 import abc
 import concurrent.futures as cf
 import dataclasses as dc
-import logging
 import socket
 import typing as ta
 
 from ...lite.abstract import Abstract
+from ...logs.protocols import LoggerLike
 from ..addresses import SocketAndAddress
 from ..handlers import SocketHandler
 from ..io import SocketIoPair
@@ -142,7 +142,7 @@ class ExecutorSocketServerHandler(SocketServerHandler_):
 @dc.dataclass(frozen=True)
 class ExceptionLoggingSocketServerHandler(SocketServerHandler_):
     handler: SocketServerHandler
-    log: logging.Logger
+    log: LoggerLike
 
     ignored: ta.Optional[ta.Container[ta.Type[Exception]]] = None
 

omlish/sockets/server/server.py

@@ -11,6 +11,7 @@ import typing as ta
 from ...lite.abstract import Abstract
 from ...lite.contextmanagers import ExitStacked
 from ...lite.contextmanagers import defer
+from ...logs.protocols import LoggerLike
 from ..addresses import SocketAndAddress
 from ..bind import SocketBinder
 from ..io import close_socket_immediately
@@ -20,7 +21,7 @@ from .handlers import SocketServerHandler
 ##
 
 
-class SocketServer(Abstract):
+class SocketServer:
     _DEFAULT_LOGGER = logging.getLogger('.'.join([__name__, 'SocketServer']))
 
     def __init__(
@@ -29,7 +30,7 @@ class SocketServer(Abstract):
             handler: SocketServerHandler,
             *,
             on_error: ta.Optional[ta.Callable[[BaseException, ta.Optional[SocketAndAddress]], None]] = None,
-            error_logger: ta.Optional[logging.Logger] = _DEFAULT_LOGGER,
+            error_logger: ta.Optional[LoggerLike] = _DEFAULT_LOGGER,
             poll_interval: float = .5,
             shutdown_timeout: ta.Optional[float] = None,
     ) -> None:

omlish/sockets/server/ssl.py

@@ -1,9 +1,9 @@
 # ruff: noqa: UP006 UP007 UP045
 # @omlish-lite
 import dataclasses as dc
-import logging
 import typing as ta
 
+from ...logs.protocols import LoggerLike
 from ..addresses import SocketAndAddress
 from ..io import close_socket_immediately
 from .handlers import SocketServerHandler
@@ -17,7 +17,7 @@ from .handlers import SocketServerHandler_
 class SslErrorHandlingSocketServerHandler(SocketServerHandler_):
     handler: SocketServerHandler
 
-    log: ta.Optional[logging.Logger] = None
+    log: ta.Optional[LoggerLike] = None
 
     #
 

omlish/subprocesses/base.py

@@ -9,6 +9,7 @@ import typing as ta
 
 from ..lite.abstract import Abstract
 from ..lite.timeouts import Timeout
+from ..logs.protocols import LoggerLike
 from .wrap import subprocess_maybe_shell_wrap_exec
 
 
@@ -55,12 +56,12 @@ class VerboseCalledProcessError(subprocess.CalledProcessError):
 
 
 class BaseSubprocesses(Abstract):
-    DEFAULT_LOGGER: ta.ClassVar[ta.Optional[logging.Logger]] = None
+    DEFAULT_LOGGER: ta.ClassVar[ta.Optional[LoggerLike]] = None
 
     def __init__(
             self,
             *,
-            log: ta.Optional[logging.Logger] = None,
+            log: ta.Optional[LoggerLike] = None,
             try_exceptions: ta.Optional[ta.Tuple[ta.Type[Exception], ...]] = None,
     ) -> None:
         super().__init__()
@@ -68,7 +69,7 @@ class BaseSubprocesses(Abstract):
         self._log = log if log is not None else self.DEFAULT_LOGGER
         self._try_exceptions = try_exceptions if try_exceptions is not None else self.DEFAULT_TRY_EXCEPTIONS
 
-    def set_logger(self, log: ta.Optional[logging.Logger]) -> None:
+    def set_logger(self, log: ta.Optional[LoggerLike]) -> None:
         self._log = log
 
     #

{omlish-0.0.0.dev426.dist-info → omlish-0.0.0.dev428.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omlish
-Version: 0.0.0.dev426
+Version: 0.0.0.dev428
 Summary: omlish
 Author: wrmsr
 License-Expression: BSD-3-Clause