microlens-submit 0.12.2__py3-none-any.whl → 0.16.0__py3-none-any.whl

microlens_submit/__init__.py

@@ -1,163 +1,13 @@
-"""microlens-submit: A stateful submission toolkit for the Microlensing Data Challenge.
+"""Stateful tools for Microlensing Data Challenge submissions.
 
-This package provides a comprehensive toolkit for managing and submitting microlensing
-data challenge solutions. It offers both programmatic API access and command-line
-interface for creating, validating, and exporting microlensing submissions.
-
-**Core Features:**
-- Project initialization and management
-- Solution creation and parameter validation
-- Submission validation and completeness checking
-- HTML dossier generation with rich visualizations
-- Export functionality for challenge submission
-- Command-line interface for all operations
-
-**Main Components:**
-- Submission: Top-level container for all submission data
-- Event: Container for microlensing events and their solutions
-- Solution: Individual microlensing solutions with parameters and metadata
-- Validation: Comprehensive parameter and submission validation
-- Dossier: HTML report generation with Tailwind CSS styling
-
-**Quick Start:**
-    >>> from microlens_submit import load, Submission
-    >>> 
-    >>> # Load an existing project
-    >>> submission = load("./my_project")
-    >>> 
-    >>> # Or create a new submission
-    >>> submission = Submission()
-    >>> submission.team_name = "Team Alpha"
-    >>> submission.tier = "advanced"
-    >>> submission.save("./my_project")
-    >>> 
-    >>> # Add a solution to an event
-    >>> event = submission.get_event("EVENT001")
-    >>> solution = event.add_solution(
-    ...     model_type="1S1L",
-    ...     parameters={"t0": 2459123.5, "u0": 0.1, "tE": 20.0}
-    ... )
-    >>> solution.log_likelihood = -1234.56
-    >>> solution.cpu_hours = 2.5
-    >>> submission.save()
-
-**Command Line Usage:**
-    # Initialize a new project
-    microlens-submit init --team-name "Team Alpha" --tier "advanced" ./project
-    
-    # Add a solution
-    microlens-submit add-solution EVENT001 1S1L ./project \
-        --param t0=2459123.5 --param u0=0.1 --param tE=20.0 \
-        --log-likelihood -1234.56 --cpu-hours 2.5
-    
-    # Validate and generate dossier
-    microlens-submit validate-submission ./project
-    microlens-submit generate-dossier ./project
-    
-    # Export for submission
-    microlens-submit export submission.zip ./project
-
-**Supported Model Types:**
-- 1S1L: Point Source, Single Point Lens (standard microlensing)
-- 1S2L: Point Source, Binary Point Lens
-- 2S1L: Binary Source, Single Point Lens
-- 2S2L: Binary Source, Binary Point Lens
-- 1S3L: Point Source, Triple Point Lens
-- 2S3L: Binary Source, Triple Point Lens
-
-**Higher-Order Effects:**
-- parallax: Microlens parallax effect
-- finite-source: Finite source size effect
-- lens-orbital-motion: Orbital motion of lens components
-- xallarap: Source orbital motion
-- gaussian-process: Gaussian process noise modeling
-- stellar-rotation: Stellar rotation effects
-- fitted-limb-darkening: Fitted limb darkening coefficients
-
-Example:
-    >>> from microlens_submit import load, Submission
-    >>> from pathlib import Path
-    >>> 
-    >>> # Create a new submission project
-    >>> submission = Submission()
-    >>> submission.team_name = "Team Alpha"
-    >>> submission.tier = "advanced"
-    >>> submission.repo_url = "https://github.com/team-alpha/microlens-analysis"
-    >>> 
-    >>> # Add hardware information
-    >>> submission.hardware_info = {
-    ...     "cpu_details": "Intel Xeon E5-2680 v4",
-    ...     "memory_gb": 64,
-    ...     "nexus_image": "roman-science-platform:latest"
-    ... }
-    >>> 
-    >>> # Create an event and add solutions
-    >>> event = submission.get_event("EVENT001")
-    >>> 
-    >>> # Simple 1S1L solution
-    >>> solution1 = event.add_solution(
-    ...     model_type="1S1L",
-    ...     parameters={
-    ...         "t0": 2459123.5,
-    ...         "u0": 0.1,
-    ...         "tE": 20.0,
-    ...         "F0_S": 1000.0,
-    ...         "F0_B": 500.0
-    ...     }
-    ... )
-    >>> solution1.log_likelihood = -1234.56
-    >>> solution1.n_data_points = 1250
-    >>> solution1.cpu_hours = 2.5
-    >>> solution1.relative_probability = 0.8
-    >>> solution1.notes = "# Simple Point Lens Fit\n\nThis is a basic 1S1L solution."
-    >>> 
-    >>> # Binary lens solution with parallax
-    >>> solution2 = event.add_solution(
-    ...     model_type="1S2L",
-    ...     parameters={
-    ...         "t0": 2459123.5,
-    ...         "u0": 0.08,
-    ...         "tE": 22.1,
-    ...         "s": 1.15,
-    ...         "q": 0.001,
-    ...         "alpha": 45.2,
-    ...         "piEN": 0.1,
-    ...         "piEE": 0.05,
-    ...         "F0_S": 1000.0,
-    ...         "F0_B": 500.0
-    ...     }
-    ... )
-    >>> solution2.higher_order_effects = ["parallax"]
-    >>> solution2.t_ref = 2459123.0
-    >>> solution2.log_likelihood = -1189.34
-    >>> solution2.cpu_hours = 15.2
-    >>> solution2.relative_probability = 0.2
-    >>> 
-    >>> # Save the submission
-    >>> submission.save("./my_submission")
-    >>> 
-    >>> # Validate the submission
-    >>> warnings = submission.validate()
-    >>> if warnings:
-    ...     print("Validation warnings:", warnings)
-    >>> else:
-    ...     print("Submission is valid!")
-    >>> 
-    >>> # Generate dossier
-    >>> from microlens_submit.dossier import generate_dashboard_html
-    >>> generate_dashboard_html(submission, Path("./my_submission/dossier"))
-
-Note:
-    This package is designed for the Microlensing Data Challenge and provides
-    comprehensive tools for managing submission data. All data is stored in
-    JSON format for portability and human readability. The package includes
-    extensive validation to ensure submission completeness and correctness.
-    The HTML dossier generation creates professional, printable reports with
-    Tailwind CSS styling and syntax-highlighted markdown notes.
+``microlens-submit`` manages events and solutions on disk so you can build,
+validate, and export a challenge submission using either the Python API or
+the command line interface.
 """
 
-__version__ = "0.12.2"
+__version__ = "0.16.0"
 
-from .api import Event, Solution, Submission, load
+from .models import Event, Solution, Submission
+from .utils import load
 
 __all__ = ["Event", "Solution", "Submission", "load"]

microlens_submit/cli/__init__.py

@@ -0,0 +1,5 @@
+"""CLI package for microlens-submit."""
+
+from .main import app
+
+__all__ = ["app"]

microlens_submit/cli/__main__.py

@@ -0,0 +1,6 @@
+"""Entry point for running the CLI as a module."""
+
+from .main import app
+
+if __name__ == "__main__":
+    app()

microlens_submit/cli/commands/__init__.py

@@ -0,0 +1 @@
+"""CLI commands package for microlens-submit."""

microlens_submit/cli/commands/dossier.py

@@ -0,0 +1,139 @@
+"""Dossier generation commands for microlens-submit CLI."""
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+
+from microlens_submit.dossier import generate_dashboard_html, generate_event_page, generate_solution_page
+from microlens_submit.dossier.full_report import generate_full_dossier_report_html
+from microlens_submit.utils import load
+
+console = Console()
+
+
+def generate_dossier(
+    project_path: Path = typer.Argument(Path("."), help="Project directory"),
+    event_id: Optional[str] = typer.Option(
+        None,
+        "--event-id",
+        help="Generate dossier for a specific event only (omit for full dossier)",
+    ),
+    solution_id: Optional[str] = typer.Option(
+        None,
+        "--solution-id",
+        help="Generate dossier for a specific solution only (omit for full dossier)",
+    ),
+    open: bool = typer.Option(
+        False,
+        "--open",
+        help="Open the generated dossier in your web browser after generation.",
+    ),
+) -> None:
+    """Generate an HTML dossier for the submission.
+
+    Use --open to automatically open the main dossier page in your browser after generation.
+    """
+    sub = load(str(project_path))
+    output_dir = Path(project_path) / "dossier"
+
+    if solution_id:
+        # Find the solution across all events (same pattern as other CLI commands)
+        solution = None
+        containing_event_id = None
+        for eid, event in sub.events.items():
+            if solution_id in event.solutions:
+                solution = event.solutions[solution_id]
+                containing_event_id = eid
+                break
+
+        if solution is None:
+            console.print(f"Solution {solution_id} not found", style="bold red")
+            raise typer.Exit(1)
+
+        # Create output directory and assets subdirectory
+        output_dir.mkdir(parents=True, exist_ok=True)
+        (output_dir / "assets").mkdir(exist_ok=True)
+
+        # Generate only the specific solution page
+        event = sub.events[containing_event_id]
+        console.print(
+            Panel(
+                f"Generating dossier for solution {solution_id} in event {containing_event_id}...",
+                style="cyan",
+            )
+        )
+        generate_solution_page(solution, event, sub, output_dir)
+        if open:
+            import webbrowser
+
+            solution_path = output_dir / f"{solution_id}.html"
+            if solution_path.exists():
+                webbrowser.open(solution_path.resolve().as_uri())
+
+    elif event_id:
+        # Generate only the specific event page
+        if event_id not in sub.events:
+            console.print(f"Event {event_id} not found", style="bold red")
+            raise typer.Exit(1)
+
+        # Create output directory and assets subdirectory
+        output_dir.mkdir(parents=True, exist_ok=True)
+        (output_dir / "assets").mkdir(exist_ok=True)
+
+        event = sub.events[event_id]
+        console.print(Panel(f"Generating dossier for event {event_id}...", style="cyan"))
+        generate_event_page(event, sub, output_dir)
+        if open:
+            import webbrowser
+
+            event_path = output_dir / f"{event_id}.html"
+            if event_path.exists():
+                webbrowser.open(event_path.resolve().as_uri())
+
+    else:
+        # Generate full dossier (all events and solutions)
+        console.print(
+            Panel(
+                "Generating comprehensive dossier for all events and solutions...",
+                style="cyan",
+            )
+        )
+        generate_dashboard_html(sub, output_dir)
+
+        # Generate comprehensive printable dossier
+        console.print(Panel("Generating comprehensive printable dossier...", style="cyan"))
+        generate_full_dossier_report_html(sub, output_dir)
+
+        # Replace placeholder in index.html with the real link
+        dashboard_path = output_dir / "index.html"
+        if dashboard_path.exists():
+            with dashboard_path.open("r", encoding="utf-8") as f:
+                dashboard_html = f.read()
+            dashboard_html = dashboard_html.replace(
+                "<!--FULL_DOSSIER_LINK_PLACEHOLDER-->",
+                '<div class="text-center">'
+                '<a href="./full_dossier_report.html" '
+                'class="inline-block bg-rtd-accent text-white py-3 px-6 '
+                "rounded-lg shadow-md hover:bg-rtd-secondary "
+                'transition-colors duration-200 text-lg font-semibold mt-8">'
+                "View Full Comprehensive Dossier (Printable)</a></div>",
+            )
+            with dashboard_path.open("w", encoding="utf-8") as f:
+                f.write(dashboard_html)
+        console.print(Panel("Comprehensive dossier generated!", style="bold green"))
+
+        # Open the main dashboard if requested
+        if open:
+            import webbrowser
+
+            webbrowser.open(dashboard_path.resolve().as_uri())
+
+    console.print(
+        Panel(
+            f"Dossier generated successfully at {output_dir / 'index.html'}",
+            style="bold green",
+        )
+    )

microlens_submit/cli/commands/export.py

@@ -0,0 +1,177 @@
+"""Export commands for microlens-submit CLI."""
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+
+from microlens_submit.utils import load
+
+console = Console()
+
+
+def export(
+    output_path: Path,
+    project_path: Path = typer.Argument(Path("."), help="Project directory"),
+) -> None:
+    """Generate a zip archive containing all active solutions.
+
+    This command creates a submission-ready archive. Unlike save operations,
+    export requires all validation checks to pass (complete team info,
+    hardware info, valid parameters, etc.) since this is for actual submission.
+
+    Args:
+        output_path: Path for the output zip file
+        project_path: Directory containing the submission project
+
+    Example:
+        # Export for submission (requires complete submission)
+        microlens-submit export submission.zip ./my_project
+
+    Note:
+        Export is strict and requires complete submissions. Use save operations
+        for saving incomplete work during development.
+    """
+    sub = load(str(project_path))
+    sub.export(str(output_path))
+    console.print(Panel(f"Exported submission to {output_path}", style="bold green"))
+
+
+def remove_event(
+    event_id: str,
+    force: bool = typer.Option(False, "--force", help="Force removal even if event has saved solutions"),
+    project_path: Path = typer.Argument(Path("."), help="Project directory"),
+) -> None:
+    """Remove an entire event and all its solutions from the submission."""
+    submission = load(str(project_path))
+
+    if event_id not in submission.events:
+        typer.echo(f"❌ Event '{event_id}' not found in submission")
+        raise typer.Exit(1)
+
+    event = submission.events[event_id]
+    solution_count = len(event.solutions)
+
+    if not force:
+        typer.echo(f"⚠️  This will permanently remove event '{event_id}' " f"and all {solution_count} solutions.")
+        typer.echo("   This action cannot be undone.")
+        confirm = typer.confirm("Are you sure you want to continue?")
+        if not confirm:
+            typer.echo("❌ Operation cancelled")
+            raise typer.Exit(0)
+
+    try:
+        removed = submission.remove_event(event_id, force=force)
+        if removed:
+            typer.echo(f"✅ Removed event '{event_id}' and all {solution_count} solutions")
+            submission.save()
+        else:
+            typer.echo(f"❌ Failed to remove event '{event_id}'")
+            raise typer.Exit(1)
+    except ValueError as e:
+        typer.echo(f"❌ Cannot remove event: {e}")
+        raise typer.Exit(1)
+
+
+def set_repo_url(
+    repo_url: str = typer.Argument(..., help="GitHub repository URL (e.g. https://github.com/owner/repo)"),
+    project_path: Path = typer.Argument(Path("."), help="Project directory"),
+) -> None:
+    """Set or update the GitHub repository URL in the submission metadata."""
+    sub = load(str(project_path))
+    sub.repo_url = repo_url
+    sub.save()
+    console.print(
+        Panel(
+            f"Set repo_url to {repo_url} in {project_path}/submission.json",
+            style="bold green",
+        )
+    )
+
+
+def set_hardware_info(
+    cpu: Optional[str] = typer.Option(None, "--cpu", help="CPU model/description"),
+    cpu_details: Optional[str] = typer.Option(None, "--cpu-details", help="Detailed CPU information"),
+    memory_gb: Optional[float] = typer.Option(None, "--memory-gb", help="Memory in GB"),
+    ram_gb: Optional[float] = typer.Option(None, "--ram-gb", help="RAM in GB (alternative to --memory-gb)"),
+    platform: Optional[str] = typer.Option(
+        None,
+        "--platform",
+        help="Platform description (e.g., 'Local Analysis', 'Roman Nexus')",
+    ),
+    nexus_image: Optional[str] = typer.Option(None, "--nexus-image", help="Roman Nexus image identifier"),
+    clear: bool = typer.Option(False, "--clear", help="Clear all existing hardware info"),
+    dry_run: bool = typer.Option(False, "--dry-run", help="Show what would be changed without saving"),
+    project_path: Path = typer.Argument(Path("."), help="Project directory"),
+) -> None:
+    """Set or update hardware information in the submission metadata."""
+    sub = load(str(project_path))
+
+    # Initialize hardware_info if it doesn't exist
+    if sub.hardware_info is None:
+        sub.hardware_info = {}
+
+    changes = []
+
+    # Clear existing info if requested
+    if clear:
+        if sub.hardware_info:
+            changes.append("Clear all existing hardware info")
+            sub.hardware_info = {}
+
+    # Set new values
+    if cpu_details is not None:
+        if sub.hardware_info.get("cpu_details") != cpu_details:
+            changes.append(f"Set cpu_details: {cpu_details}")
+            sub.hardware_info["cpu_details"] = cpu_details
+    elif cpu is not None:
+        if sub.hardware_info.get("cpu") != cpu:
+            changes.append(f"Set cpu: {cpu}")
+            sub.hardware_info["cpu"] = cpu
+
+    if memory_gb is not None:
+        if sub.hardware_info.get("memory_gb") != memory_gb:
+            changes.append(f"Set memory_gb: {memory_gb}")
+            sub.hardware_info["memory_gb"] = memory_gb
+    elif ram_gb is not None:
+        if sub.hardware_info.get("ram_gb") != ram_gb:
+            changes.append(f"Set ram_gb: {ram_gb}")
+            sub.hardware_info["ram_gb"] = ram_gb
+
+    if platform is not None:
+        if sub.hardware_info.get("platform") != platform:
+            changes.append(f"Set platform: {platform}")
+            sub.hardware_info["platform"] = platform
+
+    if nexus_image is not None:
+        if sub.hardware_info.get("nexus_image") != nexus_image:
+            changes.append(f"Set nexus_image: {nexus_image}")
+            sub.hardware_info["nexus_image"] = nexus_image
+
+    # Show dry run results
+    if dry_run:
+        if changes:
+            console.print(Panel("Hardware info changes (dry run):", style="cyan"))
+            for change in changes:
+                console.print(f"  • {change}")
+            console.print(f"\nNew hardware_info: {sub.hardware_info}")
+        else:
+            console.print(Panel("No changes would be made", style="yellow"))
+        return
+
+    # Apply changes
+    if changes:
+        sub.save()
+        console.print(
+            Panel(
+                f"Updated hardware info in {project_path}/submission.json",
+                style="bold green",
+            )
+        )
+        for change in changes:
+            console.print(f"  • {change}")
+        console.print(f"\nCurrent hardware_info: {sub.hardware_info}")
+    else:
+        console.print(Panel("No changes made", style="yellow"))

microlens_submit/cli/commands/init.py

@@ -0,0 +1,172 @@
+"""Initialization commands for microlens-submit CLI."""
+
+import subprocess
+from pathlib import Path
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+
+from microlens_submit.utils import load
+
+console = Console()
+
+
+def init(
+    team_name: str = typer.Option(..., help="Team name"),
+    tier: str = typer.Option(..., help="Challenge tier"),
+    project_path: Path = typer.Argument(Path("."), help="Project directory"),
+) -> None:
+    """Create a new submission project in the specified directory.
+
+    Initializes a new microlensing submission project with the given team name
+    and tier. The project directory structure is created automatically, and
+    the submission.json file is initialized with basic metadata.
+
+    This command also attempts to auto-detect the GitHub repository URL
+    from the current git configuration and provides helpful feedback.
+
+    Args:
+        team_name: Name of the participating team (e.g., "Team Alpha").
+        tier: Challenge tier level (e.g., "basic", "advanced").
+        project_path: Directory where the project will be created.
+            Defaults to current directory if not specified.
+
+    Raises:
+        OSError: If unable to create the project directory or write files.
+
+    Example:
+        # Create project in current directory
+        microlens-submit init --team-name "Team Alpha" --tier "advanced"
+
+        # Create project in specific directory
+        microlens-submit init --team-name "Team Beta" --tier "basic" ./my_submission
+
+        # Project structure created:
+        # ./my_submission/
+        # ├── submission.json
+        # └── events/
+
+    Note:
+        If the project directory already exists, it will be used as-is.
+        If a git repository is detected, the GitHub URL will be automatically
+        set. Otherwise, a warning is shown and you can set it later with
+        set-repo-url command.
+    """
+    # Validate tier
+    try:
+        from microlens_submit.tier_validation import get_available_tiers, get_tier_description
+
+        available_tiers = get_available_tiers()
+        if tier not in available_tiers:
+            console.print(f"[yellow]Warning: Invalid tier '{tier}'[/yellow]")
+            console.print(f"Available tiers: {', '.join(available_tiers)}")
+            console.print("[yellow]Setting tier to 'None' (no validation)[/yellow]")
+            tier = "None"
+        tier_desc = get_tier_description(tier)
+        console.print(f"[green]Using tier:[/green] {tier} - {tier_desc}")
+    except ImportError:
+        # Tier validation module not available, skip validation
+        console.print(f"[yellow]Warning: Tier validation not available, using tier '{tier}'[/yellow]")
+    except ValueError as e:
+        console.print(f"[yellow]Warning: {e}[/yellow]")
+        console.print("[yellow]Setting tier to 'None' (no validation)[/yellow]")
+        tier = "None"
+
+    sub = load(str(project_path))
+    sub.team_name = team_name
+    sub.tier = tier
+    # Try to auto-detect repo_url
+    try:
+        repo_url = (
+            subprocess.check_output(
+                ["git", "config", "--get", "remote.origin.url"],
+                stderr=subprocess.DEVNULL,
+            )
+            .decode()
+            .strip()
+        )
+    except Exception:
+        repo_url = None
+    if repo_url:
+        sub.repo_url = repo_url
+        console.print(f"[green]Auto-detected GitHub repo URL:[/green] {repo_url}")
+    else:
+        console.print(
+            "[yellow]Could not auto-detect a GitHub repository URL. "
+            "Please add it using 'microlens-submit set-repo-url <url> "
+            "<project_dir>'.[/yellow]"
+        )
+
+    # Run warnings-only validation
+    warnings = sub.run_validation_warnings()
+    if warnings:
+        console.print("[yellow]⚠️  Project initialized with warnings:[/yellow]")
+        for warning in warnings:
+            console.print(f"   [yellow]• {warning}[/yellow]")
+        console.print("[yellow]💡 These warnings will become errors when saving or exporting.[/yellow]")
+
+    # Try to save, but don't fail if there are validation errors
+    try:
+        sub.save()
+        console.print(Panel(f"Initialized project at {project_path}", style="bold green"))
+    except ValueError as e:
+        console.print("[yellow]⚠️  Project initialized but could not save due to validation errors:[/yellow]")
+        console.print(f"[yellow]{str(e)}[/yellow]")
+        console.print("[yellow]💡 Fix validation errors before saving or exporting.[/yellow]")
+        console.print(Panel(f"Initialized project at {project_path} (unsaved)", style="bold yellow"))
+
+
+def nexus_init(
+    team_name: str = typer.Option(..., help="Team name"),
+    tier: str = typer.Option(..., help="Challenge tier"),
+    project_path: Path = typer.Argument(Path("."), help="Project directory"),
+) -> None:
+    """Create a project and record Roman Nexus environment details.
+
+    This command combines the functionality of init() with automatic
+    detection of Roman Science Platform environment information. It
+    populates hardware_info with CPU details, memory information, and
+    the Nexus image identifier.
+
+    Args:
+        team_name: Name of the participating team (e.g., "Team Alpha").
+        tier: Challenge tier level (e.g., "basic", "advanced").
+        project_path: Directory where the project will be created.
+            Defaults to current directory if not specified.
+
+    Example:
+        # Initialize project with Nexus platform info
+        microlens-submit nexus-init --team-name "Team Alpha" --tier "advanced" ./project
+
+        # This will automatically detect:
+        # - CPU model from /proc/cpuinfo
+        # - Memory from /proc/meminfo
+        # - Nexus image from JUPYTER_IMAGE_SPEC
+
+    Note:
+        This command is specifically designed for the Roman Science Platform
+        environment. It will silently skip any environment information that
+        cannot be detected (e.g., if running outside of Nexus).
+    """
+    init(team_name=team_name, tier=tier, project_path=project_path)
+    sub = load(str(project_path))
+    sub.autofill_nexus_info()
+
+    # Run warnings-only validation after adding hardware info
+    warnings = sub.run_validation_warnings()
+    if warnings:
+        console.print("[yellow]⚠️  Project updated with warnings:[/yellow]")
+        for warning in warnings:
+            console.print(f"   [yellow]• {warning}[/yellow]")
+        console.print("[yellow]💡 These warnings will become errors when saving or exporting.[/yellow]")
+
+    # Try to save, but don't fail if there are validation errors
+    try:
+        sub.save()
+        console.print("Nexus platform info captured.", style="bold green")
+    except ValueError as e:
+        console.print("[yellow]⚠️  Project updated but could not save due to validation errors:[/yellow]")
+        console.print(f"[yellow]{str(e)}[/yellow]")
+        console.print("[yellow]💡 Fix validation errors before saving or exporting.[/yellow]")
+        console.print("Nexus platform info captured (unsaved).", style="bold yellow")