nnlogging 0.1.0__py3-none-any.whl → 0.1.1__py3-none-any.whl

nnlogging/__init__.py

@@ -1,7 +1,16 @@
-"""nnlog"""
+"""
+Package: `nnlogging`
+Version: ``0.1.1``
+"""
 
-from . import shell
-from . import utils
+from .shell import Shell
+from .utils import LoggerConfig
 
+__all__ = ["Shell"]
 
-__all__ = ["shell", "utils"]
+shell = Shell(
+    "__nnlogging__",
+    logger_config=LoggerConfig(
+        name="__nnlogging__",
+    ),
+)

nnlogging/shell/__init__.py

@@ -0,0 +1,8 @@
+"""
+``nnlogging.shell``
+"""
+
+from .protocol import ShellProtocol
+from .shell import Shell
+
+__all__ = ["Shell", "ShellProtocol"]

nnlogging/shell/exception/__init__.py

@@ -0,0 +1,11 @@
+from .branch_exists import raise_branch_exists_error
+from .branch_not_found import raise_branch_not_found_error
+from .task_exists import raise_task_exists_error
+from .task_not_found import raise_task_not_found_error
+
+__all__ = [
+    "raise_branch_exists_error",
+    "raise_branch_not_found_error",
+    "raise_task_exists_error",
+    "raise_task_not_found_error",
+]

nnlogging/shell/exception/branch_exists.py

@@ -0,0 +1,49 @@
+import sys
+
+if sys.version_info >= (3, 11):
+    from typing import Never
+else:
+    from typing_extensions import Never
+
+from nnlogging.shell.protocol import ShellProtocol
+from nnlogging.typings import BranchExistsError, LogOptions
+from nnlogging.utils import get__debugging, get_name
+
+
+def _branch_exists_msg(
+    inst: ShellProtocol,
+    name: str,
+    /,
+):
+    return f'branch "{name}" already exists in {get_name(inst)}.branches'
+
+
+def _branch_exists_error(
+    inst: ShellProtocol,
+    name: str,
+    /,
+):
+    return BranchExistsError(
+        f'branch "{name}" already exists in {get_name(inst)}.branches: {inst.branches}'
+    )
+
+
+def raise_branch_exists_error(
+    inst: ShellProtocol,
+    name: str,
+    /,
+    *,
+    stacklevel: int = 1,
+) -> Never:
+    try:
+        raise _branch_exists_error(inst, name)
+    except BranchExistsError as e:
+        inst.exception(
+            _branch_exists_msg(inst, name),
+            log_options=LogOptions(
+                exc_info=e,
+                stack_info=get__debugging(inst),
+                stacklevel=stacklevel + 1,
+            ),
+        )
+        raise

nnlogging/shell/exception/branch_not_found.py

@@ -0,0 +1,50 @@
+import sys
+
+if sys.version_info >= (3, 11):
+    from typing import Never
+else:
+    from typing_extensions import Never
+
+
+from nnlogging.shell.protocol import ShellProtocol
+from nnlogging.typings import BranchNotFoundError, LogOptions
+from nnlogging.utils import get__debugging, get_name
+
+
+def _branch_not_found_msg(
+    inst: ShellProtocol,
+    name: str,
+    /,
+):
+    return f'branch "{name}" not found in {get_name(inst)}.branches'
+
+
+def _branch_not_found_error(
+    inst: ShellProtocol,
+    name: str,
+    /,
+):
+    return BranchNotFoundError(
+        f'branch "{name}" not found in {get_name(inst)}.branches: {inst.branches}'
+    )
+
+
+def raise_branch_not_found_error(
+    inst: ShellProtocol,
+    name: str,
+    /,
+    *,
+    stacklevel: int = 1,
+) -> Never:
+    try:
+        raise _branch_not_found_error(inst, name)
+    except BranchNotFoundError as e:
+        inst.exception(
+            _branch_not_found_msg(inst, name),
+            log_options=LogOptions(
+                exc_info=e,
+                stack_info=get__debugging(inst),
+                stacklevel=stacklevel + 1,
+            ),
+        )
+        raise

nnlogging/shell/exception/task_exists.py

@@ -0,0 +1,54 @@
+import sys
+
+if sys.version_info >= (3, 11):
+    from typing import Never
+else:
+    from typing_extensions import Never
+
+from nnlogging.shell.protocol import ShellProtocol
+from nnlogging.typings import LogOptions, TaskExistsError
+from nnlogging.utils import get__debugging, get_name
+
+
+def _task_exists_msg(
+    inst: ShellProtocol,
+    branch: str,
+    name: str,
+    /,
+):
+    return (
+        f'task "{name}" already exists in {get_name(inst)}.branches."{branch}"."tasks"'
+    )
+
+
+def _task_exists_error(
+    inst: ShellProtocol,
+    branch: str,
+    name: str,
+    /,
+):
+    return TaskExistsError(
+        f'task "{name}" already exists in {get_name(inst)}.branches."{branch}"."tasks": {inst.branches[branch]["tasks"]}'
+    )
+
+
+def raise_task_exists_error(
+    inst: ShellProtocol,
+    branch: str,
+    name: str,
+    /,
+    *,
+    stacklevel: int = 1,
+) -> Never:
+    try:
+        raise _task_exists_error(inst, branch, name)
+    except TaskExistsError as e:
+        inst.exception(
+            _task_exists_msg(inst, branch, name),
+            log_options=LogOptions(
+                exc_info=e,
+                stack_info=get__debugging(inst),
+                stacklevel=stacklevel + 1,
+            ),
+        )
+        raise

nnlogging/shell/exception/task_not_found.py

@@ -0,0 +1,50 @@
+import sys
+
+if sys.version_info >= (3, 11):
+    from typing import Never
+else:
+    from typing_extensions import Never
+
+
+from nnlogging.shell.protocol import ShellProtocol
+from nnlogging.typings import LogOptions, TaskNotFoundError
+from nnlogging.utils import get__debugging, get_name
+
+
+def _task_not_found_msg(
+    inst: ShellProtocol,
+    name: str,
+    /,
+):
+    return f'task "{name}" not found in {get_name(inst)}.branches'
+
+
+def _task_not_found_error(
+    inst: ShellProtocol,
+    name: str,
+    /,
+):
+    return TaskNotFoundError(
+        f'task "{name}" not found in {get_name(inst)}.branches: {inst.branches}'
+    )
+
+
+def raise_task_not_found_error(
+    inst: ShellProtocol,
+    name: str,
+    /,
+    *,
+    stacklevel: int = 1,
+) -> Never:
+    try:
+        raise _task_not_found_error(inst, name)
+    except TaskNotFoundError as e:
+        inst.exception(
+            _task_not_found_msg(inst, name),
+            log_options=LogOptions(
+                exc_info=e,
+                stack_info=get__debugging(inst),
+                stacklevel=stacklevel + 1,
+            ),
+        )
+        raise

nnlogging/shell/protocol.py

@@ -0,0 +1,86 @@
+from logging import Logger as LoggingLogger
+from typing import Protocol, runtime_checkable
+
+from aim import Run as AimRun
+from aim.sdk.types import AimObject
+
+from nnlogging.typings import Branch, LogOptions
+from nnlogging.utils import BranchConfig, LoggerConfig, RunConfig
+
+
+@runtime_checkable
+class ShellProtocol(Protocol):
+    logger_config: LoggerConfig
+    run_config: RunConfig
+    branch_config: BranchConfig
+    logger: LoggingLogger | None
+    run: AimRun | None
+    branches: dict[str, Branch]
+
+    def logger_configure(
+        self,
+        config: LoggerConfig | None,
+        /,
+    ): ...
+    def run_configure(
+        self,
+        conf: RunConfig | None,
+        /,
+    ): ...
+    def branch_configure(
+        self,
+        conf: BranchConfig | None,
+        /,
+    ): ...
+    def branch_add(
+        self,
+        name: str,
+        /,
+    ): ...
+    def branch_remove(
+        self,
+        name: str,
+        /,
+    ): ...
+    def task_add(
+        self,
+        name: str,
+        /,
+        *,
+        desc: str,
+        total: float | None,
+    ): ...
+    def task_remove(
+        self,
+        name: str,
+        /,
+    ): ...
+    def log(
+        self,
+        level: int,
+        msg: object,
+        /,
+    ): ...
+    def exception(
+        self,
+        msg: object,
+        /,
+        *,
+        log_options: LogOptions | None = None,
+    ): ...
+    def advance(
+        self,
+        name: str,
+        /,
+        value: float,
+    ): ...
+    def track(
+        self,
+        value: object,
+        /,
+        name: str | None,
+        *,
+        step: int | None,
+        epoch: int | None,
+        context: AimObject,
+    ): ...