cct-cli 0.7.9.0__py3-none-any.whl

calc_terminal/report.py

@@ -0,0 +1,162 @@
+"""
+CCT Report Generator — exports solved notebooks (from session history)
+to a real Markdown file and a real PDF (via reportlab, already a
+dependency). This is a straight, faithful export of the same
+Question/Given/Find/Formula/Substitution/Calculation/Units/Verification
+/Answer structure already rendered on screen — not a separate "fake"
+summary.
+"""
+
+import os
+import re
+
+from .mathtext import compose, mathify
+
+PDF_AVAILABLE = True
+try:
+    from reportlab.lib.pagesizes import LETTER
+    from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+    from reportlab.lib.units import inch
+    from reportlab.lib import colors
+    from reportlab.platypus import (
+        SimpleDocTemplate, Paragraph, Spacer, ListFlowable, ListItem, HRFlowable
+    )
+except Exception:
+    PDF_AVAILABLE = False
+
+
+_ANSI_RE = re.compile(r"\x1b\[[0-9;]*m")
+
+
+def _plain(s):
+    return _ANSI_RE.sub("", str(s))
+
+
+def _notebook_to_markdown(nb, index):
+    lines = [f"## {index}. {nb.get('topic', 'Notebook')}", ""]
+    lines.append(f"**Question:** {_plain(nb.get('question', ''))}")
+    lines.append("")
+    lines.append("**Given data:**")
+    for g in nb.get("given", []):
+        lines.append(f"- {_plain(g)}")
+    lines.append("")
+    lines.append(f"**Find:** {_plain(nb.get('find', ''))}")
+    lines.append("")
+    lines.append("**Formula:**")
+    lines.append("```")
+    lines.append(_plain(compose(nb.get("formula", []))))
+    lines.append("```")
+    lines.append("")
+    lines.append("**Substitution:**")
+    lines.append("```")
+    lines.append(_plain(compose(nb.get("substitution", []))))
+    lines.append("```")
+    lines.append("")
+    calc = nb.get("calculation", [])
+    if calc:
+        lines.append("**Calculation:**")
+        for i, c in enumerate(calc, 1):
+            lines.append(f"{i}. {_plain(mathify(c))}")
+        lines.append("")
+    if nb.get("unit"):
+        lines.append(f"**Units:** {_plain(mathify(nb['unit']))}")
+        lines.append("")
+    if nb.get("verification"):
+        lines.append(f"**Verification:** {_plain(mathify(nb['verification']))}")
+        lines.append("")
+    lines.append(f"**Final answer:** {_plain(nb.get('final_answer', ''))}")
+    lines.append("")
+    lines.append("---")
+    lines.append("")
+    return lines
+
+
+def export_history_markdown(history, path, title="CAT Notebook Export"):
+    if not history:
+        raise ValueError("No history to export.")
+    lines = [f"# {title}", ""]
+    lines.append(f"_{len(history)} notebook(s), exported from Chemistry Calc Terminal_")
+    lines.append("")
+    for i, nb in enumerate(history, 1):
+        lines.extend(_notebook_to_markdown(nb, i))
+    text = "\n".join(lines)
+    with open(path, "w", encoding="utf-8") as f:
+        f.write(text)
+    return path
+
+
+def export_history_pdf(history, path, title="CAT Notebook Export"):
+    if not PDF_AVAILABLE:
+        raise RuntimeError("reportlab is not installed — run: pip install reportlab")
+    if not history:
+        raise ValueError("No history to export.")
+
+    doc = SimpleDocTemplate(path, pagesize=LETTER,
+                             topMargin=0.7 * inch, bottomMargin=0.7 * inch,
+                             leftMargin=0.75 * inch, rightMargin=0.75 * inch)
+    styles = getSampleStyleSheet()
+    h1 = ParagraphStyle("h1", parent=styles["Heading1"], textColor=colors.HexColor("#3b2a86"))
+    h2 = ParagraphStyle("h2", parent=styles["Heading2"], textColor=colors.HexColor("#1f6fb2"),
+                         spaceBefore=14)
+    body = ParagraphStyle("body", parent=styles["BodyText"], leading=15)
+    mono = ParagraphStyle("mono", parent=styles["Code"], backColor=colors.HexColor("#f4f4f8"),
+                           borderPadding=6, leading=13)
+    answer = ParagraphStyle("answer", parent=styles["BodyText"],
+                             textColor=colors.HexColor("#0a7d3c"), fontName="Helvetica-Bold")
+
+    def esc(s):
+        return (_plain(s).replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;"))
+
+    story = [Paragraph(esc(title), h1),
+             Paragraph(f"{len(history)} notebook(s) — Chemistry Calc Terminal", body),
+             Spacer(1, 12)]
+
+    for i, nb in enumerate(history, 1):
+        story.append(Paragraph(f"{i}. {esc(nb.get('topic', 'Notebook'))}", h2))
+        story.append(Paragraph(f"<b>Question:</b> {esc(nb.get('question', ''))}", body))
+        given = nb.get("given", [])
+        if given:
+            story.append(Paragraph("<b>Given data:</b>", body))
+            story.append(ListFlowable(
+                [ListItem(Paragraph(esc(g), body)) for g in given], bulletType="bullet"))
+        story.append(Paragraph(f"<b>Find:</b> {esc(nb.get('find', ''))}", body))
+        story.append(Paragraph("<b>Formula:</b>", body))
+        story.append(Paragraph(esc(compose(nb.get("formula", []))).replace("\n", "<br/>"), mono))
+        story.append(Paragraph("<b>Substitution:</b>", body))
+        story.append(Paragraph(esc(compose(nb.get("substitution", []))).replace("\n", "<br/>"), mono))
+        calc = nb.get("calculation", [])
+        if calc:
+            story.append(Paragraph("<b>Calculation:</b>", body))
+            story.append(ListFlowable(
+                [ListItem(Paragraph(esc(mathify(c)), body)) for c in calc], bulletType="1"))
+        if nb.get("unit"):
+            story.append(Paragraph(f"<b>Units:</b> {esc(mathify(nb['unit']))}", body))
+        if nb.get("verification"):
+            story.append(Paragraph(f"<b>Verification:</b> {esc(mathify(nb['verification']))}", body))
+        story.append(Paragraph(f"Final answer: {esc(nb.get('final_answer', ''))}", answer))
+        story.append(HRFlowable(width="100%", color=colors.HexColor("#dddddd"), spaceBefore=10, spaceAfter=10))
+
+    doc.build(story)
+    return path
+
+
+def default_export_dir():
+    """Notebook exports go into the shared Project Workspace now (spec
+    section 16, calc_terminal/workspace.py) instead of report.py's own
+    ~/CCT_exports — which, before this, was a *different* directory
+    from scires.py's ~/cct_exports (different casing, never the same
+    folder). Falls back to the old location only if the workspace
+    module can't be imported, so a broken workspace config never
+    blocks an export outright.
+
+    STRICT FIX v0.7.9.6: explicit ensure=True — this is a WRITE path
+    (the user explicitly requested an export), so directory creation
+    is authorized here. Read paths (summary/list_category) use
+    ensure=False and never create."""
+    try:
+        from . import workspace
+        return workspace.category_dir("reports", ensure=True)
+    except Exception:
+        d = os.path.join(os.path.expanduser("~"), "CCT_exports")
+        os.makedirs(d, exist_ok=True)
+        return d

calc_terminal/research/__init__.py

@@ -0,0 +1,45 @@
+"""
+CAT Research Subsystem per §48-§51, §58-§63, §97-§98:
+- Experiment Ledger & Scientific Time Machine
+- Data Lineage Graph
+- Semantic Artifact Intelligence
+- Reproducibility Engine & Package Generation
+"""
+
+from __future__ import annotations
+
+from calc_terminal.research.experiment_ledger import (
+    ExperimentRecord,
+    ExperimentVersion,
+    ExperimentLedger,
+    experiment_ledger,
+)
+from calc_terminal.research.data_lineage import (
+    LineageNode,
+    DataLineageGraph,
+    data_lineage,
+)
+from calc_terminal.research.artifact_intel import (
+    ArtifactSemantics,
+    analyze_artifact,
+)
+from calc_terminal.research.reproducibility import (
+    ReproductionReport,
+    ReproducibilityEngine,
+    reproducibility_engine,
+)
+
+__all__ = [
+    "ExperimentRecord",
+    "ExperimentVersion",
+    "ExperimentLedger",
+    "experiment_ledger",
+    "LineageNode",
+    "DataLineageGraph",
+    "data_lineage",
+    "ArtifactSemantics",
+    "analyze_artifact",
+    "ReproductionReport",
+    "ReproducibilityEngine",
+    "reproducibility_engine",
+]

calc_terminal/research/artifact_intel.py

@@ -0,0 +1,126 @@
+"""
+Semantic Artifact Intelligence per §51:
+Understands the semantic domain and compatible tool capabilities for files:
+- .pdb, .cif -> Protein 3D Structure
+- .fasta, .fa -> Biological Sequence
+- .safetensors, .pt -> Machine Learning Model
+- .ipynb -> Jupyter Notebook
+- .csv, .parquet -> Dataset
+- .png, .svg -> Scientific Visualization
+- .qasm -> Quantum Circuit
+"""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional
+
+
+@dataclass
+class ArtifactSemantics:
+    path: str
+    filename: str
+    semantic_type: str
+    domain: str
+    recommended_capabilities: List[str]
+    description: str
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "path": self.path,
+            "filename": self.filename,
+            "semantic_type": self.semantic_type,
+            "domain": self.domain,
+            "recommended_capabilities": self.recommended_capabilities,
+            "description": self.description,
+        }
+
+
+def analyze_artifact(file_path: str) -> ArtifactSemantics:
+    """Classify and return semantic domain and recommended capabilities for an artifact."""
+    norm = os.path.normpath(file_path)
+    base = os.path.basename(norm).lower()
+    ext = os.path.splitext(base)[1].lower()
+
+    if ext in (".pdb", ".cif", ".mmcif"):
+        return ArtifactSemantics(
+            path=norm,
+            filename=base,
+            semantic_type="protein_structure",
+            domain="structural_biology",
+            recommended_capabilities=["pymol.open", "chimerax.open", "biopython.parse"],
+            description="3D macromolecular coordinate structure file",
+        )
+    elif ext in (".fasta", ".fa", ".fna", ".faa"):
+        return ArtifactSemantics(
+            path=norm,
+            filename=base,
+            semantic_type="biological_sequence",
+            domain="bioinformatics",
+            recommended_capabilities=["blast.search", "ncbi.query", "biopython.parse"],
+            description="Nucleotide or amino acid biological sequence file",
+        )
+    elif ext in (".safetensors", ".pt", ".pth", ".onnx", ".bin"):
+        return ArtifactSemantics(
+            path=norm,
+            filename=base,
+            semantic_type="ml_model",
+            domain="machine_learning",
+            recommended_capabilities=["pytorch.eval", "huggingface.model", "ml.detect_hardware"],
+            description="Trained neural network model weights or serialized computational graph",
+        )
+    elif ext == ".ipynb":
+        return ArtifactSemantics(
+            path=norm,
+            filename=base,
+            semantic_type="jupyter_notebook",
+            domain="notebook_computing",
+            recommended_capabilities=["jupyter.execute", "jupyter.list_servers", "python.execute"],
+            description="Interactive literate computing Jupyter notebook",
+        )
+    elif ext in (".csv", ".tsv", ".parquet", ".arrow", ".jsonl"):
+        return ArtifactSemantics(
+            path=norm,
+            filename=base,
+            semantic_type="dataset",
+            domain="data_science",
+            recommended_capabilities=["numpy.compute", "kaggle.dataset", "python.execute"],
+            description="Tabular or columnar scientific/machine learning dataset",
+        )
+    elif ext in (".png", ".svg", ".pdf", ".eps"):
+        return ArtifactSemantics(
+            path=norm,
+            filename=base,
+            semantic_type="scientific_figure",
+            domain="scientific_visualization",
+            recommended_capabilities=["browser.navigate", "filesystem.read"],
+            description="Rendered scientific visualization or publication figure",
+        )
+    elif ext in (".qasm",):
+        return ArtifactSemantics(
+            path=norm,
+            filename=base,
+            semantic_type="quantum_circuit",
+            domain="quantum_computing",
+            recommended_capabilities=["qiskit.run_circuit", "quantum.bloch_sphere"],
+            description="OpenQASM quantum circuit specification",
+        )
+    elif ext in (".py",):
+        return ArtifactSemantics(
+            path=norm,
+            filename=base,
+            semantic_type="source_code",
+            domain="software_engineering",
+            recommended_capabilities=["python.execute", "git.diff", "filesystem.read"],
+            description="Python executable source code",
+        )
+
+    return ArtifactSemantics(
+        path=norm,
+        filename=base,
+        semantic_type="generic_file",
+        domain="general",
+        recommended_capabilities=["filesystem.read"],
+        description="General file",
+    )

calc_terminal/research/data_lineage.py

@@ -0,0 +1,123 @@
+"""
+CAT Data Lineage Graph per §58, §97:
+Tracks end-to-end transformation lineage from raw source to figures and publication reports.
+Explains dependency chains when upstream or downstream artifacts change.
+"""
+
+from __future__ import annotations
+
+import time
+import os
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional, Set
+
+
+@dataclass
+class LineageNode:
+    path: str
+    artifact_type: str  # dataset, features, model, predictions, figure, report
+    sources: List[str] = field(default_factory=list)  # parent artifact paths
+    transform_tool: str = ""  # tool or script that produced this artifact
+    experiment_id: Optional[str] = None
+    task_id: Optional[str] = None
+    created_at: float = field(default_factory=time.time)
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "path": self.path,
+            "artifact_type": self.artifact_type,
+            "sources": self.sources,
+            "transform_tool": self.transform_tool,
+            "experiment_id": self.experiment_id,
+            "task_id": self.task_id,
+            "created_at": self.created_at,
+            "metadata": self.metadata,
+        }
+
+
+class DataLineageGraph:
+    """DAG tracking artifact generation, transformations, and dependency explanations."""
+
+    def __init__(self):
+        self.nodes: Dict[str, LineageNode] = {}
+
+    def record_transformation(
+        self,
+        target_path: Optional[str] = None,
+        sources: Optional[List[str]] = None,
+        transform_tool: str = "",
+        artifact_type: str = "artifact",
+        experiment_id: Optional[str] = None,
+        task_id: Optional[str] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        output_path: Optional[str] = None,
+    ) -> LineageNode:
+        actual_path = target_path or output_path or ""
+        norm_target = os.path.normpath(actual_path)
+        norm_sources = [os.path.normpath(s) for s in (sources or [])]
+        node = LineageNode(
+            path=norm_target,
+            artifact_type=artifact_type,
+            sources=norm_sources,
+            transform_tool=transform_tool,
+            experiment_id=experiment_id,
+            task_id=task_id,
+            metadata=metadata or {},
+        )
+        self.nodes[norm_target] = node
+        return node
+
+    def get_upstream_lineage(self, target_path: str) -> List[str]:
+        """Return list of all ancestor artifacts that produced target_path."""
+        norm_target = os.path.normpath(target_path)
+        visited = []
+        queue = [norm_target]
+        while queue:
+            curr = queue.pop(0)
+            node = self.nodes.get(curr)
+            if node:
+                for s in node.sources:
+                    if s not in visited:
+                        visited.append(s)
+                        queue.append(s)
+        return visited
+
+    def get_upstream(self, target_path: str) -> List[str]:
+        return self.get_upstream_lineage(target_path)
+
+    def get_downstream_impact(self, source_path: str) -> List[str]:
+        """Return list of all downstream artifacts dependent on source_path."""
+        norm_source = os.path.normpath(source_path)
+        impacted = []
+        for path, node in self.nodes.items():
+            if norm_source in node.sources:
+                impacted.append(path)
+                impacted.extend(self.get_downstream_impact(path))
+        return list(dict.fromkeys(impacted))
+
+    def get_downstream(self, source_path: str) -> List[str]:
+        return self.get_downstream_impact(source_path)
+
+    def explain_chain(self, target_path: str) -> str:
+        """Human-readable explanation of how this artifact was generated."""
+        norm = os.path.normpath(target_path)
+        node = self.nodes.get(norm)
+        if not node:
+            return f"No recorded lineage for artifact: {os.path.basename(target_path)}"
+
+        lines = [f"Artifact: {os.path.basename(norm)} ({node.artifact_type})"]
+        if node.transform_tool:
+            lines.append(f"Produced by: {node.transform_tool}")
+        if node.experiment_id:
+            lines.append(f"Experiment: {node.experiment_id}")
+        if node.sources:
+            lines.append("Source dependencies:")
+            for s in node.sources:
+                src_node = self.nodes.get(s)
+                tool_note = f" (via {src_node.transform_tool})" if src_node and src_node.transform_tool else ""
+                lines.append(f"  └── {os.path.basename(s)}{tool_note}")
+        return "\n".join(lines)
+
+
+data_lineage = DataLineageGraph()