microlens-submit 0.16.2__py3-none-any.whl → 0.16.4__py3-none-any.whl

microlens_submit/__init__.py

@@ -5,7 +5,7 @@ validate, and export a challenge submission using either the Python API or
 the command line interface.
 """
 
-__version__ = "0.16.2"
+__version__ = "0.16.4"
 
 from .models import Event, Solution, Submission
 from .utils import load

microlens_submit/cli/commands/export.py

@@ -42,10 +42,13 @@ def export(
 
 def remove_event(
     event_id: str,
-    force: bool = typer.Option(False, "--force", help="Force removal even if event has saved solutions"),
+    force: bool = typer.Option(False, "--force", help="Required to remove an event (prevents accidents)"),
     project_path: Path = typer.Argument(Path("."), help="Project directory"),
 ) -> None:
-    """Remove an entire event and all its solutions from the submission."""
+    """Remove an entire event and all its solutions from the submission.
+
+    This action is destructive and requires --force to proceed.
+    """
     submission = load(str(project_path))
 
     if event_id not in submission.events:
@@ -57,13 +60,11 @@ def remove_event(
 
     if not force:
         typer.echo(
-            f"{symbol('warning')}  This will permanently remove event '{event_id}' and all {solution_count} solutions."
+            f"{symbol('warning')}  Refusing to remove event '{event_id}' without --force "
+            f"({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(f"{symbol('error')} Operation cancelled")
-            raise typer.Exit(0)
+        typer.echo(f"{symbol('hint')} Consider deactivating solutions instead, or re-run with --force to proceed.")
+        raise typer.Exit(0)
 
     try:
         removed = submission.remove_event(event_id, force=force)
@@ -94,11 +95,33 @@ def set_repo_url(
     )
 
 
+def set_git_dir(
+    git_dir: Path = typer.Argument(..., help="Path to the git working tree"),
+    project_path: Path = typer.Argument(Path("."), help="Project directory"),
+) -> None:
+    """Set or update the git working tree path in the submission metadata."""
+    sub = load(str(project_path))
+    git_dir_path = git_dir.expanduser().resolve()
+    if not git_dir_path.exists():
+        raise typer.BadParameter(f"git_dir does not exist: {git_dir_path}")
+    sub.git_dir = str(git_dir_path)
+    sub.save()
+    console.print(
+        Panel(
+            f"Set git_dir to {git_dir_path} 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)"),
+    gpu: Optional[str] = typer.Option(None, "--gpu", help="GPU model/description"),
+    gpu_count: Optional[int] = typer.Option(None, "--gpu-count", help="Number of GPUs"),
+    gpu_memory_gb: Optional[float] = typer.Option(None, "--gpu-memory-gb", help="GPU memory per device in GB"),
     platform: Optional[str] = typer.Option(
         None,
         "--platform",
@@ -153,6 +176,24 @@ def set_hardware_info(
             changes.append(f"Set nexus_image: {nexus_image}")
             sub.hardware_info["nexus_image"] = nexus_image
 
+    if any(value is not None for value in (gpu, gpu_count, gpu_memory_gb)):
+        gpu_info = sub.hardware_info.get("gpu")
+        if not isinstance(gpu_info, dict):
+            gpu_info = {}
+        if gpu is not None:
+            if gpu_info.get("model") != gpu:
+                changes.append(f"Set gpu.model: {gpu}")
+                gpu_info["model"] = gpu
+        if gpu_count is not None:
+            if gpu_info.get("count") != gpu_count:
+                changes.append(f"Set gpu.count: {gpu_count}")
+                gpu_info["count"] = gpu_count
+        if gpu_memory_gb is not None:
+            if gpu_info.get("memory_gb") != gpu_memory_gb:
+                changes.append(f"Set gpu.memory_gb: {gpu_memory_gb}")
+                gpu_info["memory_gb"] = gpu_memory_gb
+        sub.hardware_info["gpu"] = gpu_info
+
     # Show dry run results
     if dry_run:
         if changes:

microlens_submit/cli/commands/init.py

@@ -17,6 +17,7 @@ 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"),
+    show_warnings: bool = True,
 ) -> None:
     """Create a new submission project in the specified directory.
 
@@ -29,7 +30,7 @@ def init(
 
     Args:
         team_name: Name of the participating team (e.g., "Team Alpha").
-        tier: Challenge tier level (e.g., "basic", "advanced").
+        tier: Challenge tier level (e.g., "beginner", "experienced").
         project_path: Directory where the project will be created.
             Defaults to current directory if not specified.
 
@@ -38,10 +39,10 @@ def init(
 
     Example:
         # Create project in current directory
-        microlens-submit init --team-name "Team Alpha" --tier "advanced"
+        microlens-submit init --team-name "Team Alpha" --tier "experienced"
 
         # Create project in specific directory
-        microlens-submit init --team-name "Team Beta" --tier "basic" ./my_submission
+        microlens-submit init --team-name "Team Beta" --tier "beginner" ./my_submission
 
         # Project structure created:
         # ./my_submission/
@@ -100,12 +101,15 @@ def init(
         )
 
     # Run warnings-only validation
-    warnings = sub.run_validation_warnings()
-    if warnings:
-        console.print(f"[yellow]{symbol('warning')}  Project initialized with warnings:[/yellow]")
-        for warning in warnings:
-            console.print(f"   [yellow]• {warning}[/yellow]")
-        console.print(f"[yellow]{symbol('hint')} These warnings will become errors when saving or exporting.[/yellow]")
+    if show_warnings:
+        warnings = sub.run_validation_warnings()
+        if warnings:
+            console.print(f"[yellow]{symbol('warning')}  Project initialized with warnings:[/yellow]")
+            for warning in warnings:
+                console.print(f"   [yellow]• {warning}[/yellow]")
+            console.print(
+                f"[yellow]{symbol('hint')} These warnings will become errors when saving or exporting.[/yellow]"
+            )
 
     # Try to save, but don't fail if there are validation errors
     try:
@@ -134,13 +138,13 @@ def nexus_init(
 
     Args:
         team_name: Name of the participating team (e.g., "Team Alpha").
-        tier: Challenge tier level (e.g., "basic", "advanced").
+        tier: Challenge tier level (e.g., "beginner", "experienced").
         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
+        microlens-submit nexus-init --team-name "Team Alpha" --tier "experienced" ./project
 
         # This will automatically detect:
         # - CPU model from /proc/cpuinfo
@@ -152,7 +156,7 @@ def nexus_init(
         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)
+    init(team_name=team_name, tier=tier, project_path=project_path, show_warnings=False)
     sub = load(str(project_path))
     sub.autofill_nexus_info()
 

microlens_submit/cli/commands/solutions.py

@@ -2,8 +2,13 @@
 
 import json
 import os
+import re
+import shlex
+import shutil
+import subprocess
+import sys
 from pathlib import Path
-from typing import Dict, List, Optional, Tuple
+from typing import Any, Dict, List, Optional, Tuple
 
 import typer
 from rich.console import Console
@@ -16,6 +21,38 @@ from microlens_submit.utils import import_solutions_from_csv, load
 console = Console()
 
 
+_NUMERIC_RE = re.compile(r"^[+-]?((\\d+(\\.\\d*)?)|(\\.\\d+))([eE][+-]?\\d+)?$")
+
+
+def _parse_cli_value(value: str) -> Any:
+    """Parse a CLI value using JSON, with a numeric fallback for .001-style input."""
+    try:
+        return json.loads(value)
+    except json.JSONDecodeError:
+        if _NUMERIC_RE.match(value.strip()):
+            try:
+                if re.match(r"^[+-]?\\d+$", value.strip()):
+                    return int(value)
+                return float(value)
+            except ValueError:
+                pass
+        return value
+
+
+def _run_editor(editor_cmd: str, notes_file: Path) -> bool:
+    parts = shlex.split(editor_cmd)
+    if not parts:
+        return False
+    if os.name == "nt" and parts[0].lower() in ("code", "code.exe"):
+        if "--wait" not in parts and "-w" not in parts:
+            parts.append("--wait")
+    try:
+        subprocess.run(parts + [str(notes_file)], check=False)
+        return True
+    except FileNotFoundError:
+        return False
+
+
 def _parse_pairs(pairs: Optional[List[str]]) -> Optional[Dict]:
     """Convert CLI key=value options into a dictionary."""
     if not pairs:
@@ -25,10 +62,7 @@ def _parse_pairs(pairs: Optional[List[str]]) -> Optional[Dict]:
         if "=" not in item:
             raise typer.BadParameter(f"Invalid format: {item}")
         key, value = item.split("=", 1)
-        try:
-            out[key] = json.loads(value)
-        except json.JSONDecodeError:
-            out[key] = value
+        out[key] = _parse_cli_value(value)
     return out
 
 
@@ -219,10 +253,7 @@ def add_solution(
             if "=" not in p:
                 raise typer.BadParameter(f"Invalid parameter format: {p}")
             key, value = p.split("=", 1)
-            try:
-                params[key] = json.loads(value)
-            except json.JSONDecodeError:
-                params[key] = value
+            params[key] = _parse_cli_value(value)
     allowed_model_types = [
         "1S1L",
         "1S2L",
@@ -254,7 +285,7 @@ def add_solution(
     sol.relative_probability = relative_probability
     sol.n_data_points = n_data_points
     if cpu_hours is not None or wall_time_hours is not None:
-        sol.set_compute_info(cpu_hours=cpu_hours, wall_time_hours=wall_time_hours)
+        sol.set_compute_info(cpu_hours=cpu_hours, wall_time_hours=wall_time_hours, git_dir=sub.git_dir)
     sol.lightcurve_plot_path = str(lightcurve_plot_path) if lightcurve_plot_path else None
     sol.lens_plane_plot_path = str(lens_plane_plot_path) if lens_plane_plot_path else None
     # Handle notes file logic
@@ -368,10 +399,13 @@ def activate(
 
 def remove_solution(
     solution_id: str,
-    force: bool = typer.Option(False, "--force", help="Force removal of saved solutions (use with caution)"),
+    force: bool = typer.Option(False, "--force", help="Required to remove a solution (prevents accidents)"),
     project_path: Path = typer.Argument(Path("."), help="Project directory"),
 ) -> None:
-    """Completely remove a solution from the submission."""
+    """Completely remove a solution from the submission.
+
+    This action is destructive and requires --force to proceed.
+    """
     submission = load(project_path)
 
     # Find the solution across all events
@@ -387,6 +421,16 @@ def remove_solution(
         console.print(f"[red]Error: Solution {solution_id} not found[/red]")
         raise typer.Exit(1)
 
+    if not force:
+        console.print(
+            f"[yellow]{symbol('warning')}  Refusing to remove solution {solution_id[:8]}... without --force.[/yellow]"
+        )
+        console.print(
+            f"[blue]{symbol('hint')} Consider using deactivate to keep the solution, "
+            "or re-run with --force to proceed.[/blue]"
+        )
+        raise typer.Exit(0)
+
     try:
         removed = submission.events[event_id].remove_solution(solution_id, force=force)
         if removed:
@@ -561,16 +605,14 @@ def edit_solution(
         target_solution.set_compute_info(
             cpu_hours=cpu_hours if cpu_hours is not None else old_cpu,
             wall_time_hours=(wall_time_hours if wall_time_hours is not None else old_wall),
+            git_dir=sub.git_dir,
         )
     if param:
         for p in param:
             if "=" not in p:
                 raise typer.BadParameter(f"Invalid parameter format: {p}")
             key, value = p.split("=", 1)
-            try:
-                new_value = json.loads(value)
-            except json.JSONDecodeError:
-                new_value = value
+            new_value = _parse_cli_value(value)
             old_value = target_solution.parameters.get(key)
             if old_value != new_value:
                 changes.append(f"Update parameter {key}: {old_value} {arrow} {new_value}")
@@ -582,10 +624,7 @@ def edit_solution(
             if "=" not in p:
                 raise typer.BadParameter(f"Invalid uncertainty format: {p}")
             key, value = p.split("=", 1)
-            try:
-                new_value = json.loads(value)
-            except json.JSONDecodeError:
-                new_value = value
+            new_value = _parse_cli_value(value)
             old_value = target_solution.parameter_uncertainties.get(key)
             if old_value != new_value:
                 changes.append(f"Update uncertainty {key}: {old_value} {arrow} {new_value}")
@@ -636,21 +675,35 @@ def edit_notes(
             notes_file.parent.mkdir(parents=True, exist_ok=True)
             if not notes_file.exists():
                 notes_file.write_text("", encoding="utf-8")
-            editor = os.environ.get("EDITOR", None)
-            if editor:
-                os.system(f'{editor} "{notes_file}"')
+            editor = os.environ.get("EDITOR") or os.environ.get("VISUAL")
+            if editor and _run_editor(editor, notes_file):
+                return
+            fallbacks = ["nano", "vi", "vim", "code"]
+            if os.name == "nt":
+                fallbacks = ["code", "notepad", "notepad.exe"]
+            for fallback in fallbacks:
+                if shutil.which(fallback):
+                    if _run_editor(fallback, notes_file):
+                        return
+            if os.name == "nt":
+                try:
+                    os.startfile(notes_file)  # type: ignore[attr-defined]
+                    return
+                except OSError:
+                    pass
+            elif sys.platform == "darwin":
+                if shutil.which("open"):
+                    subprocess.run(["open", "-W", str(notes_file)], check=False)
+                    return
             else:
-                # Try nano, then vi
-                for fallback in ["nano", "vi"]:
-                    if os.system(f"command -v {fallback} > /dev/null 2>&1") == 0:
-                        os.system(f'{fallback} "{notes_file}"')
-                        break
-                else:
-                    console.print(
-                        f"Could not find an editor to open {notes_file}",
-                        style="bold red",
-                    )
-                    raise typer.Exit(code=1)
+                if shutil.which("xdg-open"):
+                    subprocess.run(["xdg-open", str(notes_file)], check=False)
+                    return
+            console.print(
+                f"Could not find an editor to open {notes_file}",
+                style="bold red",
+            )
+            raise typer.Exit(code=1)
             return
     console.print(f"Solution {solution_id} not found", style="bold red")
     raise typer.Exit(code=1)

microlens_submit/cli/main.py

@@ -17,7 +17,7 @@ and scripted usage patterns.
 
 **Example Workflow:**
     # Initialize a new project
-    microlens-submit init --team-name "Team Alpha" --tier "advanced" ./my_project
+    microlens-submit init --team-name "Team Alpha" --tier "experienced" ./my_project
 
     # Add a solution
     microlens-submit add-solution EVENT001 1S1L ./my_project \
@@ -117,4 +117,5 @@ app.command("generate-dossier")(dossier.generate_dossier)
 app.command("export")(export.export)
 app.command("remove-event")(export.remove_event)
 app.command("set-repo-url")(export.set_repo_url)
+app.command("set-git-dir")(export.set_git_dir)
 app.command("set-hardware-info")(export.set_hardware_info)

microlens_submit/error_messages.py

@@ -76,7 +76,8 @@ def get_parameter_suggestions(model_type: str, user_param: str) -> List[str]:
     for canonical, typos in common_typos.items():
         for typo in typos:
             if user_param.lower() == typo.lower():
-                suggestions.append(f"Did you mean '{canonical}' instead of '{user_param}'?")
+                if user_param != canonical:
+                    suggestions.append(f"Did you mean '{canonical}' instead of '{user_param}'?")
     # Also suggest case sensitivity if relevant
     for canonical in common_typos.keys():
         if user_param.lower() == canonical.lower() and user_param != canonical:

microlens_submit/models/solution.py

@@ -188,6 +188,7 @@ class Solution(BaseModel):
         self,
         cpu_hours: Optional[float] = None,
         wall_time_hours: Optional[float] = None,
+        git_dir: Optional[str] = None,
     ) -> None:
         """Record compute metadata and capture environment details.
 
@@ -199,6 +200,7 @@ class Solution(BaseModel):
         Args:
             cpu_hours: Total CPU time consumed by the model fit in hours.
             wall_time_hours: Real-world time consumed by the fit in hours.
+            git_dir: Optional path to the code repository for git metadata capture.
 
         Example:
             >>> solution = event.add_solution("1S1L", {"t0": 2459123.5, "u0": 0.1})
@@ -240,23 +242,27 @@ class Solution(BaseModel):
 
         # Capture Git repository information
         try:
+            git_cwd = Path(git_dir).expanduser().resolve() if git_dir else None
             commit = subprocess.run(
                 ["git", "rev-parse", "HEAD"],
                 capture_output=True,
                 text=True,
                 check=True,
+                cwd=git_cwd,
             ).stdout.strip()
             branch = subprocess.run(
                 ["git", "rev-parse", "--abbrev-ref", "HEAD"],
                 capture_output=True,
                 text=True,
                 check=True,
+                cwd=git_cwd,
             ).stdout.strip()
             status = subprocess.run(
                 ["git", "status", "--porcelain"],
                 capture_output=True,
                 text=True,
                 check=True,
+                cwd=git_cwd,
             ).stdout.strip()
             self.compute_info["git_info"] = {
                 "commit": commit,

microlens_submit/models/submission.py

@@ -9,10 +9,12 @@ import json
 import logging
 import math
 import os
+import platform
 import zipfile
 from pathlib import Path
 from typing import Dict, List, Optional
 
+import psutil
 from pydantic import BaseModel, Field
 
 from ..text_symbols import symbol
@@ -31,10 +33,11 @@ class Submission(BaseModel):
     Attributes:
         project_path: Root directory where submission files are stored.
         team_name: Name of the participating team (required for validation).
-        tier: Challenge tier for the submission (e.g., "basic", "advanced") (required for validation).
+        tier: Challenge tier for the submission (e.g., "beginner", "experienced") (required for validation).
         hardware_info: Dictionary describing the compute platform (required for validation).
         events: Mapping of event IDs to :class:`Event` instances.
         repo_url: GitHub repository URL for the team codebase (required for validation).
+        git_dir: Optional path to the codebase (used for git metadata capture).
 
     Example:
         >>> from microlens_submit import load
@@ -44,7 +47,7 @@ class Submission(BaseModel):
         >>>
         >>> # Set submission metadata
         >>> submission.team_name = "Team Alpha"
-        >>> submission.tier = "advanced"
+        >>> submission.tier = "experienced"
         >>> submission.repo_url = "https://github.com/team/microlens-submit"
         >>>
         >>> # Add events and solutions
@@ -82,6 +85,7 @@ class Submission(BaseModel):
     hardware_info: Optional[dict] = None
     events: Dict[str, Event] = Field(default_factory=dict)
     repo_url: Optional[str] = None
+    git_dir: Optional[str] = None
 
     def run_validation_warnings(self) -> List[str]:
         """Validate the submission and return warnings only (non-blocking issues).
@@ -233,12 +237,23 @@ class Submission(BaseModel):
     def autofill_nexus_info(self) -> None:
         if self.hardware_info is None:
             self.hardware_info = {}
+        try:
+            self.hardware_info.setdefault("platform", platform.platform())
+            self.hardware_info.setdefault("os", platform.system())
+        except Exception as exc:
+            logging.debug("Failed to read platform info: %s", exc)
         try:
             image = os.environ.get("JUPYTER_IMAGE_SPEC")
             if image:
                 self.hardware_info["nexus_image"] = image
         except Exception as exc:
             logging.debug("Failed to read JUPYTER_IMAGE_SPEC: %s", exc)
+        try:
+            server_name = os.environ.get("JUPYTERHUB_SERVER_NAME")
+            if server_name:
+                self.hardware_info["server_name"] = server_name
+        except Exception as exc:
+            logging.debug("Failed to read JUPYTERHUB_SERVER_NAME: %s", exc)
         try:
             with open("/proc/cpuinfo", "r", encoding="utf-8") as fh:
                 for line in fh:
@@ -256,6 +271,22 @@ class Submission(BaseModel):
                         break
         except OSError as exc:
             logging.debug("Failed to read /proc/meminfo: %s", exc)
+        try:
+            if "memory_gb" not in self.hardware_info:
+                mem_bytes = psutil.virtual_memory().total
+                self.hardware_info["memory_gb"] = round(mem_bytes / 1024**3, 2)
+        except Exception as exc:
+            logging.debug("Failed to read memory via psutil: %s", exc)
+        try:
+            if "cpu_details" not in self.hardware_info:
+                cpu = platform.processor() or platform.machine()
+                freq = psutil.cpu_freq()
+                if freq and cpu:
+                    self.hardware_info["cpu_details"] = f"{cpu} ({freq.max:.0f} MHz max)"
+                elif cpu:
+                    self.hardware_info["cpu_details"] = cpu
+        except Exception as exc:
+            logging.debug("Failed to read CPU via psutil: %s", exc)
 
     def _get_alias_lookup_path(self) -> Path:
         return Path(self.project_path) / "aliases.json"

microlens_submit/text_symbols.py

@@ -9,6 +9,8 @@ otherwise falls back to a readable ASCII alternative.
 
 from __future__ import annotations
 
+import locale
+import os
 import sys
 from typing import Dict, Tuple
 
@@ -70,6 +72,25 @@ def symbol(name: str) -> str:
         fallback.
     """
     unicode_char, fallback = _SYMBOL_MAP.get(name, ("", ""))
-    if unicode_char and _can_encode(unicode_char):
+
+    if not unicode_char:
+        return fallback
+
+    # On Windows runners the locale is frequently a legacy code page (e.g. cp1252)
+    # even when rich/click report UTF-8.  Prefer ASCII fallbacks unless we can
+    # confidently detect a UTF-capable encoding.
+    if os.name == "nt":
+        candidate_encodings = [
+            os.environ.get("PYTHONIOENCODING"),
+            getattr(sys.stdout, "encoding", None),
+            getattr(sys.stderr, "encoding", None),
+            getattr(sys.__stdout__, "encoding", None),
+            getattr(sys.__stderr__, "encoding", None),
+            locale.getpreferredencoding(False),
+        ]
+        if not any(enc and "utf" in enc.lower() for enc in candidate_encodings if enc):
+            return fallback or unicode_char
+
+    if _can_encode(unicode_char):
         return unicode_char
     return fallback or unicode_char

microlens_submit/tier_validation.py

@@ -11,9 +11,8 @@ The module defines:
 - Tier-specific validation logic
 
 **Supported Tiers:**
-- basic: Basic challenge tier with limited event set
-- standard: Standard challenge tier with full event set
-- advanced: Advanced challenge tier with all events
+- beginner: Beginner challenge tier with limited event set
+- experienced: Experienced challenge tier with full event set
 - test: Testing tier for development
 - 2018-test: 2018 test events tier
 - None: No validation tier (skips event validation)
@@ -22,11 +21,11 @@ Example:
     >>> from microlens_submit.tier_validation import validate_event_id, TIER_DEFINITIONS
     >>>
     >>> # Check if an event is valid for a tier
-    >>> is_valid = validate_event_id("EVENT001", "standard")
+    >>> is_valid = validate_event_id("EVENT001", "beginner")
     >>> if is_valid:
-    ...     print("Event is valid for standard tier")
-    >>> else:
-    ...     print("Event is not valid for standard tier")
+    ...     print("Event is valid for beginner tier")
+    ... else:
+    ...     print("Event is not valid for beginner tier")
 
     >>> # Get available tiers
     >>> print("Available tiers:", list(TIER_DEFINITIONS.keys()))
@@ -40,19 +39,22 @@ from typing import Dict, List, Optional, Set
 
 # Tier definitions with their associated event lists
 TIER_DEFINITIONS = {
-    "standard": {
-        "description": "Standard challenge tier with limited event set",
-        "event_list": [
-            # Add standard tier events here
-            "EVENT001",
-            "EVENT002",
-            "EVENT003",
-        ],
+    "beginner": {
+        "description": "Beginner challenge tier with limited event set",
+        "event_prefix": "rmdc26_",
+        "event_range": [0, 200],
     },
-    "advanced": {
-        "description": "Advanced challenge tier with full event set",
+    "experienced": {
+        "description": "Experienced challenge tier with full event set",
+        "event_prefix": "rmdc26_",
+        "event_range": [0, 2000],
+    },
+    "test": {
+        "description": "Testing tier for development",
         "event_list": [
-            # Add advanced tier events here
+            # Add test events here
+            "evt",
+            "test-event",
             "EVENT001",
             "EVENT002",
             "EVENT003",
@@ -62,16 +64,10 @@ TIER_DEFINITIONS = {
             "EVENT007",
         ],
     },
-    "test": {
-        "description": "Testing tier for development",
-        "event_list": [
-            # Add test events here
-            "evt",
-            "test-event",
-        ],
-    },
     "2018-test": {
         "description": "2018 test events tier",
+        "event_prefix": "ulwdc1_",
+        "event_range": [0, 293],
         "event_list": [
             # Add 2018 test events here
             "2018-EVENT-001",
@@ -101,8 +97,8 @@ def get_tier_event_list(tier: str) -> Set[str]:
         ValueError: If the tier is not defined.
 
     Example:
-        >>> events = get_tier_event_list("standard")
-        >>> print(f"Standard tier has {len(events)} events")
+        >>> events = get_tier_event_list("beginner")
+        >>> print(f"Beginner tier has {len(events)} events")
         >>> print("EVENT001" in events)
     """
     if tier not in TIER_DEFINITIONS:
@@ -110,7 +106,17 @@ def get_tier_event_list(tier: str) -> Set[str]:
 
     # Use cache for performance
     if tier not in _EVENT_LIST_CACHE:
-        _EVENT_LIST_CACHE[tier] = set(TIER_DEFINITIONS[tier]["event_list"])
+        event_list = list(TIER_DEFINITIONS[tier].get("event_list", []))
+        if "event_prefix" in TIER_DEFINITIONS[tier] and "event_range" in TIER_DEFINITIONS[tier]:
+            event_prefix = str(TIER_DEFINITIONS[tier]["event_prefix"])
+            event_range = tuple(TIER_DEFINITIONS[tier]["event_range"])
+            for i in range(event_range[0], event_range[1] + 1):
+                if tier == "2018-test":
+                    event_list.append(f"{event_prefix}{i:03d}")
+                else:
+                    event_list.append(f"{event_prefix}{i:04d}")
+
+        _EVENT_LIST_CACHE[tier] = set(event_list)
 
     return _EVENT_LIST_CACHE[tier]
 
@@ -126,11 +132,11 @@ def validate_event_id(event_id: str, tier: str) -> bool:
         bool: True if the event ID is valid for the tier, False otherwise.
 
     Example:
-        >>> is_valid = validate_event_id("EVENT001", "standard")
+        >>> is_valid = validate_event_id("EVENT001", "beginner")
         >>> if is_valid:
-        ...     print("Event is valid for standard tier")
+        ...     print("Event is valid for beginner tier")
         >>> else:
-        ...     print("Event is not valid for standard tier")
+        ...     print("Event is not valid for beginner tier")
     """
     # Skip validation for "None" tier or if tier is not defined
     if tier == "None" or tier not in TIER_DEFINITIONS:
@@ -151,7 +157,7 @@ def get_event_validation_error(event_id: str, tier: str) -> Optional[str]:
         Optional[str]: Error message if the event is invalid, None if valid.
 
     Example:
-        >>> error = get_event_validation_error("INVALID_EVENT", "standard")
+        >>> error = get_event_validation_error("INVALID_EVENT", "beginner")
         >>> if error:
         ...     print(f"Validation error: {error}")
         >>> else:
@@ -199,8 +205,8 @@ def get_tier_description(tier: str) -> str:
         ValueError: If the tier is not defined.
 
     Example:
-        >>> desc = get_tier_description("standard")
-        >>> print(f"Standard tier: {desc}")
+        >>> desc = get_tier_description("beginner")
+        >>> print(f"Beginner tier: {desc}")
     """
     if tier not in TIER_DEFINITIONS:
         raise ValueError(f"Unknown tier: {tier}. Available tiers: {list(TIER_DEFINITIONS.keys())}")

microlens_submit/utils.py

@@ -36,7 +36,7 @@ def load(project_path: str) -> Submission:
         >>>
         >>> # Set submission metadata
         >>> submission.team_name = "Team Alpha"
-        >>> submission.tier = "advanced"
+        >>> submission.tier = "experienced"
         >>> submission.repo_url = "https://github.com/team/repo"
         >>>
         >>> # Add an event and solution
@@ -191,6 +191,11 @@ def import_solutions_from_csv(
         )
 
         for row_num, row in enumerate(reader, start=header_row + 2):
+            row_has_data = any((key and str(key).strip()) for key in row.keys()) or any(
+                (value is not None and str(value).strip()) for value in row.values()
+            )
+            if not row_has_data:
+                continue
             stats["total_rows"] += 1
 
             try:
@@ -255,6 +260,8 @@ def import_solutions_from_csv(
                 # Parse parameters
                 parameters = {}
                 for key, value in row.items():
+                    if key is None:
+                        continue
                     if key not in [
                         "event_id",
                         "solution_id",

microlens_submit/validate_parameters.py

@@ -57,6 +57,7 @@ Note:
     custom parameters and future model types.
 """
 
+import re
 from typing import Any, Dict, List, Optional
 
 MODEL_DEFINITIONS = {
@@ -95,6 +96,27 @@ MODEL_DEFINITIONS = {
     # },
 }
 
+_FLUX_PARAM_RE = re.compile(r"^F(?P<band>\\d+)_S(?:[12])?$|^F(?P<band_b>\\d+)_B$")
+
+
+def _find_flux_params(parameters: Dict[str, Any]) -> List[str]:
+    """Return a list of parameters that look like band-specific flux terms."""
+    return [param for param in parameters.keys() if isinstance(param, str) and _FLUX_PARAM_RE.match(param)]
+
+
+def _infer_bands_from_flux_params(flux_params: List[str]) -> List[str]:
+    """Infer band identifiers from flux parameter names."""
+    bands = set()
+    for param in flux_params:
+        match = _FLUX_PARAM_RE.match(param)
+        if not match:
+            continue
+        band = match.group("band") or match.group("band_b")
+        if band is not None:
+            bands.add(band)
+    return sorted(bands)
+
+
 HIGHER_ORDER_EFFECT_DEFINITIONS = {
     "parallax": {
         "description": "Microlens parallax effect",
@@ -504,6 +526,16 @@ def check_solution_completeness(
                 messages.append(f"Reference time (t_ref) required for effect '{effect}'")
 
     # Validate band-specific parameters
+    flux_params = _find_flux_params(parameters)
+    if flux_params and not bands:
+        inferred_bands = _infer_bands_from_flux_params(flux_params)
+        example_bands = inferred_bands or ["0"]
+        messages.append(
+            "Flux parameters were provided but bands is empty. "
+            "Set bands to match your flux terms (Python API: solution.bands = "
+            f"{example_bands!r})."
+        )
+
     if bands:
         required_flux_params = get_required_flux_params(model_type, bands)
         for param in required_flux_params:
@@ -530,6 +562,8 @@ def check_solution_completeness(
 
     # Check for invalid parameters
     invalid_params = set(parameters.keys()) - all_valid_params
+    if flux_params and not bands:
+        invalid_params -= set(flux_params)
     for param in invalid_params:
         messages.append(f"Warning: Parameter '{param}' not recognized for model type " f"'{model_type}'")
 
@@ -856,6 +890,16 @@ def validate_solution_rigorously(
             if not isinstance(band, str):
                 messages.append(f"band {i} must be a string, got {type(band).__name__}")
 
+    flux_params = _find_flux_params(parameters)
+    if flux_params and not bands:
+        inferred_bands = _infer_bands_from_flux_params(flux_params)
+        example_bands = inferred_bands or ["0"]
+        messages.append(
+            "Flux parameters were provided but bands is empty. "
+            "Set bands to match your flux terms (Python API: solution.bands = "
+            f"{example_bands!r})."
+        )
+
     # 3. Check if t_ref is provided when not needed
     t_ref_required = False
     for effect in higher_order_effects:
@@ -892,6 +936,8 @@ def validate_solution_rigorously(
     # 5. Check for invalid parameters (unless model_type or effects are "other")
     if model_type != "other" and "other" not in higher_order_effects:
         invalid_params = set(parameters.keys()) - valid_params
+        if flux_params and not bands:
+            invalid_params -= set(flux_params)
         for param in invalid_params:
             messages.append(f"Invalid parameter '{param}' for model type '{model_type}'")
 

{microlens_submit-0.16.2.dist-info → microlens_submit-0.16.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: microlens-submit
-Version: 0.16.2
+Version: 0.16.4
 Summary: A tool for managing and submitting microlensing solutions
 Home-page: https://github.com/AmberLee2427/microlens-submit
 Author: Amber Malpas
@@ -29,6 +29,7 @@ Requires-Dist: typer[all]>=0.9.0
 Requires-Dist: rich>=13.0.0
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: markdown>=3.4.0
+Requires-Dist: psutil>=5.9.0
 Requires-Dist: importlib_resources>=1.0.0; python_version < "3.9"
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
@@ -97,15 +98,19 @@ You can pass ``--no-color`` to any command if your terminal does not support ANS
 1. Initialize your project:
 
    ```bash
-   microlens-submit init --team-name "Planet Pounders" --tier "advanced"
-   # if a project directory was provided to `init`, you should now `cd` into that project
+   microlens-submit init --team-name "Planet Pounders" --tier "experienced" ./my_submission
+   cd ./my_submission
    ```
 
-   To pass validation, you need to have provided a `repo_url` and `hardware_info` to the project and have a git project initialized in your sumission-project directory.
+   If you prefer to initialize inside an existing folder, run `microlens-submit init` without a path after `cd` into it.
+
+   To pass validation, you need to have provided a `repo_url` and `hardware_info` to the project and have a git project initialized in your sumission-project directory. On Roman Nexus, you can use `microlens-submit nexus-init` to auto-populate hardware info.
 
    ```bash
    microlens-submit set-repo-url <url> ./
    microlens-submit set-hardware-info --cpu-details "intel i7 xxx" --ram-gb 32 ./
+   # if your git repo lives elsewhere:
+   microlens-submit set-git-dir /path/to/repo ./
    ```
 2. Add a new solution to an event:
 
@@ -152,7 +157,7 @@ import microlens_submit
 # Load or create the project
 sub = microlens_submit.load(project_path="./my_challenge_submission")
 sub.team_name = "Planet Pounders"
-sub.tier = "advanced"
+sub.tier = "experienced"
 
 # Get an event and add a solution
 evt = sub.get_event("ogle-2025-blg-0042")
@@ -201,15 +206,15 @@ import this file directly.
 
 Bibtex:
 ```
-@software{malpas_2025_17460500,
+@software{malpas_2025_18246117,
   author       = {Malpas, Amber},
   title        = {microlens-submit},
   month        = oct,
   year         = 2025,
   publisher    = {Zenodo},
-  version      = {v0.16.1},
-  doi          = {10.5281/zenodo.17460500},
-  url          = {https://doi.org/10.5281/zenodo.17460500},
+  version      = {v0.16.3},
+  doi          = {10.5281/zenodo.18246117},
+  url          = {https://doi.org/10.5281/zenodo.18246117},
 }
 ```
 
@@ -217,4 +222,4 @@ Cite without version:
 Malpas, A. (2025). microlens-submit. Zenodo. https://doi.org/10.5281/zenodo.17459752
 
 Cite current version:
-Malpas, A. (2025). microlens-submit (v0.16.1). Zenodo. https://doi.org/10.5281/zenodo.17459753
+Malpas, A. (2025). microlens-submit (v0.16.3). Zenodo. https://doi.org/10.5281/zenodo.17468488

{microlens_submit-0.16.2.dist-info → microlens_submit-0.16.4.dist-info}/RECORD

@@ -1,19 +1,19 @@
-microlens_submit/__init__.py,sha256=mzs6GxiZgbo6__Z6nlHA5s3la80O0rDPBZMvLyJdNfs,399
-microlens_submit/error_messages.py,sha256=x_x0ZE-y7XSxbqmX4G6xR2EjVOAsldLILGalmJZtLO8,10363
-microlens_submit/text_symbols.py,sha256=D5u1MIj_37n6p6mn3zzUY6T6DDliq_gxsJGzOrgl1C0,2370
-microlens_submit/tier_validation.py,sha256=mbE9MjXRHbsPBB12aD2lyYUdvXiBacweRG2OTWgP7Fs,6168
-microlens_submit/utils.py,sha256=3kEinJXr5OWHjrQUGHhUFA6L2rNdqaLy2ogmQNx_TfY,14358
-microlens_submit/validate_parameters.py,sha256=_RBzdbY2sFwtNNd5f69bwxTpHjlNq_np3iDYvio4Oow,37645
+microlens_submit/__init__.py,sha256=UdGr8NQ2klUr7cLPboLkHX6qRsn_rTwVfv3LrJ6Z8FE,399
+microlens_submit/error_messages.py,sha256=8Wzx1NQiAF7hUOjlt-uGhtPC7akknv_PDkokoxhWquk,10411
+microlens_submit/text_symbols.py,sha256=PbQSkqF_FwTBs45TkUL0zZl74IYDz7L4xVxy8eKxQsU,3146
+microlens_submit/tier_validation.py,sha256=FbVHQwItqQnrCeKhkQSgQmMT6dgreTGOptRRYf-AYVE,6649
+microlens_submit/utils.py,sha256=0VwCgFOAD4xoNpvY-k15axrb667cXaspzuKrZCGLJ-w,14676
+microlens_submit/validate_parameters.py,sha256=lCbLTeCzjZQG00zqZ5yBfDs1PcAzqxuDoJsAQ8W-aFw,39394
 microlens_submit/assets/github-desktop_logo.png,sha256=pb4rallKrYQPHt6eC0TmJe_UyyMtf1IrP8_OWK19nH8,479821
 microlens_submit/assets/rges-pit_logo.png,sha256=45AJypXCymvt3lMeK7MHt1SBhwPpnKCMj6S000Cejtc,537645
 microlens_submit/cli/__init__.py,sha256=u4ZgVOzUe_gf89FBhY61XWjcfK4oxXCStabYTjBuRRo,82
 microlens_submit/cli/__main__.py,sha256=_7x5Hd_9ehQwYHphd3iPB3LMVvKAVmxz-e0E4pWi0lk,112
-microlens_submit/cli/main.py,sha256=iJ2bkQZ-OiuCUCVqs_EGbhpa240zB7agrYNZj6p5_3g,3938
+microlens_submit/cli/main.py,sha256=6Q_pxnMFOHDo8iPWefgFqOPkG3-GPGntv6j40hy9kb0,3988
 microlens_submit/cli/commands/__init__.py,sha256=rzIgY7T2Bz4Lhzts_RiWeoBbMoCuxODxeoktnUhH4rw,49
 microlens_submit/cli/commands/dossier.py,sha256=6gRJNzUgr29YmYJRcUj9aoiRhjb1r9Uy4dip6z2LaHI,5100
-microlens_submit/cli/commands/export.py,sha256=umtziho0Rv7IRhcVU5NnuUajdaa0SgatZbRmBw8OJ8o,6751
-microlens_submit/cli/commands/init.py,sha256=sarZXDLcWO5JgXbgb5RwllV0JrMMjS3t3geq9RmhVlE,7275
-microlens_submit/cli/commands/solutions.py,sha256=26G6gMLvxFJJYMhswgTSR_iF1xDR7e_9P-_MesV9Jco,30350
+microlens_submit/cli/commands/export.py,sha256=ojG2KkOcl90eA0tse6hqy74fHc-YX0o0alzAAbpzJew,8513
+microlens_submit/cli/commands/init.py,sha256=tpO8YlWZLJmo4PuqQTKHXzvniIyWl7WXxUOURp_yfn4,7425
+microlens_submit/cli/commands/solutions.py,sha256=GvbAiiTaCaqcDRHOAReaMY-gDLlahRpYvpnKc2Rajs0,32146
 microlens_submit/cli/commands/validation.py,sha256=1M8mYSNopsA30u3S-yFBd3iJZxsDoNa0vhwo9brJ1VQ,9028
 microlens_submit/dossier/__init__.py,sha256=INAacbrY0Wi5ueH8c7b156bGzelyUFcynbE7_YRiku0,1948
 microlens_submit/dossier/dashboard.py,sha256=4OvTUCxIC4LbAqKwimIFhi65fNo5MMJswiQ5OWtyWFA,19907
@@ -23,11 +23,11 @@ microlens_submit/dossier/solution_page.py,sha256=qp2JaDamHD__3bwOzZ3CRj2UUSCiOf9
 microlens_submit/dossier/utils.py,sha256=LopBbVg6nzQasL1lnaI63y3bpmqYqBeDEwfB_NqEeCA,3845
 microlens_submit/models/__init__.py,sha256=1sHFjAWyFtGgQBRSo8lBYiPzToo4tIoHP3uBjtgJSPY,861
 microlens_submit/models/event.py,sha256=ifQqE7d7PJTTI9lGylwWV3EGxgyyNGiJtHbm_DLmuys,17105
-microlens_submit/models/solution.py,sha256=0prKFYM3oxKXZjtzhaAaS7E5cYP2maxfbYNQhkL-IY0,23339
-microlens_submit/models/submission.py,sha256=54ssVomKh8W_nYBeuRAPexko0d_4FwcWKEl9q5Vu1as,26458
-microlens_submit-0.16.2.dist-info/licenses/LICENSE,sha256=cy1qkVR-kGxD6FXVsparmU2vHJXYeoyAAHv6SgT67sw,1069
-microlens_submit-0.16.2.dist-info/METADATA,sha256=cDpL7N5ODSsPVmWG9oODe__hYy1zNaLWcsGJCkEYt64,10084
-microlens_submit-0.16.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-microlens_submit-0.16.2.dist-info/entry_points.txt,sha256=kA85yhxYrpQnUvVZCRS2giz52gaf1ZOfZFjY4RHIZ2s,62
-microlens_submit-0.16.2.dist-info/top_level.txt,sha256=uJ9_bADYRySlhEpP-8vTm90ZLV2SrKEzutAaRx8WF0k,17
-microlens_submit-0.16.2.dist-info/RECORD,,
+microlens_submit/models/solution.py,sha256=ollTpKv8zMSEqIL2Q9gXJTbaX0fWZt6rg76edBmYOWQ,23629
+microlens_submit/models/submission.py,sha256=f_ewUFhXghnh-pn077bkfBg_6jVbcN_jRhy2wVdKUgk,27941
+microlens_submit-0.16.4.dist-info/licenses/LICENSE,sha256=cy1qkVR-kGxD6FXVsparmU2vHJXYeoyAAHv6SgT67sw,1069
+microlens_submit-0.16.4.dist-info/METADATA,sha256=cs2ufm5y99az4OLvMvDN_Y7982LhJKFolxVU9zRO-Ig,10367
+microlens_submit-0.16.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+microlens_submit-0.16.4.dist-info/entry_points.txt,sha256=kA85yhxYrpQnUvVZCRS2giz52gaf1ZOfZFjY4RHIZ2s,62
+microlens_submit-0.16.4.dist-info/top_level.txt,sha256=uJ9_bADYRySlhEpP-8vTm90ZLV2SrKEzutAaRx8WF0k,17
+microlens_submit-0.16.4.dist-info/RECORD,,