gwsim 0.1.0__py3-none-any.whl

gwsim/cli/validate.py

@@ -0,0 +1,255 @@
+"""
+Validation functions for CLI commands.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+
+def validate_command(  # pylint: disable=too-many-branches,too-many-statements,too-many-locals,import-outside-toplevel
+    paths: Annotated[
+        list[Path],
+        typer.Argument(
+            help="Files/directories to validate. Can be output files, metadata files, or directories containing either."
+        ),
+    ],
+    metadata_paths: Annotated[
+        list[str] | None, typer.Option("--metadata-paths", help="Additional metadata files or directories")
+    ] = None,
+    pattern: Annotated[
+        str | None, typer.Option("--pattern", help="File pattern to match (e.g., '*noise*' for subset validation)")
+    ] = None,
+    metadata_pattern: Annotated[
+        str | None, typer.Option("--metadata-pattern", help="Metadata file pattern to match")
+    ] = "*metadata.yaml",
+) -> None:
+    """Validate output files against metadata hashes and other checks.
+
+    This command verifies the integrity of generated simulation files by:
+    1. Loading metadata files and extracting expected file hashes
+    2. Recomputing hashes for actual output files
+    3. Comparing hashes and reporting mismatches
+    4. Future: Add sampling rate and continuity checks
+
+    The command automatically detects whether provided paths are:
+    - Output files (.gwf, etc.) - will find corresponding metadata
+    - Metadata files (.metadata.yaml) - will validate their output files
+    - Directories - will scan for both types of files
+
+    Examples:
+        Validate specific output files (finds metadata automatically):
+        gwsim validate H1-NOISE-123.gwf L1-SIGNAL-456.gwf
+
+        Validate specific metadata files:
+        gwsim validate --metadata signal-0.metadata.yaml noise-0.metadata.yaml
+
+        Validate all files in a directory:
+        gwsim validate /path/to/output/
+
+        Validate subset using pattern:
+        gwsim validate /path/to/output/ --pattern "*noise*"
+
+        Mix files and directories:
+        gwsim validate H1-NOISE-123.gwf /path/to/more/files/
+
+        Override output directory:
+        gwsim validate metadata/ --output-dir /custom/output/
+
+    Args:
+        paths: Output files, metadata files, or directories containing either
+        metadata: Additional metadata files or directories
+        output_dir: Override output directory (defaults to paths in metadata)
+        pattern: Glob pattern to filter files (e.g., '*noise*')
+        strict: Exit with error code if any validation fails
+    """
+    import fnmatch
+    import logging
+
+    import yaml
+    from rich.console import Console
+    from rich.table import Table
+
+    from gwsim.cli.utils.hash import compute_file_hash
+
+    logger = logging.getLogger("gwsim")
+
+    console = Console()
+
+    logger.info("Validating simulation files...")
+
+    # Separate into metadata files and potential output files
+    metadata_files: list[Path] = []
+    output_files: list[Path] = []
+    output_directories: list[Path] = []
+    metadata_directories: list[Path] = []
+
+    for path_str in paths:
+        path = Path(path_str)
+        if path.is_dir():
+            output_directories.append(path)
+        elif path.is_file():
+            # Assume it's an output file
+            output_files.append(path)
+        else:
+            console.print(f"[red]Error:[/red] Path not found: {path}")
+
+    for path_str in metadata_paths or []:
+        path = Path(path_str)
+        if path.is_dir():
+            metadata_directories.append(path)
+        elif path.is_file():
+            if path.suffix == ".yaml" and "metadata" in path.name:
+                metadata_files.append(path)
+            else:
+                console.print(f"[yellow]Warning:[/yellow] Ignoring non-metadata file: {path}")
+        else:
+            console.print(f"[red]Error:[/red] Metadata path not found: {path}")
+
+    # Scan directories for files
+    for directory in output_directories:
+        for file_path in directory.rglob("*"):
+            if file_path.is_file():
+                output_files.append(file_path)
+
+    for directory in metadata_directories:
+        for file_path in directory.rglob("*.yaml"):
+            if "metadata" in file_path.name and file_path.is_file():
+                metadata_files.append(file_path)
+
+    # Apply pattern filtering if specified
+    if pattern:
+        output_files = [f for f in output_files if fnmatch.fnmatch(f.name, pattern)]
+
+    if metadata_pattern:
+        metadata_files = [f for f in metadata_files if fnmatch.fnmatch(f.name, metadata_pattern)]
+
+    # Build validation plan: output_file -> metadata_file
+    output_to_metadata = {}
+
+    # First, extract output files from provided metadata files
+    for metadata_file in metadata_files:
+        try:
+            with metadata_file.open("r") as f:
+                metadata = yaml.safe_load(f)
+        except Exception as e:  # pylint: disable=broad-exception-caught
+            logger.error("Error loading metadata %s: %s", metadata_file, e)
+            continue
+
+        output_files_in_meta = metadata.get("output_files", [])
+        globals_config = metadata.get("globals_config", {})
+        output_dir = Path(globals_config.get("output_directory", "."))
+
+        for filename in output_files_in_meta:
+            # Apply pattern filtering
+            if pattern and not fnmatch.fnmatch(filename, pattern):
+                continue
+
+            output_file = output_dir / filename
+            if output_file not in output_to_metadata:
+                output_to_metadata[output_file] = metadata_file
+
+    # Then, for explicitly provided output files, find their metadata
+    for output_file in output_files:
+        if output_file not in output_to_metadata:
+            potential_metadata = None
+
+            # First, check if any already-identified metadata files contain this output file
+            for metadata_file in metadata_files:
+                try:
+                    with metadata_file.open("r") as f:
+                        meta_data = yaml.safe_load(f)
+                        if output_file.name in meta_data.get("output_files", []):
+                            potential_metadata = metadata_file
+                            break
+                except Exception as e:  # pylint: disable=broad-exception-caught
+                    logger.error("Error reading metadata file %s: %s", metadata_file, e)
+                    continue
+
+            # If not found in existing metadata, search in directories
+            if not potential_metadata:
+                # Look in the same directory or parent directories
+                search_dir = output_file.parent
+                metadata_dir = search_dir / "metadata"
+                if metadata_dir.exists():
+                    # Look for metadata files that might match
+                    for meta_file in metadata_dir.glob("*.metadata.yaml"):
+                        with meta_file.open("r") as f:
+                            try:
+                                meta_data = yaml.safe_load(f)
+                                if output_file.name in meta_data.get("output_files", []):
+                                    potential_metadata = meta_file
+                                    break
+                            except Exception as e:  # pylint: disable=broad-exception-caught
+                                logger.error("Error reading metadata file %s: %s", meta_file, e)
+                                continue
+
+            if potential_metadata:
+                output_to_metadata[output_file] = potential_metadata
+            else:
+                logger.warning("No metadata found for output file %s", output_file)  # Combine all metadata files
+    all_metadata_files = list({v for v in output_to_metadata.values() if v is not None})
+
+    if not all_metadata_files and not metadata_files:
+        logger.error("Error: No metadata files found")
+        raise typer.Exit(1)
+
+    # Create results table
+    table = Table(title="Validation Results")
+    table.add_column("Metadata File", style="cyan")
+    table.add_column("Output File", style="magenta")
+    table.add_column("Hash Match", style="green")
+    table.add_column("Status", style="yellow")
+
+    total_files = len(output_to_metadata)
+    failed_files = 0
+
+    # Order output for consistent reporting
+    for output_file in sorted(output_to_metadata.keys()):
+        metadata_file = output_to_metadata[output_file]
+        if metadata_file is None:
+            table.add_row("N/A", output_file.name, "N/A", "[red]No metadata found[/red]")
+            failed_files += 1
+            continue
+        try:
+            with metadata_file.open("r") as f:
+                metadata: dict = yaml.safe_load(f)
+        except Exception as e:  # pylint: disable=broad-exception-caught
+            logger.error("Error loading metadata %s: %s", metadata_file, e)
+            table.add_row(str(metadata_file.name), output_file.name, "N/A", "[red]Error loading metadata[/red]")
+            continue
+
+        file_hashes = metadata.get("file_hashes", {})
+        expected_hash = file_hashes.get(output_file.name)
+
+        if not output_file.exists():
+            table.add_row(str(metadata_file.name), output_file.name, "N/A", "[red]File not found[/red]")
+            failed_files += 1
+            continue
+
+        if not expected_hash:
+            table.add_row(str(metadata_file.name), output_file.name, "N/A", "[yellow]No hash in metadata[/yellow]")
+            failed_files += 1
+            continue
+
+        try:
+            actual_hash = compute_file_hash(output_file)
+            if actual_hash == expected_hash:
+                table.add_row(str(metadata_file.name), output_file.name, "[green]✓[/green]", "[green]PASS[/green]")
+            else:
+                table.add_row(str(metadata_file.name), output_file.name, "[red]✗[/red]", "[red]HASH MISMATCH[/red]")
+                failed_files += 1
+        except Exception as e:  # pylint: disable=broad-exception-caught
+            table.add_row(str(metadata_file.name), output_file.name, "N/A", f"[red]Error: {e}[/red]")
+            failed_files += 1
+
+    console.print(table)
+    console.print(f"\n[bold]Summary:[/bold] {total_files - failed_files}/{total_files} files passed validation")
+
+    if failed_files > 0:
+        console.print(f"[red]{failed_files} files failed validation[/red]")
+        raise typer.Exit(1)
+    console.print("[green]All files validated successfully![/green]")

gwsim/data/__init__.py

@@ -0,0 +1,8 @@
+"""Initialization code for the gwsim.data package."""
+
+from __future__ import annotations
+
+from gwsim.data.time_series.time_series import TimeSeries
+from gwsim.data.time_series.time_series_list import TimeSeriesList
+
+__all__ = ["TimeSeries", "TimeSeriesList"]

gwsim/data/serialize/__init__.py

@@ -0,0 +1,9 @@
+"""Init file for the serialize module."""
+
+from __future__ import annotations
+
+from gwsim.data.serialize.decoder import Decoder
+from gwsim.data.serialize.encoder import Encoder
+from gwsim.data.serialize.serializable import JSONSerializable
+
+__all__ = ["Decoder", "Encoder", "JSONSerializable"]

gwsim/data/serialize/decoder.py

@@ -0,0 +1,59 @@
+"""Custom JSON decoder for JSONSerializable objects."""
+
+from __future__ import annotations
+
+import base64
+import importlib
+import json
+from typing import Any
+
+import numpy as np
+from astropy.units import Quantity
+
+
+class Decoder(json.JSONDecoder):
+    """Custom JSON decoder for JSONSerializable objects.
+
+    Automatically reconstructs objects that have been serialized with
+    the Encoder class by checking for the "__type__" key and calling
+    the appropriate from_json_dict class method.
+    """
+
+    def __init__(self, *args, **kwargs):
+        """Initialize the decoder with custom object_hook.
+
+        Args:
+            *args: Positional arguments passed to json.JSONDecoder.
+            **kwargs: Keyword arguments passed to json.JSONDecoder.
+        """
+        super().__init__(*args, object_hook=self._object_hook, **kwargs)
+
+    def _object_hook(self, obj: dict[str, Any]) -> Any:
+        """Object hook to reconstruct JSONSerializable objects.
+
+        Args:
+            obj: Dictionary from JSON.
+
+        Returns:
+            Reconstructed object or original dict if not a known type.
+        """
+        if "__type__" in obj:
+            type_name = obj["__type__"]
+
+            if type_name == "Quantity":
+                return Quantity(value=obj["value"], unit=obj["unit"])
+
+            if type_name == "ndarray":
+                encoded_data = obj["data"]
+                bytes_data = base64.b64decode(encoded_data)
+                array = np.frombuffer(bytes_data, dtype=obj["dtype"])
+                array = array.reshape(obj["shape"])
+                return array
+
+            # Assume all serializable classes are in gwsim.data module
+            module = importlib.import_module("gwsim.data")
+            cls = getattr(module, type_name, None)
+            if cls and hasattr(cls, "from_json_dict"):
+                return cls.from_json_dict(obj)
+
+        return obj

gwsim/data/serialize/encoder.py

@@ -0,0 +1,44 @@
+"""Custom JSON encoder for JSONSerializable objects."""
+
+from __future__ import annotations
+
+import base64
+import json
+from typing import Any
+
+import numpy as np
+from astropy.units import Quantity
+
+
+class Encoder(json.JSONEncoder):
+    """Custom JSON encoder for JSONSerializable objects."""
+
+    def default(self, o: Any) -> Any:
+        """Serialize JSONSerializable objects to JSON.
+
+        Args:
+            o: Object to serialize.
+        """
+        if hasattr(o, "to_json_dict"):
+            encoded = o.to_json_dict()
+            if "__type__" not in encoded:
+                encoded["__type__"] = o.__class__.__name__
+            return encoded
+        if isinstance(o, Quantity):
+            return {
+                "__type__": "Quantity",
+                "value": o.value,
+                "unit": str(o.unit),
+            }
+        if isinstance(o, np.ndarray):
+            bytes_data = o.tobytes()
+            encoded_data = base64.b64encode(bytes_data).decode("ascii")
+            return {
+                "__type__": "ndarray",
+                "data": encoded_data,
+                "dtype": str(o.dtype),
+                "shape": list(o.shape),
+                "encoding": "base64",
+            }
+
+        return super().default(o)

gwsim/data/serialize/serializable.py

@@ -0,0 +1,33 @@
+"""Protocols for serializable objects in the simulator."""
+
+from __future__ import annotations
+
+from typing import Any, Protocol
+
+
+class JSONSerializable(Protocol):  # pylint: disable=too-few-public-methods
+    """Protocol for JSON serializable objects.
+
+    Classes implementing this protocol should provide a method to convert
+    the object to a JSON-serializable dictionary.
+    """
+
+    def to_json_dict(self) -> dict[str, Any]:
+        """Convert the object to a JSON-serializable dictionary.
+
+        Returns:
+            dict[str, Any]: JSON-serializable dictionary representation of the object.
+        """
+        raise NotImplementedError("to_json_dict method must be implemented by subclasses.")
+
+    @classmethod
+    def from_json_dict(cls, json_dict: dict[str, Any]) -> Any:
+        """Create an object from a JSON-serializable dictionary.
+
+        Args:
+            json_dict (dict[str, Any]): JSON-serializable dictionary representation of the object.
+
+        Returns:
+            JSONSerializable: An instance of the class created from the dictionary.
+        """
+        raise NotImplementedError("from_json_dict method must be implemented by subclasses.")

gwsim/data/time_series/__init__.py

@@ -0,0 +1,3 @@
+"""Time_series module."""
+
+from __future__ import annotations

gwsim/data/time_series/inject.py

@@ -0,0 +1,104 @@
+"""Module to handle injection of one TimeSeries into another, with support for time offsets."""
+
+from __future__ import annotations
+
+import logging
+from typing import cast
+
+import numpy as np
+from astropy.units import second  # pylint: disable=no-name-in-module
+from gwpy.timeseries import TimeSeries
+from scipy.interpolate import interp1d
+
+logger = logging.getLogger("gwsim")
+
+
+def inject(timeseries: TimeSeries, other: TimeSeries, interpolate_if_offset: bool = True) -> TimeSeries:
+    """Inject one TimeSeries into another, handling time offsets.
+
+    Args:
+        timeseries: The target TimeSeries to inject into.
+        other: The TimeSeries to be injected.
+        interpolate_if_offset: Whether to interpolate if there is a non-integer sample offset.
+
+    Returns:
+        TimeSeries: The resulting TimeSeries after injection.
+    """
+    # Check whether timeseries is compatible with other
+    timeseries.is_compatible(other)
+
+    # crop to fit
+    if (timeseries.xunit == second) and (other.xspan[0] < timeseries.xspan[0]):
+        other = cast(TimeSeries, other.crop(start=timeseries.xspan[0]))
+    if (timeseries.xunit == second) and (other.xspan[1] > timeseries.xspan[1]):
+        other = cast(TimeSeries, other.crop(end=timeseries.xspan[1]))
+
+    # Check if other is empty after cropping
+    if len(other.times) == 0:
+        logger.debug("Other TimeSeries is empty after cropping to fit; returning original timeseries")
+        return timeseries
+
+    target_times = timeseries.times.value
+    other_times = other.times.value
+    sample_spacing = float(timeseries.dt.value)
+
+    # Calculate offset between start times
+    offset = (other_times[0] - target_times[0]) / sample_spacing
+
+    # Check if offset is aligned (integer number of samples)
+    if not np.isclose(offset, round(offset)):
+        if not interpolate_if_offset:
+            logger.debug("Non-integer offset of %s samples; not interpolating, returning original timeseries", offset)
+            return timeseries
+
+        # Interpolate to align grids
+        logger.debug("Injecting with interpolation due to non-integer offset of %s samples", offset)
+
+        # Determine overlap range in target time grid
+        start_idx = int(np.searchsorted(target_times, other_times[0], side="left"))
+        end_idx = int(np.searchsorted(target_times, other_times[-1], side="right")) - 1
+
+        if start_idx >= len(target_times) or end_idx < 0 or start_idx > end_idx:
+            logger.debug("No overlap between timeseries and other after searching; returning original timeseries")
+            return timeseries
+
+        interp_func = interp1d(other_times, other.value, kind="cubic", axis=0, bounds_error=False, fill_value=0.0)
+        resampled = interp_func(target_times[start_idx : end_idx + 1])
+
+        # Create a new TimeSeries with explicit parameters to avoid floating-point precision issues
+        injected_data = timeseries.value.copy()
+        injected_data[start_idx : end_idx + 1] += resampled
+        injected = TimeSeries(
+            injected_data,
+            t0=timeseries.t0,
+            dt=timeseries.dt,
+            unit=timeseries.unit,
+        )
+        return injected
+
+    # Aligned case: offset is integer
+    logger.debug("Injecting with aligned grids (offset: %s samples)", round(offset))
+    start_idx = round(offset)
+    end_idx = start_idx + len(other.value) - 1
+
+    # Bounds check
+    if start_idx < 0 or end_idx >= len(target_times) or start_idx >= len(target_times):
+        logger.warning(
+            "Injection range [%s:%s] out of bounds for timeseries of length %s; skipping injection",
+            start_idx,
+            end_idx,
+            len(target_times),
+        )
+        return timeseries
+
+    # Create a new TimeSeries with explicit parameters to avoid floating-point precision issues
+    injected_data = timeseries.value.copy()
+    inject_len = min(len(other.value), end_idx - start_idx + 1)
+    injected_data[start_idx : start_idx + inject_len] += other.value[:inject_len]
+    injected = TimeSeries(
+        injected_data,
+        t0=timeseries.t0,
+        dt=timeseries.dt,
+        unit=timeseries.unit,
+    )
+    return injected