man1lab 1.2.2__py3-none-any.whl

adapters/__init__.py

@@ -0,0 +1,4 @@
+from adapters.config_parser_settings import ConfigParserSettingsProvider
+from adapters.factory import build_document_parser
+
+__all__ = ["ConfigParserSettingsProvider", "build_document_parser"]

adapters/config_parser_settings.py

@@ -0,0 +1,18 @@
+from configuration.provider import SettingsProvider, get_settings_provider
+from ports.output_format import OutputFormat
+from ports.parser_settings import ParserSettings, ParserSettingsProvider
+
+
+class ConfigParserSettingsProvider:
+    """Read parser settings from the application settings provider."""
+
+    def __init__(self, settings_provider: SettingsProvider | None = None) -> None:
+        self._settings_provider = settings_provider or get_settings_provider()
+
+    def get_parser_settings(self) -> ParserSettings:
+        settings = self._settings_provider.get_settings()
+        return ParserSettings(
+            backend=settings.parser.backend.strip().lower(),
+            output_format=OutputFormat.MARKDOWN,
+            max_paper_text_chars=settings.parser.max_paper_text_chars,
+        )

adapters/docling_parser.py

@@ -0,0 +1,88 @@
+import logging
+import time
+from pathlib import Path
+
+from docling.backend.pypdfium2_backend import PyPdfiumDocumentBackend
+from docling.datamodel.base_models import InputFormat
+from docling.datamodel.pipeline_options import PdfPipelineOptions
+from docling.document_converter import DocumentConverter, PdfFormatOption
+
+from adapters.output_export import export_docling_document
+from ports.output_format import OutputFormat
+from ports.parsed_document import ParsedDocument
+from services.exceptions import (
+    PDFEmptyError,
+    PDFEncryptedError,
+    PDFExtractionError,
+    PDFNotFoundError,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class DoclingParser:
+    """Document parser backed by Docling structured document export."""
+
+    def __init__(
+        self,
+        converter: DocumentConverter | None = None,
+        *,
+        output_format: OutputFormat = OutputFormat.MARKDOWN,
+        max_paper_text_chars: int = 80_000,
+    ) -> None:
+        self._converter = converter or _build_converter()
+        self._output_format = output_format
+        self._max_paper_text_chars = max_paper_text_chars
+
+    def parse(self, paper_path: Path) -> ParsedDocument:
+        if not paper_path.exists():
+            raise PDFNotFoundError(f"PDF not found: {paper_path}")
+
+        start = time.perf_counter()
+        try:
+            result = self._converter.convert(str(paper_path))
+        except Exception as exc:
+            message = str(exc).lower()
+            if "encrypt" in message or "password" in message:
+                raise PDFEncryptedError(
+                    f"PDF is encrypted and cannot be read: {paper_path}"
+                ) from exc
+            raise PDFExtractionError(
+                f"Failed to parse PDF with Docling: {paper_path}"
+            ) from exc
+
+        markdown = export_docling_document(
+            result.document,
+            self._output_format,
+        )
+        if not markdown:
+            raise PDFEmptyError(f"PDF contains no extractable text: {paper_path}")
+
+        if self._max_paper_text_chars and len(markdown) > self._max_paper_text_chars:
+            markdown = markdown[: self._max_paper_text_chars]
+
+        duration = time.perf_counter() - start
+        logger.info(
+            "Docling parse complete: chars=%d duration=%.3fs file=%s status=%s format=%s",
+            len(markdown),
+            duration,
+            paper_path.name,
+            getattr(result, "status", "unknown"),
+            self._output_format.value,
+        )
+        return ParsedDocument(markdown=markdown)
+
+
+def _build_converter() -> DocumentConverter:
+    pipeline_options = PdfPipelineOptions(
+        do_ocr=False,
+        do_table_structure=True,
+    )
+    return DocumentConverter(
+        format_options={
+            InputFormat.PDF: PdfFormatOption(
+                pipeline_options=pipeline_options,
+                backend=PyPdfiumDocumentBackend,
+            )
+        }
+    )

adapters/factory.py

@@ -0,0 +1,31 @@
+from adapters.config_parser_settings import ConfigParserSettingsProvider
+from adapters.docling_parser import DoclingParser
+from adapters.pymupdf_parser import PyMuPDFParser
+from ports.document_parser import DocumentParser
+from ports.parser_settings import ParserSettings, ParserSettingsProvider
+
+_SUPPORTED_BACKENDS = frozenset({"docling", "pymupdf"})
+
+
+def build_document_parser(
+    settings: ParserSettings | None = None,
+    settings_provider: ParserSettingsProvider | None = None,
+) -> DocumentParser:
+    """Construct a document parser from explicit or provider-supplied settings."""
+    if settings is None:
+        provider = settings_provider or ConfigParserSettingsProvider()
+        settings = provider.get_parser_settings()
+
+    backend = settings.backend.strip().lower()
+    if backend not in _SUPPORTED_BACKENDS:
+        supported = ", ".join(sorted(_SUPPORTED_BACKENDS))
+        raise ValueError(
+            f"Unsupported parser backend={settings.backend!r}. "
+            f"Expected one of: {supported}"
+        )
+    if backend == "pymupdf":
+        return PyMuPDFParser()
+    return DoclingParser(
+        output_format=settings.output_format,
+        max_paper_text_chars=settings.max_paper_text_chars,
+    )

adapters/output_export.py

@@ -0,0 +1,21 @@
+from typing import Any
+
+from ports.output_format import OutputFormat
+
+
+def export_docling_document(
+    document: Any,
+    output_format: OutputFormat,
+) -> str:
+    """Serialize a Docling document using the configured output format."""
+    if output_format is OutputFormat.MARKDOWN:
+        return document.export_to_markdown().strip()
+    if output_format is OutputFormat.JSON:
+        raise NotImplementedError(
+            "OutputFormat.JSON is reserved for future Docling export support."
+        )
+    if output_format is OutputFormat.DOCTAGS:
+        raise NotImplementedError(
+            "OutputFormat.DOCTAGS is reserved for future Docling export support."
+        )
+    raise ValueError(f"Unsupported output format: {output_format!r}")

adapters/pymupdf_parser.py

@@ -0,0 +1,15 @@
+from pathlib import Path
+
+from ports.parsed_document import ParsedDocument
+from services.pdf_service import PDFService
+
+
+class PyMuPDFParser:
+    """Document parser backed by PyMuPDF plain-text extraction (legacy fallback)."""
+
+    def __init__(self, pdf_service: PDFService | None = None) -> None:
+        self._pdf_service = pdf_service or PDFService()
+
+    def parse(self, paper_path: Path) -> ParsedDocument:
+        text = self._pdf_service.extract(paper_path)
+        return ParsedDocument(markdown=text)

agents/__init__.py

@@ -0,0 +1,8 @@
+from agents.coder import Coder
+from agents.planner import Planner
+from agents.reader import Reader
+from agents.reporter import Reporter
+from agents.reviewer import Reviewer
+from agents.runner import Runner
+
+__all__ = ["Coder", "Planner", "Reader", "Reporter", "Reviewer", "Runner"]

agents/analysis_context.py

@@ -0,0 +1,147 @@
+"""Build agent-facing context from PaperReproductionAnalysis modules."""
+
+from __future__ import annotations
+
+import sys
+
+from agents.coder_quality import build_framework_binding
+from models.execution_strategy import ExecutionStrategy
+from models.paper_reproduction_analysis import PaperReproductionAnalysis
+from models.routing import TaskRoutingTable
+from models.task import TaskModel, TaskStep
+from models.verification import VerificationResult
+from routing.task_router import TaskRouter
+
+
+def build_planner_user_content(execution_strategy: ExecutionStrategy) -> str:
+    """Build planner context from committed ExecutionStrategy only."""
+    return (
+        "Committed execution strategy for task decomposition:\n\n"
+        f"Strategy:\n{execution_strategy.strategy.model_dump_json(indent=2)}\n\n"
+        f"Resource bindings:\n{execution_strategy.resource_bindings.model_dump_json(indent=2)}\n\n"
+        f"Reuse plan:\n{execution_strategy.reuse_plan.model_dump_json(indent=2)}\n\n"
+        f"Adaptation plan:\n{execution_strategy.adaptation_plan.model_dump_json(indent=2)}\n\n"
+        f"Generation plan:\n{execution_strategy.generation_plan.model_dump_json(indent=2)}\n\n"
+        f"Risk assessment:\n{execution_strategy.risk_assessment.model_dump_json(indent=2)}\n\n"
+        "Decompose engineering tasks that implement this strategy. "
+        "Do not choose repository, greenfield, adaptation, or reuse — those are already decided."
+    )
+
+
+def build_planner_legacy_user_content(analysis: PaperReproductionAnalysis) -> str:
+    return (
+        "Reproduction analysis for planning:\n\n"
+        f"Metadata:\n{analysis.metadata.model_dump_json(indent=2)}\n\n"
+        f"Goal:\n{analysis.goal.model_dump_json(indent=2)}\n\n"
+        f"Resources:\n{analysis.resources.model_dump_json(indent=2)}\n\n"
+        f"Method:\n{analysis.method.model_dump_json(indent=2)}\n\n"
+        f"Evaluation:\n{analysis.evaluation.model_dump_json(indent=2)}\n\n"
+        f"Reproduction gaps:\n"
+        f"{_gaps_json(analysis)}"
+    )
+
+
+def build_reviewer_user_content(
+    analysis: PaperReproductionAnalysis,
+    task: TaskModel,
+    verification_result: VerificationResult,
+) -> str:
+    return (
+        "Reproduction analysis:\n\n"
+        f"Goal:\n{analysis.goal.model_dump_json(indent=2)}\n\n"
+        f"Method:\n{analysis.method.model_dump_json(indent=2)}\n\n"
+        f"Evaluation:\n{analysis.evaluation.model_dump_json(indent=2)}\n\n"
+        f"Reproduction gaps:\n"
+        f"{_gaps_json(analysis)}\n\n"
+        "Task plan:\n"
+        f"{task.model_dump_json(indent=2)}\n\n"
+        "VerificationResult (ground truth):\n"
+        f"{verification_result.model_dump_json(indent=2)}"
+    )
+
+
+def build_coder_shared_context(
+    analysis: PaperReproductionAnalysis,
+    task: TaskModel,
+    routing_table: TaskRoutingTable,
+) -> dict[str, object]:
+    targets = routing_table.targets
+    framework = analysis.method.framework
+    return {
+        "paper_title": analysis.metadata.title,
+        "framework": framework,
+        "framework_binding": build_framework_binding(framework),
+        "dataset": _join_resource_names(analysis.resources.datasets),
+        "model": _join_resource_names(analysis.resources.models),
+        "optimizer": analysis.method.optimizer,
+        "loss": analysis.method.loss,
+        "training_pipeline": analysis.method.training_pipeline,
+        "evaluation_metric": _join_metric_names(analysis.evaluation.metrics),
+        "architecture": analysis.method.architecture,
+        "data_processing": analysis.method.data_processing,
+        "hyperparameters": [
+            item.model_dump() for item in analysis.method.hyperparameters
+        ],
+        "benchmarks": list(analysis.evaluation.benchmarks),
+        "reproduction_gaps": [
+            item.model_dump() for item in analysis.reproduction_gaps
+        ],
+        "python_version": f"{sys.version_info.major}.{sys.version_info.minor}",
+        "repository_files": [target.relative_path for target in targets],
+        "source_modules": [
+            target.relative_path.removesuffix(".py").replace("/", ".")
+            for target in targets
+            if target.file_category == "source"
+        ],
+        "config_files": [
+            target.relative_path
+            for target in targets
+            if target.file_category == "config"
+        ],
+        "script_files": [
+            target.relative_path
+            for target in targets
+            if target.file_category == "script"
+        ],
+        "train_entrypoint": "scripts/train.py",
+        "eval_entrypoint": "scripts/evaluate.py",
+        "engineering_tasks": [
+            {"id": step.id, "name": step.name, "description": step.description}
+            for step in task.steps
+        ],
+        "routing_coverage": _compute_routing_coverage(task, routing_table),
+    }
+
+
+def _gaps_json(analysis: PaperReproductionAnalysis) -> str:
+    if not analysis.reproduction_gaps:
+        return "[]"
+    return "[" + ", ".join(
+        gap.model_dump_json() for gap in analysis.reproduction_gaps
+    ) + "]"
+
+
+def _join_resource_names(resources: list) -> str:
+    names = [resource.name for resource in resources if resource.name]
+    return ", ".join(names)
+
+
+def _join_metric_names(metrics: list) -> str:
+    names = [metric.name for metric in metrics if metric.name]
+    return ", ".join(names)
+
+
+def _compute_routing_coverage(
+    task: TaskModel,
+    routing_table: TaskRoutingTable,
+) -> dict[str, object]:
+    covered_ids: set[str] = set()
+    router = TaskRouter()
+    for step in task.steps:
+        if router.route_step(step):
+            covered_ids.add(step.id)
+    unrouted = [step.id for step in task.steps if step.id not in covered_ids]
+    return {
+        "routed_step_ids": sorted(covered_ids),
+        "unrouted_step_ids": unrouted,
+    }

agents/analysis_snapshot.py

@@ -0,0 +1,20 @@
+"""Serialize PaperReproductionAnalysis artifacts produced by Reader."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from models.paper_reproduction_analysis import PaperReproductionAnalysis
+
+
+def analysis_snapshot_dict(analysis: PaperReproductionAnalysis) -> dict:
+    return analysis.model_dump(mode="json")
+
+
+def write_analysis_snapshot(analysis: PaperReproductionAnalysis, path: Path) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(
+        json.dumps(analysis_snapshot_dict(analysis), indent=2, default=str) + "\n",
+        encoding="utf-8",
+    )