nnlogging 0.1.2__py3-none-any.whl → 0.1.4__py3-none-any.whl

nnlogging/__init__.py

@@ -1,16 +1,4 @@
-"""
-Package: `nnlogging`
-Version: ``0.1.1``
-"""
+from .global_ import *
+from .shell import Shell
 
-from .shell import (
-    Shell,
-    get_global_shell,
-    replace_global_shell,
-)
-
-__all__ = [
-    "Shell",
-    "get_global_shell",
-    "replace_global_shell",
-]
+__all__ = ["Shell"]

nnlogging/exceptions/__init__.py

@@ -0,0 +1,15 @@
+from .branch_exists import BranchExistsError, call_branch_exists_error
+from .branch_not_found import BranchNotFoundError, call_branch_not_found_error
+from .task_exists import TaskExistsError, call_task_exists_error
+from .task_not_found import TaskNotFoundError, call_task_not_found_error
+
+__all__ = [
+    "call_branch_exists_error",
+    "call_branch_not_found_error",
+    "call_task_exists_error",
+    "call_task_not_found_error",
+    "BranchExistsError",
+    "BranchNotFoundError",
+    "TaskExistsError",
+    "TaskNotFoundError",
+]

nnlogging/exceptions/branch_exists.py

@@ -0,0 +1,29 @@
+from nnlogging.options import LogOptionDict
+from nnlogging.typings.exts import Unpack
+from nnlogging.typings.protocols import ExceptionProtocol
+from nnlogging.utils.helpers import (
+    get_name,
+    inc_stacklevel,
+    inject_excinfo,
+)
+
+
+class BranchExistsError(LookupError): ...
+
+
+def call_branch_exists_error(
+    inst: ExceptionProtocol,
+    name: str,
+    /,
+    **kwargs: Unpack[LogOptionDict],
+):
+    e = BranchExistsError(
+        f'branch "{name}" already exists in {get_name(inst)}.branches: {inst.branches}'
+    )
+    inst.exception(
+        'branch "%s" already exists in %s.branches',
+        name,
+        get_name(inst),
+        **inc_stacklevel(inject_excinfo(kwargs, e)),
+    )
+    return e

nnlogging/exceptions/branch_not_found.py

@@ -0,0 +1,29 @@
+from nnlogging.options import LogOptionDict
+from nnlogging.typings.exts import Unpack
+from nnlogging.typings.protocols import ExceptionProtocol
+from nnlogging.utils.helpers import (
+    get_name,
+    inc_stacklevel,
+    inject_excinfo,
+)
+
+
+class BranchNotFoundError(LookupError): ...
+
+
+def call_branch_not_found_error(
+    inst: ExceptionProtocol,
+    name: str,
+    /,
+    **kwargs: Unpack[LogOptionDict],
+):
+    e = BranchNotFoundError(
+        f'branch "{name}" not found in {get_name(inst)}.branches: {inst.branches}'
+    )
+    inst.exception(
+        'branch "%s" not found in %s.branches',
+        name,
+        get_name(inst),
+        **inc_stacklevel(inject_excinfo(kwargs, e)),
+    )
+    return e

nnlogging/exceptions/task_exists.py

@@ -0,0 +1,31 @@
+from nnlogging.options import LogOptionDict
+from nnlogging.typings.exts import Unpack
+from nnlogging.typings.protocols import ExceptionProtocol
+from nnlogging.utils.helpers import (
+    get_name,
+    inc_stacklevel,
+    inject_excinfo,
+)
+
+
+class TaskExistsError(LookupError): ...
+
+
+def call_task_exists_error(
+    inst: ExceptionProtocol,
+    branch: str,
+    name: str,
+    /,
+    **kwargs: Unpack[LogOptionDict],
+):
+    e = TaskExistsError(
+        f'task "{name}" already exists in {get_name(inst)}.branches."{branch}"."tasks": {inst.branches[branch]["tasks"]}'
+    )
+    inst.exception(
+        'task "%s" already exists in %s.branches."%s"."tasks"',
+        name,
+        get_name(inst),
+        branch,
+        **inc_stacklevel(inject_excinfo(kwargs, e)),
+    )
+    return e

nnlogging/exceptions/task_not_found.py

@@ -0,0 +1,29 @@
+from nnlogging.options import LogOptionDict
+from nnlogging.typings.exts import Unpack
+from nnlogging.typings.protocols import ExceptionProtocol
+from nnlogging.utils.helpers import (
+    get_name,
+    inc_stacklevel,
+    inject_excinfo,
+)
+
+
+class TaskNotFoundError(LookupError): ...
+
+
+def call_task_not_found_error(
+    inst: ExceptionProtocol,
+    name: str,
+    /,
+    **kwargs: Unpack[LogOptionDict],
+):
+    e = TaskNotFoundError(
+        f'task "{name}" not found in {get_name(inst)}.branches: {inst.branches}'
+    )
+    inst.exception(
+        'task "%s" not found in %s.branches',
+        name,
+        get_name(inst),
+        **inc_stacklevel(inject_excinfo(kwargs, e)),
+    )
+    return e

nnlogging/global_.py

@@ -0,0 +1,322 @@
+import threading
+from typing import Literal
+
+from aim.storage.types import AimObject
+
+import nnlogging.shell_funcs as f
+from nnlogging.options import (
+    BranchConfigOptionDict,
+    LoggerConfigOptionDict,
+    LogOptionDict,
+    RunConfigOptionDict,
+    TaskOptionDict,
+    TrackOptionDict,
+)
+from nnlogging.shell import Shell
+from nnlogging.typings.exts import Unpack
+from nnlogging.typings.protocols import Sink
+from nnlogging.utils.helpers import with_lock
+
+_global_shell_lock: threading.Lock = threading.Lock()
+_global_shell: Shell = Shell("_global_")
+
+
+__all__ = [
+    "replace_global_shell",
+    "logger_configure",
+    "run_configure",
+    "branch_configure",
+    "branch_add",
+    "branch_remove",
+    "task_add",
+    "task_remove",
+    "log",
+    "debug",
+    "info",
+    "warn",
+    "error",
+    "critical",
+    "exception",
+    "advance",
+    "track",
+    "add_tag",
+    "remove_tag",
+    "update_metadata",
+]
+
+
+@with_lock(_global_shell_lock)
+def replace_global_shell(shell: Shell):
+    global _global_shell, _global_shell_lock
+    if _global_shell.logger is not None:
+        _global_shell.logger_configure()
+    if _global_shell.run is not None:
+        _global_shell.run_configure()
+    for name in list(_global_shell.branches.keys()):
+        _global_shell.branch_remove(name)
+    _global_shell = shell
+
+
+@with_lock(_global_shell_lock)
+def logger_configure(
+    **kwargs: Unpack[LoggerConfigOptionDict],
+):
+    global _global_shell
+    f.logger_configure(
+        _global_shell,
+        **kwargs,
+    )
+
+
+@with_lock(_global_shell_lock)
+def run_configure(
+    **kwargs: Unpack[RunConfigOptionDict],
+):
+    global _global_shell
+    f.run_configure(
+        _global_shell,
+        **kwargs,
+    )
+
+
+@with_lock(_global_shell_lock)
+def branch_configure(
+    **kwargs: Unpack[BranchConfigOptionDict],
+):
+    global _global_shell
+    f.branch_configure(
+        _global_shell,
+        **kwargs,
+    )
+
+
+@with_lock(_global_shell_lock)
+def branch_add(
+    name: str,
+    /,
+    sink: Sink | Literal["stderr", "stdout"] = "stderr",
+    **kwargs: Unpack[BranchConfigOptionDict],
+):
+    global _global_shell
+    f.branch_add(
+        _global_shell,
+        name,
+        sink=sink,
+        **kwargs,
+    )
+
+
+@with_lock(_global_shell_lock)
+def branch_remove(
+    name: str,
+    /,
+):
+    global _global_shell
+    f.branch_remove(
+        _global_shell,
+        name,
+    )
+
+
+@with_lock(_global_shell_lock)
+def task_add(
+    name: str,
+    /,
+    **kwargs: Unpack[TaskOptionDict],
+):
+    global _global_shell
+    f.task_add(
+        _global_shell,
+        name,
+        **kwargs,
+    )
+
+
+@with_lock(_global_shell_lock)
+def task_remove(
+    name: str,
+    /,
+):
+    global _global_shell
+    f.task_remove(
+        _global_shell,
+        name,
+    )
+
+
+@with_lock(_global_shell_lock)
+def log(
+    level: int,
+    msg: object,
+    *args: object,
+    **kwargs: Unpack[LogOptionDict],
+):
+    global _global_shell
+    kwargs["stacklevel"] = kwargs.get("stacklevel", 3)
+    f.log(
+        _global_shell,
+        level,
+        msg,
+        *args,
+        **kwargs,
+    )
+
+
+@with_lock(_global_shell_lock)
+def debug(
+    msg: object,
+    *args: object,
+    **kwargs: Unpack[LogOptionDict],
+):
+    global _global_shell
+    kwargs["stacklevel"] = kwargs.get("stacklevel", 3)
+    f.debug(
+        _global_shell,
+        msg,
+        *args,
+        **kwargs,
+    )
+
+
+@with_lock(_global_shell_lock)
+def info(
+    msg: object,
+    *args: object,
+    **kwargs: Unpack[LogOptionDict],
+):
+    global _global_shell
+    kwargs["stacklevel"] = kwargs.get("stacklevel", 3)
+    f.info(
+        _global_shell,
+        msg,
+        *args,
+        **kwargs,
+    )
+
+
+@with_lock(_global_shell_lock)
+def warn(
+    msg: object,
+    *args: object,
+    **kwargs: Unpack[LogOptionDict],
+):
+    global _global_shell
+    kwargs["stacklevel"] = kwargs.get("stacklevel", 3)
+    f.warn(
+        _global_shell,
+        msg,
+        *args,
+        **kwargs,
+    )
+
+
+@with_lock(_global_shell_lock)
+def error(
+    msg: object,
+    *args: object,
+    **kwargs: Unpack[LogOptionDict],
+):
+    global _global_shell
+    kwargs["stacklevel"] = kwargs.get("stacklevel", 3)
+    f.error(
+        _global_shell,
+        msg,
+        *args,
+        **kwargs,
+    )
+
+
+@with_lock(_global_shell_lock)
+def critical(
+    msg: object,
+    *args: object,
+    **kwargs: Unpack[LogOptionDict],
+):
+    global _global_shell
+    kwargs["stacklevel"] = kwargs.get("stacklevel", 3)
+    f.critical(
+        _global_shell,
+        msg,
+        *args,
+        **kwargs,
+    )
+
+
+@with_lock(_global_shell_lock)
+def exception(
+    msg: object,
+    *args: object,
+    **kwargs: Unpack[LogOptionDict],
+):
+    global _global_shell
+    kwargs["stacklevel"] = kwargs.get("stacklevel", 3)
+    f.exception(
+        _global_shell,
+        msg,
+        *args,
+        **kwargs,
+    )
+
+
+@with_lock(_global_shell_lock)
+def advance(
+    name: str,
+    value: float,
+):
+    global _global_shell
+    f.advance(
+        _global_shell,
+        name,
+        value,
+    )
+
+
+@with_lock(_global_shell_lock)
+def track(
+    value: object,
+    /,
+    **kwargs: Unpack[TrackOptionDict],
+):
+    global _global_shell
+    f.track(
+        _global_shell,
+        value,
+        **kwargs,
+    )
+
+
+@with_lock(_global_shell_lock)
+def add_tag(
+    tag: str,
+    /,
+):
+    global _global_shell
+    f.add_tag(
+        _global_shell,
+        tag,
+    )
+
+
+@with_lock(_global_shell_lock)
+def remove_tag(
+    tag: str,
+    /,
+):
+    global _global_shell
+    f.remove_tag(
+        _global_shell,
+        tag,
+    )
+
+
+@with_lock(_global_shell_lock)
+def update_metadata(
+    key: str,
+    value: AimObject,
+):
+    global _global_shell
+    f.update_metadata(
+        _global_shell,
+        key,
+        value,
+    )

nnlogging/options/__init__.py

@@ -0,0 +1,31 @@
+from .branch_config import BranchConfigOption, BranchConfigOptionDict
+from .log_option import LoggingLogOptionDict, LogOptionDict, RichPrintOptionDict
+from .logger_config import LoggerConfigOption, LoggerConfigOptionDict
+from .rich_console import RichConsoleOption, RichConsoleOptionDict
+from .rich_handler import RichHandlerOption, RichHandlerOptionDict
+from .rich_progress import RichProgressOption, RichProgressOptionDict
+from .run_config import RunConfigOption, RunConfigOptionDict
+from .task_option import TaskOption, TaskOptionDict
+from .track_option import TrackOption, TrackOptionDict
+
+__all__ = [
+    "RichConsoleOption",
+    "RichConsoleOptionDict",
+    "RichHandlerOption",
+    "RichHandlerOptionDict",
+    "RichProgressOption",
+    "RichProgressOptionDict",
+    "LoggerConfigOption",
+    "LoggerConfigOptionDict",
+    "RunConfigOption",
+    "RunConfigOptionDict",
+    "BranchConfigOption",
+    "BranchConfigOptionDict",
+    "TaskOption",
+    "TaskOptionDict",
+    "TrackOption",
+    "TrackOptionDict",
+    "LogOptionDict",
+    "RichPrintOptionDict",
+    "LoggingLogOptionDict",
+]

nnlogging/options/branch_config.py

@@ -0,0 +1,19 @@
+from dataclasses import dataclass
+
+from .rich_console import RichConsoleOption, RichConsoleOptionDict
+from .rich_handler import RichHandlerOption, RichHandlerOptionDict
+from .rich_progress import RichProgressOption, RichProgressOptionDict
+
+
+@dataclass(kw_only=True)
+class BranchConfigOption(RichConsoleOption, RichHandlerOption, RichProgressOption):
+    def __post_init__(self):
+        RichConsoleOption.__post_init__(self)
+        RichHandlerOption.__post_init__(self)
+
+
+class BranchConfigOptionDict(
+    RichConsoleOptionDict,
+    RichHandlerOptionDict,
+    RichProgressOptionDict,
+): ...

nnlogging/options/log_option.py

@@ -0,0 +1,34 @@
+from collections.abc import Mapping
+from types import TracebackType
+from typing import TypeAlias, TypedDict
+
+from rich.console import (
+    JustifyMethod as RichConsoleJustifyMethod,
+    OverflowMethod as RichConsoleOverflowMethod,
+)
+
+ExcInfoType: TypeAlias = (
+    None
+    | bool
+    | BaseException
+    | tuple[None, None, None]
+    | tuple[type[BaseException], BaseException, TracebackType | None]
+)
+
+
+class RichPrintOptionDict(TypedDict, total=False):
+    end: str
+    justify: RichConsoleJustifyMethod
+    no_wrap: bool
+    overflow: RichConsoleOverflowMethod
+    new_line_start: bool
+
+
+class LoggingLogOptionDict(TypedDict, total=False):
+    exc_info: ExcInfoType
+    stack_info: bool
+    stacklevel: int
+    extra: Mapping[str, object]
+
+
+class LogOptionDict(LoggingLogOptionDict, RichPrintOptionDict): ...

nnlogging/options/logger_config.py

@@ -0,0 +1,16 @@
+import logging
+from dataclasses import dataclass, field
+from typing import TypedDict
+
+
+@dataclass(kw_only=True)
+class LoggerConfigOption:
+    name: str = field(default="nnlogging")
+    level: int | str = field(default=logging.INFO)
+    propagate: bool = field(default=False)
+
+
+class LoggerConfigOptionDict(TypedDict, total=False):
+    name: str
+    level: int | str
+    propagate: bool

nnlogging/options/rich_console.py

@@ -0,0 +1,44 @@
+from dataclasses import dataclass, field
+from typing import Literal, TypedDict
+
+from rich.highlighter import (
+    Highlighter as RichHighlighter,
+    NullHighlighter as RichNullHighlighter,
+)
+from rich.theme import Theme as RichTheme
+
+
+@dataclass(kw_only=True)
+class RichConsoleOption:
+    width: int | None = field(default=None)
+    height: int | None = field(default=None)
+    markup: bool = field(default=True)
+    emoji: bool = field(default=True)
+    color_system: Literal["auto", "standard", "truecolor"] | None = field(
+        default="auto"
+    )
+    theme: RichTheme | None = field(default=None)
+    highlighter: RichHighlighter = field(default_factory=RichNullHighlighter)
+    soft_wrap: bool = field(default=False)
+    force_terminal: bool | None = field(default=None)
+    force_jupyter: bool | None = field(default=None)
+    force_interactive: bool | None = field(default=None)
+
+    highlight: bool = field(init=False)
+
+    def __post_init__(self):
+        self.highlight = not isinstance(self.highlighter, RichNullHighlighter)
+
+
+class RichConsoleOptionDict(TypedDict, total=False):
+    width: int | None
+    height: int | None
+    markup: bool
+    emoji: bool
+    color_system: Literal["auto", "standard", "truecolor"] | None
+    theme: RichTheme | None
+    highlighter: RichHighlighter
+    soft_wrap: bool
+    force_terminal: bool | None
+    force_jupyter: bool | None
+    force_interactive: bool | None

nnlogging/options/rich_handler.py

@@ -0,0 +1,47 @@
+import logging
+from dataclasses import dataclass, field
+from logging import Formatter as LoggingFormatter
+from typing import TypedDict
+
+from rich.highlighter import (
+    Highlighter as RichHighlighter,
+    NullHighlighter as RichNullHighlighter,
+)
+
+from nnlogging.typings.aliases import FormatTimeCallable
+
+
+@dataclass(kw_only=True)
+class RichHandlerOption:
+    level: str | int = field(default=logging.NOTSET)
+    show_level: bool = field(default=True)
+    show_time: bool = field(default=True)
+    show_path: bool = field(default=True)
+    log_time_format: str | FormatTimeCallable = field(default="[%x %X]")
+    omit_repeated_times: bool = field(default=True)
+    markup: bool = field(default=True)
+    highlighter: RichHighlighter = field(default_factory=RichNullHighlighter)
+    rich_tracebacks: bool = field(default=True)
+    tracebacks_extra_lines: int = field(default=0)
+    tracebacks_max_frames: int = field(default=1)
+    tracebacks_show_locals: bool = field(default=False)
+    locals_max_length: int = field(default=10)
+    log_message_format: str | LoggingFormatter = field(default="%(message)s")
+
+    def __post_init__(self):
+        if isinstance(self.log_message_format, str):
+            self.log_message_format = LoggingFormatter(self.log_message_format)
+
+
+class RichHandlerOptionDict(TypedDict, total=False):
+    level: str | int
+    show_level: bool
+    show_time: bool
+    show_path: bool
+    log_time_format: str | FormatTimeCallable
+    omit_repeated_times: bool
+    markup: bool
+    highlighter: RichHighlighter
+    rich_tracebacks: bool
+    tracebacks_show_locals: bool
+    log_message_format: str | LoggingFormatter