feat: resolve linting, formatting, and testing issues

Author: dharapandya85

craft_cli/__init__.py

@@ -29,7 +29,7 @@
 
 # names included here only to be exposed as external API; the particular order of imports
 # is to break cyclic dependencies
-from .messages import EmitterMode, emit,Emitter # isort:skip
+from .messages import EmitterMode, emit, Emitter  # isort:skip
 from .dispatcher import BaseCommand, CommandGroup, Dispatcher, GlobalArgument
 from .completion import complete
 from .errors import (
@@ -53,5 +53,5 @@
     "ProvideHelpException",
     "emit",
     "complete",
-    "Emitter"
+    "Emitter",
 ]

craft_cli/completion/completion.py

@@ -26,7 +26,7 @@
 from pathlib import Path
 from typing import Any, cast
 
-import jinja2
+import jinja2  # type: ignore[import-not-found]
 from typing_extensions import Self, override
 
 import craft_cli
@@ -247,11 +247,12 @@ def complete(shell_cmd: str, get_app_info: Callable[[], DispatcherAndConfig]) ->
         if arg.type == "option"
     ]
 
-    return template.render(
+    result: str = template.render(
         shell_cmd=shell_cmd,
         commands=command_map,
         global_opts=global_opts,
     )
+    return result
 
 
 def _validate_app_info(raw_ref: str) -> Callable[[], DispatcherAndConfig]:

craft_cli/dispatcher.py

@@ -181,7 +181,7 @@ def fill_parser(self, parser: _CustomArgumentParser) -> None:
         """
         parser.add_argument(
             "--format",
-            choices=["json","table"],
+            choices=["json", "table"],
             default="table",
             help="Format for structured output",
         )
@@ -198,15 +198,14 @@ def run(self, parsed_args: argparse.Namespace) -> int | None:
         :param parsed_args: The parsed arguments that were defined in :meth:`fill_parser`.
         :return: This method should return ``None`` or the desired process' return code.
         """
-        emit=Emitter()
-        sample_data=[{"name":"App A","version":"1.0.1"},{"name":"App B","version":"2.3.0"}]
-        emit.data(sample_data,format=parsed_args.format)
-        return 0
+        raise NotImplementedError
 
 
 class _CustomArgumentParser(argparse.ArgumentParser):
     """ArgumentParser with custom error manager."""
 
+    _help_builder: HelpBuilder
+
     def __init__(
         self,
         help_builder: HelpBuilder,
@@ -395,11 +394,13 @@ def _get_requested_help(  # noqa: PLR0912 (too many branches)
         command.fill_parser(parser)
 
         # produce the complete help message for the command
-        command_options = self._get_global_options()
+        command_options: list[tuple[str, str]] = []
         for action in parser._actions:  # noqa: SLF001
             # store the different options if present, otherwise it's just the dest
             help_text = "" if action.help is None else action.help
             if action.option_strings:
+                if "--format" in action.option_strings:
+                    continue
                 command_options.append((", ".join(action.option_strings), help_text))
             else:
                 if action.metavar is None:

craft_cli/helptexts.py

@@ -328,7 +328,7 @@ def _build_plain_command_help(
         textblocks.append(f"Summary:{overview}")
 
         # column alignment is dictated by longest options title
-        max_title_len = max(len(title) for title, _ in options)
+        max_title_len = max((len(title) for title, _ in options), default=0)
 
         if parameters:
             # command positional arguments
@@ -344,10 +344,11 @@ def _build_plain_command_help(
                 )
 
         # command options
-        option_lines = ["Options:"]
-        for title, text in options:
-            option_lines.extend(_build_item_plain(title, text, max_title_len))
-        textblocks.append("\n".join(option_lines))
+        if options:
+            option_lines = ["Options:"]
+            for title, text in options:
+                option_lines.extend(_build_item_plain(title, text, max_title_len))
+            textblocks.append("\n".join(option_lines))
 
         if other_command_names:
             see_also_block = ["See also:"]

craft_cli/messages.py

@@ -26,77 +26,93 @@
 import enum
 import functools
 import getpass
+import json
 import logging
 import os
 import pathlib
 import select
 import sys
 import threading
 import traceback
+from abc import ABC, abstractmethod
 from collections.abc import Callable, Generator
 from contextlib import contextmanager
 from datetime import datetime
-from typing import TYPE_CHECKING, Any, Literal, TextIO, TypeVar, cast, Union, List, Dict
-import json
-import platformdirs
+from typing import TYPE_CHECKING, Any, Literal, TextIO, TypeVar, cast
+
+import platformdirs  # type: ignore [import-not-found]
 
 from craft_cli import errors
 from craft_cli.printer import Printer
-from abc import ABC, abstractmethod
-#from .formatters import BaseFormatter
 
-TabularData=Union[List[Dict[str,Any]],Dict[str,Any]]
+TabularData = list[dict[str, Any]] | dict[str, Any]
+
 
 class BaseFormatter(ABC):
     @abstractmethod
-    def format(self,data:TabularData,headers:dict[str,str] | None=None)->str:
+    def format(self, data: TabularData, headers: dict[str, str] | None = None) -> str:
         pass
+
+
 class JSONFormatter(BaseFormatter):
-    """
-    Format data into JSON.
+    """Format data into JSON.
 
-    Example
+    Example:
     -------
-    >>> formatter=JsonFormatter()
+    >>> formatter = JsonFormatter()
     >>> formatter.format([{"name":"Alice","age":30})
     '{"name":"Alice","age":30}'
+
     """
-    def format(self,data: TabularData,headers: dict[str,str] | None=None)->str:
-        return json.dumps(data,indent=2,default=str)
+
+    def format(self, data: TabularData, headers: dict[str, str] | None = None) -> str:
+        _ = headers
+        return json.dumps(data, indent=2, default=str)
+
+
 class TableFormatter(BaseFormatter):
-    """
-    Format data into a pretty table.
+    r"""Format data into a pretty table.
 
-    Example
+    Example:
     -------
-    >>> formatter=TableFormatter()
-    >>> formatter.format([["Name","Age"],["Alice",30]])
+    >>> formatter = TableFormatter()
+    >>> formatter.format([["Name", "Age"], ["Alice", 30]])
     'Name Age\nAlice 30'
+
     """
-    def format(self,data:TabularData,headers:dict[str,str] | None=None)->str:
+
+    def format(self, data: TabularData, headers: dict[str, str] | None = None) -> str:
+        _ = headers
         """Format a list of rows into a table string."""
         if not data:
             return "[no data]"
-        table_headers:list[str]
-        if isinstance(data,list):
-            #list_data=cast(List[Dict[str,Any]],data)
-            all_keys: set[str]=set().union(*(row.keys() for row in data))
-            table_headers:list[str]=sorted(list(all_keys))
-            rows=[[str(row.get(h,"")) for h in table_headers] for row in data]
+        if isinstance(data, list):
+            all_keys: set[str] = set()
+            for row in data:
+                all_keys.update(str(k) for k in row)
+            table_headers = sorted(all_keys)
+            rows = [[str(row.get(h, "")) for h in table_headers] for row in data]
         else:
-            table_headers=["Key", "Value"]
-            #data_dict=cast(Dict[str,Any],data)
-            rows=[[str(k),str(v)] for k,v in data.items()]
-        cols_widths=[max(len(str(item)) for item in col) for col in zip(*([table_headers]+rows))]
-
-        def format_row(row: list[str])->str:
-            return " | ".join(str(cell).ljust(width) for cell, width in zip(row,cols_widths))
-        table=[format_row(table_headers)]
-        table.append("-" * sum(cols_widths)+"---"*(len(table_headers)-1))
-        table.extend(format_row(row) for row in rows)
+            table_headers = ["Key", "Value"]
+            rows = [[str(k), str(v)] for k, v in data.items()]
+        cols_widths = [
+            max(len(str(item)) for item in col) for col in zip(table_headers, *rows)
+        ]
+
+        def format_row(row: list[str]) -> str:
+            return " | ".join(
+                cell.ljust(width) for cell, width in zip(row, cols_widths)
+            )
+
+        separator = "-+-".join("-" * width for width in cols_widths)
+        table = [
+            format_row(table_headers),
+            separator,
+            *(format_row(row) for row in rows),
+        ]
         return "\n".join(table)
-        
-                     
+
+
 if TYPE_CHECKING:
     from types import TracebackType
 
@@ -516,10 +532,10 @@ def __init__(self) -> None:
         self._log_handler: _Handler = None  # type: ignore[assignment]
         self._streaming_brief = False
         self._docs_base_url: str | None = None
-        self._formatters={
-"json":JSONFormatter(),
-"table":TableFormatter(),
-}
+        self._formatters = {
+            "json": JSONFormatter(),
+            "table": TableFormatter(),
+        }
 
     def init(
         self,
@@ -785,6 +801,45 @@ def open_stream(self, text: str | None = None) -> _StreamContextManager:
             ephemeral_mode=ephemeral,
         )
 
+    @_active_guard()
+    def data(
+        self,
+        data: TabularData,
+        output_format: Literal["json", "table"] = "table",
+        headers: dict[str, str] | None = None,
+    ) -> None:
+        """Output structured data to the terminal in a specific format.
+
+        :param data: The structured data to output( list of dicts or a single dict).
+        :param format: The format( defaults to 'table')
+        :param headers: Optional dictionary to map internal data keys to displayed header.
+        """
+        formatter = self._formatters.get(output_format)
+        if not formatter:
+            raise ValueError(f"Unsupported format: {format}")
+
+        formatted_data = formatter.format(data, headers)
+        stream = None if self._mode == EmitterMode.QUIET else sys.stdout
+        self._printer.show(stream, formatted_data, raw_output=True)
+
+    @_active_guard()
+    def table(
+        self,
+        data: TabularData,
+        headers: dict[str, str] | None = None,
+    ) -> None:
+        """Output data as table."""
+        self.data(data, output_format="table", headers=headers)
+
+    @_active_guard()
+    def json(
+        self,
+        data: TabularData,
+        headers: dict[str, str] | None = None,
+    ) -> None:
+        """Output data as JSON."""
+        self.data(data, output_format="json", headers=headers)
+
     @_active_guard()
     @contextmanager
     def pause(self) -> Generator[None, None, None]:
@@ -946,14 +1001,6 @@ def prompt(self, prompt_text: str, *, hide: bool = False) -> str:
         if not val:
             raise errors.CraftError("input cannot be empty")
         return val
-    
-    @_active_guard()
-    def data(self,records: list[dict], format:str="table")->None:
-        if format not in self._formatters:
-            raise ValueError(f"Unsupported format: {format}")
-        formatter=self._formatters[format]
-        formatted_output=formatter.format(records)
-        self.message(formatted_output)
 
     @property
     def log_filepath(self) -> pathlib.Path:
@@ -971,4 +1018,3 @@ def _format_details(details: str) -> str:
     if "\n" in details:
         return details if details.startswith("\n") else f"\n{details}"
     return details
-

craft_cli/printer.py

@@ -444,13 +444,14 @@ def show(
         use_timestamp: bool = False,
         end_line: bool = False,
         avoid_logging: bool = False,
+        raw_output: bool = False,
     ) -> None:
         """Show a text to the given stream if not stopped."""
         if self.stopped:
             return
 
         text = self._apply_secrets(text)
-
+        _ = raw_output
         msg = _MessageInfo(
             stream=stream,
             text=text.rstrip(),

craft_cli/pytest_plugin.py

@@ -25,8 +25,7 @@
 from typing import TYPE_CHECKING, Any, Literal
 from unittest.mock import call
 
-
-import pytest
+import pytest  # type: ignore[import-not-found]
 from typing_extensions import Self
 
 from craft_cli import messages, printer
@@ -35,17 +34,15 @@
     from unittest.mock import _Call  # type: ignore[reportPrivateUsage]
 
 
-@pytest.fixture(autouse=True)
-def init_emitter(monkeypatch: pytest.MonkeyPatch) -> Generator[None]:
+@pytest.fixture(autouse=True)  # type: ignore[misc]
+def init_emitter(monkeypatch: pytest.MonkeyPatch) -> Generator[None, None, None]:
     """Ensure ``emit`` is always clean, and initiated (in test mode).
 
     Note that the ``init`` is done in the current instance that all modules already
     acquired.
 
     This is an "autouse" fixture, so it just works, no need to declare it in your tests.
     """
-    # messages.emit._initiated = False
-    # messages.emit._stopped = False
     # initiate with a custom log filepath so user directories are not involved here; note that
     # we're not using pytest's standard tmp_path as Emitter would write logs there, and in
     # effect we would be polluting that temporary directory (potentially messing with
@@ -62,8 +59,7 @@ def init_emitter(monkeypatch: pytest.MonkeyPatch) -> Generator[None]:
         yield
     # end machinery (just in case it was not ended before; note it's ok to "double end")
     messages.emit.ended_ok()
-    # messages.emit._initiated = False
-    # messages.emit._stopped = True
+
 
 class _RegexComparingText(str):
     """A string that compares for equality using regex.match."""
@@ -245,7 +241,7 @@ def advance(self, *a: Any, **k: Any) -> None:
         self.recording_emitter.record("advance", a, k)
 
 
-@pytest.fixture
+@pytest.fixture  # type: ignore[misc]
 def emitter(monkeypatch: pytest.MonkeyPatch) -> RecordingEmitter:
     """Provide a helper to test everything that was shown using the Emitter."""
     recording_emitter = RecordingEmitter()

docs/conf.py

@@ -46,7 +46,7 @@ def run_apidoc(_):
     import os
     import sys
 
-    from sphinx.ext.apidoc import main
+    from sphinx.ext.apidoc import main # type: ignore[reportMissingImports]
 
     sys.path.append(os.path.join(os.path.dirname(__file__), ".."))
     cur_dir = os.path.abspath(os.path.dirname(__file__))