gwsim 0.1.0__py3-none-any.whl

gwsim/__init__.py

@@ -0,0 +1,11 @@
+"""A package to simulate a population of gravitational waves."""
+
+from __future__ import annotations
+
+from . import utils
+from .utils.log import setup_logger
+from .version import __version__
+
+setup_logger()
+
+__all__ = ["__version__", "utils"]

gwsim/__main__.py

@@ -0,0 +1,8 @@
+"""Main entry point for gwsim package."""
+
+from __future__ import annotations
+
+if __name__ == "__main__":
+    from gwsim.utils.log import setup_logger
+
+    setup_logger(print_version=True)

gwsim/cli/config.py

@@ -0,0 +1,88 @@
+"""
+Utility functions to load and save configuration files.
+"""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+from ..utils.io import check_file_exist, check_file_overwrite
+
+logger = logging.getLogger("gwsim")
+
+
+@check_file_exist()
+def load_config(file_name: Path, encoding: str = "utf-8") -> dict:
+    """Load configuration file.
+
+    Args:
+        file_name (Path): File name.
+        encoding (str, optional): File encoding. Defaults to "utf-8".
+
+    Returns:
+        dict: A dictionary of the configuration.
+    """
+    with open(file_name, encoding=encoding) as f:
+        config = yaml.safe_load(f)
+    return config
+
+
+@check_file_overwrite()
+def save_config(
+    file_name: Path, config: dict, overwrite: bool = False, encoding: str = "utf-8", backup: bool = True
+) -> None:
+    """Save configuration file safely with optional backup.
+
+    Args:
+        file_name (Path): File name.
+        config (dict): A dictionary of configuration.
+        overwrite (bool, optional): If True, overwrite the existing file, or otherwise raise an error.
+            Defaults to False.
+        encoding (str, optional): File encoding. Defaults to "utf-8".
+        backup (bool, optional): If True and overwriting, create a backup of the existing file.
+            Defaults to True.
+
+    Raises:
+        FileExistsError: If file_name exists and overwrite is False, raise an error.
+    """
+    # Create backup if file exists and we're overwriting
+    if file_name.exists() and overwrite and backup:
+        backup_path = file_name.with_suffix(f"{file_name.suffix}.backup")
+        logger.info("Creating backup: %s", backup_path)
+        backup_path.write_text(file_name.read_text(encoding=encoding), encoding=encoding)
+
+    # Atomic write using temporary file
+    temp_file = file_name.with_suffix(f"{file_name.suffix}.tmp")
+    try:
+        with open(temp_file, "w", encoding=encoding) as f:
+            yaml.safe_dump(config, f, default_flow_style=False, sort_keys=False)
+
+        # Atomic move (rename) - this is atomic on most filesystems
+        temp_file.replace(file_name)
+        logger.info("Configuration saved to: %s", file_name)
+
+    except Exception:
+        # Clean up temp file if something went wrong
+        if temp_file.exists():
+            temp_file.unlink()
+        raise
+
+
+def get_config_value(config: dict, key: str, default_value: Any | None = None) -> Any:
+    """Get the argument
+
+    Args:
+        config (dict): A dictionary of configuration.
+        key (str): Key of the entry.
+        default_value (Any | None, optional): Default value if key is not present. Defaults to None.
+
+    Returns:
+        Any: Value of the corresponding key in config.
+    """
+    if key in config:
+        return config[key]
+    return default_value

gwsim/cli/default_config.py

@@ -0,0 +1,56 @@
+"""
+A tool to generate default configuration file.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+_DEFAULT_CONFIG = {
+    "globals": {
+        "working-directory": ".",
+        "sampling-frequency": 16384,
+        "duration": 4,
+        "output-directory": "output",
+        "metadata-directory": "metadata",
+    },
+    "simulators": {
+        "example": {
+            "class": "WhiteNoise",  # Resolves to gwsim.noise.WhiteNoise
+            "arguments": {
+                "batch_size": 1,
+                "max_samples": 10,
+                "loc": 0.0,
+                "scale": 1.0,
+                "seed": 0,
+            },
+            "output": {
+                "file_name": "example-{{ start-time }}-{{ duration }}.gwf",
+                "arguments": {
+                    "channel": "STRAIN",
+                },
+            },
+        },
+    },
+}
+
+
+def default_config_command(
+    output: Annotated[str, typer.Option("--output", help="File name of the output", prompt=True)] = "config.yaml",
+    overwrite: Annotated[bool, typer.Option("--overwrite", help="Overwrite the existing file")] = False,
+) -> None:
+    """Write the default configuration file to disk.
+
+    Args:
+        output (str): Name of the output file.
+        overwrite (bool): If True, overwrite the existing file, otherwise raise an error if output already exists.
+
+    Raises:
+        FileExistsError: If file_name exists and overwrite is False, raise an error.
+    """
+    from gwsim.cli.utils.config import save_config  # pylint: disable=import-outside-toplevel
+
+    save_config(file_name=Path(output), config=_DEFAULT_CONFIG, overwrite=overwrite)

gwsim/cli/main.py

@@ -0,0 +1,101 @@
+"""
+Main command line tool to generate mock data.
+"""
+
+from __future__ import annotations
+
+import enum
+from typing import Annotated
+
+import typer
+
+
+class LoggingLevel(str, enum.Enum):
+    """Logging levels for the CLI."""
+
+    NOTSET = "NOTSET"
+    DEBUG = "DEBUG"
+    INFO = "INFO"
+    WARNING = "WARNING"
+    ERROR = "ERROR"
+    CRITICAL = "CRITICAL"
+
+
+# Create the main Typer app
+app = typer.Typer(
+    name="gwsim",
+    help="Gravitational Wave Simulation Data Simulator",
+    rich_markup_mode="rich",
+)
+
+
+def setup_logging(level: LoggingLevel = LoggingLevel.INFO) -> None:
+    """Set up logging with Rich handler."""
+    import logging  # pylint: disable=import-outside-toplevel
+
+    from rich.console import Console  # pylint: disable=import-outside-toplevel
+    from rich.logging import RichHandler  # pylint: disable=import-outside-toplevel
+
+    logger = logging.getLogger("gwsim")
+
+    logger.setLevel(level.value)
+
+    console = Console()
+
+    # Remove any existing handlers to ensure RichHandler is used
+    for h in logger.handlers[:]:  # Use slice copy to avoid modification during iteration
+        logger.removeHandler(h)
+    # Add the RichHandler
+    if not logger.handlers:
+        handler = RichHandler(
+            console=console,
+            rich_tracebacks=True,
+            show_time=True,
+            show_level=True,  # Keep level (e.g., DEBUG, INFO) for clarity
+            markup=True,  # Enable Rich markup in messages for styling
+            level=level.value,  # Ensure handler respects the level
+            omit_repeated_times=False,
+            log_time_format="%H:%M",
+        )
+        handler.setLevel(level.value)
+        logger.addHandler(handler)
+
+    # Prevent propagation to root logger to avoid duplicate output
+    logger.propagate = False
+
+
+@app.callback()
+def main(
+    verbose: Annotated[
+        LoggingLevel,
+        typer.Option("--verbose", "-v", help="Set verbosity level"),
+    ] = LoggingLevel.INFO,
+) -> None:
+    """Gravitational Wave Simulation Data Simulator.
+
+    This command-line tool provides functionality for generating
+    gravitational wave detector simulation data.
+    """
+    setup_logging(verbose)
+
+
+# Import and register commands after app is created
+def register_commands() -> None:
+    """Register all CLI commands."""
+
+    # Fast imports
+    from gwsim.cli.default_config import default_config_command  # pylint: disable=import-outside-toplevel
+    from gwsim.cli.merge import merge_command  # pylint: disable=import-outside-toplevel
+    from gwsim.cli.repository.main import repository_app  # pylint: disable=import-outside-toplevel
+    from gwsim.cli.simulate import simulate_command  # pylint: disable=import-outside-toplevel
+    from gwsim.cli.validate import validate_command  # pylint: disable=import-outside-toplevel
+
+    app.command("simulate")(simulate_command)
+    app.command("merge")(merge_command)
+    app.command("default-config")(default_config_command)
+    app.command("validate")(validate_command)
+
+    app.add_typer(repository_app, name="repository", help="Manage Zenodo repositories")
+
+
+register_commands()

gwsim/cli/merge.py

@@ -0,0 +1,150 @@
+"""CLI to merge the frame files generated by gwsim simulations."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+
+def merge_command(  # pylint: disable=too-many-locals,too-many-branches,too-many-statements
+    file_names: Annotated[list[Path], typer.Argument(..., help="List of frame files to merge")],
+    channel: Annotated[str, typer.Option("--channel", help="Channel name to merge")] = "STRAIN",
+    output: Annotated[str, typer.Option("--output", help="Output merged frame file name")] = "merged.gwf",
+    output_channel: (
+        Annotated[str, typer.Option("--output-channel", help="Channel name for the output file")] | None
+    ) = None,
+    metadata: Annotated[list[str], typer.Option("--metadata", help="Metadata file to use for merging")] | None = None,
+    author: Annotated[str, typer.Option("--author", help="Author of the merged file")] | None = None,
+    email: Annotated[str, typer.Option("--email", help="Email of the author")] | None = None,
+    force: Annotated[bool, typer.Option("--force", help="Bypass the requirements of providing metadata files")] = False,
+):
+    """Merge multiple frame files into a single file.
+
+    Args:
+        file_names (list[str]): List of frame files to merge.
+        channel (str): Channel name to merge.
+        output (str): Output merged frame file name.
+        output_channel (str | None): Channel name for the output file. If None, use
+        metadata (list[str] | None): List of metadata files corresponding to the frame files.
+        author (str | None): Author of the merged file.
+        email (str | None): Email of the author.
+        force (bool): If True, bypass the requirement of providing metadata files.
+
+    Raises:
+        ValueError: If metadata files are not provided and force is False.
+    """
+    import datetime  # pylint: disable=import-outside-toplevel
+    import getpass  # pylint: disable=import-outside-toplevel
+    from typing import cast  # pylint: disable=import-outside-toplevel
+
+    import yaml  # pylint: disable=import-outside-toplevel
+    from gwpy.timeseries import TimeSeries  # pylint: disable=import-outside-toplevel
+
+    from gwsim.cli.utils.hash import compute_file_hash  # pylint: disable=import-outside-toplevel
+    from gwsim.utils.log import get_dependency_versions  # pylint: disable=import-outside-toplevel
+
+    if file_names is None:
+        file_names = []
+    if not isinstance(metadata, list) and not force:
+        raise ValueError("Metadata files must be provided unless --force is used.")
+
+    if isinstance(metadata, list) and not force:
+        typer.echo("Validating files...")
+
+        if len(file_names) != len(metadata or []):
+            raise ValueError("The number of metadata files must match the number of frame files.")
+
+        # Validate the files against the metadata
+        for i, file_name in enumerate(file_names):
+            metadata_file = Path(metadata[i])
+
+            # Find the corresponding metadata entry for the file_name
+            with metadata_file.open("r", encoding="utf-8") as f:
+                file_metadata = yaml.safe_load(f)
+
+            file_hashes: dict = file_metadata.get("file_hashes", {})
+            expected_hash = file_hashes.get(file_name.name)
+
+            if expected_hash is None:
+                raise ValueError(f"No hash found in metadata for file {file_name.name}")
+
+            actual_hash = compute_file_hash(file_name)
+
+            if actual_hash != expected_hash:
+                raise ValueError(
+                    f"Hash mismatch for file {file_name.name}: expected {expected_hash}, got {actual_hash}"
+                )
+
+    # Placeholder for actual merging logic
+    typer.echo(f"Merging files: {file_names}")
+
+    # Read the first file
+    frame_data = cast(TimeSeries, TimeSeries.read(file_names[0], channel))
+
+    # Get the start time, duration and sampling frequency
+    start_time = frame_data.epoch
+    duration = frame_data.duration
+    sampling_frequency = frame_data.sample_rate
+
+    for i in range(1, len(file_names)):
+        next_frame_data = cast(TimeSeries, TimeSeries.read(file_names[i], channel))
+
+        if next_frame_data.epoch != start_time:
+            raise ValueError(f"Start time mismatch: {next_frame_data.epoch} != {start_time}")
+        if next_frame_data.duration != duration:
+            raise ValueError(f"Duration mismatch: {next_frame_data.duration} != {duration}")
+        if next_frame_data.sample_rate != sampling_frequency:
+            raise ValueError(f"Sampling frequency mismatch: {next_frame_data.sample_rate} != {sampling_frequency}")
+
+        frame_data = frame_data.inject(next_frame_data)
+
+    # Write the merged data to a new file
+    # Atomic write to avoid partial writes
+    # The write function is suffix sensitive, so we prepend a .tmp to the original suffix
+    temp_output = Path(output).with_suffix(".tmp" + Path(output).suffix)
+    if output_channel is not None:
+        frame_data.channel = output_channel
+    frame_data.write(temp_output)
+    temp_output.rename(output)
+
+    if metadata:
+        # If metadata is provided, create a new metadata file for the merged file
+
+        typer.echo("Creating merged metadata file...")
+
+        merged_metadata = {"type": "merged", "source_files": {}}
+
+        for i, file_name in enumerate(file_names):
+            metadata_file = Path(metadata[i])
+
+            with metadata_file.open("r", encoding="utf-8") as f:
+                file_metadata = yaml.safe_load(f)
+
+            merged_metadata["source_files"][file_name] = file_metadata
+
+        if author is None:
+            author = getpass.getuser()
+
+        timestamp = datetime.datetime.now(datetime.timezone.utc)
+
+        merged_metadata["output_files"] = [output]
+        merged_metadata["file_hashes"] = {output: compute_file_hash(output)}
+        merged_metadata["author"] = author
+        merged_metadata["email"] = email
+        merged_metadata["timestamp"] = timestamp.isoformat()
+        merged_metadata["versions"] = get_dependency_versions()
+
+        # Atomic write of metadata file
+        merged_metadata_file = Path(output).with_suffix(".metadata.yaml")
+        temp_metadata_file = merged_metadata_file.with_suffix(".tmp")
+        with temp_metadata_file.open("w", encoding="utf-8") as f:
+            yaml.safe_dump(merged_metadata, f)
+        temp_metadata_file.rename(merged_metadata_file)
+
+        typer.echo(f"Merged metadata file created at {merged_metadata_file}")
+
+    else:
+        typer.echo("No metadata provided for the source files.")
+        typer.echo("No metadata file will be created for the merged file.")

gwsim/cli/repository/create.py

@@ -0,0 +1,91 @@
+"""CLI for creating Zenodo repository depositions."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+
+def create_command(  # pylint: disable=too-many-locals
+    title: Annotated[str | None, typer.Option("--title", help="Deposition title")] = None,
+    description: Annotated[str | None, typer.Option("--description", help="Deposition description")] = None,
+    metadata_file: Annotated[
+        Path | None, typer.Option("--metadata-file", help="YAML file with additional metadata")
+    ] = None,
+    sandbox: Annotated[bool, typer.Option("--sandbox", help="Use sandbox environment for testing")] = False,
+    token: Annotated[
+        str | None,
+        typer.Option(
+            "--token",
+            help=(
+                "Zenodo access token (default: ZENODO_API_TOKEN env or"
+                " ZENODO_SANDBOX_API_TOKEN env for Zenodo Sandbox)"
+            ),
+        ),
+    ] = None,
+) -> None:
+    """Create a new deposition on Zenodo.
+
+    Interactive mode: Leave options blank to be prompted.
+
+    Examples:
+        # Interactive mode
+        gwsim repository create
+
+        # With all options
+        gwsim repository create --title "GW Simulation Data" --description "MDC v1"
+
+        # Using metadata file
+        gwsim repository create --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()
+
+    client = get_zenodo_client(sandbox=sandbox, token=token)
+
+    if title is None:
+        title = typer.prompt("Deposition Title")
+
+    if description is None:
+        description = typer.prompt("Deposition Description", default="")
+
+    metadata_dict = {"title": title}
+    metadata_dict["description"] = description
+
+    if metadata_file:
+        if not metadata_file.exists():
+            console.print(f"[red]Error:[/red] Metadata file not found: {metadata_file}")
+            raise typer.Exit(1)
+        with metadata_file.open("r") as f:
+            extra = yaml.safe_load(f)
+            if extra:
+                metadata_dict.update(extra)
+
+    console.print("[bold blue]Creating deposition...[/bold blue]")
+    try:
+        result = client.create_deposition(metadata=metadata_dict)
+        deposition_id = result.get("id")
+        if sandbox:
+            console.print("[yellow]Note:[/yellow] Created in Zenodo Sandbox environment.")
+        console.print("[green]✓ Deposition created successfully![/green]")
+        console.print(f"  [cyan]ID:[/cyan] {deposition_id}")
+        if sandbox:
+            console.print(
+                "[yellow]Note:[/yellow] This is a sandbox deposition. Use [bold]--sandbox[/bold] to access it later."
+            )
+            console.print(f"  [cyan]Next:[/cyan] gwsim repository upload {deposition_id} --file <path> --sandbox")
+        else:
+            console.print(f"  [cyan]Next:[/cyan] gwsim repository upload {deposition_id} --file <path>")
+    except Exception as e:
+        console.print(f"[red]✗ Failed to create deposition: {e}[/red]")
+        logger.error("Create deposition failed: %s", e)
+        raise typer.Exit(1) from e

gwsim/cli/repository/delete.py

@@ -0,0 +1,51 @@
+"""CLI for deleting Zenodo repository depositions."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+
+
+def delete_command(
+    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,
+    force: Annotated[bool, typer.Option("--force", "-f", help="Skip confirmation prompt")] = False,
+) -> None:
+    """Delete an unpublished deposition.
+
+    Warning: Only unpublished (draft) depositions can be deleted.
+
+    Examples:
+        gwsim repository delete 123456
+        gwsim repository delete 123456 --force
+    """
+    import logging  # pylint: disable=import-outside-toplevel
+
+    from rich.console import Console  # pylint: disable=import-outside-toplevel
+    from rich.prompt import Confirm  # 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 force and not Confirm.ask(
+        f"[red bold]Delete deposition {deposition_id}?[/red bold] [dim]This cannot be undone.[/dim]",
+        console=console,
+        default=False,
+    ):
+        console.print("[yellow]Cancelled.[/yellow]")
+        raise typer.Exit(0)
+
+    client = get_zenodo_client(sandbox=sandbox, token=token)
+
+    console.print(f"[bold blue]Deleting deposition {deposition_id}...[/bold blue]")
+    try:
+        client.delete_deposition(deposition_id)
+        console.print("[green]✓ Deposition deleted[/green]")
+    except Exception as e:
+        console.print(f"[red]✗ Failed to delete: {e}[/red]")
+        logger.error("Delete failed: %s", e)
+        raise typer.Exit(1) from e

gwsim/cli/repository/download.py

@@ -0,0 +1,54 @@
+"""CLI for downloading Zenodo repository files."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+
+def download_command(
+    deposition_id: Annotated[str | None, typer.Argument(help="Deposition ID")] = None,
+    filename: Annotated[str | None, typer.Option("--file", help="Filename to download")] = None,
+    output: Annotated[Path | None, typer.Option("--output", help="Output file path")] = None,
+    sandbox: Annotated[bool, typer.Option("--sandbox", help="Use sandbox environment")] = False,
+    file_size_mb: Annotated[int | None, typer.Option("--file-size-mb", help="File size in MB (for timeout)")] = None,
+) -> None:
+    """Download a file from a published Zenodo record.
+
+    Examples:
+        gwsim repository download 10.5281/zenodo.123456 --file data.gwf --output ./data.gwf
+        gwsim repository download 10.5281/zenodo.123456 --file metadata.yaml
+    """
+    import logging  # 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 deposition_id:
+        deposition_id = typer.prompt("Deposition ID (e.g., 123456)")
+    if not filename:
+        filename = typer.prompt("Filename to download")
+    if not output and filename:
+        output = Path(filename)
+    else:
+        console.print("[red]Error:[/red] Output path must be specified.")
+        raise typer.Exit(1)
+
+    client = get_zenodo_client(sandbox=sandbox, token=None)  # Downloads don't require auth
+
+    console.print(f"[bold blue]Downloading {filename} from {deposition_id}...[/bold blue]")
+
+    try:
+        client.download_file(str(deposition_id), filename, output, file_size_in_mb=file_size_mb)
+        console.print("[green]✓ Downloaded successfully[/green]")
+        console.print(f"  [cyan]Saved to:[/cyan] {output.resolve()}")
+    except Exception as e:
+        console.print(f"[red]✗ Download failed: {e}[/red]")
+        logger.error("Download failed: %s", e)
+        raise typer.Exit(1) from e

gwsim/cli/repository/list_depositions.py

@@ -0,0 +1,63 @@
+"""CLI for managing Zenodo repositories."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+
+
+def list_depositions_command(  # pylint: disable=import-outside-toplevel,too-many-locals
+    status: Annotated[
+        str, typer.Option("--status", help="Filter by status (draft, published, unsubmitted)")
+    ] = "published",
+    sandbox: Annotated[bool, typer.Option("--sandbox", help="Use sandbox environment")] = False,
+    token: Annotated[str | None, typer.Option("--token", help="Zenodo access token")] = None,
+) -> None:
+    """List depositions for the authenticated user.
+
+    Examples:
+        gwsim repository list
+        gwsim repository list --status draft
+        gwsim repository list --status published --sandbox
+    """
+    import logging
+
+    from rich.console import Console
+    from rich.table import Table
+
+    from gwsim.cli.repository.utils import get_zenodo_client
+
+    logger = logging.getLogger("gwsim")
+    console = Console()
+
+    client = get_zenodo_client(sandbox=sandbox, token=token)
+
+    console.print(f"[bold blue]Listing {status} depositions...[/bold blue]")
+    try:
+        depositions = client.list_depositions(status=status)
+
+        if not depositions:
+            console.print(f"[yellow]No {status} depositions found.[/yellow]")
+            return
+
+        table = Table(title=f"{status.capitalize()} Depositions")
+        table.add_column("ID", style="cyan", width=12)
+        table.add_column("Title", style="green", width=40)
+        table.add_column("DOI", style="blue", width=20)
+        table.add_column("Created", style="magenta", width=12)
+
+        for dep in depositions:
+            dep_id = str(dep.get("id", "N/A"))
+            title = dep.get("metadata", {}).get("title", "N/A")
+            if len(title) > 38:
+                title = title[:35] + "..."
+            doi = dep.get("doi", "N/A")
+            created = dep.get("created", "N/A")[:10]
+            table.add_row(dep_id, title, doi, created)
+
+        console.print(table)
+    except Exception as e:
+        console.print(f"[red]✗ Failed to list depositions: {e}[/red]")
+        logger.error("List depositions failed: %s", e)
+        raise typer.Exit(1) from e