pocketutils.tools.sys_tools

Complexity

Total Complexity

7

Size/Duplication

Total Lines	62
Duplicated Lines	0 %

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	SystemTools.trace_signals()	0	9	2
A	ExitHandler.__call__()	0	5	2
A	SystemTools.trace_exit()	0	6	1
A	SignalHandler.__call__()	0	5	2

"""
Low-level tools (e.g. memory management).
"""
import atexit
import signal
import sys
import traceback
from collections import Callable

The name Callable does not seem to exist in module collections.

from dataclasses import dataclass
from typing import Any, Union

from pocketutils.core.input_output import Writeable

The name core does not seem to exist in module pocketutils.

from pocketutils.tools.base_tools import BaseTools


@dataclass(frozen=True, repr=True)

Missing class docstring

class SignalHandler:
    name: str
    code: int
    desc: str
    sink: Union[Writeable, Callable[[str], Any]]

    def __call__(self):
        sys.stderr.write(f"~~{self.name}[{self.code}] ({self.desc})~~")
        traceback.print_stack(file=sys.stderr)
        for line in traceback.format_stack():
            sys.stderr.write(line)


@dataclass(frozen=True, repr=True)

Missing class docstring

class ExitHandler:
    sink: Writeable

    def __call__(self):
        self.sink.write(f"~~EXIT~~")

Using an f-string that does not have any interpolated variables

        traceback.print_stack(file=sys.stderr)
        for line in traceback.format_stack():
            self.sink.write(line)


class SystemTools(BaseTools):

Missing class docstring

    @classmethod
    def trace_signals(cls, sink: Writeable = sys.stderr) -> None:
        """
        Registers signal handlers for all signals that log the traceback.
        Uses ``signal.signal``.
        """
        for sig in signal.valid_signals():

The Module signal does not seem to have a member named valid_signals.

            handler = SignalHandler(sig.name, sig.value, signal.strsignal(sig), sink)

The Module signal does not seem to have a member named strsignal.

            signal.signal(sig.value, handler)

    @classmethod
    def trace_exit(cls, sink: Writeable = sys.stderr) -> None:
        """
        Registers an exit handler via ``atexit.register`` that logs the traceback.
        """
        atexit.register(ExitHandler(sink))


__all__ = ["SignalHandler", "ExitHandler", "SystemTools"]