ragbits-cli 0.0.1__tar.gz → 0.0.8.dev23005__tar.gz

{ragbits_cli-0.0.1 → ragbits_cli-0.0.8.dev23005}/.gitignore

@@ -5,8 +5,13 @@
 .pytest_cache/
 .mypy_cache/
 venv/
+.venv/
 __pycache__/
 **.egg-info/
+.deepeval/
+
+# Local cursor rules
+.cursor/rules/local/
 
 # Byte-compiled / optimized / DLL files
 __pycache__/
@@ -87,11 +92,25 @@ cmake-build-*/
 **/.terraform.lock.hcl
 **/.terraform
 
-# benchmarks
-benchmarks/sql/data/
-
 # mkdocs generated files
 site/
 
 # build artifacts
 dist/
+
+# examples
+chroma/
+qdrant/
+
+.aider*
+
+.DS_Store
+node_modules/
+
+lazygit
+
+lazygit.tar.gz
+
+# chat conversation logs
+duet_conversation.log
+worktrees/

ragbits_cli-0.0.8.dev23005/CHANGELOG.md

@@ -0,0 +1,219 @@
+# CHANGELOG
+
+## Unreleased
+
+## 1.3.0 (2025-09-11)
+
+### Changed
+
+- ragbits-core updated to version v1.3.0
+
+- feat: add current working directory to Python path for better CLI module discovery
+
+## 1.2.2 (2025-08-08)
+
+### Changed
+
+- ragbits-core updated to version v1.2.2
+
+## 1.2.1 (2025-08-04)
+
+### Changed
+
+- ragbits-core updated to version v1.2.1
+
+## 1.2.0 (2025-08-01)
+
+### Changed
+
+- ragbits-core updated to version v1.2.0
+
+## 1.1.0 (2025-07-09)
+
+### Changed
+
+- ragbits-core updated to version v1.1.0
+
+## 1.0.0 (2025-06-04)
+
+### Changed
+
+- ragbits-core updated to version v1.0.0
+
+## 0.20.1 (2025-06-04)
+
+### Changed
+
+- ragbits-core updated to version v0.20.1
+
+## 0.20.0 (2025-06-03)
+
+### Changed
+
+- ragbits-core updated to version v0.20.0
+
+## 0.19.1 (2025-05-27)
+
+### Changed
+
+- ragbits-core updated to version v0.19.1
+
+## 0.19.0 (2025-05-27)
+
+### Changed
+
+- ragbits-core updated to version v0.19.0
+
+## 0.18.0 (2025-05-22)
+
+### Changed
+
+- ragbits-core updated to version v0.18.0
+
+- Update audit imports (#427)
+
+## 0.17.1 (2025-05-09)
+
+### Changed
+
+- ragbits-core updated to version v0.17.1
+
+## 0.17.0 (2025-05-06)
+
+### Changed
+
+- ragbits-core updated to version v0.17.0
+
+## 0.16.0 (2025-04-29)
+
+### Changed
+
+- ragbits-core updated to version v0.16.0
+
+## 0.15.0 (2025-04-28)
+
+### Changed
+
+- ragbits-core updated to version v0.15.0
+
+## 0.14.0 (2025-04-22)
+
+### Changed
+
+- ragbits-core updated to version v0.14.0
+
+- do not download litellm costmap in CLI commands (#521)
+
+## 0.13.0 (2025-04-02)
+
+### Changed
+
+- ragbits-core updated to version v0.13.0
+
+## 0.12.0 (2025-03-25)
+
+### Changed
+
+- ragbits-core updated to version v0.12.0
+
+## 0.11.0 (2025-03-25)
+
+### Changed
+
+- ragbits-core updated to version v0.11.0
+
+## 0.10.2 (2025-03-21)
+
+### Changed
+
+- ragbits-core updated to version v0.10.2
+
+## 0.10.1 (2025-03-19)
+
+### Changed
+
+- ragbits-core updated to version v0.10.1
+
+## 0.10.0 (2025-03-17)
+
+### Changed
+
+- ragbits-core updated to version v0.10.0
+
+- ragbits-conversations added traceable
+- ragbits-core added traceable
+- ragbits-document-search added traceable
+- ragbits-evaluate added traceable
+
+## 0.9.0 (2025-02-25)
+
+### Changed
+
+- ragbits-core updated to version v0.9.0
+
+## 0.8.0 (2025-01-29)
+
+### Changed
+
+- ragbits-core updated to version v0.8.0
+
+## 0.7.0 (2025-01-21)
+
+### Changed
+
+- ragbits-core updated to version v0.7.0
+
+## 0.6.0 (2024-12-27)
+
+### Added
+
+- Better error handling when dynamic importing fails in the CLI (#259).
+- Add option to choose what columns to display in the output (#257).
+
+### Changed
+
+- ragbits-core updated to version v0.6.0
+
+## 0.5.1 (2024-12-09)
+
+### Changed
+
+- ragbits-core updated to version v0.5.1
+
+## 0.5.0 (2024-12-05)
+
+### Added
+
+- Add global flag to specify output type: text or json (#232).
+
+### Changed
+
+- ragbits-core updated to version v0.5.0
+
+## 0.4.0 (2024-11-27)
+
+### Changed
+
+- ragbits-core updated to version v0.4.0
+
+## 0.3.0 (2024-11-06)
+
+### Changed
+
+- ragbits-core updated to version v0.3.0
+
+## 0.2.0 (2024-10-23)
+
+### Changed
+
+- Improved performance by lazy-loading the modules (#111 #113 #120)
+- ragbits-core updated to version v0.2.0
+
+## 0.1.0 (2024-10-08)
+
+### Added
+
+- Initial release of the package.
+- Add prompts lab command.
+- Add prompts generate-promptfoo-configs command.
+

ragbits_cli-0.0.8.dev23005/PKG-INFO

@@ -0,0 +1,71 @@
+Metadata-Version: 2.4
+Name: ragbits-cli
+Version: 0.0.8.dev23005
+Summary: A CLI application for ragbits - building blocks for rapid development of GenAI applications
+Project-URL: Homepage, https://github.com/deepsense-ai/ragbits
+Project-URL: Bug Reports, https://github.com/deepsense-ai/ragbits/issues
+Project-URL: Documentation, https://ragbits.deepsense.ai/
+Project-URL: Source, https://github.com/deepsense-ai/ragbits
+Author-email: "deepsense.ai" <ragbits@deepsense.ai>
+License-Expression: MIT
+Keywords: GenAI,Generative AI,LLMs,Large Language Models,Prompt Management,RAG,Retrieval Augmented Generation
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Requires-Dist: ragbits-core==0.0.8.dev23005
+Requires-Dist: typer<1.0.0,>=0.12.5
+Description-Content-Type: text/markdown
+
+# Ragbits CLI
+
+Ragbits CLI provides the `ragbits` command-line interface (CLI) tool that allows you to interact with Ragbits from the terminal. Other packages can extend the CLI by adding their own commands, so the exact set of available commands may vary depending on the installed packages.
+
+## Installation
+
+To use the complete Ragbits stack, install the `ragbits` package:
+
+```sh
+pip install ragbits
+```
+
+## Example Usage
+The following example assumes that `ragbits-core` is installed and that the current ddirectory contains a `song_prompt.py` file with a prompt class named `SongPrompt`, as defined in the [Quickstart Guide](https://ragbits.deepsense.ai/quickstart/quickstart1_prompts/#making-the-prompt-dynamic).
+
+The example demonstrates how to execute the prompt using the `ragbits` CLI tool.
+The left side of the table shows the system and user prompts (rendered with placeholders replaced by the provided values), and the right side shows the generated response from the Large Language Model.
+
+```sh
+$ ragbits prompts exec song_prompt:SongPrompt --payload '{"subject": "unicorns", "age_group": 12, "genre": "pop"}'
+
+┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+┃ Question                              ┃ Answer                                ┃
+┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩
+│ [{'role': 'system', 'content': 'You   │ (Verse 1)                             │
+│ are a professional songwriter.        │ In a land of rainbows and glitter,    │
+│ You only use language that is         │ Where flowers bloom and skies are     │
+│ appropriate for children.'},          │ brighter,                             │
+│ {'role': 'user', 'content': 'Write a  │ There's a magical creature so rare,   │
+│ song about a unicorns for 12 years    │ With a horn that sparkles in the air. │
+│ old pop fans.'}]                      │                                       │
+│                                       │ (Chorus)                              │
+│                                       │ Unicorns, unicorns, oh so divine,     │
+│                                       │ With their mane that shines and eyes  │
+│                                       │ that shine,                           │
+│                                       │ Gallop through the meadows, so free,  │
+│                                       │ In a world of wonder, just you and    │
+│                                       │ me.                                   │
+└───────────────────────────────────────┴───────────────────────────────────────┘
+```
+
+## Documentation
+* [Documentation of the `ragbits` CLI](https://ragbits.deepsense.ai/cli/main/)

ragbits_cli-0.0.8.dev23005/README.md

@@ -0,0 +1,43 @@
+# Ragbits CLI
+
+Ragbits CLI provides the `ragbits` command-line interface (CLI) tool that allows you to interact with Ragbits from the terminal. Other packages can extend the CLI by adding their own commands, so the exact set of available commands may vary depending on the installed packages.
+
+## Installation
+
+To use the complete Ragbits stack, install the `ragbits` package:
+
+```sh
+pip install ragbits
+```
+
+## Example Usage
+The following example assumes that `ragbits-core` is installed and that the current ddirectory contains a `song_prompt.py` file with a prompt class named `SongPrompt`, as defined in the [Quickstart Guide](https://ragbits.deepsense.ai/quickstart/quickstart1_prompts/#making-the-prompt-dynamic).
+
+The example demonstrates how to execute the prompt using the `ragbits` CLI tool.
+The left side of the table shows the system and user prompts (rendered with placeholders replaced by the provided values), and the right side shows the generated response from the Large Language Model.
+
+```sh
+$ ragbits prompts exec song_prompt:SongPrompt --payload '{"subject": "unicorns", "age_group": 12, "genre": "pop"}'
+
+┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+┃ Question                              ┃ Answer                                ┃
+┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩
+│ [{'role': 'system', 'content': 'You   │ (Verse 1)                             │
+│ are a professional songwriter.        │ In a land of rainbows and glitter,    │
+│ You only use language that is         │ Where flowers bloom and skies are     │
+│ appropriate for children.'},          │ brighter,                             │
+│ {'role': 'user', 'content': 'Write a  │ There's a magical creature so rare,   │
+│ song about a unicorns for 12 years    │ With a horn that sparkles in the air. │
+│ old pop fans.'}]                      │                                       │
+│                                       │ (Chorus)                              │
+│                                       │ Unicorns, unicorns, oh so divine,     │
+│                                       │ With their mane that shines and eyes  │
+│                                       │ that shine,                           │
+│                                       │ Gallop through the meadows, so free,  │
+│                                       │ In a world of wonder, just you and    │
+│                                       │ me.                                   │
+└───────────────────────────────────────┴───────────────────────────────────────┘
+```
+
+## Documentation
+* [Documentation of the `ragbits` CLI](https://ragbits.deepsense.ai/cli/main/)

{ragbits_cli-0.0.1 → ragbits_cli-0.0.8.dev23005}/pyproject.toml

@@ -1,12 +1,12 @@
 [project]
 name = "ragbits-cli"
-version = "0.0.1"
+version = "0.0.8.dev23005"
 description = "A CLI application for ragbits - building blocks for rapid development of GenAI applications"
 readme = "README.md"
 requires-python = ">=3.10"
 license = "MIT"
 authors = [
-    { name = "deepsense.ai", email = "contact@deepsense.ai"}
+    { name = "deepsense.ai", email = "ragbits@deepsense.ai"}
 ]
 keywords = [
     "Retrieval Augmented Generation",
@@ -18,7 +18,7 @@ keywords = [
     "Prompt Management"
 ]
 classifiers = [
-    "Development Status :: 1 - Planning",
+    "Development Status :: 4 - Beta",
     "Environment :: Console",
     "Intended Audience :: Science/Research",
     "License :: OSI Approved :: MIT License",
@@ -27,12 +27,17 @@ classifiers = [
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
     "Topic :: Scientific/Engineering :: Artificial Intelligence",
     "Topic :: Software Development :: Libraries :: Python Modules",
 ]
-dependencies = [
-    "typer>=0.12.5",
-]
+dependencies = ["typer>=0.12.5,<1.0.0", "ragbits-core==0.0.8.dev23005"]
+
+[project.urls]
+"Homepage" = "https://github.com/deepsense-ai/ragbits"
+"Bug Reports" = "https://github.com/deepsense-ai/ragbits/issues"
+"Documentation" = "https://ragbits.deepsense.ai/"
+"Source" = "https://github.com/deepsense-ai/ragbits"
 
 [project.scripts]
 ragbits = "ragbits.cli:main"

ragbits_cli-0.0.8.dev23005/src/ragbits/cli/__init__.py

@@ -0,0 +1,89 @@
+import importlib.util
+import os
+import pkgutil
+import sys
+from pathlib import Path
+from typing import Annotated
+
+# litellm downloads cost map on import, which creates extra latency in CLI.
+# This config disables it.
+os.environ["LITELLM_LOCAL_MODEL_COST_MAP"] = "True"
+
+import click
+import typer
+from typer.main import get_command
+
+import ragbits
+from ragbits.core.audit.traces import set_trace_handlers
+
+from .state import OutputType, cli_state, print_output
+
+__all__ = [
+    "OutputType",
+    "app",
+    "cli_state",
+    "print_output",
+]
+
+app = typer.Typer(no_args_is_help=True)
+_click_app: click.Command | None = None  # initialized in the `init_for_mkdocs` function
+
+
+@app.callback()
+def ragbits_cli(
+    # `OutputType.text.value` used as a workaround for the issue with `typer.Option` not accepting Enum values
+    output: Annotated[
+        OutputType, typer.Option("--output", "-o", help="Set the output type (text or json)")
+    ] = OutputType.text.value,  # type: ignore
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Print additional information"),
+) -> None:
+    """Common CLI arguments for all ragbits commands."""
+    cli_state.output_type = output
+    cli_state.verbose = verbose
+
+    if verbose == 1:
+        typer.echo("Verbose mode is enabled.")
+        set_trace_handlers("cli")
+
+
+def autoregister() -> None:
+    """
+    Autodiscover and register all the CLI modules in the ragbits packages.
+
+    This function registers all the CLI modules in the ragbits packages:
+        - iterates over every package in the ragbits.* namespace
+        - it looks for `cli` package / module
+        - if found it imports the `register` function from the `cli` module and calls it with the `app` object
+        - register function should add the CLI commands to the `app` object
+    """
+    cli_enabled_modules = [
+        module
+        for module in pkgutil.iter_modules(ragbits.__path__)
+        if module.ispkg and module.name != "cli" and (Path(module.module_finder.path) / module.name / "cli.py").exists()  # type: ignore
+    ]
+    sys.path.append(os.getcwd())
+
+    for module in cli_enabled_modules:
+        register_func = importlib.import_module(f"ragbits.{module.name}.cli").register
+        register_func(app)
+
+
+def _init_for_mkdocs() -> None:
+    """
+    Initializes the CLI app for the mkdocs environment.
+
+    This function registers all the CLI commands and sets the `_click_app` variable to a click
+    command object containing all the CLI commands. This way the `mkdocs-click` plugin can
+    create an automatic CLI documentation.
+    """
+    global _click_app  # noqa: PLW0603
+    autoregister()
+    _click_app = get_command(app)
+
+
+def main() -> None:
+    """
+    Main entry point for the CLI. Registers all the CLI commands and runs the app.
+    """
+    autoregister()
+    app()

ragbits_cli-0.0.8.dev23005/src/ragbits/cli/_utils.py

@@ -0,0 +1,67 @@
+from pathlib import Path
+from typing import Protocol, TypeVar
+
+import typer
+from pydantic.alias_generators import to_snake
+from rich.console import Console
+
+from ragbits.core.config import CoreConfig, core_config
+from ragbits.core.utils.config_handling import InvalidConfigError, NoPreferredConfigError, WithConstructionConfig
+
+WithConstructionConfigT_co = TypeVar("WithConstructionConfigT_co", bound=WithConstructionConfig, covariant=True)
+
+
+# Using a Protocol instead of simply typing the `cls` argument to `get_instance_or_exit`
+# as `type[WithConstructionConfigT]` in order to workaround the issue of mypy not allowing abstract classes
+# to be used as types: https://github.com/python/mypy/issues/4717
+class WithConstructionConfigProtocol(Protocol[WithConstructionConfigT_co]):
+    @classmethod
+    def preferred_subclass(
+        cls, config: CoreConfig, factory_path_override: str | None = None, yaml_path_override: Path | None = None
+    ) -> WithConstructionConfigT_co: ...
+
+
+def get_instance_or_exit(
+    cls: WithConstructionConfigProtocol[WithConstructionConfigT_co],
+    type_name: str | None = None,
+    yaml_path: Path | None = None,
+    factory_path: str | None = None,
+    config_override: CoreConfig | None = None,
+    yaml_path_argument_name: str = "--yaml-path",
+    factory_path_argument_name: str = "--factory-path",
+) -> WithConstructionConfigT_co:
+    """
+    Returns an instance of the provided class, initialized using its `preferred_subclass` method.
+    If the instance can't be created, prints an error message and exits the program.
+
+    Args:
+        cls: The class to create an instance of.
+        type_name: The name to use in error messages. If None, inferred from the class name.
+        yaml_path: Path to a YAML configuration file to use for initialization.
+        factory_path: Python path to a factory function to use for initialization.
+        yaml_path_argument_name: The name of the argument to use in error messages for the YAML path.
+        config_override: A config instance to be used
+        factory_path_argument_name: The name of the argument to use in error messages for the factory path.
+    """
+    if not isinstance(cls, type):
+        raise TypeError(f"get_instance_or_exit expects the `cls` argument to be a class, got {cls}")
+
+    type_name = type_name or to_snake(cls.__name__).replace("_", " ")
+    try:
+        return cls.preferred_subclass(
+            config_override or core_config,
+            factory_path_override=factory_path,
+            yaml_path_override=yaml_path,
+        )
+    except NoPreferredConfigError as e:
+        Console(
+            stderr=True
+        ).print(f"""You need to provide the [b]{type_name}[/b] instance to be used. You can do this by either:
+- providing a path to a YAML configuration file with the [b]{yaml_path_argument_name}[/b] option
+- providing a Python path to a function that creates a vector store with the [b]{factory_path_argument_name}[/b] option
+- setting the preferred {type_name} configuration in your project's [b]pyproject.toml[/b] file
+  (see https://ragbits.deepsense.ai/how-to/project/component_preferences/ for more information)""")
+        raise typer.Exit(1) from e
+    except InvalidConfigError as e:
+        Console(stderr=True).print(e)
+        raise typer.Exit(1) from e

ragbits_cli-0.0.8.dev23005/src/ragbits/cli/state.py

@@ -0,0 +1,151 @@
+import json
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+from enum import Enum
+from types import UnionType
+from typing import Optional, TypeVar, Union, get_args, get_origin
+
+import typer
+from pydantic import BaseModel
+from pydantic.fields import FieldInfo
+from rich.console import Console
+from rich.table import Column, Table
+
+
+class OutputType(Enum):
+    """Indicates a type of CLI output formatting"""
+
+    text = "text"
+    json = "json"
+
+
+@dataclass()
+class CliState:
+    """A dataclass describing CLI state"""
+
+    verbose: bool = False
+    output_type: OutputType = OutputType.text
+
+
+cli_state = CliState()
+
+ModelT = TypeVar("ModelT", bound=BaseModel)
+
+
+def print_output_table(
+    data: Sequence[ModelT], columns: Mapping[str, Column] | Sequence[str] | str | None = None
+) -> None:
+    """
+    Display data from Pydantic models in a table format.
+
+    Args:
+        data: a list of pydantic models representing output of CLI function
+        columns: a list of columns to display in the output table: either as a list, string with comma separated names,
+            or for grater control over how the data is displayed a mapping of column names to Column objects.
+            If not provided, the columns will be inferred from the model schema.
+    """
+    console = Console()
+
+    if not data:
+        console.print("No results")
+        return
+
+    base_fields = {**data[0].model_fields, **data[0].model_computed_fields}
+
+    # Normalize the list of columns
+    if columns is None:
+        columns = {key: Column() for key in base_fields}
+    elif isinstance(columns, str):
+        columns = {key: Column() for key in columns.split(",")}
+    elif isinstance(columns, Sequence):
+        columns = {key: Column() for key in columns}
+
+    # check if columns are correct
+    for column_name in columns:
+        field = _get_nested_field(column_name, base_fields)
+        column = columns[column_name]
+        if column.header == "":
+            column.header = field.title if field.title else column_name.replace("_", " ").replace(".", " ").title()
+
+    # Create and print the table
+    table = Table(*columns.values(), show_header=True, header_style="bold magenta")
+
+    for row in data:
+        row_to_add = []
+        for key in columns:
+            *path_fragments, field_name = key.strip().split(".")
+            base_row = row
+            for fragment in path_fragments:
+                base_row = getattr(base_row, fragment)
+            z = getattr(base_row, field_name)
+            row_to_add.append(str(z))
+        table.add_row(*row_to_add)
+
+    console.print(table)
+
+
+def _get_nested_field(column_name: str, base_fields: dict) -> FieldInfo:
+    """
+    Check if column name exists in the model schema.
+
+    Args:
+        column_name: name of the column to check
+        base_fields: model fields
+    Returns:
+        field: nested field
+    """
+    fields = base_fields
+    *path_fragments, field_name = column_name.strip().split(".")
+    for fragment in path_fragments:
+        if fragment not in fields:
+            Console(stderr=True).print(
+                f"Unknown column: {'.'.join(path_fragments + [field_name])} ({fragment} not found)"
+            )
+            raise typer.Exit(1)
+        model_class = fields[fragment].annotation
+        if get_origin(model_class) in [UnionType, Optional, Union]:
+            types = get_args(model_class)
+            model_class = next((t for t in types if t is not type(None)), None)
+        if model_class and issubclass(model_class, BaseModel):
+            fields = {**model_class.model_fields, **model_class.model_computed_fields}
+    if field_name not in fields:
+        Console(stderr=True).print(
+            f"Unknown column: {'.'.join(path_fragments + [field_name])} ({field_name} not found)"
+        )
+        raise typer.Exit(1)
+    return fields[field_name]
+
+
+def print_output_json(data: Sequence[ModelT]) -> None:
+    """
+    Display data from Pydantic models in a JSON format.
+
+    Args:
+        data: a list of pydantic models representing output of CLI function
+    """
+    console = Console()
+    console.print(json.dumps([output.model_dump(mode="json") for output in data], indent=4))
+
+
+def print_output(
+    data: Sequence[ModelT] | ModelT, columns: Mapping[str, Column] | Sequence[str] | str | None = None
+) -> None:
+    """
+    Process and display output based on the current state's output type.
+
+    Args:
+        data: a list of pydantic models representing output of CLI function
+        columns: a list of columns to display in the output table: either as a list, string with comma separated names,
+            or for grater control over how the data is displayed a mapping of column names to Column objects.
+            If not provided, the columns will be inferred from the model schema.
+    """
+    if not isinstance(data, Sequence):
+        data = [data]
+
+    match cli_state.output_type:
+        case OutputType.text:
+            print_output_table(data, columns)
+        case OutputType.json:
+            print_output_json(data)
+        case _:
+            raise ValueError(f"Unsupported output type: {cli_state.output_type}")

ragbits_cli-0.0.8.dev23005/tests/unit/test_state.py

@@ -0,0 +1,121 @@
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import pytest
+import typer
+from pydantic import BaseModel
+from pydantic.fields import Field, FieldInfo
+from rich.table import Column, Table
+
+from ragbits.cli.state import OutputType, _get_nested_field, print_output, print_output_table
+from ragbits.core.sources.local import LocalFileSource
+
+
+class InnerTestModel(BaseModel):
+    id: int
+    name: str = Field(title="Name of the inner model", description="Name of the inner model")
+    location: LocalFileSource
+
+
+class OtherTestModel(BaseModel):
+    id: int
+    name: str
+    location: InnerTestModel
+
+
+class MainTestModel(BaseModel):
+    id: int
+    name: str
+    model: OtherTestModel | None
+
+
+data = [
+    MainTestModel(
+        id=1,
+        name="A",
+        model=OtherTestModel(
+            id=11,
+            name="aa",
+            location=InnerTestModel(id=111, name="aa1", location=LocalFileSource(path=Path("folder_1"))),
+        ),
+    ),
+    MainTestModel(
+        id=2,
+        name="B",
+        model=OtherTestModel(
+            id=22,
+            name="bb",
+            location=InnerTestModel(id=222, name="aa2", location=LocalFileSource(path=Path("folder_2"))),
+        ),
+    ),
+]
+
+
+@patch("ragbits.cli.state.print_output_table")
+@patch("ragbits.cli.state.print_output_json")
+def test_print_output_text(mock_print_output_json: MagicMock, mock_print_output_table: MagicMock):
+    with patch("ragbits.cli.state.cli_state") as mock_cli_state:
+        mock_cli_state.output_type = OutputType.text
+        columns = {"id": Column(), "name": Column()}
+        print_output(data, columns=columns)
+        mock_print_output_table.assert_called_once_with(data, columns)
+        mock_print_output_json.assert_not_called()
+
+
+@patch("ragbits.cli.state.print_output_table")
+@patch("ragbits.cli.state.print_output_json")
+def test_print_output_json(mock_print_output_json: MagicMock, mock_print_output_table: MagicMock):
+    with patch("ragbits.cli.state.cli_state") as mock_cli_state:
+        mock_cli_state.output_type = OutputType.json
+        print_output(data)
+        mock_print_output_table.assert_not_called()
+        mock_print_output_json.assert_called_once_with(data)
+
+
+def test_print_output_unsupported_output_type():
+    with patch("ragbits.cli.state.cli_state") as mock_cli_state:
+        mock_cli_state.output_type = "unsupported_type"
+        with pytest.raises(ValueError, match="Unsupported output type: unsupported_type"):
+            print_output(data)
+
+
+def test_print_output_table():
+    with patch("rich.console.Console.print") as mock_print:
+        columns = {"id": Column(), "model.location.location.path": Column(), "model.location.name": Column()}
+        print_output_table(data, columns)
+        mock_print.assert_called_once()
+        args, _ = mock_print.call_args_list[0]
+        printed_table = args[0]
+        assert isinstance(printed_table, Table)
+        assert printed_table.columns[0].header == "Id"
+        assert printed_table.columns[1].header == "Model Location Location Path"
+        assert printed_table.columns[2].header == "Name of the inner model"
+        assert printed_table.row_count == 2
+
+
+def test_get_nested_field():
+    column = "model.location.location.path"
+    fields = {"name": FieldInfo(annotation=str), "model": FieldInfo(annotation=OtherTestModel)}
+
+    try:
+        result = _get_nested_field(column, fields)
+        assert result.annotation == Path
+    except typer.Exit:
+        pytest.fail("typer.Exit was raised unexpectedly")
+
+
+def test_get_nested_field_wrong_field():
+    column_names = [
+        ("model.location.wrong_field", "wrong_field"),
+        ("model.wrong_path.location.path", "wrong_path"),
+        ("wrong_path.location.location.path", "wrong_path"),
+        ("model.location.path", "path"),
+        ("model.location.location.path.additional_field", "additional_field"),
+    ]
+    fields = {"name": FieldInfo(annotation=str), "model": FieldInfo(annotation=OtherTestModel)}
+
+    for wrong_column, wrong_fragment in column_names:
+        with patch("rich.console.Console.print") as mock_print:
+            with pytest.raises(typer.Exit, match="1"):
+                _get_nested_field(wrong_column, fields)
+            mock_print.assert_called_once_with(f"Unknown column: {wrong_column} ({wrong_fragment} not found)")

ragbits_cli-0.0.8.dev23005/tests/unit/test_utils.py

@@ -0,0 +1,38 @@
+import sys
+
+from ragbits.cli._utils import get_instance_or_exit
+from ragbits.core.utils.config_handling import WithConstructionConfig
+
+
+class ExampleClassForCLI(WithConstructionConfig):
+    default_module = sys.modules[__name__]
+    configuration_key = "example_cli"
+
+    def __init__(self, foo: str, bar: int) -> None:
+        self.foo = foo
+        self.bar = bar
+
+
+def sync_factory_for_cli() -> ExampleClassForCLI:
+    return ExampleClassForCLI("sync_cli", 123)
+
+
+async def async_factory_for_cli() -> ExampleClassForCLI:
+    """Async factory function for testing CLI with async support."""
+    return ExampleClassForCLI("async_cli", 456)
+
+
+def test_get_instance_or_exit_with_sync_factory():
+    """Test that get_instance_or_exit works with sync factory functions."""
+    instance = get_instance_or_exit(ExampleClassForCLI, factory_path="sync_factory_for_cli")
+    assert isinstance(instance, ExampleClassForCLI)
+    assert instance.foo == "sync_cli"
+    assert instance.bar == 123
+
+
+def test_get_instance_or_exit_with_async_factory():
+    """Test that get_instance_or_exit works with async factory functions."""
+    instance = get_instance_or_exit(ExampleClassForCLI, factory_path="async_factory_for_cli")
+    assert isinstance(instance, ExampleClassForCLI)
+    assert instance.foo == "async_cli"
+    assert instance.bar == 456

ragbits_cli-0.0.1/PKG-INFO

@@ -1,23 +0,0 @@
-Metadata-Version: 2.3
-Name: ragbits-cli
-Version: 0.0.1
-Summary: A CLI application for ragbits - building blocks for rapid development of GenAI applications
-Author-email: "deepsense.ai" <contact@deepsense.ai>
-License-Expression: MIT
-Keywords: GenAI,Generative AI,LLMs,Large Language Models,Prompt Management,RAG,Retrieval Augmented Generation
-Classifier: Development Status :: 1 - Planning
-Classifier: Environment :: Console
-Classifier: Intended Audience :: Science/Research
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Natural Language :: English
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.10
-Requires-Dist: typer>=0.12.5
-Description-Content-Type: text/markdown
-
-# Ragbits CLI

ragbits_cli-0.0.1/README.md

@@ -1 +0,0 @@
-# Ragbits CLI

ragbits_cli-0.0.1/src/ragbits/cli/__init__.py

@@ -1,31 +0,0 @@
-import importlib.util
-import pkgutil
-
-from typer import Typer
-
-import ragbits
-
-app = Typer(no_args_is_help=True)
-
-
-def main() -> None:
-    """
-    Main entry point for the CLI.
-
-    This function registers all the CLI modules in the ragbits packages:
-        - iterates over every package in the ragbits.* namespace
-        - it looks for `cli` package / module
-        - if found it imports the `register` function from the `cli` module and calls it with the `app` object
-        - register function should add the CLI commands to the `app` object
-    """
-
-    cli_enabled_modules = [
-        module
-        for module in pkgutil.iter_modules(ragbits.__path__)
-        if module.ispkg and module.name != "cli" and importlib.util.find_spec(f"ragbits.{module.name}.cli")
-    ]
-    for module in cli_enabled_modules:
-        register_func = importlib.import_module(f"ragbits.{module.name}.cli").register
-        register_func(app)
-
-    app()