wavesimpro 0.9.0__tar.gz → 0.9.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wavesimpro
-Version: 0.9.0
+Version: 0.9.2
 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.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "wavesimpro"
-version = "0.9.0"
+version = "0.9.2"
 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.2}/src/wavesimpro/__init__.py

@@ -30,7 +30,7 @@ from .binary_utils import (
 )
 from .validate import validate_parameters, ParameterValidationError
 from .execute import execute_via_api
-from .simulate import simulate, configure
+from .simulate import simulate, simulate_pro, configure
 from .json_helper import (
     create_simulation_domain,
     create_stl_primitive,
@@ -49,7 +49,7 @@ from .json_helper import (
     parse_progress_data,
 )
 
-__version__ = "0.9.0"
+__version__ = "0.9.2"
 __all__ = [
     # Client
     "RayfosClient",

{wavesimpro-0.9.0 → wavesimpro-0.9.2}/src/wavesimpro/client.py

@@ -896,6 +896,7 @@ class RayfosClient:
         version_id: str,
         engine_preference: str = 'Any',
         use_gpu: Optional[bool] = None,
+        preferred_machine_id: Optional[str] = None,
     ) -> Dict[str, Any]:
         """
         Create a simulation command for a project version.
@@ -927,7 +928,7 @@ class RayfosClient:
         if self.config.machine_service_url:
             return self._create_command_machine_service(project_id, version_id)
         else:
-            return self._create_command_cloud(project_id, version_id, engine_preference, use_gpu)
+            return self._create_command_cloud(project_id, version_id, engine_preference, use_gpu, preferred_machine_id)
     
     def _create_command_machine_service(
         self,
@@ -956,6 +957,7 @@ class RayfosClient:
         version_id: str,
         engine_preference: str = 'Any',
         use_gpu: Optional[bool] = None,
+        preferred_machine_id: Optional[str] = None,
     ) -> Dict[str, Any]:
         """Create command via RayfosJobServer (cloud mode)"""
         data: Dict[str, Any] = {}
@@ -963,6 +965,8 @@ class RayfosClient:
             data['enginePreference'] = engine_preference
         if use_gpu is not None:
             data['useGpu'] = use_gpu
+        if preferred_machine_id:
+            data['preferredMachineServiceId'] = preferred_machine_id
         return self._post(f"/api/projects/{project_id}/versions/{version_id}/command", json=data)
     
     # ========================================================================

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

@@ -63,6 +63,9 @@ def execute_via_api(
     progress_callback: Optional[Callable[[Dict[str, Any]], None]] = None,
     engine_preference: str = "Any",
     use_gpu: Optional[bool] = None,
+    preferred_machine_id: Optional[str] = None,
+    alpha: float = 0.75,
+    keep_residuals_list: bool = False,
 ) -> Tuple[np.ndarray, bool]:
     """
     Execute a Wavesim simulation via the Rayfos REST API.
@@ -123,8 +126,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 +145,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
@@ -303,6 +314,8 @@ def execute_via_api(
         periodic_x=bool(periodic[0]),
         periodic_y=bool(periodic[1]),
         periodic_z=bool(periodic[2]),
+        alpha=float(alpha),
+        keep_residuals_list=bool(keep_residuals_list),
     )
 
     logger.info(f"  Payload created with {len(sources_info)} source(s)")
@@ -313,7 +326,7 @@ def execute_via_api(
 
     # 12. Submit command
     logger.info("Submitting simulation command...")
-    cmd_status = client.create_command(project_id, version_id, engine_preference, use_gpu)
+    cmd_status = client.create_command(project_id, version_id, engine_preference, use_gpu, preferred_machine_id)
     command_id = cmd_status.get("commandId") or cmd_status.get("id")
     if not command_id:
         raise RuntimeError("No command ID found in response")
@@ -321,11 +334,32 @@ 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}")
+    if preferred_machine_id:
+        print(f"  Machine   : {preferred_machine_id}")
+    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 +379,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 +443,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 +519,15 @@ def execute_via_api(
         dims = (nx, ny, nz)
 
     E = read_binary_field(output_data, dims, "Complex64")
+
+    # Squeeze all trailing size-1 spatial dimensions to match local wavesim.simulate() output.
+    # Local always squeezes: [nx,1,1]→(nx,), [3,nx,1,1]→[3,nx], etc.
+    while E.ndim > 1 and 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.2}/src/wavesimpro/json_helper.py

@@ -640,7 +640,9 @@ def create_wavesim_properties(
     residual_norm_max_iterations: int = 10000,
     periodic_x: bool = False,
     periodic_y: bool = False,
-    periodic_z: bool = False
+    periodic_z: bool = False,
+    alpha: float = 0.75,
+    keep_residuals_list: bool = False,
 ) -> Dict[str, Any]:
     """
     Create complete WavesimProperties structure
@@ -688,6 +690,8 @@ def create_wavesim_properties(
         "PeriodicX": periodic_x,
         "PeriodicY": periodic_y,
         "PeriodicZ": periodic_z,
+        "Alpha": alpha,
+        "KeepResidualsList": keep_residuals_list,
         "DefaultLengthUnit": "Micrometers",
         "CoordinateSystemCenter": {
             "X": {"Value": 0.0, "Unit": "Micrometers"},
@@ -699,33 +703,36 @@ def create_wavesim_properties(
 
 def parse_progress_data(progress_obj: Optional[Dict[str, Any]]) -> Dict[str, Any]:
     """
-    Parse CommandProgressDto with nested JSON strings.
-
-    Args:
-        progress_obj: CommandProgressDto dict from get_command_status()
+    Parse the progress 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"]
+
+    # Full residuals list (ProgressSnapshot.ResidualsList from machine service)
+    residuals_list = norm.get("residualslist") or norm.get("residuals_list")
+    if residuals_list and isinstance(residuals_list, list):
+        info["residuals_list"] = residuals_list
 
+    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,23 +740,43 @@ 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:
+            # Intermediate C++ format: "C++ iteration 400, residual: 1.23E-04"
+            m = re.search(r'iteration\s+(\d+)', progress_str, re.IGNORECASE)
+            if m:
+                info["iteration"] = int(m.group(1))
+            m = re.search(r'residual[:\s]+([\d.E+\-]+)', progress_str, re.IGNORECASE)
+            if m:
+                info["residual_norm"] = float(m.group(1))
+
+            # Final completion summary: "Last Iteration : 200 / 10000"
+            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:
                 info["threshold"] = data_obj["residual_norm_threshold"]
+            rlist = data_obj.get("ResidualsList") or data_obj.get("residuals_list")
+            if rlist and isinstance(rlist, list):
+                info["residuals_list"] = rlist
         except (json.JSONDecodeError, TypeError, ValueError):
             pass
 
+    # Derive percentage if not already set but iteration + max_iterations are known
+    if "percentage" not in info and info.get("iteration") and info.get("max_iterations"):
+        info["percentage"] = 100.0 * info["iteration"] / info["max_iterations"]
+
     return info

{wavesimpro-0.9.0 → wavesimpro-0.9.2}/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.2/src/wavesimpro/simulate.py

@@ -0,0 +1,286 @@
+"""
+Remote simulate — drop-in replacement for wavesim.simulate() that executes via the Rayfos API.
+
+To switch an example from local to remote, change only the import:
+    from wavesim.simulate import simulate       # local GPU
+    from wavesimPro_api import simulate         # Rayfos cloud
+
+Credentials are resolved automatically — run the setup wizard once on each machine:
+    python -m wavesimPro_api setup
+
+Call configure() to override programmatically.
+"""
+
+import inspect
+from pathlib import Path
+from typing import Callable, Optional, Sequence
+
+import numpy as np
+
+from .execute import execute_via_api
+
+
+def _caller_script_name() -> str:
+    for frame_info in inspect.stack():
+        path = frame_info.filename
+        if "wavesimpro" not in path and path not in ("<stdin>", "<string>"):
+            return Path(path).stem
+    return "wavesimpro"
+
+# Module-level defaults — overridden by configure() or per-call kwargs
+_defaults = {
+    "api_key": None,
+    "api_url": None,
+    "description": None,
+    "poll_interval": 10.0,
+    "engine_preference": "Any",
+    "use_gpu": None,
+}
+
+
+def configure(
+    *,
+    api_key: Optional[str] = None,
+    api_url: Optional[str] = None,
+    description: Optional[str] = None,
+    poll_interval: Optional[float] = None,
+    engine_preference: Optional[str] = None,
+    use_gpu: Optional[bool] = None,
+):
+    """Set module-level defaults for remote execution.
+
+    Call once at the top of a script to avoid repeating credentials on every
+    simulate() call.  Any value left as None keeps its current default.
+
+    Args:
+        api_key: Rayfos API key (overrides RAYFOS_API_KEY env var).
+        api_url: Rayfos API base URL (overrides RAYFOS_API_URL env var).
+        description: Job label shown in the Rayfos dashboard.
+        poll_interval: Status polling interval in seconds.
+        engine_preference: 'Any' (default), 'Python', or 'Cpp'.
+        use_gpu: None (auto), True (require GPU), False (force CPU).
+    """
+    if api_key is not None:
+        _defaults["api_key"] = api_key
+    if api_url is not None:
+        _defaults["api_url"] = api_url
+    if description is not None:
+        _defaults["description"] = description
+    if poll_interval is not None:
+        _defaults["poll_interval"] = poll_interval
+    if engine_preference is not None:
+        _defaults["engine_preference"] = engine_preference
+    if use_gpu is not None:
+        _defaults["use_gpu"] = use_gpu
+
+
+def simulate(
+    permittivity: np.ndarray,
+    sources: Sequence[tuple],
+    wavelength: float,
+    pixel_size: float,
+    boundary_width: float = 1.0,
+    periodic: tuple = (False, False, False),  # forwarded to PeriodicX/Y/Z in JSON
+    use_gpu=None,                              # forwarded to API (None = auto)
+    n_domains=None,          # local only — accepted and ignored
+    max_iterations: int = 100000,
+    threshold: float = 1.0e-6,
+    alpha: float = 0.75,
+    full_residuals: bool = False,
+    crop_boundaries: bool = True,  # local only — accepted and ignored
+    callback: Optional[Callable] = None,
+    **kwargs,
+):
+    """Execute a Wavesim simulation remotely via the Rayfos API.
+
+    Identical signature to wavesim.simulate() — swap the import, nothing else changes.
+    Local-only parameters (periodic, n_domains, alpha, full_residuals, crop_boundaries)
+    are silently ignored.
+
+    Credentials are resolved in this order:
+        1. configure() call
+        2. Local .env in the current working directory
+        3. ~/.wavesimPro_api/.env (written by: python -m wavesimPro_api setup)
+        4. RAYFOS_API_KEY / RAYFOS_API_URL environment variables
+
+    Returns:
+        u: np.ndarray, output field (same shape as wavesim.simulate()).
+        iterations: int or None, last reported iteration count.
+        residual_norm: float or None, last reported residual norm.
+    """
+    from .setup import resolve_credentials
+    _api_key, _api_url = resolve_credentials()
+    api_key = _defaults["api_key"] or _api_key
+    api_url = _defaults["api_url"] or _api_url
+    if not api_key:
+        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"] or _caller_script_name()
+    poll_interval = _defaults["poll_interval"]
+    engine_preference = _defaults["engine_preference"]
+    effective_use_gpu = use_gpu if use_gpu is not None else _defaults["use_gpu"]
+
+    is_vectorial = any(len(s[1]) == 4 for s in sources)
+    boundary_width_px = int(np.round(boundary_width / pixel_size))
+
+    api_sources = []
+    for src_array, src_pos in sources:
+        pos = list(src_pos)
+        if is_vectorial:
+            pol_1based = int(pos[0]) + 1
+            api_pos = [pos[1] * pixel_size, pos[2] * pixel_size, pos[3] * pixel_size, pol_1based]
+            src_field = (src_array[0] if src_array.ndim == 4 else src_array).astype(np.complex64)
+        else:
+            api_pos = [pos[0] * pixel_size, pos[1] * pixel_size, pos[2] * pixel_size]
+            src_field = src_array.astype(np.complex64)
+        api_sources.append({"Es": src_field, "position": api_pos})
+
+    _last = {"iteration": None, "residual_norm": None, "residuals_list": None}
+
+    def _progress_cb(info: dict):
+        _last["iteration"] = info.get("iteration", _last["iteration"])
+        _last["residual_norm"] = info.get("residual_norm", _last["residual_norm"])
+        if info.get("residuals_list") is not None:
+            _last["residuals_list"] = info["residuals_list"]
+        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")}
+            callback(None, _last["iteration"], None, _last["residual_norm"], **extra)
+
+    E, _ = execute_via_api(
+        refractive_index=permittivity,
+        source=api_sources,
+        wavelength=wavelength,
+        pixel_size=pixel_size,
+        boundary_width=boundary_width_px,
+        is_vectorial=is_vectorial,
+        data_type="Permittivity",
+        max_iterations=max_iterations,
+        threshold=threshold,
+        periodic=periodic,
+        api_key=api_key,
+        api_url=api_url,
+        description=description,
+        poll_interval=poll_interval,
+        engine_preference=engine_preference,
+        use_gpu=effective_use_gpu,
+        alpha=alpha,
+        keep_residuals_list=full_residuals,
+        progress_callback=_progress_cb,
+    )
+
+    iterations = _last["iteration"] or 1
+    final_residual = _last["residual_norm"] if _last["residual_norm"] is not None else float("nan")
+    if full_residuals:
+        residual_norm = _last["residuals_list"] if _last["residuals_list"] else [final_residual] * iterations
+    else:
+        residual_norm = final_residual
+    return E, iterations, residual_norm
+
+
+def simulate_pro(
+    permittivity: np.ndarray,
+    sources: Sequence[tuple],
+    wavelength: float,
+    pixel_size: float,
+    boundary_width: float = 1.0,
+    periodic: tuple = (False, False, False),
+    max_iterations: int = 100000,
+    threshold: float = 1.0e-6,
+    alpha: float = 0.75,
+    n_domains=None,
+    full_residuals: bool = False,
+    crop_boundaries: bool = True,  # local only — accepted and ignored
+    callback: Optional[Callable] = None,
+    # remote execution options
+    engine: str = "Any",
+    use_gpu: Optional[bool] = None,
+    machine_id: Optional[str] = None,
+    poll_interval: float = 10.0,
+    description: Optional[str] = None,
+    server: Optional[str] = None,
+    **kwargs,
+):
+    """Execute a Wavesim simulation remotely with full control over execution options.
+
+    Drop-in compatible with wavesim.simulate() but exposes all remote-specific options
+    that simulate() manages via configure():
+
+        engine       : 'Any' (default) | 'Cpp' | 'Python'
+        use_gpu      : None (auto) | True (require GPU) | False (force CPU)
+        machine_id   : preferred machine service ID to pin the job to a specific machine
+        poll_interval: seconds between status polls (default 10)
+        description  : job label shown in the Rayfos dashboard (default: caller script name)
+    """
+    from .setup import resolve_credentials
+    _api_key, _api_url = resolve_credentials()
+    api_key = _defaults["api_key"] or _api_key
+    api_url = server or _defaults["api_url"] or _api_url
+    if not api_key:
+        raise SystemExit(
+            "\nwavesimpro: no API key configured.\n"
+            "Run the setup wizard once to get started:\n\n"
+            "    python -m wavesimpro setup\n"
+        )
+
+    effective_description = description or _defaults["description"] or _caller_script_name()
+    effective_use_gpu = use_gpu if use_gpu is not None else _defaults["use_gpu"]
+
+    is_vectorial = any(len(s[1]) == 4 for s in sources)
+    boundary_width_px = int(np.round(boundary_width / pixel_size))
+
+    api_sources = []
+    for src_array, src_pos in sources:
+        pos = list(src_pos)
+        if is_vectorial:
+            pol_1based = int(pos[0]) + 1
+            api_pos = [pos[1] * pixel_size, pos[2] * pixel_size, pos[3] * pixel_size, pol_1based]
+            src_field = (src_array[0] if src_array.ndim == 4 else src_array).astype(np.complex64)
+        else:
+            api_pos = [pos[0] * pixel_size, pos[1] * pixel_size, pos[2] * pixel_size]
+            src_field = src_array.astype(np.complex64)
+        api_sources.append({"Es": src_field, "position": api_pos})
+
+    _last = {"iteration": None, "residual_norm": None, "residuals_list": None}
+
+    def _progress_cb(info: dict):
+        _last["iteration"] = info.get("iteration", _last["iteration"])
+        _last["residual_norm"] = info.get("residual_norm", _last["residual_norm"])
+        if info.get("residuals_list") is not None:
+            _last["residuals_list"] = info["residuals_list"]
+        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")}
+            callback(None, _last["iteration"], None, _last["residual_norm"], **extra)
+
+    E, _ = execute_via_api(
+        refractive_index=permittivity,
+        source=api_sources,
+        wavelength=wavelength,
+        pixel_size=pixel_size,
+        boundary_width=boundary_width_px,
+        is_vectorial=is_vectorial,
+        data_type="Permittivity",
+        max_iterations=max_iterations,
+        threshold=threshold,
+        periodic=periodic,
+        api_key=api_key,
+        api_url=api_url,
+        description=effective_description,
+        poll_interval=poll_interval,
+        engine_preference=engine,
+        use_gpu=effective_use_gpu,
+        preferred_machine_id=machine_id,
+        alpha=alpha,
+        keep_residuals_list=full_residuals,
+        progress_callback=_progress_cb,
+    )
+
+    iterations = _last["iteration"] or 1
+    final_residual = _last["residual_norm"] if _last["residual_norm"] is not None else float("nan")
+    if full_residuals:
+        residual_norm = _last["residuals_list"] if _last["residuals_list"] else [final_residual] * iterations
+    else:
+        residual_norm = final_residual
+    return E, iterations, residual_norm

{wavesimpro-0.9.0 → wavesimpro-0.9.2}/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.2}/src/wavesimpro.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wavesimpro
-Version: 0.9.0
+Version: 0.9.2
 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/src/wavesimpro/simulate.py

@@ -1,162 +0,0 @@
-"""
-Remote simulate — drop-in replacement for wavesim.simulate() that executes via the Rayfos API.
-
-To switch an example from local to remote, change only the import:
-    from wavesim.simulate import simulate       # local GPU
-    from wavesimPro_api import simulate         # Rayfos cloud
-
-Credentials are resolved automatically — run the setup wizard once on each machine:
-    python -m wavesimPro_api setup
-
-Call configure() to override programmatically.
-"""
-
-from typing import Callable, Optional, Sequence
-
-import numpy as np
-
-from .execute import execute_via_api
-
-# Module-level defaults — overridden by configure() or per-call kwargs
-_defaults = {
-    "api_key": None,
-    "api_url": None,
-    "description": "Wavesim Python API",
-    "poll_interval": 10.0,
-    "engine_preference": "Any",
-    "use_gpu": None,
-}
-
-
-def configure(
-    *,
-    api_key: Optional[str] = None,
-    api_url: Optional[str] = None,
-    description: Optional[str] = None,
-    poll_interval: Optional[float] = None,
-    engine_preference: Optional[str] = None,
-    use_gpu: Optional[bool] = None,
-):
-    """Set module-level defaults for remote execution.
-
-    Call once at the top of a script to avoid repeating credentials on every
-    simulate() call.  Any value left as None keeps its current default.
-
-    Args:
-        api_key: Rayfos API key (overrides RAYFOS_API_KEY env var).
-        api_url: Rayfos API base URL (overrides RAYFOS_API_URL env var).
-        description: Job label shown in the Rayfos dashboard.
-        poll_interval: Status polling interval in seconds.
-        engine_preference: 'Any' (default), 'Python', or 'Cpp'.
-        use_gpu: None (auto), True (require GPU), False (force CPU).
-    """
-    if api_key is not None:
-        _defaults["api_key"] = api_key
-    if api_url is not None:
-        _defaults["api_url"] = api_url
-    if description is not None:
-        _defaults["description"] = description
-    if poll_interval is not None:
-        _defaults["poll_interval"] = poll_interval
-    if engine_preference is not None:
-        _defaults["engine_preference"] = engine_preference
-    if use_gpu is not None:
-        _defaults["use_gpu"] = use_gpu
-
-
-def simulate(
-    permittivity: np.ndarray,
-    sources: Sequence[tuple],
-    wavelength: float,
-    pixel_size: float,
-    boundary_width: float = 1.0,
-    periodic: tuple = (False, False, False),  # forwarded to PeriodicX/Y/Z in JSON
-    use_gpu=None,                              # forwarded to API (None = auto)
-    n_domains=None,          # local only — accepted and ignored
-    max_iterations: int = 100000,
-    threshold: float = 1.0e-6,
-    alpha: float = 0.75,     # local only — accepted and ignored
-    full_residuals: bool = False,  # local only — accepted and ignored
-    crop_boundaries: bool = True,  # local only — accepted and ignored
-    callback: Optional[Callable] = None,
-    **kwargs,
-):
-    """Execute a Wavesim simulation remotely via the Rayfos API.
-
-    Identical signature to wavesim.simulate() — swap the import, nothing else changes.
-    Local-only parameters (periodic, n_domains, alpha, full_residuals, crop_boundaries)
-    are silently ignored.
-
-    Credentials are resolved in this order:
-        1. configure() call
-        2. Local .env in the current working directory
-        3. ~/.wavesimPro_api/.env (written by: python -m wavesimPro_api setup)
-        4. RAYFOS_API_KEY / RAYFOS_API_URL environment variables
-
-    Returns:
-        u: np.ndarray, output field (same shape as wavesim.simulate()).
-        iterations: int or None, last reported iteration count.
-        residual_norm: float or None, last reported residual norm.
-    """
-    from .setup import resolve_credentials
-    _api_key, _api_url = resolve_credentials()
-    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."
-        )
-    description = _defaults["description"]
-    poll_interval = _defaults["poll_interval"]
-    engine_preference = _defaults["engine_preference"]
-    effective_use_gpu = use_gpu if use_gpu is not None else _defaults["use_gpu"]
-
-    is_vectorial = any(len(s[1]) == 4 for s in sources)
-    boundary_width_px = int(np.round(boundary_width / pixel_size))
-
-    api_sources = []
-    for src_array, src_pos in sources:
-        pos = list(src_pos)
-        if is_vectorial:
-            pol_1based = int(pos[0]) + 1
-            api_pos = [pos[1] * pixel_size, pos[2] * pixel_size, pos[3] * pixel_size, pol_1based]
-            src_field = (src_array[0] if src_array.ndim == 4 else src_array).astype(np.complex64)
-        else:
-            api_pos = [pos[0] * pixel_size, pos[1] * pixel_size, pos[2] * pixel_size]
-            src_field = src_array.astype(np.complex64)
-        api_sources.append({"Es": src_field, "position": api_pos})
-
-    _last = {"iteration": None, "residual_norm": None}
-
-    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:
-            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(
-        refractive_index=permittivity,
-        source=api_sources,
-        wavelength=wavelength,
-        pixel_size=pixel_size,
-        boundary_width=boundary_width_px,
-        is_vectorial=is_vectorial,
-        data_type="Permittivity",
-        max_iterations=max_iterations,
-        threshold=threshold,
-        periodic=periodic,
-        api_key=api_key,
-        api_url=api_url,
-        description=description,
-        poll_interval=poll_interval,
-        engine_preference=engine_preference,
-        use_gpu=effective_use_gpu,
-        progress_callback=_progress_cb,
-    )
-
-    return E, _last["iteration"], _last["residual_norm"]