wavesimpro 0.9.0__tar.gz → 0.9.1__tar.gz

{wavesimpro-0.9.0 → wavesimpro-0.9.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wavesimpro
-Version: 0.9.0
+Version: 0.9.1
 Summary: WavesimPro Python API — cloud execution client for the Rayfos simulation platform
 Author: Rayfos
 Project-URL: Repository, https://github.com/rayfos/wavesimpro

{wavesimpro-0.9.0 → wavesimpro-0.9.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "wavesimpro"
-version = "0.9.0"
+version = "0.9.1"
 description = "WavesimPro Python API — cloud execution client for the Rayfos simulation platform"
 readme = "README.md"
 requires-python = ">=3.8"

{wavesimpro-0.9.0 → wavesimpro-0.9.1}/src/wavesimpro/execute.py

@@ -123,8 +123,13 @@ def execute_via_api(
     logger.info(f"  API URL: {api_url}")
     logger.info(f"  Engine: {engine_preference}  GPU: {'auto' if use_gpu is None else ('GPU' if use_gpu else 'CPU')}")
 
-    # 2. Extract domain info
-    nx, ny, nz = refractive_index.shape[:3]
+    # 2. Extract domain info — pad to 3D for 1D/2D inputs
+    _input_ndim = refractive_index.ndim
+    _ri_shape = refractive_index.shape
+    while len(_ri_shape) < 3:
+        _ri_shape = _ri_shape + (1,)
+    refractive_index = refractive_index.reshape(_ri_shape)
+    nx, ny, nz = _ri_shape[0], _ri_shape[1], _ri_shape[2]
 
     logger.info(f"  Domain: [{nx}, {ny}, {nz}]")
     logger.info(f"  Wavelength: {wavelength:.3f} um")
@@ -137,7 +142,10 @@ def execute_via_api(
     if data_type == "RefractiveIndex":
         background_ri = float(np.min(np.real(refractive_index)))
     else:
-        background_ri = float(np.sqrt(np.min(np.real(refractive_index))))
+        eps_real = np.real(refractive_index)
+        positive_eps = eps_real[eps_real > 0]
+        min_positive_eps = float(np.min(positive_eps)) if positive_eps.size > 0 else 1.0
+        background_ri = float(np.sqrt(min_positive_eps))
     em_data = refractive_index
 
     # 4. Prepare sources
@@ -321,11 +329,30 @@ def execute_via_api(
 
     # 13. Poll for completion
     logger.info("Waiting for simulation to complete...")
+    _mode = "Maxwell (vectorial)" if is_vectorial else "Helmholtz (scalar)"
+    _engine = engine_preference if engine_preference and engine_preference != "Any" else "Any (auto-select)"
+    _gpu = "auto" if use_gpu is None else ("GPU" if use_gpu else "CPU")
+    _domain_str = f"{nx}×{ny}×{nz} voxels"
+    print(f"\n  {'─'*54}")
+    print(f"  Rayfos remote simulation")
+    print(f"  {'─'*54}")
+    print(f"  Project   : {project_id}")
+    print(f"  Version   : {version_id}")
+    print(f"  Command   : {command_id}")
+    print(f"  Mode      : {_mode}")
+    print(f"  Domain    : {_domain_str}  λ={wavelength} µm  Δx={pixel_size} µm")
+    print(f"  Engine    : {_engine}  |  GPU: {_gpu}")
+    print(f"  Threshold : {threshold:.1e}  max iter: {max_iterations}")
+    print(f"  {'─'*54}")
     start_time = time.time()
     consecutive_errors = 0
     max_consecutive_errors = 3
     final_status = None
 
+    # C# enum: 7=Cancelled, 9=Running, 10=Completed, 11=Failed, 12=FailedRemovedFromMachine
+    _TERMINAL_INT = {7, 8, 10, 11, 12}
+    _TERMINAL_STR = {"Completed", "Failed", "Cancelled", "Deleted", "FailedRemovedFromMachine"}
+
     while True:
         try:
             status = client.get_command_status(command_id)
@@ -345,28 +372,63 @@ def execute_via_api(
             continue
 
         elapsed = time.time() - start_time
-        status_str = status.get("status", "Unknown")
 
-        # Parse progress if available
-        progress_dto = status.get("progressDto")
+        # Resolve status string — API may return 'status' (str) or 'commandStatus' (int)
+        raw_status = status.get("status") or status.get("Status")
+        cmd_status_int = status.get("commandStatus") or status.get("CommandStatus")
+        if raw_status:
+            status_str = raw_status
+        elif cmd_status_int is not None:
+            status_str = RayfosClient._parse_command_status(cmd_status_int)
+        else:
+            status_str = "Unknown"
+
+        # Find progress dto — try multiple field names
+        progress_dto = (
+            status.get("progress")
+            or status.get("Progress")
+            or status.get("progressDto")
+            or status.get("CommandProgress")
+        )
+
         if progress_dto:
             progress_info = parse_progress_data(progress_dto)
             if progress_callback:
                 progress_callback(progress_info)
-
-            residual = progress_info.get("residual_norm")
-            iteration = progress_info.get("iteration")
-            if residual is not None:
-                logger.info(f"  [{elapsed:.0f}s] {status_str} (residual: {residual:.2e}, iter: {iteration})")
-            elif iteration is not None:
-                max_iter = progress_info.get("max_iterations", "?")
-                logger.info(f"  [{elapsed:.0f}s] {status_str} (iter {iteration}/{max_iter})")
-            else:
-                logger.info(f"  [{elapsed:.0f}s] {status_str}")
         else:
-            logger.info(f"  [{elapsed:.0f}s] {status_str}")
-
-        if status_str in ("Completed", "Failed", "Cancelled"):
+            progress_info = {}
+
+        # Top-level CommandStatusDto fields
+        pct = progress_info.get("percentage") or status.get("progressValue") or status.get("ProgressValue")
+        status_text = status.get("statusText") or status.get("StatusText")
+        machine_id = status.get("preferredMachineServiceId") or status.get("PreferredMachineServiceId")
+
+        residual = progress_info.get("residual_norm")
+        iteration = progress_info.get("iteration")
+        max_iter = progress_info.get("max_iterations")
+
+        details = []
+        if pct is not None and float(pct) > 0:
+            details.append(f"{float(pct):.0f}%")
+        if iteration is not None:
+            details.append(f"iter {iteration}" + (f"/{max_iter}" if max_iter else ""))
+        if residual is not None:
+            details.append(f"residual {residual:.2e}")
+        if machine_id:
+            details.append(f"machine {machine_id}")
+        if status_text and status_text.strip() and status_text.strip().lower() != status_str.lower():
+            details.append(status_text.strip())
+
+        detail_str = ", ".join(details)
+        msg = f"  [{elapsed:.0f}s] {status_str}" + (f" — {detail_str}" if detail_str else "")
+        logger.info(msg)
+        print(msg)
+
+        is_terminal = (
+            status_str in _TERMINAL_STR
+            or (cmd_status_int is not None and cmd_status_int in _TERMINAL_INT)
+        )
+        if is_terminal:
             final_status = status
             break
 
@@ -374,9 +436,9 @@ def execute_via_api(
 
     total_time = time.time() - start_time
 
-    if final_status.get("status") != "Completed":
+    if status_str != "Completed":
         # Build detailed error message
-        error_parts = [f"Simulation ended with status: {final_status.get('status')}"]
+        error_parts = [f"Simulation ended with status: {status_str}"]
         for field in ("errorMessage", "ErrorMessage", "statusText", "StatusText"):
             val = final_status.get(field)
             if val:
@@ -450,9 +512,15 @@ def execute_via_api(
         dims = (nx, ny, nz)
 
     E = read_binary_field(output_data, dims, "Complex64")
+
+    # Squeeze trailing size-1 spatial dimensions added for 1D/2D inputs
+    for _ in range(3 - _input_ndim):
+        if E.shape[-1] == 1:
+            E = E[..., 0]
+
     logger.info(f"  Output shape: {E.shape}")
 
-    converged = final_status.get("status") == "Completed"
+    converged = status_str == "Completed"
 
     logger.info("=" * 60)
     logger.info("Simulation completed successfully!")

{wavesimpro-0.9.0 → wavesimpro-0.9.1}/src/wavesimpro/json_helper.py

@@ -699,33 +699,31 @@ def create_wavesim_properties(
 
 def parse_progress_data(progress_obj: Optional[Dict[str, Any]]) -> Dict[str, Any]:
     """
-    Parse CommandProgressDto with nested JSON strings.
+    Parse the progress dict from get_command_status().
 
-    Args:
-        progress_obj: CommandProgressDto dict from get_command_status()
-
-    Returns:
-        Dict with parsed progress fields: status, iteration, percentage,
-        max_iterations, residual_norm, threshold
+    Handles both JSON-structured progress and the human-readable text format
+    the server embeds in the final Completed status, e.g.:
+        Last Iteration : 200 / 10000
+        Final Residual : 9.406141E-008
     """
+    import re
+
     info: Dict[str, Any] = {}
 
     if not progress_obj:
         return info
 
-    if "status" in progress_obj:
-        info["status"] = progress_obj["status"]
+    # Normalise keys to lowercase so we handle both 'Status'/'status', 'Progress'/'progress', etc.
+    norm = {k.lower(): v for k, v in progress_obj.items()}
 
-    # Parse Progress JSON string
-    progress_str = progress_obj.get("progress")
-    if progress_str:
-        try:
-            if isinstance(progress_str, str):
-                import json as _json
-                progress_data = _json.loads(progress_str)
-            else:
-                progress_data = progress_str
+    if "status" in norm:
+        info["status"] = norm["status"]
 
+    progress_str = norm.get("progress")
+    if progress_str and isinstance(progress_str, str):
+        # Try JSON first
+        try:
+            progress_data = json.loads(progress_str)
             if "iteration" in progress_data:
                 info["iteration"] = progress_data["iteration"]
             if "percentage" in progress_data:
@@ -733,18 +731,23 @@ def parse_progress_data(progress_obj: Optional[Dict[str, Any]]) -> Dict[str, Any
             if "max_iterations" in progress_data:
                 info["max_iterations"] = progress_data["max_iterations"]
         except (json.JSONDecodeError, TypeError, ValueError):
-            pass
-
-    # Parse Data JSON string
-    data_str = progress_obj.get("data")
-    if data_str:
+            # Parse human-readable summary text
+            m = re.search(r'Last Iteration\s*:\s*(\d+)\s*/\s*(\d+)', progress_str)
+            if m:
+                info["iteration"] = int(m.group(1))
+                info["max_iterations"] = int(m.group(2))
+            m = re.search(r'Final Residual\s*:\s*([\d.E+\-]+)', progress_str, re.IGNORECASE)
+            if m:
+                info["residual_norm"] = float(m.group(1))
+            m = re.search(r'Time/iter\s*:\s*([\d.]+)\s*ms', progress_str)
+            if m:
+                info["time_per_iter_ms"] = float(m.group(1))
+
+    # Parse data field if present (JSON dict or string)
+    data_val = norm.get("data")
+    if data_val:
         try:
-            if isinstance(data_str, str):
-                import json as _json
-                data_obj = _json.loads(data_str)
-            else:
-                data_obj = data_str
-
+            data_obj = json.loads(data_val) if isinstance(data_val, str) else data_val
             if "residual_norm" in data_obj:
                 info["residual_norm"] = data_obj["residual_norm"]
             if "residual_norm_threshold" in data_obj:

{wavesimpro-0.9.0 → wavesimpro-0.9.1}/src/wavesimpro/setup.py

@@ -1,11 +1,11 @@
 """
-Setup wizard and credential management for wavesimPro_api.
+Setup wizard and credential management for wavesimpro.
 
-Global config lives at ~/.wavesimPro_api/.env and is written by run_setup().
+Global config lives at ~/.wavesimpro/.env and is written by run_setup().
 Credential resolution order:
     1. configure() call
     2. Local .env in the current working directory
-    3. ~/.wavesimPro_api/.env  (global, written by this wizard)
+    3. ~/.wavesimpro/.env  (global, written by this wizard)
     4. RAYFOS_API_KEY / RAYFOS_API_URL environment variables
 """
 
@@ -14,7 +14,7 @@ import os
 from pathlib import Path
 
 DEFAULT_API_URL = "https://server.rayfos.com"
-GLOBAL_CONFIG_DIR = Path.home() / ".wavesimPro_api"
+GLOBAL_CONFIG_DIR = Path.home() / ".wavesimpro"
 GLOBAL_CONFIG_FILE = GLOBAL_CONFIG_DIR / ".env"
 
 
@@ -41,7 +41,7 @@ def save_global_config(api_key: str, api_url: str):
 
 def resolve_credentials() -> tuple[str | None, str]:
     """Return (api_key, api_url) from the first source that has them."""
-    from . import _defaults  # module-level configure() values
+    from .simulate import _defaults
 
     api_key = _defaults.get("api_key")
     api_url = _defaults.get("api_url")
@@ -88,7 +88,7 @@ def _test_connection(api_key: str, api_url: str) -> bool:
 
 def run_setup():
     print()
-    print("wavesimPro_api — setup wizard")
+    print("wavesimpro — setup wizard")
     print("=" * 40)
 
     existing = load_global_config()
@@ -107,10 +107,12 @@ def run_setup():
             return
 
     print()
-    api_key = getpass.getpass("API key (input hidden): ").strip()
+    api_key = input("API key: ").strip()
     if not api_key:
         print("No API key entered. Aborting.")
         return
+    masked_preview = api_key[:6] + "*" * max(0, len(api_key) - 6)
+    print(f"  Got: {masked_preview}")
 
     url_prompt = f"Server URL [{DEFAULT_API_URL}]: "
     api_url = input(url_prompt).strip() or DEFAULT_API_URL
@@ -126,27 +128,26 @@ def run_setup():
     save_global_config(api_key, api_url)
     print()
     print(f"Config saved to: {GLOBAL_CONFIG_FILE}")
-    print("You're all set. Import wavesimPro_api in any project without extra setup.")
+    print("You're all set. Import wavesimpro in any project without extra setup.")
     print()
 
 
 def run_status():
     print()
-    print("wavesimPro_api — current configuration")
+    print("wavesimpro — current configuration")
     print("=" * 40)
 
     api_key, api_url = resolve_credentials()
 
     if not api_key:
         print("No credentials found.")
-        print(f"Run: python -m wavesimPro_api setup")
+        print("Run: python -m wavesimpro setup")
         return
 
     masked = api_key[:6] + "..." + api_key[-4:] if len(api_key) > 10 else "***"
     print(f"API key : {masked}")
     print(f"Server  : {api_url}")
 
-    # Show source
     cfg = load_global_config()
     if cfg.get("RAYFOS_API_KEY") == api_key:
         print(f"Source  : {GLOBAL_CONFIG_FILE}")

{wavesimpro-0.9.0 → wavesimpro-0.9.1}/src/wavesimpro/simulate.py

@@ -103,10 +103,10 @@ def simulate(
     api_key = _defaults["api_key"] or _api_key
     api_url = _defaults["api_url"] or _api_url
     if not api_key:
-        raise RuntimeError(
-            "No API key found. Run the setup wizard once:\n"
-            "    python -m wavesimPro_api setup\n"
-            "Or set RAYFOS_API_KEY in your environment / .env file."
+        raise SystemExit(
+            "\nwavesimpro: no API key configured.\n"
+            "Run the setup wizard once to get started:\n\n"
+            "    python -m wavesimpro setup\n"
         )
     description = _defaults["description"]
     poll_interval = _defaults["poll_interval"]
@@ -133,10 +133,8 @@ def simulate(
     def _progress_cb(info: dict):
         _last["iteration"] = info.get("iteration", _last["iteration"])
         _last["residual_norm"] = info.get("residual_norm", _last["residual_norm"])
-        if callback is not None:
+        if callback is not None and _last["iteration"] is not None:
             extra = {k: v for k, v in info.items() if k not in ("iteration", "residual_norm")}
-            # Mirror the Richardson callback signature so existing callbacks work unchanged:
-            # callback(domain, iteration, x, residual_norm, **kwargs)
             callback(None, _last["iteration"], None, _last["residual_norm"], **extra)
 
     E, _ = execute_via_api(
@@ -159,4 +157,7 @@ def simulate(
         progress_callback=_progress_cb,
     )
 
-    return E, _last["iteration"], _last["residual_norm"]
+    iterations = _last["iteration"] or 1
+    final_residual = _last["residual_norm"] if _last["residual_norm"] is not None else float("nan")
+    residual_norm = [final_residual] * iterations if full_residuals else final_residual
+    return E, iterations, residual_norm

{wavesimpro-0.9.0 → wavesimpro-0.9.1}/src/wavesimpro/validate.py

@@ -68,8 +68,10 @@ def validate_parameters(
             shape = shape + (1,)
         nx, ny, nz = shape[0], shape[1], shape[2]
 
-        if nx < 2 or ny < 2 or nz < 2:
-            errors.append(f"Domain too small: [{nx}, {ny}, {nz}]. Minimum is [2, 2, 2]")
+        # Allow size-1 in any dimension (collapsed 2D/1D), but non-singleton dims must be >= 2
+        _small = [d for d in (nx, ny, nz) if d != 1 and d < 2]
+        if _small or all(d == 1 for d in (nx, ny, nz)):
+            errors.append(f"Domain too small: [{nx}, {ny}, {nz}]. Non-singleton dimensions must be >= 2")
 
         if np.any(np.isnan(refractive_index)):
             errors.append("Refractive index contains NaN values")
@@ -151,8 +153,8 @@ def validate_parameters(
                     exceeded.append(f"{dim_names[i]} ({dims[i]}->{max_allowed})")
             if exceeded:
                 warnings.append(
-                    f"Boundary width ({boundary_width} pixels) exceeds maximum for "
-                    f"dimension(s): {', '.join(exceeded)}. Backend will clamp boundary width per dimension."
+                    f"Boundary width ({boundary_width} pixels) is large relative to domain size "
+                    f"in dimension(s): {', '.join(exceeded)}. Results may differ from local execution."
                 )
 
     # 7. Validate GPU memory requirements

{wavesimpro-0.9.0 → wavesimpro-0.9.1}/src/wavesimpro.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wavesimpro
-Version: 0.9.0
+Version: 0.9.1
 Summary: WavesimPro Python API — cloud execution client for the Rayfos simulation platform
 Author: Rayfos
 Project-URL: Repository, https://github.com/rayfos/wavesimpro