import syft_client as sc

# For Google Colab (auto-detects your Google account)
client = sc.login_do()

# For Jupyter (requires token file)
client = sc.login_do(
    email="[email protected]",
    token_path="path/to/token_do.json"
)

# See all peers (approved and pending)
peers = client.peers
print(peers)

# Filter by state
for peer in peers:
    if peer.is_pending:
        print(f"Pending: {peer.email}")
    elif peer.is_approved:
        print(f"Approved: {peer.email}")

# Create dataset with mock and private data
client.create_dataset(
    name="patient-records",
    mock_path="/path/to/mock_data.csv",
    private_path="/path/to/real_data.csv",
    summary="Anonymized patient records for research",
    readme_path="/path/to/README.md",
    tags=["healthcare", "research"],
    users=["[email protected]"]  # Specific users
)

# Share with a list of email addresses
client.create_dataset(
    name="restricted-data",
    mock_path="mock.csv",
    private_path="private.csv",
    summary="Restricted access dataset",
    users=["[email protected]", "[email protected]"]
)

# Share with anyone who has been approved
client.create_dataset(
    name="public-research-data",
    mock_path="mock.csv",
    private_path="private.csv",
    summary="Publicly available research data",
    users="any"  # Available to all approved peers
)

client.create_dataset(
    name="sensitive-data",
    mock_path="mock.csv",
    private_path="private.csv",
    summary="Sensitive dataset with separate private storage",
    users="any",
    upload_private=True  # Stores private data separately
)

# Share with additional users
client.share_dataset(
    tag="patient-records",
    users=["[email protected]"]
)

# Make available to all approved peers
client.share_dataset(
    tag="patient-records",
    users="any"
)

client.delete_dataset(name="old-dataset")

# View all datasets you've created
datasets = client.datasets.get_all()
for dataset in datasets:
    print(f"{dataset.name}: {dataset.summary}")

# See all jobs from data scientists
jobs = client.jobs

for job in jobs:
    print(f"Job: {job.name}")
    print(f"Status: {job.status}")
    print(f"Submitted by: {job.submitted_by}")
    print(f"Submitted at: {job.submitted_at}")
    print("---")

# Process all approved jobs
client.process_approved_jobs(
    stream_output=True,           # Show real-time output
    timeout=300,                  # 5 minute timeout per job
    share_outputs_with_submitter=True,  # Share results
    share_logs_with_submitter=True      # Share execution logs
)

# Force execution of all jobs (bypass version checks)
client.process_approved_jobs(force_execution=True)

# Execute jobs without auto-sharing
client.process_approved_jobs(
    share_outputs_with_submitter=False,
    share_logs_with_submitter=False
)

# Review results, then share manually
client.job_runner.share_job_results(
    job_name="Analysis Job",
    share_outputs=True,
    share_logs=True
)

SyftBox_{your_email}/
└── [email protected]/
    └── jobs/
        └── [email protected]/
            └── Analysis Job/
                ├── config.yaml      # Job metadata
                ├── run.sh          # Execution script
                ├── analysis.py     # Submitted code
                ├── outputs/        # Computation results
                │   └── result.json
                └── logs/           # Execution logs
                    ├── stdout.txt
                    └── stderr.txt

# Manually create a checkpoint
client.create_checkpoint()

# Check if checkpoint is needed (>= 50 events since last checkpoint)
if client.should_create_checkpoint(threshold=50):
    client.create_checkpoint()

# Auto-checkpoint during sync (default behavior)
client.sync(auto_checkpoint=True, checkpoint_threshold=50)

import os
os.environ["PRE_SYNC"] = "false"

# Now these won't auto-sync
datasets = client.datasets.get_all()
jobs = client.jobs

# Manually sync when ready
client.sync()

import os
os.environ["PRE_SYNC"] = "false"  # Faster when reviewing multiple jobs

client.sync()
jobs = client.jobs

for job in jobs:
    if job.status == "pending":
        print(f"\n{'='*60}")
        print(f"Job: {job.name}")
        print(f"From: {job.submitted_by}")
        print(f"Submitted: {job.submitted_at}")
        print(f"{'='*60}")
        
        # Show the code
        code_files = list(job.job_dir.rglob("*.py"))
        for code_file in code_files:
            print(f"\n--- {code_file.name} ---")
            with open(code_file, "r") as f:
                print(f.read())
        
        # Manual approval decision
        decision = input("Approve? (y/n): ")
        if decision.lower() == "y":
            job.approve()
            print("✓ Approved")
        else:
            reason = input("Rejection reason: ")
            job.reject(reason=reason)
            print("✗ Rejected")

# Execute all approved jobs
client.process_approved_jobs(
    timeout=300,
    share_outputs_with_submitter=True,
    share_logs_with_submitter=True
)

TRUSTED_PEERS = [
    "[email protected]",
    "[email protected]"
]

client.load_peers()
for peer in client.peers:
    if peer.is_pending and peer.email in TRUSTED_PEERS:
        client.approve_peer_request(peer.email)
        print(f"Auto-approved: {peer.email}")

# Delete all Google Drive files, local caches, and folders
client.delete_syftbox(
    verbose=True,                    # Show deletion progress
    broadcast_delete_events=True     # Notify peers of deletion
)

client.approve_peer_request("[email protected]")
client.sync()  # Push approval to Google Drive

client.sync()  # Pull approval

# Data scientist should include all dependencies
client.submit_python_job(
    user="[email protected]",
    code_path="analysis.py",
    dependencies=["pandas==2.0.0", "numpy", "scikit-learn"]
)