Add reporter handler, output handler and reporter manager class structure to conda

conda/common/io.py

@@ -2,11 +2,14 @@
 # SPDX-License-Identifier: BSD-3-Clause
 """Common I/O utilities."""
 
+from __future__ import annotations
+
 import json
 import logging
 import os
 import signal
 import sys
+from abc import ABC, abstractmethod
 from collections import defaultdict
 from concurrent.futures import Executor, Future, ThreadPoolExecutor, _base, as_completed
 from concurrent.futures.thread import _WorkItem
@@ -20,6 +23,7 @@
 from os.path import dirname, isdir, isfile, join
 from threading import Event, Lock, RLock, Thread
 from time import sleep, time
+from typing import Dict, Union
 
 from ..auxlib.decorators import memoizemethod
 from ..auxlib.logz import NullHandler
@@ -689,6 +693,130 @@
             os.makedirs(dirname(self.record_file))
 
 
+Reporter = Dict[str, Union[bool, int, str]]
+DetailRecord = Dict[str, Union[str, int, bool]]
+
+
+class ReporterHandlerBase(ABC):
+    """
+    Base class for all reporter handlers
+    """
+
+    @abstractmethod
+    def detail_view(self, data: DetailRecord, **kwargs) -> str:
+        """
+        This method is responsible for generating the output in a "tabular" format.
+        """
+        ...
+
+    @abstractmethod
+    def string_view(self, data: str, **kwargs) -> str:
+        """
+        This method returns simple string output.
+        """
+        ...
+
+
+class ConsoleHandler(ReporterHandlerBase):
+    """
+    Reporter handler for standard output (classic output).
+    """
+
+    def detail_view(self, data: DetailRecord, **kwargs) -> str:
+        table_str = ""
+        longest_header = len(sorted(data.keys(), key=len).pop())
+
+        for header, value in data.items():
+            row_header = header.ljust(longest_header, " ")
+            table_str += f"{row_header} : {value}\n"
+
+        return table_str
+
+    def string_view(self, data: str, **kwargs) -> str:
+        return data
+
+
+class JSONHandler(ReporterHandlerBase):
+    """
+    Reporter handler for JSON output.
+    """
+
+    def detail_view(self, data: DetailRecord, **kwargs) -> str:
+        json_str = json.dumps(data)
+
+        return json_str
+
+    def string_view(self, data: str, **kwargs) -> str:
+        json_str = json.dumps(data)
+
+        return json_str
+
+
+class OutputHandlerBase(ABC):
+    """
+    Base class for all output handlers
+    """
+
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """
+        Name of the output handler; this will be how this output handler is referenced
+        in configuration files
+        """
+        ...
+
+    @abstractmethod
+    def render(self, renderable: str, **kwargs) -> None:
+        """Render implementation goes here"""
+        ...
+
+
+class StdoutHandler(OutputHandlerBase):
+    """
+    Handles writing output strings to stdout.
+    """
+
+    @property
+    def name(self) -> str:
+        return "stdout"
+
+    def render(self, renderable: str, **kwargs) -> None:
+        sys.stdout.write(renderable)
+
+
+class ReporterManager:
+    """
+    This is the glue that holds together the ``ReporterHandler`` implementations with the
+    ``OutputHandler`` implementations. A single ``render`` method is provided for rendering
+    our configured reporter handlers.
+    """
+
+    def __init__(self, reporters: tuple[Reporter, ...]) -> None:
+        self._reporters = reporters
+        self._reporter_handlers = {
+            "console": ConsoleHandler(),
+            "json": JSONHandler(),
+        }
+        self._output_handlers = {
+            "stdout": StdoutHandler(),
+        }
+
+    def render(self, name, data, **kwargs) -> None:
+        for reporter in self._reporters:
+            reporter_handler = self._reporter_handlers.get(reporter.get("backend"))
+            output_handler = self._output_handlers.get(reporter.get("output"))
+
+            if reporter_handler is not None and output_handler is not None:
+                render_func = getattr(reporter_handler, name, None)
+                if render_func is None:
+                    raise AttributeError(
+                        f"'{name}' is not a valid reporter handler component"
+                    )
+                render_str = render_func(data, **kwargs)
+                output_handler.render(render_str, **reporter)
+
+
 def print_instrumentation_data():  # pragma: no cover
     record_file = get_instrumentation_record_file()
 

tests/common/test_io.py

@@ -1,10 +1,22 @@
 # Copyright (C) 2012 Anaconda, Inc
 # SPDX-License-Identifier: BSD-3-Clause
+import json
 import sys
 from io import StringIO
 from logging import DEBUG, NOTSET, WARN, getLogger
 
-from conda.common.io import CaptureTarget, attach_stderr_handler, captured
+import pytest
+from pytest import CaptureFixture
+
+from conda.common.io import (
+    CaptureTarget,
+    ConsoleHandler,
+    JSONHandler,
+    ReporterManager,
+    StdoutHandler,
+    attach_stderr_handler,
+    captured,
+)
 
 
 def test_captured():
@@ -80,3 +92,76 @@ def test_attach_stderr_handler():
     assert c.stdout == ""
     assert "test message" in c.stderr
     assert debug_message in c.stderr
+
+
+def test_console_handler():
+    """
+    Tests the ConsoleHandler ReporterHandler class
+    """
+    test_data = {"one": "value_one", "two": "value_two", "three": "value_three"}
+    test_str = "a string value"
+    expected_table_str = "one   : value_one\ntwo   : value_two\nthree : value_three\n"
+    console_handler_object = ConsoleHandler()
+    table_str = console_handler_object.detail_view(test_data)
+
+    assert table_str == expected_table_str
+    assert console_handler_object.string_view(test_str) == test_str
+
+
+def test_json_handler():
+    """
+    Tests the JsonHandler ReporterHandler class
+    """
+    test_data = {"one": "value_one", "two": "value_two", "three": "value_three"}
+    test_str = "a string value"
+    json_handler_object = JSONHandler()
+    assert json_handler_object.detail_view(test_data) == json.dumps(test_data)
+    assert json_handler_object.string_view(test_str) == json.dumps(test_str)
+
+
+def test_std_out_handler(capsys: CaptureFixture):
+    """
+    Tests the StdoutHandler OutputHandler class
+    """
+    test_str = "a string value"
+    std_out_handler_object = StdoutHandler()
+    assert std_out_handler_object.name == "stdout"
+    std_out_handler_object.render(test_str)
+    stdout = capsys.readouterr()
+    assert test_str in stdout
+
+
+def test_reporter_manager(capsys: CaptureFixture):
+    """
+    Tests the ReporterManager class
+    """
+    reporters = (
+        {"backend": "console", "output": "stdout"},
+        {"backend": "json", "output": "stdout"},
+    )
+    test_data = {"one": "value_one", "two": "value_two", "three": "value_three"}
+    test_str = "a string value"
+
+    # the expected output is output via ConsoleHandler.detail_view  plus JsonHandler.detail_view.
+    expected_detail_view_str = f"one   : value_one\ntwo   : value_two\nthree : value_three\n{json.dumps(test_data)}"
+    expected_string_view_str = f"a string value{json.dumps(test_str)}"
+
+    reporter_manager_object = ReporterManager(reporters)
+
+    # test detail view passes
+    reporter_manager_object.render("detail_view", test_data)
+    stdout = capsys.readouterr()
+    assert expected_detail_view_str in stdout
+
+    # test string view passes
+    reporter_manager_object.render("string_view", test_str)
+    stdout = capsys.readouterr()
+    assert expected_string_view_str in stdout
+
+    # test fails
+    with pytest.raises(AttributeError) as err:
+        reporter_manager_object.render("non_existent_view", test_data)
+    assert (
+        str(err.value)
+        == "'non_existent_view' is not a valid reporter handler component"
+    )