Thanh Quang
update api, ui
6b8bb0d
Raw History Blame
5.28 kB
"""Typer command-line entrypoint for DocuLearn-RAG."""
from __future__ import annotations
import json
from pathlib import Path
import typer
from pydantic import BaseModel, ValidationError
from src.export import ExportFormat, export
from src.filters import MetadataFilter, filters_to_dict
from src.indexing import ingest as ingest_data
from src.learning import generate_flashcards, generate_quiz
from src.learning import summarize as summarize_learning
from src.rag import answer, retrieve
from src.schemas import RetrievedChunk
app = typer.Typer(help="Index PDFs and use grounded DocuLearn-RAG learning features.")
def _parse_filters(value: str | None) -> MetadataFilter | None:
if value is None or not value.strip():
return None
parsed: dict[str, object] = {}
allowed = set(MetadataFilter.model_fields)
for expression in value.split(","):
key, separator, raw_value = expression.partition("=")
key = key.strip()
raw_value = raw_value.strip()
if not separator or not key or not raw_value:
raise typer.BadParameter("Filters must use key=value pairs separated by commas.")
if key not in allowed:
raise typer.BadParameter(
f"Unknown filter '{key}'. Expected one of: {', '.join(sorted(allowed))}."
)
if key == "page":
try:
parsed[key] = int(raw_value)
except ValueError as error:
raise typer.BadParameter("The page filter must be an integer.") from error
elif key == "filenames":
parsed[key] = [item.strip() for item in raw_value.split("|") if item.strip()]
else:
parsed[key] = raw_value
try:
return MetadataFilter.model_validate(parsed)
except ValidationError as error:
raise typer.BadParameter(str(error)) from error
def _write_result(
result: BaseModel,
output: Path | None,
fmt: ExportFormat,
) -> None:
rendered = export(result, fmt=fmt, output=output)
if output is None:
typer.echo(rendered, nl=False)
else:
typer.echo(f"Exported to {rendered}")
def _print_sources(chunks: list[RetrievedChunk]) -> None:
if not chunks:
return
typer.echo("\nSources:")
for index, chunk in enumerate(chunks, start=1):
metadata = chunk.metadata
typer.echo(f"S{index}: {metadata.filename}, page {metadata.page}")
@app.command()
def ingest(recreate: bool = False) -> None:
"""Index all PDFs in the configured data directory."""
count = ingest_data(recreate=recreate)
typer.echo(f"Done. {count} chunks indexed.")
@app.command()
def ask(
question: str,
k: int | None = None,
filters: str | None = None,
) -> None:
"""Ask a grounded question and show its retrieved sources."""
result = answer(question, k=k, filters=filters_to_dict(_parse_filters(filters)))
typer.echo(result.answer)
_print_sources(result.chunks)
@app.command("debug-retrieval")
def debug_retrieval(
question: str,
k: int | None = None,
filters: str | None = None,
as_json: bool = False,
) -> None:
"""Inspect the chunks retrieved for a question."""
chunks = retrieve(question, k=k, filters=filters_to_dict(_parse_filters(filters)))
if as_json:
typer.echo(
json.dumps(
[chunk.model_dump(mode="json") for chunk in chunks],
ensure_ascii=False,
indent=2,
)
)
return
for index, chunk in enumerate(chunks, start=1):
metadata = chunk.metadata
typer.echo(
f"S{index} {metadata.filename} p.{metadata.page} "
f"score={chunk.score:.4f}\n{chunk.text}\n"
)
@app.command()
def summarize(
document: str | None = None,
query: str | None = None,
filters: str | None = None,
k: int | None = None,
output: Path | None = None,
fmt: ExportFormat = "text",
) -> None:
"""Create a grounded summary."""
result = summarize_learning(
document=document,
query=query,
filters=filters_to_dict(_parse_filters(filters)),
k=k,
)
_write_result(result, output, fmt)
@app.command()
def quiz(
document: str | None = None,
query: str | None = None,
filters: str | None = None,
count: int | None = None,
k: int | None = None,
output: Path | None = None,
fmt: ExportFormat = "text",
) -> None:
"""Generate a grounded multiple-choice quiz."""
result = generate_quiz(
document=document,
query=query,
filters=filters_to_dict(_parse_filters(filters)),
count=count,
k=k,
)
_write_result(result, output, fmt)
@app.command()
def flashcards(
document: str | None = None,
query: str | None = None,
filters: str | None = None,
count: int | None = None,
k: int | None = None,
output: Path | None = None,
fmt: ExportFormat = "text",
) -> None:
"""Generate grounded flashcards."""
result = generate_flashcards(
document=document,
query=query,
filters=filters_to_dict(_parse_filters(filters)),
count=count,
k=k,
)
_write_result(result, output, fmt)
if __name__ == "__main__":
app()