Bump version 0.6: Show results in panels... like on searchcode.com :)

Author: rly0nheart

pyproject.toml

@@ -34,5 +34,5 @@ requires = ["poetry-core"]
 build-backend = "poetry.core.masonry.api"
 
 [tool.poetry.scripts]
-sc = "searchcode.__cli.app:cli"
-searchcode = "searchcode.__cli.app:cli"
+sc = "searchcode._cli.app:cli"
+searchcode = "searchcode._cli.app:cli"

src/searchcode/__init__.py

@@ -23,6 +23,8 @@
 __version__ = "0.6.0"
 __author__ = "Ritchie Mwewa"
 
+__all__ = ["Searchcode"]
+
 
 class License:
     terms_and_conditions: str = """

src/searchcode/__cli/__init__.py src/searchcode/_cli/__init__.pysrc/searchcode/__cli/__init__.py renamed to src/searchcode/_cli/__init__.py

@@ -19,17 +19,14 @@
 from types import SimpleNamespace
 
 import rich_click as click
-from rich.syntax import Syntax
 
-from .lib import (
-    console,
-    update_window_title,
+from .panels import console, print_panels
+from .. import __pkg__, __version__, License
+from .._lib import (
     clear_screen,
-    print_jsonp,
-    print_panels,
     namespace_to_dict,
+    update_window_title,
 )
-from .. import __pkg__, __version__, License
 from ..api import Searchcode
 
 __all__ = ["cli"]
@@ -149,12 +146,12 @@ def search(
             lines_of_code_gt=lines_of_code_gt,
             callback=callback,
         )
-        print_jsonp(jsonp=response)
+        print_panels(data=response)
         return
 
     # normal paginated search
-    with console.status(f"Querying: [green]{query}[/]") as status:
-        results, total = fetch_paginated_results(
+    with console.status(f"Querying code index with [green]{query}[/]...") as status:
+        results, total = _fetch_paginated_results(
             query=query,
             start_page=page,
             per_page=per_page,
@@ -166,12 +163,20 @@ def search(
             status=status,
         )
 
-    print_results(
-        results=results, total=total, query=query, callback=callback, pretty=pretty
-    )
+    if results:
+        if not callback and not pretty:
+            console.log(f"Showing {len(results)} of {total} results for '{query}'")
+        if pretty:
+            console.print(namespace_to_dict(obj=results))
+        else:
+            print_panels(data=results)
+    else:
+        console.log(
+            f"[bold yellow]✘[/bold yellow] No results found for [bold yellow]{query}[/bold yellow]."
+        )
 
 
-def fetch_paginated_results(
+def _fetch_paginated_results(
     query: str,
     start_page: int,
     per_page: int,
@@ -192,11 +197,6 @@ def fetch_paginated_results(
     total_results = 0
 
     for current_iteration in range(1, pages + 1):
-        status.update(
-            f"Fetching page [cyan]{current_iteration}[/]/[cyan]{pages}[/] "
-            f"([cyan]{len(all_results)}[/] results collected)"
-        )
-
         response = sc.search(
             query=query,
             page=current_page,
@@ -207,6 +207,10 @@ def fetch_paginated_results(
             lines_of_code_gt=lines_of_code_gt,
             callback=None,
         )
+        status.update(
+            f"Getting page results on page [cyan]{current_iteration}[/] of [cyan]{pages}[/] "
+            f"([cyan]{len(all_results)}[/] results collected)..."
+        )
 
         if isinstance(response, str):
             break
@@ -224,35 +228,6 @@ def fetch_paginated_results(
     return all_results, total_results
 
 
-def print_results(
-    results: t.List, total: int, query: str, callback: t.Optional[str], pretty: bool
-):
-    """
-    Print search results.
-
-    :param results: List of code records.
-    :param total: Total result count.
-    :param query: Search query.
-    :param callback: JSONP callback (should be None).
-    :param pretty: Whether to print raw JSON.
-    """
-    if results:
-        if pretty:
-            console.print(namespace_to_dict(obj=results))
-        else:
-            print_panels(data=results)
-
-        if not callback and not pretty:
-            console.log(
-                f"[bold green]✔[/bold green] Returned {len(results)} of {total} "
-                f"results for [bold green]{query}[/bold green]."
-            )
-    else:
-        console.log(
-            f"[bold yellow]✘[/bold yellow] No results for [bold yellow]{query}[/bold yellow]."
-        )
-
-
 @cli.command()
 @click.argument("id", type=int)
 def code(id: int):
@@ -263,16 +238,6 @@ def code(id: int):
     """
     clear_screen()
     update_window_title(text=str(id))
-    with console.status(f"Fetching code file: [cyan]{id}[/]"):
+    with console.status(f"Getting code file [cyan]{id}[/]..."):
         data = sc.code(id)
-        lines = data.code
-        language = data.language
-        if lines:
-            syntax = Syntax(
-                code=lines, lexer=language, line_numbers=True, theme="dracula"
-            )
-            console.print(syntax)
-        else:
-            console.log(
-                f"[bold yellow]✘[/bold yellow] No matching file found: [bold yellow]{id}[/bold yellow]."
-            )
+        print_panels(data=data, id=id)

src/searchcode/__cli/app.py src/searchcode/_cli/app.pysrc/searchcode/__cli/app.py renamed to src/searchcode/_cli/app.py

@@ -0,0 +1,135 @@
+import typing as t
+from types import SimpleNamespace
+
+from rich.console import Group, Console
+from rich.panel import Panel
+from rich.rule import Rule
+from rich.syntax import Syntax
+from rich.text import Text
+
+console = Console(highlight=True, log_time=False)
+
+
+def _extract_code_string_with_linenumbers(lines_dict: t.Dict[str, str]) -> str:
+    """
+    Convert a dictionary of line_number: code_line into a single
+    multiline string sorted by line number.
+
+    Each line is right-aligned to maintain visual alignment in output.
+
+    :param lines_dict: Dictionary where keys are line numbers (as strings) and values are lines of code.
+    :return: Multiline string with original line numbers included.
+    """
+    sorted_lines = sorted(lines_dict.items(), key=lambda x: int(x[0]))
+    numbered_lines = [
+        f"{line_no.rjust(4)} {line.rstrip()}" for line_no, line in sorted_lines
+    ]
+    return "\n".join(numbered_lines)
+
+
+def _make_syntax(code: str, language: str, **syntax_kwargs) -> Syntax:
+    """
+    Create a Syntax object with consistent settings.
+
+    :param code: The source code to render.
+    :type code: str
+    :param language: The programming language lexer to use.
+    :type language: str
+    :param syntax_kwargs: Additional keyword arguments for Syntax.
+    :type syntax_kwargs: Any
+    :return: A rich Syntax object for displaying code.
+    :rtype: Syntax
+    """
+    return Syntax(code=code, lexer=language, theme="dracula", **syntax_kwargs)
+
+
+def _make_syntax_panel(
+    syntax: Syntax, header_text: t.Optional[str] = None, add_divider: bool = False
+) -> Panel:
+    """
+    Wrap a Syntax (or any renderable) in a styled Panel. Optionally include a header and divider.
+
+    :param syntax: The Syntax object to display inside the Panel.
+    :type syntax: Syntax
+    :param header_text: Optional markup string for the header above the syntax.
+    :type header_text: Optional[str]
+    :param add_divider: Whether to include a horizontal rule between header and syntax.
+    :type add_divider: bool
+    :return: A rich Panel containing the syntax (and optional header/divider).
+    :rtype: Panel
+    """
+    if header_text:
+        header = Text.from_markup(header_text, justify="left", overflow="ellipsis")
+        divider = Rule(style="#444444") if add_divider else None
+        content_items = [header, divider, syntax] if divider else [header, syntax]
+        content = Group(*content_items)
+    else:
+        content = syntax
+
+    return Panel(renderable=content, border_style="#444444", title_align="left")
+
+
+def print_panels(
+    data: t.Union[t.List[SimpleNamespace], SimpleNamespace, str], **kwargs
+) -> None:
+    """
+    Print panels for displaying code or structured file information.
+
+    Accepts either:
+      - a single SimpleNamespace with fields `code`, `language`
+      - a string of raw code
+      - a list of SimpleNamespace objects with fields `filename`, `repo`, `language`, `linescount`, `lines`
+
+    :param data: The input data to display as panels.
+    :type data: Union[List[SimpleNamespace], SimpleNamespace, str]
+    :param kwargs: Additional optional keyword arguments (e.g., id for logging).
+    :type kwargs: Any
+    :return: None
+    :rtype: None
+    """
+    panels: t.List[Panel] = []
+
+    if isinstance(data, SimpleNamespace):
+        code = data.code
+        language = data.language
+        if code:
+            syntax = _make_syntax(code, language, line_numbers=True)
+            panel = _make_syntax_panel(syntax)
+            panels.append(panel)
+        else:
+            console.log(
+                f"[bold yellow]✘[/bold yellow] No matching file found: [bold yellow]{kwargs.get('id')}[/bold yellow]."
+            )
+            return
+    elif isinstance(data, str):
+        syntax = _make_syntax(data, "text", line_numbers=True)
+        panel = _make_syntax_panel(syntax)
+        panels.append(panel)
+    else:
+        for item in data:
+            filename = item.filename
+            repo = item.repo
+            language = item.language
+            lines_count = item.linescount
+            lines = item.lines
+
+            code_string = _extract_code_string_with_linenumbers(
+                lines_dict=lines.__dict__
+            )
+
+            syntax = _make_syntax(
+                code=code_string, language=language, word_wrap=False, indent_guides=True
+            )
+
+            header_text = (
+                f"[bold]{filename}[/] ([blue]{repo}[/]) "
+                f"{language} · [cyan]{lines_count}[/] lines"
+            )
+
+            panel = _make_syntax_panel(
+                syntax=syntax, header_text=header_text, add_divider=True
+            )
+
+            panels.append(panel)
+
+    console.print(*panels)

src/searchcode/_cli/panels.py

@@ -3,13 +3,6 @@
 import typing as t
 from types import SimpleNamespace
 
-from rich import box
-from rich.console import Console
-from rich.panel import Panel
-from rich.syntax import Syntax
-
-console = Console(highlight=True, log_time=False)
-
 
 def namespace_to_dict(
     obj: t.Union[SimpleNamespace, t.List[SimpleNamespace]],
@@ -54,74 +47,14 @@ def dict_to_namespace(
         return obj
 
 
-def print_jsonp(jsonp: str) -> None:
-    """
-    Pretty-prints a raw JSONP string.
-
-    :param jsonp: A complete JSONP string.
-    """
-    syntax = Syntax(jsonp, "text", line_numbers=True)
-    console.print(syntax)
-
-
-def print_panels(data: t.List[SimpleNamespace]):
-    """
-    Render a list of code records as rich panels with syntax highlighting.
-    Line numbers are preserved and displayed alongside code content.
-
-    :param data: A list of dictionaries, where each dictionary represents a code record
-    """
-
-    def extract_code_string_with_linenumbers(lines_dict: t.Dict[str, str]) -> str:
-        """
-        Convert a dictionary of line_number: code_line into a single
-        multiline string sorted by line number.
-
-        Each line is right-aligned to maintain visual alignment in output.
-
-        :param lines_dict: Dictionary where keys are line numbers (as strings) and values are lines of code.
-        :return: Multiline string with original line numbers included.
-        """
-        sorted_lines = sorted(lines_dict.items(), key=lambda x: int(x[0]))
-        numbered_lines = [
-            f"{line_no.rjust(4)} {line.rstrip()}" for line_no, line in sorted_lines
-        ]
-        return "\n".join(numbered_lines)
-
-    for item in data:
-        filename = item.filename
-        repo = item.repo
-        language = item.language
-        lines_count = item.linescount
-        lines = item.lines
-
-        code_string = extract_code_string_with_linenumbers(lines_dict=lines.__dict__)
-
-        syntax = Syntax(
-            code=code_string,
-            lexer=language,
-            word_wrap=False,
-            indent_guides=True,
-            theme="dracula",
-        )
-
-        panel = Panel(
-            renderable=syntax,
-            box=box.ROUNDED,
-            title=f"[bold]{filename}[/] ([blue]{repo}[/]) {language} ⸱ [cyan]{lines_count}[/] lines",
-            highlight=True,
-        )
-
-        console.print(panel)
-
-
 def update_window_title(text: str):
     """
     Update the current window title with the specified text.
 
     :param text: Text to update the window with.
     """
-    from .. import __pkg__, __version__
+    from . import __pkg__, __version__
+    from ._cli.panels import console
 
     console.set_window_title(f"{__pkg__.capitalize()} v{__version__} - {text}")