brainforge-cli 0.1.0__tar.gz

brainforge_cli-0.1.0/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: brainforge-cli
+Version: 0.1.0
+Summary: Command-line interface for Brainforge
+Author: Daniel Trinh
+Requires-Python: >=3.10
+Requires-Dist: requests
+Requires-Dist: click
+Requires-Dist: PyYAML
+Requires-Dist: globus-sdk
+Dynamic: author
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

brainforge_cli-0.1.0/README.md

@@ -0,0 +1,42 @@
+# Brainforge CLI
+
+Command-line interface for Brainforge V3.
+
+## Local Installation (Development)
+
+To install the CLI for local development with real-time updates:
+
+```bash
+pip install -e .
+```
+
+## Publishing to PyPI
+
+If you want others to install the CLI simply via `pip install brainforge`, follow these steps:
+
+### 1. Install Publishing Tools
+You will need Python's official packaging tools. Install them globally:
+```bash
+pip install --upgrade build twine
+```
+
+### 2. Build the Package
+From inside the `brainforge-cli` folder (where `setup.py` is), run:
+```bash
+python -m build
+```
+*(This generates two files inside a new `dist/` folder: a `.whl` and a `.tar.gz`)*
+
+### 3. Upload to PyPI
+You need an account on [PyPI (Python Package Index)](https://pypi.org/).
+- Register an account.
+- Go to your Account Settings and [create an API token](https://pypi.org/manage/account/token/).
+- Upload your build using `twine`:
+
+```bash
+twine upload dist/*
+```
+
+*(When prompted for a username, type `__token__`. For the password, paste your PyPI API token!)*
+
+> **Note**: If the name `brainforge` is already taken by someone else on PyPI, you will need to rename your package in `setup.py` (e.g. `name="brainforge-cli"` or `name="brainforge-v3"`).

brainforge_cli-0.1.0/brainforge/__init__.py

@@ -0,0 +1,5 @@
+"""
+Brainforge CLI Package
+"""
+
+__version__ = "0.1.0"

brainforge_cli-0.1.0/brainforge/auth.py

@@ -0,0 +1,76 @@
+import json
+import os
+
+import click
+import globus_sdk
+
+# The Client ID should be replaced with a real Globus Native App Client ID
+# registered in the Globus Developer Console.
+# Default to an environment variable if provided.
+CLIENT_ID = os.environ.get("GLOBUS_CLIENT_ID", "64371d44-2d7f-4330-a7fb-046d03f1d418")
+CREDENTIALS_FILE = os.path.expanduser("~/.brainforge/credentials.json")
+
+
+def get_auth_client():
+    return globus_sdk.NativeAppAuthClient(CLIENT_ID)
+
+
+def login():
+    try:
+        client = get_auth_client()
+        # Request necessary scopes to get a recognizable token back
+        client.oauth2_start_flow(
+            refresh_tokens=True, requested_scopes=globus_sdk.scopes.AuthScopes.openid
+        )
+
+        auth_url = client.oauth2_get_authorize_url()
+        click.echo("Please authenticate with Globus here:\n")
+        click.secho(f"{auth_url}\n", fg="cyan")
+
+        auth_code = click.prompt("Please enter the authorization code you received")
+
+        token_response = client.oauth2_exchange_code_for_tokens(auth_code.strip())
+
+        # Save tokens
+        os.makedirs(os.path.dirname(CREDENTIALS_FILE), exist_ok=True)
+        with open(CREDENTIALS_FILE, 'w') as f:
+            # We save the dictionary of tokens by resource server
+            json.dump(token_response.by_resource_server, f)
+
+        click.secho(
+            f"Successfully authenticated! Credentials saved to {CREDENTIALS_FILE}",
+            fg="green",
+        )
+    except globus_sdk.AuthAPIError as e:
+        click.secho(f"Globus Auth failed: {e.message}", fg="red")
+    except Exception as e:
+        click.secho(f"Authentication failed: {e}", fg="red")
+
+
+def get_access_token():
+    """
+    Returns the Globus Access Token from local storage.
+    """
+    if not os.path.exists(CREDENTIALS_FILE):
+        return None
+
+    try:
+        with open(CREDENTIALS_FILE, 'r') as f:
+            tokens = json.load(f)
+
+        # The Auth server's token is typically what we need to pass back to the Django API
+        auth_data = tokens.get("auth.globus.org", {})
+        return auth_data.get("access_token")
+    except Exception:
+        return None
+
+
+def logout():
+    """
+    Logs out the user by deleting local credentials.
+    """
+    if os.path.exists(CREDENTIALS_FILE):
+        os.remove(CREDENTIALS_FILE)
+        click.secho("Successfully logged out (Local credentials deleted).", fg="green")
+    else:
+        click.secho("You are already logged out.", fg="yellow")

brainforge_cli-0.1.0/brainforge/cli.py

@@ -0,0 +1,168 @@
+import sys
+
+import brainforge.auth as auth
+import click
+from brainforge.job_logs import fetch_logs
+from brainforge.job_status import check_status
+from brainforge.run import generate_sbatch_script
+from brainforge.run import parse_spec
+from brainforge.run import submit_job
+from brainforge.run import validate_spec
+from brainforge.template import generate_yaml_template
+
+
+@click.group()
+@click.version_option(version="0.1.0")
+def main():
+    """
+    BrainForge CLI: The premier interface for executing neuroimaging analyses.
+
+    Provides tools for generating SLURM job configurations, securely
+    submitting arrays to the cluster, and tracking runtime statuses.
+    """
+    pass
+
+
+@main.command()
+def info():
+    """Display information about Brainforge CLI and its current version."""
+    click.echo("Welcome to the Brainforge CLI v0.1.0")
+    click.echo("Run 'brainforge --help' to see all available commands.")
+
+
+@main.command()
+def login():
+    """Authenticate with Globus."""
+    auth.login()
+
+
+@main.command()
+def logout():
+    """Logout of Globus."""
+    auth.logout()
+
+
+@main.group()
+def job():
+    """
+    Manage and monitor SLURM jobs submitted via BrainForge.
+
+    Use this group to submit jobs, check their queue/execution status,
+    or tail their logs live on the cluster.
+    """
+    pass
+
+
+@job.command(name='run')
+@click.argument('spec_file', type=click.Path(exists=True, dir_okay=False), required=False)
+@click.option(
+    '--yaml',
+    'yaml_str',
+    help="Parse the YAML spec directly from a string instead of a file.",
+)
+@click.option(
+    '--dry-run',
+    is_flag=True,
+    help="Generate and print the sbatch script without submitting to SLURM.",
+)
+def run_job(spec_file, yaml_str, dry_run):
+    """
+    Submit a SLURM job using a YAML specification file or string.
+
+    Takes a SPEC_FILE containing `slurm` and `execution` blocks.
+    Will automatically detect if this is a single job or a multiple job
+    (array job) based on the presence of `participant` or `participants`.
+    """
+    import yaml
+    if yaml_str:
+        try:
+            spec = yaml.safe_load(yaml_str)
+        except Exception as e:
+            click.secho(f"Error parsing YAML string: {e}", fg="red")
+            sys.exit(1)
+    elif spec_file:
+        spec = parse_spec(spec_file)
+    else:
+        click.secho("Error: You must provide either a SPEC_FILE argument or a --yaml configuration.", fg="red")
+        sys.exit(1)
+
+    # Validate the spec
+    validate_spec(spec)
+
+    # Generate script
+    script_content = generate_sbatch_script(spec)
+
+    # Submit job (or print if dry_run)
+    submit_job(script_content, spec, dry_run=dry_run)
+
+
+@job.command()
+@click.argument('job_id')
+@click.option('--json', 'as_json', is_flag=True, help="Output status securely in JSON format")
+def status(job_id, as_json):
+    """
+    Check the queue and runtime status of a scheduled SLURM job.
+
+    Uses `sacct` (for comprehensive history) and falls back to `squeue`
+    for nascent jobs. Can lookup both active and completed jobs.
+    """
+    check_status(job_id, as_json=as_json)
+
+
+@job.command()
+@click.argument('job_id')
+@click.option(
+    '--type',
+    '-t',
+    'log_type',
+    type=click.Choice(['output', 'error']),
+    default='output',
+    help="Type of logs to view (output or error).",
+)
+@click.option(
+    '--follow',
+    '-f',
+    is_flag=True,
+    help="Follow the log contents live.",
+)
+def logs(job_id, log_type, follow):
+    """
+    Tail or view the live standard logs of a SLURM job.
+
+    Dynamically finds the output file SLURM is writing to using `scontrol`.
+    By default it cats the standard output to the console. Use `--type error` for standard error,
+    and `-f` to follow the stream live (like tail -f).
+    """
+    fetch_logs(job_id, log_type, follow=follow)
+
+
+@job.command(name="generate")
+@click.option(
+    '--type',
+    '-t',
+    'job_type',  # map back to variable name
+    prompt='Select job template type',
+    type=click.Choice(['single', 'multiple']),
+    default='single',
+    help="Type of job template (single or multiple).",
+)
+@click.option(
+    '--name',
+    '-n',
+    prompt='Enter output filename',
+    default='template.yaml',
+    help="Output filename for the generated template.",
+)
+def generate_cmd(job_type, name):
+    """
+    Generate a working YAML template for a BrainForge SLURM job.
+
+    Creates a boilerplate .yaml file pre-filled with all required
+    variables (`SINGULARITY_IMAGE`, `HOST_INPUT_DIR`, etc.) to run
+    either a `single` job or an array job over `multiple` participants.
+    """
+    generate_yaml_template(job_type, name)
+
+
+if __name__ == "__main__":
+    main()

brainforge_cli-0.1.0/brainforge/job_logs.py

@@ -0,0 +1,84 @@
+import os
+import subprocess
+
+import click
+
+
+def fetch_logs(job_id, log_type, follow=False):
+    """
+    Fetch the StdOut or StdErr log path for a given active SLURM job
+    and print its contents (or follow live) to the console.
+    """
+    try:
+        cmd = ["scontrol", "show", "job", str(job_id)]
+        res = subprocess.run(cmd, capture_output=True, text=True, check=True)
+
+        stdout_path = None
+        stderr_path = None
+
+        for line in res.stdout.split('\n'):
+            # scontrol output lines often have multiple key=value pairs separated by spaces
+            tokens = line.split()
+            for token in tokens:
+                if token.startswith("StdOut="):
+                    stdout_path = token.split("=", 1)[1]
+                elif token.startswith("StdErr="):
+                    stderr_path = token.split("=", 1)[1]
+
+        target_path = stdout_path if log_type == 'output' else stderr_path
+
+        if not target_path or target_path == '/dev/null':
+            click.secho(
+                f"Could not determine the {log_type} file path from SLURM configuration.",
+                fg="red",
+            )
+            return
+
+        if not os.path.exists(target_path):
+            click.secho(
+                f"Log file does not exist yet (or was deleted):\n{target_path}",
+                fg="yellow",
+            )
+            return
+
+        if follow:
+            click.secho(
+                f"--- Following {log_type} logs for Job {job_id} ---",
+                fg="cyan",
+                bold=True,
+            )
+            click.secho(f"File: {target_path} (Ctrl+C to stop)\n", fg="cyan")
+            try:
+                subprocess.run(["tail", "-f", target_path])
+            except KeyboardInterrupt:
+                click.echo("\nStopped following.")
+                return
+        else:
+            click.secho(
+                f"--- Viewing {log_type} logs for Job {job_id} ---",
+                fg="cyan",
+                bold=True,
+            )
+            click.secho(f"File: {target_path}\n", fg="cyan")
+
+            with open(target_path, 'r') as f:
+                content = f.read()
+
+            if not content.strip():
+                click.echo("<File is currently empty>")
+            else:
+                click.echo(content)
+
+    except subprocess.CalledProcessError:
+        click.secho(f"Job {job_id} not found in active SLURM queue.", fg="red")
+        click.echo(
+            "Hint: SLURM only registers paths for currently active or very recently finished jobs."
+        )
+        click.echo(
+            "If your job finished a while ago, check the 'logs/' folder in the directory where you submitted it."
+        )
+    except FileNotFoundError:
+        click.secho(
+            "Error: 'scontrol' command not found. Are you on a system with SLURM installed?",
+            fg="red",
+        )

brainforge_cli-0.1.0/brainforge/job_status.py

@@ -0,0 +1,88 @@
+import json
+import subprocess
+
+import click
+
+
+def check_status(job_id, as_json=False):
+    """
+    Check the status of a SLURM job using sacct.
+    If sacct returns empty (sometimes happens right after submission), fall back to squeue.
+    """
+    try:
+        if as_json:
+            cmd = ["sacct", "-j", str(job_id), "-X", "-P", "--format=JobID,State,ExitCode,End"]
+            result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+            output = result.stdout.strip()
+            lines = output.split('\n')
+            if len(lines) > 1:
+                parts = lines[1].split('|')
+                if len(parts) >= 4:
+                    click.echo(json.dumps({
+                        "job_id": parts[0],
+                        "state": parts[1].split(' ')[0],
+                        "exit_code": parts[2],
+                        "end_time": parts[3]
+                    }))
+                    return
+            # fallback
+            cmd2 = ["squeue", "-j", str(job_id), "-O", "jobid,state", "-h"]
+            res2 = subprocess.run(cmd2, capture_output=True, text=True)
+            if res2.returncode == 0 and res2.stdout.strip():
+                parts = res2.stdout.strip().split()
+                if len(parts) >= 2:
+                    click.echo(json.dumps({
+                        "job_id": parts[0],
+                        "state": parts[1],
+                        "exit_code": "",
+                        "end_time": ""
+                    }))
+                    return
+            
+            click.echo(json.dumps({}))
+            return
+
+        # -X only shows the main allocation, hiding duplicate .batch and .extern steps
+        cmd = ["sacct", "-j", str(job_id), "-X"]
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+
+        output = result.stdout.strip()
+
+        # sacct prints headers even if empty, but let's check if there are no real data lines
+        lines = output.split('\n')
+
+        # Usually sacct has 2 header lines. If there are <= 2 lines, it might not have loaded
+        if len(lines) <= 2:
+            # Fallback to squeue for very nascent jobs
+            cmd2 = ["squeue", "-j", str(job_id)]
+            try:
+                res2 = subprocess.run(cmd2, capture_output=True, text=True, check=True)
+                queue_output = res2.stdout.strip()
+                if queue_output:
+                    click.secho(
+                        f"--- Status for SLURM Job: {job_id} (squeue) ---",
+                        fg="cyan",
+                        bold=True,
+                    )
+                    click.echo(queue_output)
+                    return
+            except subprocess.CalledProcessError:
+                pass
+
+        click.secho(f"--- Status for SLURM Job: {job_id} ---", fg="cyan", bold=True)
+        click.echo(output)
+
+    except subprocess.CalledProcessError as e:
+        if as_json:
+            click.echo(json.dumps({"error": f"Failed to query status: {e.stderr}"}))
+            return
+        click.secho(f"Failed to query status for job ID {job_id}.", fg="red")
+        click.echo(e.stderr)
+    except FileNotFoundError:
+        if as_json:
+            click.echo(json.dumps({"error": "sacct command not found"}))
+            return
+        click.secho(
+            "Error: 'sacct' command not found. Are you on a system with SLURM installed?",
+            fg="red",
+        )

brainforge_cli-0.1.0/brainforge/run.py

@@ -0,0 +1,277 @@
+import os
+import subprocess
+import sys
+import tempfile
+
+import click
+import requests
+import yaml
+from brainforge.auth import get_access_token
+
+
+def parse_spec(filepath):
+    try:
+        with open(filepath, 'r') as f:
+            return yaml.safe_load(f)
+    except Exception as e:
+        click.secho(f"Error reading YAML file: {e}", fg="red")
+        sys.exit(1)
+
+
+def validate_spec(spec):
+    """
+    Validates that the provided YAML spec has the required structure and fields.
+    Exits the CLI with an error if validation fails.
+    """
+    if not isinstance(spec, dict):
+        click.secho("Error: YAML spec must be a dictionary at the top level.", fg="red")
+        sys.exit(1)
+
+    if 'slurm' not in spec:
+        click.secho(
+            "Error: Missing required 'slurm' section in the spec file.", fg="red"
+        )
+        sys.exit(1)
+
+    if not isinstance(spec['slurm'], dict):
+        click.secho("Error: The 'slurm' section must be a dictionary.", fg="red")
+        sys.exit(1)
+
+    required_slurm_keys = [
+        'job-name',
+        'partition',
+        'account',
+        'time',
+        'mem',
+        'cpus-per-task',
+        'output',
+        'error',
+    ]
+    for key in required_slurm_keys:
+        if key not in spec['slurm']:
+            click.secho(f"Error: Missing required slurm parameter: '{key}'.", fg="red")
+            sys.exit(1)
+
+    if 'execution' not in spec:
+        click.secho(
+            "Error: Missing required 'execution' section in the spec file.", fg="red"
+        )
+        sys.exit(1)
+
+    execution = spec['execution']
+    if not isinstance(execution, dict):
+        click.secho("Error: The 'execution' section must be a dictionary.", fg="red")
+        sys.exit(1)
+
+    if 'command' not in execution or not execution['command']:
+        click.secho(
+            "Error: The 'execution' block must contain a 'command' string to run.",
+            fg="red",
+        )
+        sys.exit(1)
+
+    modules = execution.get('modules', [])
+    if not isinstance(modules, list):
+        click.secho("Error: 'execution.modules' must be a list.", fg="red")
+        sys.exit(1)
+
+    has_singularity = any(
+        m == 'singularity' or m.startswith('singularity/') for m in modules
+    )
+    if not has_singularity:
+        click.secho(
+            "Error: 'execution.modules' must contain 'singularity' or specify a version (e.g., 'singularity/3.10.2').",
+            fg="red",
+        )
+        sys.exit(1)
+
+    env_vars = execution.get('env', {})
+    if not isinstance(env_vars, dict):
+        click.secho("Error: 'execution.env' must be a dictionary.", fg="red")
+        sys.exit(1)
+
+    required_env_keys = ['SINGULARITY_IMAGE', 'HOST_INPUT_DIR', 'HOST_OUTPUT_DIR']
+    for key in required_env_keys:
+        if key not in env_vars:
+            click.secho(
+                f"Error: Missing required execution.env parameter: '{key}'.", fg="red"
+            )
+            sys.exit(1)
+
+    participants = execution.get('participants')
+    participant = execution.get('participant')
+
+    if participants is not None and participant is not None:
+        click.secho(
+            "Error: Cannot specify both 'participant' and 'participants'. Choose one.",
+            fg="red",
+        )
+        sys.exit(1)
+
+    if participants is None and participant is None:
+        click.secho(
+            "Error: You must specify either 'participant' (for single jobs) or 'participants' (for array jobs).",
+            fg="red",
+        )
+        sys.exit(1)
+
+    if participants is not None:
+        if not isinstance(participants, list) or len(participants) == 0:
+            click.secho(
+                "Error: 'participants' must be a non-empty list of subject identifiers.",
+                fg="red",
+            )
+            sys.exit(1)
+
+    if participant is not None:
+        # Checking if it's truthy handles empty strings intuitively (e.g. "")
+        if not str(participant).strip():
+            click.secho(
+                "Error: 'participant' must be a valid, non-empty identifier.", fg="red"
+            )
+            sys.exit(1)
+
+
+def generate_sbatch_script(spec):
+    lines = ["#!/bin/bash"]
+
+    slurm_config = spec.get('slurm', {})
+    execution = spec.get('execution', {})
+
+    # 1. Add #SBATCH directives
+    for key, value in slurm_config.items():
+        if value is True:
+            # Some flags might not have a value, e.g. --exclusive
+            lines.append(f"#SBATCH --{key}")
+        elif value is False:
+            continue
+        else:
+            lines.append(f"#SBATCH --{key}={value}")
+
+    # 2. Add array logic if applicable
+    participants = execution.get('participants', [])
+    if participants:
+        # Array bounds
+        num_items = len(participants)
+        lines.append(f"#SBATCH --array=0-{num_items - 1}")
+
+    lines.append("")
+    lines.append("# --- Auto-generated by BrainForge CLI ---")
+    lines.append("")
+
+    # 3. Handle array item mapping or single participant mapping
+    if participants:
+        lines.append('BFG_PARTICIPANTS=(')
+        for item in participants:
+            # Safely quote items
+            lines.append(f'  "{item}"')
+        lines.append(')')
+        lines.append('BFG_PARTICIPANT=${BFG_PARTICIPANTS[$SLURM_ARRAY_TASK_ID]}')
+        lines.append('echo "BrainForge Task running for participant: $BFG_PARTICIPANT"')
+        lines.append("")
+    elif 'participant' in execution:
+        # Singular participant definition
+        val = execution['participant']
+        lines.append(f'BFG_PARTICIPANT="{val}"')
+        lines.append('echo "BrainForge Task running for participant: $BFG_PARTICIPANT"')
+        lines.append("")
+
+    # 4. Modules loading
+    modules = execution.get('modules', [])
+    if modules:
+        for mod in modules:
+            lines.append(f"module load {mod}")
+        lines.append("")
+
+    # 5. Environment variables
+    env_vars = execution.get('env', {})
+    if env_vars:
+        for key, val in env_vars.items():
+            lines.append(f'export {key}="{val}"')
+        lines.append("")
+
+    # 6. Actual command
+    cmd = execution.get('command', '')
+    if cmd:
+        lines.append(cmd)
+
+    return "\n".join(lines)
+
+
+def submit_job(script_content, spec, dry_run=False):
+    # Optional Database Logging via API
+    api_config = spec.get('api', {})
+    if 'raw_image_id' in api_config and 'spec_id' in api_config:
+        base_url = api_config.get('base_url', 'http://localhost:8000/api')
+        token = get_access_token()
+        if not token:
+            click.secho(
+                "Error: API config found but you are not logged in. Run 'brainforge login' first.",
+                fg="red",
+            )
+            if not dry_run:
+                sys.exit(1)
+        else:
+            click.echo("Registering run with BrainForge Backend API...")
+            headers = {
+                "Authorization": f"Bearer {token}",
+                "Content-Type": "application/json",
+            }
+            try:
+                # Based on the serializers.py, it expects raw_image_id and spec_id
+                resp = requests.post(
+                    f"{base_url}/preprocessing_analyses/run_analysis/",
+                    json={
+                        "raw_image_id": api_config['raw_image_id'],
+                        "spec_id": api_config['spec_id'],
+                    },
+                    headers=headers,
+                )
+
+                if resp.status_code == 201:
+                    click.secho(
+                        "Successfully registered job in the backend database.",
+                        fg="green",
+                    )
+                else:
+                    click.secho(
+                        f"Failed to register job. HTTP {resp.status_code}: {resp.text}",
+                        fg="yellow",
+                    )
+            except Exception as e:
+                click.secho(f"API request failed: {e}", fg="red")
+
+    if dry_run:
+        click.secho("--- DRY RUN: Generated batch script ---", fg="cyan")
+        click.echo(script_content)
+        click.secho("---------------------------------------", fg="cyan")
+        return
+
+    # Create a temporary file to hold the generated sbatch script
+    fd, path = tempfile.mkstemp(suffix=".sh", prefix="bfg_run_")
+    with os.fdopen(fd, 'w') as f:
+        f.write(script_content)
+
+    try:
+        # Run sbatch on the temporary file
+        result = subprocess.run(
+            ['sbatch', path], capture_output=True, text=True, check=True
+        )
+        click.secho("Job submitted successfully!", fg="green")
+        click.echo(result.stdout.strip())
+    except subprocess.CalledProcessError as e:
+        click.secho("Failed to submit job to SLURM:", fg="red")
+        click.echo(e.stderr)
+        sys.exit(1)
+    except FileNotFoundError:
+        click.secho(
+            "Error: 'sbatch' command not found. Are you on a system with SLURM installed?",
+            fg="red",
+        )
+        sys.exit(1)
+    finally:
+        # Clean up the temporary file
+        try:
+            os.remove(path)
+        except OSError:
+            pass

brainforge_cli-0.1.0/brainforge/template.py

@@ -0,0 +1,72 @@
+import os
+
+import click
+
+SINGLE_JOB_TEMPLATE = """# Single Job Template for BrainForge CLI
+slurm:
+  job-name: "name"
+  partition: "partition"
+  account: "account"
+  nodes: 1
+  ntasks: 1
+  mem: "8G"
+  cpus-per-task: 4
+  output: "logs/job_%j.out"
+  error: "logs/job_%j.err"
+
+execution:
+  modules:
+    - singularity
+  env:
+    SINGULARITY_IMAGE: "/path/to/container.sif"
+    HOST_INPUT_DIR: "/path/to/input"
+    HOST_OUTPUT_DIR: "/path/to/output"
+  participant: "sub-01"
+  command: "echo 'Running Single Job for item $BFG_PARTICIPANT'"
+"""
+
+MULTIPLE_JOB_TEMPLATE = """# Multiple Job Template for BrainForge CLI
+slurm:
+  job-name: "name"
+  partition: "partition"
+  account: "account"
+  nodes: 1
+  ntasks: 1
+  mem: "8G"
+  cpus-per-task: 4
+  output: "logs/job_%A_%a.out"
+  error: "logs/job_%A_%a.err"
+
+execution:
+  modules:
+    - singularity
+  env:
+    SINGULARITY_IMAGE: "/path/to/container.sif"
+    HOST_INPUT_DIR: "/path/to/input"
+    HOST_OUTPUT_DIR: "/path/to/output"
+  participants:
+    - "sub-01"
+    - "sub-02"
+    - "sub-03"
+  command: "echo 'Running Multiple Job for item $BFG_PARTICIPANT'"
+"""
+
+
+def generate_yaml_template(job_type, output_name):
+    if job_type == 'multiple':
+        content = MULTIPLE_JOB_TEMPLATE
+    else:
+        content = SINGLE_JOB_TEMPLATE
+
+    # Ensure we don't accidentally overwrite without warning, though
+    # for simplicity we'll just open and write.
+    # If file exists, click.confirm could be used, but let's keep it simple first.
+    if os.path.exists(output_name):
+        click.confirm(f"File '{output_name}' already exists. Overwrite?", abort=True)
+
+    with open(output_name, 'w') as f:
+        f.write(content)
+
+    click.secho(
+        f"Successfully generated {job_type} template: {output_name}", fg="green"
+    )

brainforge_cli-0.1.0/brainforge_cli.egg-info/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: brainforge-cli
+Version: 0.1.0
+Summary: Command-line interface for Brainforge
+Author: Daniel Trinh
+Requires-Python: >=3.10
+Requires-Dist: requests
+Requires-Dist: click
+Requires-Dist: PyYAML
+Requires-Dist: globus-sdk
+Dynamic: author
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

brainforge_cli-0.1.0/brainforge_cli.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+README.md
+setup.py
+brainforge/__init__.py
+brainforge/auth.py
+brainforge/cli.py
+brainforge/job_logs.py
+brainforge/job_status.py
+brainforge/run.py
+brainforge/template.py
+brainforge_cli.egg-info/PKG-INFO
+brainforge_cli.egg-info/SOURCES.txt
+brainforge_cli.egg-info/dependency_links.txt
+brainforge_cli.egg-info/entry_points.txt
+brainforge_cli.egg-info/requires.txt
+brainforge_cli.egg-info/top_level.txt

brainforge_cli-0.1.0/brainforge_cli.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

brainforge_cli-0.1.0/brainforge_cli.egg-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+bf = brainforge.cli:main
+brainforge = brainforge.cli:main

brainforge_cli-0.1.0/brainforge_cli.egg-info/requires.txt

@@ -0,0 +1,4 @@
+requests
+click
+PyYAML
+globus-sdk

brainforge_cli-0.1.0/brainforge_cli.egg-info/top_level.txt

@@ -0,0 +1 @@
+brainforge

brainforge_cli-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

brainforge_cli-0.1.0/setup.py

@@ -0,0 +1,23 @@
+from setuptools import find_packages
+from setuptools import setup
+
+setup(
+    name="brainforge-cli",
+    version="0.1.0",
+    description="Command-line interface for Brainforge",
+    author="Daniel Trinh",
+    packages=find_packages(),
+    install_requires=[
+        "requests",
+        "click",
+        "PyYAML",
+        "globus-sdk",
+    ],
+    entry_points={
+        "console_scripts": [
+            "brainforge=brainforge.cli:main",
+            "bf=brainforge.cli:main",
+        ],
+    },
+    python_requires=">=3.10",
+)