ReportGenerator

class ReportGenerator:
    """Generates publication-ready Markdown reports using Gemini 3.

    Key features:
    - Single Gemini call for all narrative sections (efficient API usage)
    - Complete fallback report if Gemini fails (template-only)
    - Locally-built structured sections (tables, stats)
    - Saves report with timestamped filename
    """

    def __init__(self, gemini_client: GeminiClient):
        """Initialize the report generator.

        Args:
            gemini_client: Shared GeminiClient instance for API calls.
        """

def generate(
    self,
    state: ExperimentState,
    output_dir: Path,
    plot_paths: Optional[list[Path]] = None,
) -> Path:
    """Generate the final experiment report.

    Args:
        state: Complete ExperimentState after all iterations.
        output_dir: Base output directory (reports saved to output_dir/reports/).
        plot_paths: Optional list of paths to generated visualization PNGs.

    Returns:
        Path to the generated Markdown report file.
    """

from pathlib import Path
from src.cognitive.gemini_client import GeminiClient
from src.cognitive.report_generator import ReportGenerator

# Initialize
client = GeminiClient()
generator = ReportGenerator(gemini_client=client)

# Generate report after autopilot completes
report_path = generator.generate(
    state=final_state,
    output_dir=Path("./output")
)

print(f"Report saved to: {report_path}")

from pathlib import Path

# Generate plots
plot_paths = [
    Path("output/plots/metrics_over_time.png"),
    Path("output/plots/model_comparison.png"),
    Path("output/plots/feature_importance.png"),
]

# Generate report with visualizations
report_path = generator.generate(
    state=final_state,
    output_dir=Path("./output"),
    plot_paths=plot_paths
)

print(f"Report with {len(plot_paths)} visualizations saved to: {report_path}")

from pathlib import Path
from src.orchestration.state import ExperimentState
from src.cognitive.gemini_client import GeminiClient
from src.cognitive.experiment_designer import ExperimentDesigner
from src.cognitive.results_analyzer import ResultsAnalyzer
from src.cognitive.report_generator import ReportGenerator

# Shared client
client = GeminiClient()

# Initialize components
designer = ExperimentDesigner(client)
analyzer = ResultsAnalyzer(client)
generator = ReportGenerator(client)

# Initialize state
state = ExperimentState(config=config)
output_dir = Path("./output")

# Run experiment loop
for iteration in range(1, state.config.max_iterations + 1):
    # Design and execute
    spec = designer.design_experiment(
        data_profile=state.data_profile,
        previous_results=state.experiments,
        task_type=state.config.task_type.value,
        iteration=iteration
    )
    
    result = execute_experiment(spec)
    analysis = analyzer.analyze(result, state)
    state.add_experiment(result)
    
    # Check termination
    if should_stop(state):
        state.termination_reason = "Maximum iterations reached"
        break

# Generate final report
report_path = generator.generate(
    state=state,
    output_dir=output_dir
)

print(f"\nAutopilot complete!")
print(f"Report: {report_path}")

from pathlib import Path
from datetime import datetime

# Create custom output structure
project_dir = Path("./ml_experiments")
run_name = f"run_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
output_dir = project_dir / run_name
output_dir.mkdir(parents=True, exist_ok=True)

# Generate report
report_path = generator.generate(
    state=state,
    output_dir=output_dir
)

print(f"Report: {report_path}")
# Output: ./ml_experiments/run_20260302_143022/reports/report_housing_20260302_143022.md

# Generate report
report_path = generator.generate(state, output_dir)

# Read and display
with open(report_path, 'r') as f:
    report_content = f.read()

print("=" * 80)
print(report_content)
print("=" * 80)

# Extract specific sections
sections = report_content.split("##")
executive_summary = sections[1] if len(sections) > 1 else ""
print("Executive Summary:")
print(executive_summary.strip())

try:
    report_path = generator.generate(
        state=state,
        output_dir=output_dir,
        plot_paths=plot_paths
    )
    
    # Check if fallback was used (by reading content)
    with open(report_path, 'r') as f:
        content = f.read()
    
    if "This report summarizes an automated ML experiment session" in content:
        print("Note: Fallback report generated (Gemini unavailable)")
    else:
        print("Full report with Gemini-generated insights")
    
except Exception as e:
    print(f"Report generation failed: {e}")

import re

# Generate report
report_path = generator.generate(state, output_dir)

# Parse report sections
with open(report_path, 'r') as f:
    content = f.read()

# Extract sections using regex
sections = {}
current_section = None
for line in content.split('\n'):
    if line.startswith('## '):
        current_section = line[3:].strip()
        sections[current_section] = []
    elif current_section:
        sections[current_section].append(line)

# Access specific sections
if 'Key Insights' in sections:
    insights = '\n'.join(sections['Key Insights'])
    print("Key Insights:")
    print(insights)

if 'Recommendations' in sections:
    recommendations = '\n'.join(sections['Recommendations'])
    print("\nRecommendations:")
    print(recommendations)

from pathlib import Path
import glob

# Run multiple autopilot sessions
output_dir = Path("./experiments")

for dataset in ["housing", "iris", "wine"]:
    # ... run autopilot for each dataset
    
    report_path = generator.generate(
        state=session_state,
        output_dir=output_dir
    )
    print(f"Generated report for {dataset}: {report_path}")

# List all generated reports
reports = sorted(glob.glob(str(output_dir / "reports" / "*.md")))
print(f"\nTotal reports generated: {len(reports)}")
for report in reports:
    print(f"  - {Path(report).name}")

report_{dataset_name}_{timestamp}.md