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

nnlogging/options/rich_progress.py

@@ -0,0 +1,62 @@
+from collections.abc import Collection
+from dataclasses import dataclass, field
+from typing import TypedDict
+
+from rich.progress import ProgressColumn as RichProgressColumn
+
+
+def get_default_progress_columns():
+    from rich.progress import (
+        BarColumn,
+        SpinnerColumn,
+        TaskProgressColumn,
+        TextColumn,
+        TimeRemainingColumn,
+    )
+
+    spinner_column = SpinnerColumn(
+        spinner_name="dots",
+        style="progress.spinner",
+        finished_text=" ",
+    )
+    text_column = TextColumn(
+        text_format="{task.description}",
+        style="progress.description",
+        justify="left",
+    )
+    bar_column = BarColumn(bar_width=40)
+    task_progress_column = TaskProgressColumn(
+        text_format="{task.percentage:>3.0f}%",
+        text_format_no_percentage="",
+        style="progress.percentage",
+        justify="right",
+        show_speed=True,
+    )
+    time_remaining_column = TimeRemainingColumn(
+        compact=False,
+        elapsed_when_finished=True,
+    )
+    return (
+        spinner_column,
+        text_column,
+        bar_column,
+        task_progress_column,
+        time_remaining_column,
+    )
+
+
+@dataclass(kw_only=True)
+class RichProgressOption:
+    columns: Collection[str | RichProgressColumn] = field(
+        default_factory=get_default_progress_columns
+    )
+    transient: bool = field(default=False)
+    refresh_per_second: float = field(default=10)
+    speed_estimate_period: float = field(default=3600)
+
+
+class RichProgressOptionDict(TypedDict, total=False):
+    columns: Collection[str | RichProgressColumn]
+    transient: bool
+    refresh_per_second: float
+    speed_estimate_period: float

nnlogging/options/run_config.py

@@ -0,0 +1,27 @@
+from dataclasses import dataclass, field
+from typing import TypedDict
+
+from aim import Repo as AimRepo
+
+
+@dataclass(kw_only=True)
+class RunConfigOption:
+    experiment: str | None = field(default=None)
+    repo: str | AimRepo | None = field(default=None)
+    system_tracking_interval: float | None = field(default=10)
+    capture_terminal_logs: bool = field(default=False)
+    log_system_params: bool = field(default=False)
+    run_hash: str | None = field(default=None)
+    read_only: bool = field(default=False)
+    force_resume: bool = field(default=False)
+
+
+class RunConfigOptionDict(TypedDict, total=False):
+    experiment: str | None
+    repo: str | AimRepo | None
+    system_tracking_interval: float | None
+    capture_terminal_logs: bool
+    log_system_params: bool
+    run_hash: str | None
+    read_only: bool
+    force_resume: bool

nnlogging/options/task_option.py

@@ -0,0 +1,17 @@
+from dataclasses import dataclass, field
+from typing import TypedDict
+
+from nnlogging.typings.exts import NotRequired, Required
+
+
+@dataclass(kw_only=True)
+class TaskOption:
+    description: str = field()
+    total: float | None = field()
+    completed: float = field(default=0)
+
+
+class TaskOptionDict(TypedDict):
+    description: Required[str]
+    total: Required[float | None]
+    completed: NotRequired[float]

nnlogging/options/track_option.py

@@ -0,0 +1,19 @@
+from dataclasses import dataclass, field
+from typing import TypedDict
+
+from aim.storage.types import AimObject
+
+
+@dataclass
+class TrackOption:
+    name: str | None = field(default=None)
+    step: int | None = field(default=None)
+    epoch: int | None = field(default=None)
+    context: AimObject = field(default=None)
+
+
+class TrackOptionDict(TypedDict, total=False):
+    name: str | None
+    step: int | None
+    epoch: int | None
+    context: AimObject

nnlogging/shell.py

@@ -1,48 +1,24 @@
-import sys
-from collections.abc import Collection
-from logging import Formatter as LoggingFormatter, Logger as LoggingLogger
-from typing import Literal, cast
+from logging import Logger as LoggingLogger
+from typing import Literal
 
-from aim import Repo as AimRepo, Run as AimRun
-from aim.sdk.types import AimObject
-from rich.highlighter import Highlighter as RichHighlighter
-from rich.progress import ProgressColumn as RichProgressColumn
-from rich.theme import Theme as RichTheme
+from aim import Run as AimRun
+from aim.storage.types import AimObject
 
-from nnlogging.typings import (
-    Branch,
-    ConsolePrintOptions,
-    FormatTimeCallable,
-    LogOptions,
-    Omitable,
-    Sink,
+import nnlogging.shell_funcs as f
+from nnlogging.options import (
+    BranchConfigOption,
+    BranchConfigOptionDict,
+    LoggerConfigOption,
+    LoggerConfigOptionDict,
+    LogOptionDict,
+    RunConfigOption,
+    RunConfigOptionDict,
+    TaskOptionDict,
+    TrackOptionDict,
 )
-from nnlogging.utils import (
-    BranchConfig,
-    LoggerConfig,
-    RunConfig,
-    add_tag as _add_tag,
-    advance as _advance,
-    branch_add as _branch_add,
-    branch_configure as _branch_configure,
-    branch_remove as _branch_remove,
-    critical as _critical,
-    debug as _debug,
-    error as _error,
-    exception as _exception,
-    info as _info,
-    log as _log,
-    logger_configure as _logger_configure,
-    remove_tag as _remove_tag,
-    run_configure as _run_configure,
-    task_add as _task_add,
-    task_remove as _task_remove,
-    track as _track,
-    update_metadata as _update_metadata,
-    warn as _warn,
-)
-
-global_shell = None
+from nnlogging.typings.aliases import Branch
+from nnlogging.typings.exts import Unpack
+from nnlogging.typings.protocols import Sink
 
 
 class Shell:
@@ -51,175 +27,63 @@ class Shell:
         shell_name: str = "nnlogging",
         /,
         *,
-        logger_config: LoggerConfig | None = None,
-        run_config: RunConfig | None = None,
-        branch_config: BranchConfig | None = None,
+        logger_config: LoggerConfigOption | None = None,
+        run_config: RunConfigOption | None = None,
+        branch_config: BranchConfigOption | None = None,
+        strict: bool = False,
     ):
         self.logger: LoggingLogger | None = None
         self.run: AimRun | None = None
         self.branches: dict[str, Branch] = dict()
 
         self.name: str = shell_name
-        self.logger_config: LoggerConfig = logger_config or LoggerConfig()
-        self.run_config: RunConfig = run_config or RunConfig()
-        self.branch_config: BranchConfig = branch_config or BranchConfig()
+        self.logger_config: LoggerConfigOption = logger_config or LoggerConfigOption(
+            name=shell_name
+        )
+        self.run_config: RunConfigOption = run_config or RunConfigOption()
+        self.branch_config: BranchConfigOption = branch_config or BranchConfigOption()
+
+        self.strict: bool = strict
 
     def logger_configure(
         self,
-        config: LoggerConfig | None = None,
-        /,
-        *,
-        name: Omitable[str] = ...,
-        level: Omitable[int | str] = ...,
-        propagate: Omitable[bool] = ...,
+        **kwargs: Unpack[LoggerConfigOptionDict],
     ):
-        _logger_configure(
+        f.logger_configure(
             self,
-            config,
-            name=name,
-            level=level,
-            propagate=propagate,
+            **kwargs,
         )
 
     def run_configure(
         self,
-        config: RunConfig | None = None,
-        /,
-        *,
-        experiment: Omitable[str | None] = ...,
-        repo: Omitable[str | AimRepo | None] = ...,
-        system_tracking_interval: Omitable[float | None] = ...,
-        capture_terminal_logs: Omitable[bool] = ...,
-        log_system_params: Omitable[bool] = ...,
-        run_hash: Omitable[str | None] = ...,
-        read_only: Omitable[bool] = ...,
-        force_resume: Omitable[bool] = ...,
+        **kwargs: Unpack[RunConfigOptionDict],
     ):
-        _run_configure(
+        f.run_configure(
             self,
-            config,
-            experiment=experiment,
-            repo=repo,
-            system_tracking_interval=system_tracking_interval,
-            capture_terminal_logs=capture_terminal_logs,
-            log_system_params=log_system_params,
-            run_hash=run_hash,
-            read_only=read_only,
-            force_resume=force_resume,
+            **kwargs,
         )
 
     def branch_configure(
         self,
-        config: BranchConfig | None = None,
-        /,
-        *,
-        markup: Omitable[bool] = ...,
-        highlighter: Omitable[RichHighlighter] = ...,
-        width: Omitable[int | None] = ...,
-        height: Omitable[int | None] = ...,
-        emoji: Omitable[bool] = ...,
-        color_system: Omitable[Literal["auto", "standard", "truecolor"] | None] = ...,
-        theme: Omitable[RichTheme] = ...,
-        soft_wrap: Omitable[bool] = ...,
-        force_terminal: Omitable[bool | None] = ...,
-        force_jupyter: Omitable[bool | None] = ...,
-        force_interactive: Omitable[bool | None] = ...,
-        level: Omitable[str | int] = ...,
-        show_level: Omitable[bool] = ...,
-        show_time: Omitable[bool] = ...,
-        show_path: Omitable[bool] = ...,
-        log_time_format: Omitable[str | FormatTimeCallable] = ...,
-        omit_repeated_times: Omitable[bool] = ...,
-        rich_tracebacks: Omitable[bool] = ...,
-        tracebacks_show_locals: Omitable[bool] = ...,
-        log_message_format: Omitable[str | LoggingFormatter] = ...,
-        columns: Omitable[Collection[str | RichProgressColumn]] = ...,
-        transient: Omitable[bool] = ...,
-        refresh_per_second: Omitable[float] = ...,
-        speed_estimate_period: Omitable[float] = ...,
-        default_column_markup: Omitable[bool] = ...,
+        **kwargs: Unpack[BranchConfigOptionDict],
     ):
-        _branch_configure(
+        f.branch_configure(
             self,
-            config,
-            markup=markup,
-            highlighter=highlighter,
-            width=width,
-            height=height,
-            emoji=emoji,
-            color_system=color_system,
-            theme=theme,
-            soft_wrap=soft_wrap,
-            force_terminal=force_terminal,
-            force_jupyter=force_jupyter,
-            force_interactive=force_interactive,
-            level=level,
-            show_level=show_level,
-            show_time=show_time,
-            show_path=show_path,
-            log_time_format=log_time_format,
-            omit_repeated_times=omit_repeated_times,
-            rich_tracebacks=rich_tracebacks,
-            tracebacks_show_locals=tracebacks_show_locals,
-            log_message_format=log_message_format,
-            columns=columns,
-            transient=transient,
-            refresh_per_second=refresh_per_second,
-            speed_estimate_period=speed_estimate_period,
-            default_column_markup=default_column_markup,
+            **kwargs,
         )
 
     def branch_add(
         self,
         name: str,
         /,
-        sink: Sink | None = None,
-        *,
-        markup: Omitable[bool] = ...,
-        highlighter: Omitable[RichHighlighter] = ...,
-        width: Omitable[int | None] = ...,
-        height: Omitable[int | None] = ...,
-        emoji: Omitable[bool] = ...,
-        color_system: Omitable[Literal["auto", "standard", "truecolor"] | None] = ...,
-        theme: Omitable[RichTheme] = ...,
-        soft_wrap: Omitable[bool] = ...,
-        force_terminal: Omitable[bool | None] = ...,
-        force_jupyter: Omitable[bool | None] = ...,
-        force_interactive: Omitable[bool | None] = ...,
-        level: Omitable[str | int] = ...,
-        show_level: Omitable[bool] = ...,
-        show_time: Omitable[bool] = ...,
-        show_path: Omitable[bool] = ...,
-        log_time_format: Omitable[str | FormatTimeCallable] = ...,
-        omit_repeated_times: Omitable[bool] = ...,
-        rich_tracebacks: Omitable[bool] = ...,
-        tracebacks_show_locals: Omitable[bool] = ...,
-        log_message_format: Omitable[str | LoggingFormatter] = ...,
+        sink: Sink | Literal["stderr", "stdout"] = "stderr",
+        **kwargs: Unpack[BranchConfigOptionDict],
     ):
-        _branch_add(
+        f.branch_add(
             self,
             name,
             sink=sink,
-            markup=markup,
-            highlighter=highlighter,
-            width=width,
-            height=height,
-            emoji=emoji,
-            color_system=color_system,
-            theme=theme,
-            soft_wrap=soft_wrap,
-            force_terminal=force_terminal,
-            force_jupyter=force_jupyter,
-            force_interactive=force_interactive,
-            level=level,
-            show_level=show_level,
-            show_time=show_time,
-            show_path=show_path,
-            log_time_format=log_time_format,
-            omit_repeated_times=omit_repeated_times,
-            rich_tracebacks=rich_tracebacks,
-            tracebacks_show_locals=tracebacks_show_locals,
-            log_message_format=log_message_format,
+            **kwargs,
         )
 
     def branch_remove(
@@ -227,7 +91,7 @@ class Shell:
         name: str,
         /,
     ):
-        _branch_remove(
+        f.branch_remove(
             self,
             name,
         )
@@ -236,17 +100,12 @@ class Shell:
         self,
         name: str,
         /,
-        *,
-        desc: str,
-        total: float | None,
-        done: float = 0,
+        **kwargs: Unpack[TaskOptionDict],
     ):
-        _task_add(
+        f.task_add(
             self,
             name,
-            desc=desc,
-            total=total,
-            done=done,
+            **kwargs,
         )
 
     def task_remove(
@@ -254,7 +113,7 @@ class Shell:
         name: str,
         /,
     ):
-        _task_remove(
+        f.task_remove(
             self,
             name,
         )
@@ -264,187 +123,147 @@ class Shell:
         level: int,
         msg: object,
         *args: object,
-        log_options: LogOptions | None = None,
-        console_options: ConsolePrintOptions | None = None,
+        **kwargs: Unpack[LogOptionDict],
     ):
-        _log(
+        kwargs["stacklevel"] = kwargs.get("stacklevel", 2)
+        f.log(
             self,
             level,
             msg,
             *args,
-            log_options=log_options,
-            console_options=console_options,
+            **kwargs,
         )
 
     def debug(
         self,
         msg: object,
         *args: object,
-        log_options: LogOptions | None = None,
-        console_options: ConsolePrintOptions | None = None,
+        **kwargs: Unpack[LogOptionDict],
     ):
-        _debug(
+        kwargs["stacklevel"] = kwargs.get("stacklevel", 2)
+        f.debug(
             self,
             msg,
             *args,
-            log_options=log_options,
-            console_options=console_options,
+            **kwargs,
         )
 
     def info(
         self,
         msg: object,
         *args: object,
-        log_options: LogOptions | None = None,
-        console_options: ConsolePrintOptions | None = None,
+        **kwargs: Unpack[LogOptionDict],
     ):
-        _info(
+        kwargs["stacklevel"] = kwargs.get("stacklevel", 2)
+        f.info(
             self,
             msg,
             *args,
-            log_options=log_options,
-            console_options=console_options,
+            **kwargs,
         )
 
     def warn(
         self,
         msg: object,
         *args: object,
-        log_options: LogOptions | None = None,
-        console_options: ConsolePrintOptions | None = None,
+        **kwargs: Unpack[LogOptionDict],
     ):
-        _warn(
+        kwargs["stacklevel"] = kwargs.get("stacklevel", 2)
+        f.warn(
             self,
             msg,
             *args,
-            log_options=log_options,
-            console_options=console_options,
+            **kwargs,
         )
 
     def error(
         self,
         msg: object,
         *args: object,
-        log_options: LogOptions | None = None,
-        console_options: ConsolePrintOptions | None = None,
+        **kwargs: Unpack[LogOptionDict],
     ):
-        _error(
+        kwargs["stacklevel"] = kwargs.get("stacklevel", 2)
+        f.error(
             self,
             msg,
             *args,
-            log_options=log_options,
-            console_options=console_options,
+            **kwargs,
         )
 
     def critical(
         self,
         msg: object,
         *args: object,
-        log_options: LogOptions | None = None,
-        console_options: ConsolePrintOptions | None = None,
+        **kwargs: Unpack[LogOptionDict],
     ):
-        _critical(
+        kwargs["stacklevel"] = kwargs.get("stacklevel", 2)
+        f.critical(
             self,
             msg,
             *args,
-            log_options=log_options,
-            console_options=console_options,
+            **kwargs,
         )
 
     def exception(
         self,
         msg: object,
         *args: object,
-        log_options: LogOptions | None = None,
-        console_options: ConsolePrintOptions | None = None,
+        **kwargs: Unpack[LogOptionDict],
     ):
-        _exception(
+        kwargs["stacklevel"] = kwargs.get("stacklevel", 2)
+        f.exception(
             self,
             msg,
             *args,
-            log_options=log_options,
-            console_options=console_options,
+            **kwargs,
         )
 
-    def advance(
-        self,
-        name: str,
-        /,
-        value: float,
-    ):
-        _advance(
+    def advance(self, name: str, value: float):
+        f.advance(
             self,
             name,
-            advance=value,
+            value,
         )
 
     def track(
         self,
         value: object,
         /,
-        name: str | None,
-        *,
-        step: int | None,
-        epoch: int | None,
-        context: AimObject,
+        **kwargs: Unpack[TrackOptionDict],
     ):
-        _track(
+        f.track(
             self,
             value,
-            name=name,
-            step=step,
-            epoch=epoch,
-            context=context,
+            **kwargs,
         )
 
     def add_tag(
         self,
-        name: str,
+        tag: str,
         /,
     ):
-        _add_tag(
+        f.add_tag(
             self,
-            name,
+            tag,
         )
 
     def remove_tag(
         self,
-        name: str,
+        tag: str,
         /,
     ):
-        _remove_tag(
+        f.remove_tag(
             self,
-            name,
+            tag,
         )
 
     def update_metadata(
         self,
-        name: str,
-        /,
-        metadata: AimObject,
+        key: str,
+        value: AimObject,
     ):
-        _update_metadata(
+        f.update_metadata(
             self,
-            name,
-            metadata,
+            key,
+            value,
         )
-
-
-def get_global_shell(sink: Sink | Literal["stderr", "stdout"] = "stderr"):
-    global global_shell
-    if global_shell is None:
-        global_shell = Shell()
-        if isinstance(sink, str) and sink in ("stderr", "stdout"):
-            sink = cast(Sink, getattr(sys, sink))
-        global_shell.branch_add("default", sink)
-        global_shell.debug(f'"global_shell" is now initialized as {repr(global_shell)}')
-    return global_shell
-
-
-def replace_global_shell(shell: Shell):
-    global global_shell
-    msg = f'"global_shell" has been replaced from {repr(global_shell)} to {repr(shell)}'
-    if global_shell is not None:
-        global_shell.info(msg)
-    global_shell = shell
-    global_shell.debug(msg)

nnlogging/shell_funcs/__init__.py

@@ -0,0 +1,4 @@
+from .branch_ import *
+from .logger_ import *
+from .run_ import *
+from .task_ import *