socx-cli 0.13.3__tar.gz → 0.13.4__tar.gz

{socx_cli-0.13.3 → socx_cli-0.13.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: socx-cli
-Version: 0.13.3
+Version: 0.13.4
 Summary: System on chip verification and tooling infrastructure.
 Project-URL: Issues, https://github.com/sagikimhi/socx-cli/issues
 Project-URL: Homepage, https://sagikimhi.dev/socx-cli
@@ -31,6 +31,7 @@ Requires-Python: >=3.12
 Requires-Dist: anyio>=4.12.1
 Requires-Dist: click
 Requires-Dist: copier~=9.11
+Requires-Dist: declare
 Requires-Dist: dynaconf<3.2.12
 Requires-Dist: gitpython
 Requires-Dist: hoptex

{socx_cli-0.13.3 → socx_cli-0.13.4}/pyproject.toml

@@ -29,7 +29,7 @@ socx = 'socx.__main__:main'
 [project]
 name = "socx-cli"
 readme = "README.md"
-version = "0.13.3"
+version = "0.13.4"
 license = "Apache-2.0"
 authors = [{ name = "Sagi Kimhi", email = "sagi.kim5@gmail.com" }]
 maintainers = [{ name = "Sagi Kimhi", email = "sagi.kim5@gmail.com" }]
@@ -59,6 +59,7 @@ dependencies = [
     "pip",
     "rich",
     "click",
+    "declare",
     "typer~=0.19",
     "jinja2",
     "psutil",

{socx_cli-0.13.3 → socx_cli-0.13.4}/socx/__init__.py

@@ -47,7 +47,6 @@ __all__ = (
     "DEFAULT_HANDLERS",
     "DEFAULT_TIME_FORMAT",
     "Level",
-    "log",
     "log_it",
     "logger",
     "console",
@@ -135,7 +134,6 @@ __all__ = (
     "Regression",
     "TestStatus",
     "TestResult",
-    "RegressionTree",
     "RegressionProgress",
 )
 
@@ -180,11 +178,6 @@ from socx.core import deduplicate as deduplicate
 
 from socx.utils import join_decorators as join_decorators
 
-from socx.io import log as log
-from socx.io import DEFAULT_LEVEL as DEFAULT_LEVEL
-from socx.io import DEFAULT_FORMAT as DEFAULT_FORMAT
-from socx.io import DEFAULT_HANDLERS as DEFAULT_HANDLERS
-from socx.io import DEFAULT_TIME_FORMAT as DEFAULT_TIME_FORMAT
 from socx.io import Level as Level
 from socx.io import log_it as log_it
 from socx.io import logger as logger
@@ -264,7 +257,6 @@ from socx.regression import TestBase as TestBase
 from socx.regression import Regression as Regression
 from socx.regression import TestStatus as TestStatus
 from socx.regression import TestResult as TestResult
-from socx.regression import RegressionTree as RegressionTree
 from socx.regression import RegressionProgress as RegressionProgress
 
 from socx.cli import FuncType as FuncType

{socx_cli-0.13.3 → socx_cli-0.13.4}/socx/cli/callbacks.py

@@ -12,7 +12,7 @@ from rich_click import Context
 from rich_click import Parameter
 from rich_click import RichContext
 
-import socx.io.log as log
+from socx.io.log import Level, set_level, get_level, _get_logger
 from socx.io.console import console
 from socx.io.decorators import log_it
 from socx.config._config import settings
@@ -45,10 +45,11 @@ def cwd_cb(ctx: Context, param: Parameter, value: Path) -> Path:
 @log_it(logger=logger)
 def debug_cb(_: Context, param: Parameter, value: bool) -> bool:
     """Enable debug logging and persist the CLI switch to settings."""
+    socx_logger = _get_logger()
     settings.cli.params[param.name] = value
     if value:
-        log.set_level(log.Level.DEBUG)
-        settings.cli.params["verbosity"] = log.get_level().name
+        set_level(Level.DEBUG, socx_logger)
+        settings.cli.params["verbosity"] = get_level().name
     return value
 
 
@@ -88,10 +89,11 @@ def configure_cb(ctx: Context, param: Parameter, value: str) -> str:
 @log_it(logger=logger)
 def verbosity_cb(_: Context, param: Parameter, value: str) -> str:
     """Update the global log level while respecting existing overrides."""
-    level = log.Level[value.upper()]
+    socx_logger = _get_logger()
+    level = Level[value.upper()]
     if not settings.cli.params.debug:
-        log.set_level(level)
-    settings.cli.params[param.name] = log.get_level().name
+        set_level(level, socx_logger)
+    settings.cli.params[param.name] = get_level().name
     return settings.cli.params[param.name]
 
 

{socx_cli-0.13.3 → socx_cli-0.13.4}/socx/core/_paths.py

@@ -109,8 +109,11 @@ USER_LOG_DIR: Path = user_log_path(
 ).resolve()
 """Absolute path to platform's native application logs directory."""
 
-USER_LOG_FILENAME: str = f"{__appname__}.log"
-"""File name of application's native log file used for debug and tracing."""
+USER_LOG_FILENAME: str = f"{__appname__}_log.log"
+"""File name of application's log file."""
+
+USER_ROTATING_LOG_FILENAME: str = f"rotating_{__appname__}_log.log"
+"""File name of application's rotating log file."""
 
 USER_CONFIG_FILENAME: str = f"{__appname__}.yaml"
 """File name searched in user's config directory to load user configs."""
@@ -118,6 +121,9 @@ USER_CONFIG_FILENAME: str = f"{__appname__}.yaml"
 USER_LOG_FILE: Path = USER_LOG_DIR / USER_LOG_FILENAME
 """Absolute path to application's main log for the current local user."""
 
+USER_ROTATING_LOG_FILE: Path = USER_LOG_DIR / USER_ROTATING_LOG_FILENAME
+"""Absolute path to application's rotating log for the current local user."""
+
 USER_CONFIG_FILE: Path = USER_CONFIG_DIR / USER_CONFIG_FILENAME
 """Absolute path to application's user config file."""
 

{socx_cli-0.13.3 → socx_cli-0.13.4}/socx/io/__init__.py

@@ -1,8 +1,6 @@
 """Expose logging, console, and decorator utilities for I/O facilities."""
 
 __all__ = (
-    # Modules
-    "log",
     # Constants
     "DEFAULT_LEVEL",
     "DEFAULT_FORMAT",
@@ -32,12 +30,6 @@ __all__ = (
     "print_command_outputs",
 )
 
-from socx.io import log as log
-
-from socx.io.log import DEFAULT_LEVEL as DEFAULT_LEVEL
-from socx.io.log import DEFAULT_FORMAT as DEFAULT_FORMAT
-from socx.io.log import DEFAULT_HANDLERS as DEFAULT_HANDLERS
-from socx.io.log import DEFAULT_TIME_FORMAT as DEFAULT_TIME_FORMAT
 from socx.io.log import Level as Level
 from socx.io.log import logger as logger
 from socx.io.log import get_level as get_level

{socx_cli-0.13.3 → socx_cli-0.13.4}/socx/io/log.py

@@ -1,19 +1,21 @@
 """Logging helpers that standardise Rich-powered output across SoCX."""
 
 from __future__ import annotations
+from types import ModuleType
 
-import os
 import enum
 import logging
 import logging.handlers
-from typing import Any
+from typing import Any, IO
 from pathlib import Path
 from collections import ChainMap
 from collections.abc import Iterable
 
 from rich.console import Console
 from rich.logging import RichHandler
-from platformdirs import user_log_path
+
+from socx.config._config import settings
+from socx.core.metadata import __appname__
 
 __all__ = (
     # Logging
@@ -39,10 +41,7 @@ __all__ = (
     # Types
     "Level",
     # Defaults
-    "DEFAULT_LEVEL",
-    "DEFAULT_FORMAT",
     "DEFAULT_HANDLERS",
-    "DEFAULT_TIME_FORMAT",
 )
 
 
@@ -59,95 +58,195 @@ class Level(enum.IntEnum):
     CRITICAL = logging.CRITICAL
 
 
-def _get_console_handler(level: Level = Level.INFO) -> logging.Handler:
+def _get_console(
+    file: IO | None = None,
+    stderr: bool = False,
+    markup: bool = True,
+    tab_size: int = 4,
+    force_terminal: bool = True,
+    **kwargs: Any,
+) -> Console:
+    defaults = dict(
+        file=file,
+        markup=markup,
+        stderr=stderr,
+        tab_size=tab_size,
+        force_terminal=force_terminal,
+    )
+    kwargs = dict(ChainMap(kwargs, defaults))
+    return Console(**kwargs)
+
+
+def _get_level(level: str | int | Level) -> Level:
+    if isinstance(level, str):
+        level = Level[level]
+    elif isinstance(level, int):
+        level = Level(level)
+    return level
+
+
+def _get_console_handler(
+    file: IO | None = None,
+    level: int | str | Level = Level.INFO,
+    stderr: bool = False,
+    tab_size: int = 4,
+    tracebacks: bool = True,
+    force_terminal: bool = True,
+    tracebacks_theme: str | None = None,
+    tracebacks_suppress: Iterable[ModuleType] | None = None,
+    tracebacks_show_locals: bool = True,
+) -> logging.Handler:
     """Create a Rich console handler configured for interactive output."""
-    console = Console(tab_size=4, markup=True, force_terminal=True)
-    return RichHandler(
-        level=level,
+    import click
+    import rich_click
+    from socx.io.console import console as _console
+
+    level = _get_level(level)
+    tracebacks_theme = tracebacks_theme or "ansi_dark"
+    tracebacks_suppress = tracebacks_suppress or [click, rich_click]
+    if file is None and stderr is None:
+        console = _console
+    else:
+        console = _get_console(
+            file=file,
+            stderr=stderr,
+            tab_size=tab_size,
+            force_terminal=force_terminal,
+        )
+    handler = RichHandler(
         console=console,
-        tracebacks_suppress=("rich-click", "click"),
-        rich_tracebacks=True,
-        tracebacks_show_locals=True,
+        rich_tracebacks=tracebacks,
+        tracebacks_theme=tracebacks_theme,
+        tracebacks_suppress=tracebacks_suppress,
+        tracebacks_show_locals=tracebacks_show_locals,
     )
+    formatter = logging.Formatter(**settings.logging.formatters.default)
+    handler.name = "console"
+    handler.setLevel(level)
+    handler.setFormatter(formatter)
+    return handler
 
 
 def _get_file_handler(
-    path: str | Path, level: Level = Level.NOTSET
+    path: str | Path,
+    mode: str | None = None,
+    level: Level = Level.INFO,
+    stderr: bool = False,
+    tab_size: int = 4,
+    tracebacks: bool = True,
+    force_terminal: bool = False,
+    tracebacks_theme: str | None = None,
+    tracebacks_suppress: Iterable[ModuleType] | None = None,
+    tracebacks_show_locals: bool = True,
+) -> logging.Handler:
+    import atexit
+
+    def close_if_open(file: IO) -> None:
+        if not file.closed:
+            file.close()
+
+    mode = mode or "a"
+    file = open(path, mode=mode)  # noqa: SIM115
+    atexit.register(close_if_open, file)
+    handler = _get_console_handler(
+        file=file,
+        level=level,
+        stderr=stderr,
+        tab_size=tab_size,
+        tracebacks=tracebacks,
+        force_terminal=force_terminal,
+        tracebacks_theme=tracebacks_theme,
+        tracebacks_suppress=tracebacks_suppress,
+        tracebacks_show_locals=tracebacks_show_locals,
+    )
+    handler.name = "file"
+    handler.setFormatter(DEFAULT_CHILD_FORMATTER)
+    return handler
+
+
+def _get_rotating_file_handler(
+    path: str | Path,
+    level: Level = Level.DEBUG,
+    stderr: bool = False,
+    mode: str | None = None,
 ) -> logging.Handler:
     """Create a Rich handler that writes log output to ``path``."""
+
+    def MBs(n: int) -> int:  # noqa: N802
+        return 1024 * 1024 * n
+
+    mode = mode or "w"
     handler = logging.handlers.RotatingFileHandler(
-        path, maxBytes=1024 * 1024 * 5, backupCount=5
+        # no particular reason for size or backup count - arbitrarily chosen
+        path,
+        mode=mode,
+        maxBytes=MBs(10),
+        backupCount=5,
     )
+    handler.name = "rotating_file"
     handler.setLevel(level)
-    handler.setFormatter(
-        logging.Formatter(DEFAULT_CHILD_FORMAT, DEFAULT_TIME_FORMAT)
-    )
+    handler.setFormatter(DEFAULT_CHILD_FORMATTER)
     return handler
 
 
-APP_LIB_NAME = __name__.partition(".")[0]
-"""Application library namespace used for loggers."""
+def _get_handler(handler: str) -> logging.Handler | None:
+    match handler:
+        case "file":
+            return _get_file_handler(**settings.logging.handlers.file)
+        case "console":
+            return _get_console_handler(**settings.logging.handlers.console)
+        case "rotating_file":
+            return _get_rotating_file_handler(
+                **settings.logging.handlers.rotating_file
+            )
+        case _:
+            return None
+
+
+def _get_logger() -> logging.Logger:
+    """Initialise and return the module-level root logger."""
+    socx_logger = logging.getLogger(__appname__)
+
+    if not socx_logger.hasHandlers():
+        unknown_handlers = []
 
-DEFAULT_ENCODING: str = "utf-8"
-"""Default text encoding for emitted log files."""
+        for handler_name in settings.logging.handlers:
+            handler = _get_handler(handler_name)
+            if handler is not None:
+                socx_logger.addHandler(handler)
+            else:
+                unknown_handlers.append(handler_name)
 
-DEFAULT_LEVEL: Level = Level[os.environ.get("SOCX_VERBOSITY", "FATAL")]
-"""Default logger level, a.k.a verbosity."""
+        for handler in unknown_handlers:
+            msg = f"Ignored unknown handler configuration: '{handler}'"
+            socx_logger.warning(msg)
 
-DEFAULT_FORMAT: str = os.environ.get("SOCX_LOG_FORMAT", "%(message)s")
-"""Default log message format used by the root handler."""
+    return socx_logger
 
-DEFAULT_TIME_FORMAT: str = os.environ.get("SOCX_TIME_FORMAT", "[%x %X]")
-"""Default timestamp format injected into log records."""
 
-DEFAULT_CHILD_FORMAT: str = os.environ.get(
-    "SOCX_LOG_FORMAT",
-    "%(asctime)s %(levelname)5s - %(filename)5s:%(lineno)-4d - %(message)s",
+DEFAULT_FORMATTER: logging.Formatter = logging.Formatter(
+    **settings.logging.formatters.default
 )
-"""Message format for child loggers that also emit timestamps."""
+"""Default application logging formatter."""
 
 DEFAULT_CHILD_FORMATTER: logging.Formatter = logging.Formatter(
-    DEFAULT_CHILD_FORMAT, DEFAULT_TIME_FORMAT
+    **settings.logging.formatters.child
 )
 """Formatter applied to file handlers registered on child loggers."""
 
-DEFAULT_LOG_DIRECTORY: Path = Path(
-    os.environ.get(
-        "SOCX_LOG_DIR",
-        user_log_path(appname=APP_LIB_NAME, ensure_exists=True),
-    )
-)
-"""Default application log directory."""
-
-DEFAULT_LOG_FILE: str = os.environ.get("SOCX_LOG_FILE", f"{APP_LIB_NAME}.log")
-"""Default application log file."""
-
 DEFAULT_HANDLERS: list[logging.Handler] = [
-    _get_console_handler(DEFAULT_LEVEL),
-    _get_file_handler(DEFAULT_LOG_DIRECTORY / DEFAULT_LOG_FILE),
+    _get_file_handler(**settings.logging.handlers.file),
+    _get_console_handler(**settings.logging.handlers.console),
+    _get_rotating_file_handler(**settings.logging.handlers.rotating_file),
 ]
 """Handlers attached to the module-level logger by default."""
 
-DEFAULT_LOGGING_CONFIG: dict[str, Any] = dict(
-    level=DEFAULT_LEVEL,
-    format=DEFAULT_FORMAT,
-    handlers=DEFAULT_HANDLERS,
-    encoding=DEFAULT_ENCODING,
-    datefmt=DEFAULT_TIME_FORMAT,
-)
-
-
-def _get_logger(**kwargs: Any) -> logging.Logger:
-    """Initialise and return the module-level root logger."""
-    logging.basicConfig(**dict(ChainMap(kwargs, DEFAULT_LOGGING_CONFIG)))
-    return logging.getLogger(APP_LIB_NAME)
-
 
 def get_logger(name: str, filename: str | None = None) -> logging.Logger:
     """Return a child logger configured with optional file output."""
     rv = logger.getChild(name)
     if filename is not None:
-        handler = _get_file_handler(filename)
+        handler = _get_rotating_file_handler(filename)
         handler.setFormatter(DEFAULT_CHILD_FORMATTER)
         rv.addHandler(handler)
     return rv
@@ -243,8 +342,11 @@ def get_level(logger_: logging.Logger | None = None) -> Level:
 
 
 def set_level(level: Level, logger_: logging.Logger | None = None) -> None:
-    """Set the log level on the provided logger (defaults to module logger)."""
+    """Set the log level on ``logger_`` and all currently attached handlers."""
     logger_ = logger_ or logger
+    level = level if isinstance(level, str | int) else level.value
+    for handler in logger_.handlers:
+        handler.setLevel(level)
     logger_.setLevel(level)
 
 

{socx_cli-0.13.3 → socx_cli-0.13.4}/socx/regression/__init__.py

@@ -6,7 +6,6 @@ __all__ = (
     "TestStatus",
     "TestResult",
     "Regression",
-    "RegressionTree",
     "RegressionProgress",
 )
 
@@ -15,5 +14,4 @@ from socx.regression.test import TestBase as TestBase
 from socx.regression.test import TestStatus as TestStatus
 from socx.regression.test import TestResult as TestResult
 from socx.regression.regression import Regression as Regression
-from socx.regression.regression import RegressionTree as RegressionTree
 from socx.regression.progress import RegressionProgress as RegressionProgress

{socx_cli-0.13.3 → socx_cli-0.13.4}/socx/regression/progress.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
 
 import anyio
-import anyio.lowlevel
 import logging
+from typing import Any
+from collections import ChainMap
 
 from rich.progress import (
     Progress as BaseProgress,
@@ -17,30 +18,23 @@ from rich.progress import (
     Task,
 )
 
-from socx.io.console import console
 from socx.regression.test import TestStatus
 from socx.regression.regression import Regression
 
+
 logger = logging.getLogger(__name__)
 
 
 class PipelineProgress(BaseProgress):
-    def __init__(self) -> None:
-        super().__init__(
-            *self.get_default_columns(),
-            speed_estimate_period=10,
-            redirect_stderr=True,
-            redirect_stdout=True,
-            console=console,
-        )
+    def __init__(self, **kwargs: Any) -> None:
+        kwargs = dict(ChainMap(kwargs, dict(speed_estimate_period=10)))
+        super().__init__(*self.get_default_columns(), **kwargs)
 
     @classmethod
     def get_default_columns(cls) -> tuple[ProgressColumn, ...]:
         return (
             SpinnerColumn(),
-            TextColumn(
-                "[progress.description]{task.description}", justify="right"
-            ),
+            TextColumn("[progress.description]{task.description}"),
             MofNCompleteColumn(),
             BarColumn(),
             TaskProgressColumn(),
@@ -56,11 +50,7 @@ class RegressionProgress:
         self.tasks = {}
         self.total = len(regression)
         self.regression = regression
-        self.progress_map = {}
-        # for child in self.regression.tests:
-        #     if isinstance(child, Regression):
-        #         self.progress_map[child.id] = PipelineProgress()
-        self.progress_map[self.regression.id] = PipelineProgress()
+        self.progress = PipelineProgress()
 
     def __len__(self) -> int:
         """Get the total number of test items in a regression's progress."""
@@ -72,11 +62,20 @@ class RegressionProgress:
         exclude: set[str] | None = None,
     ) -> None:
         """Update progress tasks and flush log messages while running."""
-        with (
-            console.status("regression running..."),
-            PipelineProgress() as progress,
-        ):
-            self.progress_map[self.regression.id] = progress
+        with self.progress:
+            if include is None and exclude is None:
+                async with anyio.create_task_group() as tg:
+                    for obj in self.regression.tests:
+                        tg.start_soon(
+                            self.track_regression,
+                            obj,
+                            name=f"track_{obj.name}_progress",
+                        )
+                    tg.start_soon(
+                        self.regression.start,
+                        name=f"{self.regression.name}",
+                    )
+                return
 
             async with anyio.create_task_group() as tg:
                 for obj in self.regression.tests:
@@ -86,41 +85,31 @@ class RegressionProgress:
                     if include is not None and obj.name not in include:
                         continue
 
-                    if isinstance(obj, Regression):
-                        track_task_func = self.track_regression
-                        track_task_name = f"track_{obj.name}_progress"
+                    if isinstance(obj, Regression) and not obj.started:
+                        tg.start_soon(obj.start, name=obj.name)
                         tg.start_soon(
-                            track_task_func, obj, name=track_task_name
+                            self.track_regression,
+                            obj,
+                            name=f"track_{obj.name}_progress",
                         )
 
-                        run_task_func = obj.start
-                        run_task_name = f"run_{obj.name}"
-                        tg.start_soon(run_task_func, name=run_task_name)
-
-                if include is None and exclude is None:
-                    run_task_func = self.regression.start
-                    run_task_name = f"run_{self.regression.name}"
-                    tg.start_soon(run_task_func, name=run_task_name)
-
-            del self.progress_map[self.regression.id]
-
     async def track_regression(self, regression: Regression) -> None:
-        progress = self.progress_map[self.regression.id]
+        finished = 0
+        status = TestStatus.Idle
+        progress = self.progress
+
         if regression.id not in self.tasks:
             self.tasks[regression.id] = progress.add_task(
                 total=len(regression),
                 description=(
-                    f"[light_red]{regression.name}: {regression.status.name}"
+                    f"[gray39]{self._get_task_tag(regression)}: "
+                    f"{regression.status.name}"
                 ),
             )
-        await self._track_regression(regression)
 
-    async def _track_regression(self, regression: Regression) -> None:
-        finished = 0
-        status = regression.status
-        while True:
+        while not progress.finished:
             if regression.finished:
-                await self.update_regression(regression, len(regression))
+                self.update_regression(regression, len(regression))
                 break
 
             prev_status = status
@@ -133,39 +122,49 @@ class RegressionProgress:
             )
 
             if prev_finished != finished or prev_status != status:
-                await self.update_regression(regression, finished)
+                self.update_regression(regression, finished)
 
-            await anyio.sleep(0.1)
+            await anyio.sleep(0.5)
 
-    async def advance_regression(self, regression: Regression, n: int) -> None:
-        progress = self.progress_map.get(self.regression.id)
+    def advance_regression(self, regression: Regression, n: int) -> None:
+        progress = self.progress
         tid = self.tasks.get(regression.id)
         if progress is not None and tid is not None:
             task = progress.tasks[tid]
-            await self.update_regression(regression, task.completed + n)
+            self.update_regression(regression, task.completed + n)
 
-    async def update_regression(self, regression: Regression, n: int) -> None:
-        progress = self.progress_map.get(self.regression.id)
+    def update_regression(self, regression: Regression, n: int) -> None:
+        progress = self.progress
         tid = self.tasks.get(regression.id)
         if progress is not None and tid is not None:
             task: Task = progress.tasks[tid]
-            if task.completed >= n:
-                return
 
-            if task.completed < n:
-                description = (
-                    f"[yellow]{regression.name}: {regression.status.name}"
+            if (
+                regression.is_idle()
+                or regression.is_pending()
+                or regression.is_suspended()
+            ):
+                task.description = (
+                    f"[gray39]{self._get_task_tag(regression)}: "
+                    f"{regression.status.name}"
                 )
-            else:
-                description = (
-                    f"[green]{regression.name}: {regression.status.name}"
+            elif regression.is_running():
+                task.description = (
+                    f"[yellow]{self._get_task_tag(regression)}: "
+                    f"{regression.status.name}"
+                )
+            elif regression.finished:
+                task.description = (
+                    f"[green]{self._get_task_tag(regression)}: "
+                    f"{regression.status.name}"
+                )
+            elif regression.terminated:
+                task.description = (
+                    f"[red]{self._get_task_tag(regression)}: "
+                    f"{regression.status.name}"
                 )
 
-            progress.update(
-                tid,
-                completed=min(n, task.total),
-                description=description,
-            )
+            task.completed = min(n, task.total)
 
     def _count_statuses(
         self, regression: Regression, *statuses: TestStatus
@@ -174,3 +173,6 @@ class RegressionProgress:
             return sum(
                 1 for test in regression.tests if test.status in statuses
             )
+
+    def _get_task_tag(self, regression: Regression) -> str:
+        return f"{regression.__class__.__name__}({regression.name})"