pip install anthropic

import anthropic
import json
import time

client = anthropic.Anthropic(
    api_key="your-api-key",
    base_url="https://api.claudeapi.com"  # ClaudeAPI.com endpoint
)

def build_batch_requests(projects: list[dict]) -> list[dict]:
    """
    projects: [{"id": "proj_001", "name": "...", "readme": "..."}]
    """
    requests = []
  
    for project in projects:
        request = {
            "custom_id": project["id"],  # Your own ID — used to match results later
            "params": {
                "model": "claude-opus-4-6",
                "max_tokens": 300000,  # Up to 300K output tokens per request
                "messages": [
                    {
                        "role": "user",
                        "content": f"""Perform a deep analysis of the following open-source project and output a structured report:

Project name: {project['name']}

README contents:
{project['readme']}

Please structure your report as follows:

## Project Overview
(One-sentence summary of core functionality)

## Tech Stack Assessment
(List major technologies; evaluate maturity and community activity)

## Core Use Cases
(3–5 best-fit use cases)

## Risks & Limitations
(Tech debt, maintenance risks, scope boundaries)

## Overall Recommendation Score
(1–10, with justification)
"""
                    }
                ]
            }
        }
        requests.append(request)
  
    return requests

def submit_batch(projects: list[dict]) -> str:
    """Submit the batch and return the batch_id."""
  
    requests = build_batch_requests(projects)
  
    print(f"Submitting {len(requests)} requests...")
  
    batch = client.messages.batches.create(requests=requests)
  
    print(f"Batch submitted!")
    print(f"  Batch ID: {batch.id}")
    print(f"  Status: {batch.processing_status}")
    print(f"  Total requests: {batch.request_counts.processing}")
  
    return batch.id

def wait_for_batch(batch_id: str, poll_interval: int = 60) -> None:
    """Poll batch status until processing ends."""
  
    print(f"\nWaiting for batch to complete (checking every {poll_interval}s)...")
  
    while True:
        batch = client.messages.batches.retrieve(batch_id)
        counts = batch.request_counts
      
        print(f"[{time.strftime('%H:%M:%S')}] Status: {batch.processing_status} | "
              f"Processing: {counts.processing} | "
              f"Succeeded: {counts.succeeded} | "
              f"Errored: {counts.errored}")
      
        if batch.processing_status == "ended":
            print(f"\nBatch complete!")
            print(f"  Succeeded: {counts.succeeded}")
            print(f"  Errored: {counts.errored}")
            print(f"  Expired: {counts.expired}")
            break
      
        time.sleep(poll_interval)

def collect_results(batch_id: str) -> dict[str, str]:
    """Collect all successful results."""
  
    results = {}
    errors = []
  
    for result in client.messages.batches.results(batch_id):
        custom_id = result.custom_id
      
        if result.result.type == "succeeded":
            # Extract text content
            content = result.result.message.content[0].text
            results[custom_id] = content
          
        elif result.result.type == "errored":
            error_msg = result.result.error.error.message
            errors.append({"id": custom_id, "error": error_msg})
            print(f"Request failed [{custom_id}]: {error_msg}")
  
    if errors:
        with open("batch_errors.json", "w", encoding="utf-8") as f:
            json.dump(errors, f, ensure_ascii=False, indent=2)
        print(f"\n{len(errors)} requests failed — details saved to batch_errors.json")
  
    return results


def save_reports(results: dict[str, str], output_dir: str = "reports") -> None:
    """Save each report as a separate file."""
    import os
    os.makedirs(output_dir, exist_ok=True)
  
    for custom_id, content in results.items():
        filepath = os.path.join(output_dir, f"{custom_id}.md")
        with open(filepath, "w", encoding="utf-8") as f:
            f.write(content)
  
    print(f"\n{len(results)} reports saved to {output_dir}/")

def main():
    # Sample data — in production, load from files or a database
    projects = [
        {
            "id": f"proj_{i:03d}",
            "name": f"Sample Project {i}",
            "readme": f"This is the README for project {i}..." * 100  # Simulating long text
        }
        for i in range(1, 501)  # 500 projects
    ]
  
    # 1. Submit the batch
    batch_id = submit_batch(projects)
  
    # Persist the batch_id in case the script crashes
    with open("batch_id.txt", "w") as f:
        f.write(batch_id)
    print(f"Batch ID saved to batch_id.txt")
  
    # 2. Wait for completion
    wait_for_batch(batch_id, poll_interval=60)
  
    # 3. Collect results
    results = collect_results(batch_id)
  
    # 4. Save reports
    save_reports(results)
  
    print("\nAll done!")


if __name__ == "__main__":
    main()

# Recover from the saved batch_id
with open("batch_id.txt") as f:
    batch_id = f.read().strip()

# Check status and collect results
wait_for_batch(batch_id)
results = collect_results(batch_id)
save_reports(results)

"custom_id": f"contract_{contract_id}_v{version}"

# Re-submit only the ones that failed
failed_ids = {e["id"] for e in errors}
failed_projects = [p for p in projects if p["id"] in failed_ids]
retry_batch_id = submit_batch(failed_projects)