gwsim 0.1.0__py3-none-any.whl

gwsim/cli/repository/main.py

@@ -0,0 +1,38 @@
+"""CLI for managing Zenodo repositories."""
+
+from __future__ import annotations
+
+import typer
+
+# Create the repository subcommand app
+repository_app = typer.Typer(
+    name="repository",
+    help="Manage Zenodo repositories for simulation data.",
+    rich_markup_mode="rich",
+)
+
+
+# Import and register commands after app is created
+def register_commands() -> None:
+    """Register all CLI commands."""
+
+    from gwsim.cli.repository.create import create_command  # pylint: disable=import-outside-toplevel
+    from gwsim.cli.repository.delete import delete_command  # pylint: disable=import-outside-toplevel
+    from gwsim.cli.repository.download import download_command  # pylint: disable=import-outside-toplevel
+    from gwsim.cli.repository.list_depositions import (  # pylint: disable=import-outside-toplevel
+        list_depositions_command,
+    )
+    from gwsim.cli.repository.metadata.main import metadata_app  # pylint: disable=import-outside-toplevel
+    from gwsim.cli.repository.upload import upload_command  # pylint: disable=import-outside-toplevel
+    from gwsim.cli.repository.verify import verify_command  # pylint: disable=import-outside-toplevel
+
+    repository_app.command("create")(create_command)
+    repository_app.command("upload")(upload_command)
+    repository_app.command("download")(download_command)
+    repository_app.command("list")(list_depositions_command)
+    repository_app.command("delete")(delete_command)
+    repository_app.command("verify")(verify_command)
+    repository_app.add_typer(metadata_app, name="metadata", help="Manage Zenodo metadata")
+
+
+register_commands()

gwsim/cli/repository/metadata/main.py

@@ -0,0 +1,24 @@
+"""CLI for managing Zenodo metadata."""
+
+from __future__ import annotations
+
+import typer
+
+# Create the metadata subcommand app
+metadata_app = typer.Typer(
+    name="metadata",
+    help="Manage Zenodo metadata for simulation data.",
+    rich_markup_mode="rich",
+)
+
+
+# Import and register commands after app is created
+def register_commands() -> None:
+    """Register all CLI commands."""
+
+    from gwsim.cli.repository.metadata.update import update_command  # pylint: disable=import-outside-toplevel
+
+    metadata_app.command("update")(update_command)
+
+
+register_commands()

gwsim/cli/repository/metadata/update.py

@@ -0,0 +1,58 @@
+"""CLI for updating Zenodo repository depositions."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+
+def update_command(
+    deposition_id: Annotated[str, typer.Argument(help="Deposition ID")],
+    metadata_file: Annotated[
+        Path | None, typer.Option("--metadata-file", help="YAML file with metadata to update")
+    ] = None,
+    sandbox: Annotated[bool, typer.Option("--sandbox", help="Use sandbox environment")] = False,
+    token: Annotated[str | None, typer.Option("--token", help="Zenodo access token")] = None,
+) -> None:
+    """Update metadata for a deposition.
+
+    Examples:
+        gwsim repository update 123456 --metadata-file metadata.yaml
+    """
+    import logging  # pylint: disable=import-outside-toplevel
+
+    import yaml  # pylint: disable=import-outside-toplevel
+    from rich.console import Console  # pylint: disable=import-outside-toplevel
+
+    from gwsim.cli.repository.utils import get_zenodo_client  # pylint: disable=import-outside-toplevel
+
+    logger = logging.getLogger("gwsim")
+    console = Console()
+
+    if not metadata_file:
+        metadata_file = Path(typer.prompt("Path to metadata YAML file"))
+
+    if not metadata_file.exists():
+        console.print(f"[red]Error:[/red] File not found: {metadata_file}")
+        raise typer.Exit(1)
+
+    with metadata_file.open("r", encoding="utf-8") as f:
+        metadata = yaml.safe_load(f)
+
+    if not metadata:
+        console.print("[red]Error:[/red] Metadata file is empty.")
+        raise typer.Exit(1)
+
+    client = get_zenodo_client(sandbox=sandbox, token=token)
+
+    console.print(f"[bold blue]Updating metadata for deposition {deposition_id}...[/bold blue]")
+    try:
+        client.update_metadata(deposition_id, metadata)
+        console.print("[green]✓ Metadata updated successfully[/green]")
+        console.print(f"[cyan]Next:[/cyan] gwsim repository publish {deposition_id}")
+    except Exception as e:
+        console.print(f"[red]✗ Failed to update metadata: {e}[/red]")
+        logger.error("Update metadata failed: %s", e)
+        raise typer.Exit(1) from e

gwsim/cli/repository/publish.py

@@ -0,0 +1,52 @@
+"""CLI for publishing Zenodo repository depositions."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+
+
+def publish(  # pylint: disable=import-outside-toplevel
+    deposition_id: Annotated[str, typer.Argument(help="Deposition ID")],
+    sandbox: Annotated[bool, typer.Option("--sandbox", help="Use sandbox environment")] = False,
+    token: Annotated[str | None, typer.Option("--token", help="Zenodo access token")] = None,
+) -> None:
+    """Publish a deposition to Zenodo.
+
+    Warning: Publishing is permanent and cannot be undone.
+
+    Examples:
+        gwsim repository publish 123456
+    """
+    import logging
+
+    from rich.console import Console
+
+    from gwsim.cli.repository.utils import get_zenodo_client
+
+    logger = logging.getLogger("gwsim")
+    console = Console()
+
+    if not typer.confirm(
+        f"[yellow]Publish deposition {deposition_id}?[/yellow] This action is permanent and cannot be undone."
+    ):
+        console.print("[yellow]Cancelled.[/yellow]")
+        raise typer.Exit(0)
+
+    client = get_zenodo_client(sandbox=sandbox, token=token)
+
+    console.print(f"[bold blue]Publishing deposition {deposition_id}...[/bold blue]")
+    try:
+        result = client.publish_deposition(deposition_id)
+        doi = result.get("doi")
+        console.print("[green]✓ Published successfully![/green]")
+        console.print(f"  [cyan]DOI:[/cyan] {doi}")
+        if sandbox:
+            console.print(
+                "[yellow]Note:[/yellow] This is a sandbox record. Use [bold]--sandbox[/bold] to access it later."
+            )
+    except Exception as e:
+        console.print(f"[red]✗ Failed to publish: {e}[/red]")
+        logger.error("Publish failed: %s", e)
+        raise typer.Exit(1) from e

gwsim/cli/repository/upload.py

@@ -0,0 +1,74 @@
+"""CLI for uploading files to Zenodo depositions."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+
+def upload_command(  # pylint: disable=import-outside-toplevel,too-many-locals
+    deposition_id: Annotated[str, typer.Argument(help="Deposition ID")],
+    files: Annotated[list[str] | None, typer.Option("--file", help="Files to upload (repeat for multiple)")] = None,
+    sandbox: Annotated[bool, typer.Option("--sandbox", help="Use sandbox environment")] = False,
+    token: Annotated[str | None, typer.Option("--token", help="Zenodo access token")] = None,
+) -> None:
+    """Upload files to a deposition.
+
+    Examples:
+        # Single file
+        gwsim repository upload 123456 --file data.gwf
+
+        # Multiple files
+        gwsim repository upload 123456 --file data1.gwf --file data2.gwf --file metadata.yaml
+    """
+    import logging
+
+    from rich.console import Console
+    from rich.progress import Progress
+
+    from gwsim.cli.repository.utils import get_zenodo_client
+
+    logger = logging.getLogger("gwsim")
+    console = Console()
+
+    if not files:
+        console.print("[red]Error:[/red] No files specified. Use [bold]--file <path>[/bold] to specify files.")
+        raise typer.Exit(1)
+
+    client = get_zenodo_client(sandbox=sandbox, token=token)
+
+    console.print(f"[bold blue]Uploading {len(files)} file(s) to deposition {deposition_id}...[/bold blue]")
+
+    failed_count = 0
+    with Progress() as progress:
+        task = progress.add_task("Uploading", total=len(files))
+
+        for file_path_str in files:
+            file_path = Path(file_path_str)
+            if not file_path.exists():
+                console.print(f"[red]✗ File not found:[/red] {file_path}")
+                failed_count += 1
+                progress.update(task, advance=1)
+                continue
+
+            try:
+                file_size_mb = file_path.stat().st_size / (1024 * 1024)
+                client.upload_file(deposition_id, file_path, auto_timeout=True)
+                console.print(f"[green]✓ {file_path.name}[/green] ({file_size_mb:.2f} MB)")
+                progress.update(task, advance=1)
+            except Exception as e:  # pylint: disable=broad-exception-caught
+                console.print(f"[red]✗ Failed to upload {file_path.name}:[/red] {e}")
+                logger.error("Upload failed for %s: %s", file_path, e)
+                failed_count += 1
+                progress.update(task, advance=1)
+
+    if failed_count == 0:
+        if sandbox:
+            console.print("[cyan]Next:[/cyan] gwsim repository update <id> --metadata-file <file> --sandbox")
+        else:
+            console.print("[cyan]Next:[/cyan] gwsim repository update <id> --metadata-file <file>")
+    else:
+        console.print(f"[yellow]Warning:[/yellow] {failed_count} file(s) failed to upload.")
+        raise typer.Exit(1)

gwsim/cli/repository/utils.py

@@ -0,0 +1,47 @@
+"""Utility functions for repository CLI commands."""
+
+from __future__ import annotations
+
+import os
+
+import typer
+from rich.console import Console
+
+from gwsim.repository.zenodo import ZenodoClient
+
+console = Console()
+
+
+def get_zenodo_client(sandbox: bool = False, token: str | None = None) -> ZenodoClient:
+    """Get a ZenodoClient instance with token from env or argument.
+
+    Args:
+        sandbox: Use sandbox environment for testing.
+        token: Access token (defaults to ZENODO_TOKEN env var).
+
+    Returns:
+        Configured ZenodoClient.
+
+    Raises:
+        typer.Exit: If no token is provided or found in environment.
+    """
+    if token is None:
+        if sandbox:
+            token = os.environ.get("ZENODO_SANDBOX_API_TOKEN")
+        else:
+            token = os.environ.get("ZENODO_API_TOKEN")
+    if not token:
+        if sandbox:
+            console.print(
+                "[red]Error:[/red] No Zenodo Sandbox access token provided.\n"
+                "Set [bold]ZENODO_SANDBOX_API_TOKEN[/bold] environment variable or use [bold]--token[/bold] option.\n"
+                "Get a token from: https://sandbox.zenodo.org/account/settings/applications/tokens/new"
+            )
+        else:
+            console.print(
+                "[red]Error:[/red] No Zenodo access token provided.\n"
+                "Set [bold]ZENODO_API_TOKEN[/bold] environment variable or use [bold]--token[/bold] option.\n"
+                "Get a token from: https://zenodo.org/account/settings/applications/tokens/new"
+            )
+        raise typer.Exit(1)
+    return ZenodoClient(access_token=token, sandbox=sandbox)

gwsim/cli/repository/verify.py

@@ -0,0 +1,61 @@
+"""CLI for managing Zenodo repositories."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+
+
+def verify_command(  # pylint: disable=import-outside-toplevel
+    sandbox: Annotated[bool, typer.Option("--sandbox", help="Verify sandbox token")] = False,
+    token: Annotated[str | None, typer.Option("--token", help="Zenodo access token to verify")] = None,
+) -> None:
+    """Verify that your Zenodo API token is valid and has the correct permissions.
+
+    Examples:
+        # Verify production token
+        gwsim repository verify
+
+        # Verify sandbox token
+        gwsim repository verify --sandbox
+
+        # Verify with explicit token
+        gwsim repository verify --token your_token_here
+    """
+    from rich.console import Console
+
+    from gwsim.cli.repository.utils import get_zenodo_client
+
+    console = Console()
+
+    console.print("[bold blue]Verifying Zenodo API token...[/bold blue]")
+
+    try:
+        client = get_zenodo_client(sandbox=sandbox, token=token)
+
+        # Try to list depositions as a test
+        console.print("Testing API access...")
+        depositions = client.list_depositions(status="draft")
+
+        env_name = "Zenodo Sandbox" if sandbox else "Zenodo (Production)"
+        console.print("[green]✓ Token is valid![/green]")
+        console.print(f"  [cyan]Environment:[/cyan] {env_name}")
+        console.print(f"  [cyan]Found {len(depositions)} draft deposition(s)[/cyan]")
+
+    except Exception as e:
+        env_name = "Zenodo Sandbox" if sandbox else "Zenodo (Production)"
+        console.print(f"[red]✗ Token verification failed for {env_name}[/red]")
+        console.print(f"  [yellow]Error:[/yellow] {e}")
+        console.print("\n[bold]Troubleshooting:[/bold]")
+        if sandbox:
+            console.print(
+                "  1. Get a new token from: https://sandbox.zenodo.org/account/settings/applications/tokens/new"
+            )
+            console.print("  2. Ensure the token has 'deposit:write' and 'deposit:actions' scopes")
+            console.print("  3. Set: export ZENODO_SANDBOX_API_TOKEN='your_token'")
+        else:
+            console.print("  1. Get a new token from: https://zenodo.org/account/settings/applications/tokens/new")
+            console.print("  2. Ensure the token has 'deposit:write' and 'deposit:actions' scopes")
+            console.print("  3. Set: export ZENODO_API_TOKEN='your_token'")
+        raise typer.Exit(1) from e

gwsim/cli/simulate.py

@@ -0,0 +1,220 @@
+"""
+A sub-command to handle data generation using simulation plans.
+"""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+
+
+def _simulate_impl(  # pylint: disable=too-many-locals, too-many-branches, too-many-statements
+    config_file_names: str | list[str],
+    output_dir: str | None = None,
+    metadata_dir: str | None = None,
+    overwrite: bool = False,
+    metadata: bool = True,
+    author: str | None = None,
+    email: str | None = None,
+) -> None:
+    """Internal implementation of simulate command that accepts both str and list[str].
+
+    Unified approach: All simulation goes through the same plan execution system.
+    The difference is only in how we create the initial plan:
+    - Config file → SimulationPlan with pre_batch_state=None (fresh simulation)
+    - Metadata files → SimulationPlan with pre_batch_state=<dict> (reproduce)
+
+    Both cases end up calling execute_plan with batches that may or may not have
+    state snapshots. The execute_plan function handles both transparently.
+
+    Args:
+        config_file_names: Path to YAML config file OR one or more metadata files
+        output_dir: Output directory override
+        metadata_dir: Metadata directory override (config mode only)
+        overwrite: Whether to overwrite existing files
+        metadata: Whether to save metadata files (config mode only)
+        author: Author name for metadata
+        email: Author email for metadata
+
+    Returns:
+        None
+    """
+    import logging  # pylint: disable=import-outside-toplevel
+    from pathlib import Path  # pylint: disable=import-outside-toplevel
+
+    from gwsim.cli.simulate_utils import (  # pylint: disable=import-outside-toplevel
+        execute_plan,
+        validate_plan,
+    )
+    from gwsim.cli.utils.config import load_config  # pylint: disable=import-outside-toplevel
+    from gwsim.cli.utils.simulation_plan import (  # pylint: disable=import-outside-toplevel
+        create_plan_from_config,
+        create_plan_from_metadata_files,
+    )
+
+    logger = logging.getLogger("gwsim")
+    logger.setLevel(logging.DEBUG)
+
+    checkpoint_dir = Path(".gwsim_checkpoints")
+    checkpoint_dir.mkdir(parents=True, exist_ok=True)
+
+    try:
+        # ===== Normalize input: accept both string and list =====
+        if isinstance(config_file_names, str):
+            config_file_names_list = [config_file_names]
+        else:
+            config_file_names_list = config_file_names
+
+        # ===== Auto-detect mode: Config file vs Metadata files =====
+        if len(config_file_names_list) == 1:
+            # Single argument: could be YAML config or metadata file
+            single_path = Path(config_file_names_list[0])
+            is_metadata = (
+                single_path.suffix == ".metadata.yaml"
+                or (single_path.is_file() and "metadata" in single_path.name)
+                or single_path.is_dir()  # Directory assumed to be metadata dir
+            )
+        else:
+            # Multiple arguments: must be metadata files
+            is_metadata = True
+
+        # ===== Create plan (unified approach: both modes create same data structure) =====
+        if is_metadata:
+            logger.info("Reproduction mode: %d metadata file(s)", len(config_file_names_list))
+
+            metadata_paths = [Path(f) for f in config_file_names_list]
+
+            # If single directory, load all metadata files from it
+            if len(metadata_paths) == 1 and metadata_paths[0].is_dir():
+                metadata_dir_path = metadata_paths[0]
+                metadata_files = list(metadata_dir_path.glob("*.metadata.yaml"))
+                if not metadata_files:
+                    raise ValueError(f"No metadata files found in directory: {metadata_dir_path}")
+                logger.info("Found %d metadata files in directory: %s", len(metadata_files), metadata_dir_path)
+                plan = create_plan_from_metadata_files(metadata_files, checkpoint_dir, author=author, email=email)
+            else:
+                # Individual metadata files
+                plan = create_plan_from_metadata_files(metadata_paths, checkpoint_dir, author=author, email=email)
+
+            logger.info(
+                "Created reproduction plan from %d metadata file(s) with %d batches",
+                len(config_file_names_list),
+                plan.total_batches,
+            )
+        else:
+            logger.info("Config mode: %s", config_file_names_list[0])
+            config_path = Path(config_file_names_list[0])
+            config = load_config(file_name=config_path)
+            logger.debug("Configuration loaded successfully from %s", config_file_names_list[0])
+
+            plan = create_plan_from_config(config, checkpoint_dir, author=author, email=email)
+            logger.info("Created simulation plan with %d batches", plan.total_batches)
+
+        # ===== Determine output directories (same logic for both modes) =====
+        # Get reference config from first batch
+        if not plan.batches:
+            raise ValueError("No batches found in simulation plan")
+
+        first_batch = plan.batches[0]
+        globals_cfg = first_batch.globals_config
+        working_dir = Path(globals_cfg.working_directory or ".")  # pylint: disable=no-member
+        output_dir_config = globals_cfg.output_directory or "output"  # pylint: disable=no-member
+
+        # Handle absolute vs relative paths
+        config_output_dir = (
+            Path(output_dir_config) if Path(output_dir_config).is_absolute() else working_dir / output_dir_config
+        )
+        final_output_dir = Path(output_dir) if output_dir else config_output_dir
+
+        # Metadata directory only used in config mode (fresh simulation)
+        final_metadata_dir = None
+        if not is_metadata and metadata:
+            metadata_dir_config = globals_cfg.metadata_directory or "metadata"  # pylint: disable=no-member
+            config_metadata_dir = (
+                Path(metadata_dir_config)
+                if Path(metadata_dir_config).is_absolute()
+                else working_dir / metadata_dir_config
+            )
+            final_metadata_dir = Path(metadata_dir) if metadata_dir else config_metadata_dir
+
+        logger.debug("Output directory: %s", final_output_dir)
+        if final_metadata_dir:
+            logger.debug("Metadata directory: %s", final_metadata_dir)
+
+        # ===== Validate and execute plan =====
+        validate_plan(plan)
+        logger.info("Simulation plan validation passed")
+
+        execute_plan(
+            plan=plan,
+            output_directory=final_output_dir,
+            metadata_directory=final_metadata_dir or Path("metadata"),
+            overwrite=overwrite,
+            max_retries=3,
+        )
+
+        logger.info("Simulation completed successfully. Output written to %s", final_output_dir)
+
+    except Exception as e:
+        logger.error("Simulation failed: %s", str(e), exc_info=True)
+        raise typer.Exit(code=1) from e
+
+
+def simulate_command(
+    config_file_names: Annotated[
+        list[str],
+        typer.Argument(help="Configuration file (YAML) or metadata files (can specify multiple metadata files)"),
+    ],
+    output_dir: Annotated[
+        str | None, typer.Option("--output-dir", help="Output directory (overrides config/metadata defaults)")
+    ] = None,
+    metadata_dir: Annotated[
+        str | None,
+        typer.Option(
+            "--metadata-dir", help="Metadata directory (overrides config/metadata defaults, only for config mode)"
+        ),
+    ] = None,
+    overwrite: Annotated[bool, typer.Option("--overwrite", help="Overwrite existing files")] = False,
+    metadata: Annotated[bool, typer.Option("--metadata", help="Generate metadata files (only in config mode)")] = True,
+    author: Annotated[str | None, typer.Option("--author", help="Author name for the simulation")] = None,
+    email: Annotated[str | None, typer.Option("--email", help="Author email for the simulation")] = None,
+) -> None:
+    """Generate gravitational wave simulation data using specified simulators.
+
+    This command can run in two modes, automatically detected from the input:
+
+    1. **Config Mode**: Provide a single YAML configuration file to create a simulation plan.
+       Executes all simulators with state tracking for reproducibility.
+       Example: `gwsim simulate config.yaml`
+
+    2. **Reproduction Mode**: Provide one or more metadata files to reproduce specific batches.
+       Each metadata file contains the exact configuration and pre-batch state needed for
+       exact reproducibility. Users can distribute individual metadata files, and anyone
+       can reproduce those specific batches independently.
+       Example: `gwsim simulate signal-0.metadata.yaml signal-1.metadata.yaml`
+
+    Path Overrides:
+    - Use `--output-dir` to specify where output files should be saved
+    - Use `--metadata-dir` to specify where metadata should be saved (config mode only)
+    - These override paths from the configuration or metadata files
+
+    Args:
+        config_file_names: Path to YAML config file OR one or more metadata files
+        output_dir: Output directory override
+        metadata_dir: Metadata directory override (config mode only)
+        overwrite: Whether to overwrite existing files
+        metadata: Whether to save metadata files (config mode only)
+
+    Returns:
+        None
+    """
+    _simulate_impl(
+        config_file_names=config_file_names,
+        output_dir=output_dir,
+        metadata_dir=metadata_dir,
+        overwrite=overwrite,
+        metadata=metadata,
+        author=author,
+        email=email,
+    )