wavesimpro 1.10.0__tar.gz → 1.10.2__tar.gz

{wavesimpro-1.10.0 → wavesimpro-1.10.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wavesimpro
-Version: 1.10.0
+Version: 1.10.2
 Summary: WavesimPro Python API — cloud execution client for the Rayfos simulation platform
 Author: Rayfos
 Project-URL: Repository, https://github.com/rayfos/wavesimpro
@@ -67,7 +67,8 @@ field = wp.read_binary_field(run.download("output.bin"))
   `create_stl_primitive`, `create_gds_primitive` (with `create_gds_layer_config` /
   `create_gds_structure_override`), `create_voxels_model_primitive`.
 - Per-primitive sub-pixel flag (`subpixel=True/False` on every shape, STL and GDSII helper)
-  to choose which shapes get smoothed interfaces.
+  to choose which shapes get smoothed interfaces. Off by default: a setup with no averaged
+  shape is voxelised exactly as before 1.10 and runs on every compute node.
 - Per-axis pixel sizes (`pixel_size=[dx, dy, dz]`) and sub-pixel permittivity averaging
   (`subpixel_factor=`), when the compute node supports them.
 - Preflight memory check and cost estimate before a run.

{wavesimpro-1.10.0 → wavesimpro-1.10.2}/README.md

@@ -44,7 +44,8 @@ field = wp.read_binary_field(run.download("output.bin"))
   `create_stl_primitive`, `create_gds_primitive` (with `create_gds_layer_config` /
   `create_gds_structure_override`), `create_voxels_model_primitive`.
 - Per-primitive sub-pixel flag (`subpixel=True/False` on every shape, STL and GDSII helper)
-  to choose which shapes get smoothed interfaces.
+  to choose which shapes get smoothed interfaces. Off by default: a setup with no averaged
+  shape is voxelised exactly as before 1.10 and runs on every compute node.
 - Per-axis pixel sizes (`pixel_size=[dx, dy, dz]`) and sub-pixel permittivity averaging
   (`subpixel_factor=`), when the compute node supports them.
 - Preflight memory check and cost estimate before a run.

{wavesimpro-1.10.0 → wavesimpro-1.10.2}/pyproject.toml

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

{wavesimpro-1.10.0 → wavesimpro-1.10.2}/src/wavesimpro/__init__.py

@@ -6,7 +6,7 @@ supporting both cloud and local deployment modes, as well as direct interaction
 with RayfosMachineService via its REST API.
 """
 
-from .client import RayfosClient
+from .client import RayfosClient, command_status_name, is_terminal_command_status
 from .config import ClientConfig
 from .exceptions import (
     RayfosAPIError,
@@ -54,10 +54,12 @@ from .json_helper import (
     parse_progress_data,
 )
 
-__version__ = "1.10.0"
+__version__ = "1.10.2"
 __all__ = [
     # Client
     "RayfosClient",
+    "command_status_name",
+    "is_terminal_command_status",
     "ClientConfig",
     # Exceptions
     "RayfosAPIError",

{wavesimpro-1.10.0 → wavesimpro-1.10.2}/src/wavesimpro/client.py

@@ -77,6 +77,49 @@ def _make_progress_callback(total_bytes: int, desc: str):
 logger = logging.getLogger(__name__)
 
 
+
+# CommandStatus enum (C# RayfosCommandModels) by value; the server sends the NAME in "status"
+# (JsonStringEnumConverter). Older servers sent the integer in "commandStatus".
+_COMMAND_STATUS_BY_INT = {
+    0: 'New', 1: 'Assigned', 2: 'SentToMachine', 3: 'SendToMachineForceCancellation',
+    4: 'SendToMachineForceDeleteTask', 5: 'RequestedForceCancellationInMachine',
+    6: 'RequestedForceStopTaskInMachine', 7: 'Cancelled', 8: 'Deleted', 9: 'Running',
+    10: 'Completed', 11: 'Failed', 12: 'FailedRemovedFromMachine',
+}
+_TERMINAL_STATUSES = {'Cancelled', 'Deleted', 'Completed', 'Failed', 'FailedRemovedFromMachine'}
+
+
+def command_status_name(status: Dict[str, Any]) -> str:
+    """The command state name from a command-status dict, whatever the server version.
+
+    Reads ``status`` (current servers: the enum name, e.g. ``"Completed"``), falling back to the
+    legacy ``commandStatus`` / ``CommandStatus`` (integer or name). Returns ``"Unknown"`` when absent.
+    """
+    if not isinstance(status, dict):
+        return 'Unknown'
+    for key in ('status', 'Status', 'commandStatus', 'CommandStatus'):
+        raw = status.get(key)
+        if raw is None or raw == '':
+            continue
+        if isinstance(raw, bool):
+            continue
+        if isinstance(raw, int):
+            return _COMMAND_STATUS_BY_INT.get(raw, f'Unknown({raw})')
+        text = str(raw).strip()
+        if text.isdigit():
+            return _COMMAND_STATUS_BY_INT.get(int(text), f'Unknown({text})')
+        for name in _COMMAND_STATUS_BY_INT.values():
+            if name.lower() == text.lower():
+                return name
+        return text
+    return 'Unknown'
+
+
+def is_terminal_command_status(name: str) -> bool:
+    """True for Completed, Failed, FailedRemovedFromMachine, Cancelled and Deleted."""
+    return name in _TERMINAL_STATUSES
+
+
 class RayfosClient:
     """
     Client for interacting with RayfosJobServer API
@@ -740,9 +783,9 @@ class RayfosClient:
         
         Example:
             >>> version = client.get_project_version(project_id, version_id)
-            >>> if version.get('command') and version['command'].get('outputFiles'):
-            ...     for file in version['command']['outputFiles']:
-            ...         print(f"Output file: {file['originalFileName']}")
+            >>> for file_id in version.get('outputFileIds', []):
+            ...     info = client.get_file_info(project_id, version_id, file_id)
+            ...     print(f"Output file: {info.get('fileName')} ({info.get('fileSize')} bytes)")
         """
         return self._get(f"/api/projects/{project_id}/versions/{version_id}")
     
@@ -1287,7 +1330,7 @@ class RayfosClient:
         Returns:
             File metadata dictionary
         """
-        return self._get(f"/api/projects/{project_id}/versions/{version_id}/files/{file_id}")
+        return self._get(f"/api/projects/{project_id}/versions/{version_id}/files/{file_id}/metadata")
     
     # ========================================================================
     # COMMAND OPERATIONS
@@ -1382,7 +1425,8 @@ class RayfosClient:
                 Ignored when using a local machine service URL.
 
         Returns:
-            Command status dictionary with the created command ID and status
+            Command status dictionary. The command id is under ``"id"`` and, for convenience,
+            ``"commandId"``; the state is under ``"status"`` (read it with ``command_status_name``).
 
         Example:
             >>> command = client.create_command(project_id, version_id,
@@ -1390,9 +1434,17 @@ class RayfosClient:
             >>> print(f"Command created: {command['id']}")
         """
         if self.config.machine_service_url:
-            return self._create_command_machine_service(project_id, version_id)
+            result = self._create_command_machine_service(project_id, version_id)
         else:
-            return self._create_command_cloud(project_id, version_id, engine_preference, use_gpu, preferred_machine_id)
+            result = self._create_command_cloud(project_id, version_id, engine_preference, use_gpu, preferred_machine_id)
+        # The server names the command id "id"; other API calls and version records use "commandId".
+        # Return both so either spelling works.
+        if isinstance(result, dict):
+            cid = result.get('id') or result.get('commandId') or result.get('Id')
+            if cid:
+                result.setdefault('id', cid)
+                result.setdefault('commandId', cid)
+        return result
     
     def _create_command_machine_service(
         self,
@@ -1439,35 +1491,8 @@ class RayfosClient:
     
     @staticmethod
     def _parse_command_status(status_raw) -> str:
-        """
-        Parse commandStatus from C# enum (integer) to string name
-        
-        Args:
-            status_raw: Either integer enum value or string name
-        
-        Returns:
-            String name of the status
-        """
-        # CommandStatus enum from C# RayfosCommandModels
-        COMMAND_STATUS_MAP = {
-            0: 'New',
-            1: 'Assigned', 
-            2: 'SentToMachine',
-            3: 'SendToMachineForceCancellation',
-            4: 'SendToMachineForceDeleteTask',
-            5: 'RequestedForceCancellationInMachine',
-            6: 'RequestedForceStopTaskInMachine',
-            7: 'Cancelled',
-            8: 'Deleted',
-            9: 'Running',
-            10: 'Completed',
-            11: 'Failed',
-            12: 'FailedRemovedFromMachine'
-        }
-        
-        if isinstance(status_raw, int):
-            return COMMAND_STATUS_MAP.get(status_raw, f'Unknown({status_raw})')
-        return status_raw
+        """Command state name from an integer (legacy ``commandStatus``) or a name (current ``status``)."""
+        return command_status_name({"status": status_raw})
     
     @staticmethod
     def _parse_progress_data(progress_obj) -> Dict[str, Any]:
@@ -1542,16 +1567,16 @@ class RayfosClient:
             command_id: Command UUID
         
         Returns:
-            CommandStatusDto dictionary with status, progress, and output files
-            Note: commandStatus is returned as integer from C#, use _parse_command_status() to convert
-        
+            Command-status dict: ``id``, ``status`` (enum name such as ``"Running"`` or
+            ``"Completed"``), ``statusText``, ``progressValue``. Older servers sent
+            the state as the integer ``commandStatus``; :func:`command_status_name` reads either.
+
         Example:
             >>> status = client.get_command_status("command-uuid")
-            >>> status_name = client._parse_command_status(status['commandStatus'])
-            >>> print(f"Status: {status_name}")
-            >>> print(f"Progress: {status.get('progressValue', 0)}%")
-            >>> if status['commandStatus'] == 10:  # Completed
-            ...     print(f"Output files: {status.get('outputFileIds', [])}")
+            >>> name = command_status_name(status)          # "Running", "Completed", ...
+            >>> print(f"{name}: {status.get('statusText')} ({status.get('progressValue', 0)}%)")
+            >>> if name == "Completed":
+            ...     files = client.get_project_version(project_id, version_id)["outputFileIds"]
         """
         # Always call RayfosJobServer directly for command status (user endpoint)
         # Machine service is only for file operations, not command status
@@ -1561,113 +1586,73 @@ class RayfosClient:
         self,
         command_id: str,
         poll_interval: float = 2.0,
-        timeout: Optional[float] = None,
+        timeout: Optional[float] = 24 * 3600,
         progress_callback: Optional[callable] = None
     ) -> Dict[str, Any]:
         """
-        Wait for a command to complete (synchronous execution)
-        
-        This method polls the command status until it reaches a terminal state
-        (Completed, Failed, Cancelled). Useful for blocking until simulation finishes.
-        
+        Wait for a command to finish (synchronous execution).
+
+        Polls :meth:`get_command_status` until the command reaches a terminal state and returns the
+        final status dict on ``Completed``. The state is read with :func:`command_status_name`, which
+        understands both the current ``status`` field (enum name) and the legacy ``commandStatus``
+        integer, so this works against every server version.
+
         Args:
-            command_id: Command UUID to wait for
-            poll_interval: Seconds between status checks (default: 2.0)
-            timeout: Maximum seconds to wait before raising TimeoutError (default: None - no timeout)
-            progress_callback: Optional callback(status_dict) called on each status check
-        
+            command_id: Command UUID (``create_command(...)["id"]``, also available as ``["commandId"]``)
+            poll_interval: Seconds between status checks (default 2.0)
+            timeout: Maximum seconds to wait (default 24 h; ``None`` waits forever)
+            progress_callback: Optional ``callback(status_dict)`` called on each poll
+
         Returns:
-            Final CommandStatusDto dictionary when command completes
-        
+            Final command-status dict (``status == "Completed"``). To get the result files, list the
+            version's ``outputFileIds`` (``get_project_version(project_id, version_id)["outputFileIds"]``,
+            then ``download_file``); the ``outputFileIds`` field
+            of the status is not filled by current servers.
+
         Raises:
-            TimeoutError: If timeout is reached before completion
-            RayfosAPIError: If command fails or is cancelled
-        
+            TimeoutError: the command did not finish within ``timeout`` seconds
+            RayfosAPIError: the command failed, was cancelled or was deleted
+
         Example:
-            >>> # Create command
-            >>> command = client.create_command(project_id, version_id, args_json)
-            >>> 
-            >>> # Wait for completion with progress updates
-            >>> def show_progress(status):
-            ...     print(f"Progress: {status.get('progressValue', 0)}% - {status.get('statusText', 'Running')}")
-            >>> 
-            >>> final_status = client.wait_for_command_completion(
-            ...     command['id'],
-            ...     progress_callback=show_progress,
-            ...     timeout=3600  # 1 hour timeout
-            ... )
-            >>> print(f"Command completed! Output files: {final_status.get('outputFileIds', [])}")
+            >>> command = client.create_command(project_id, version_id)
+            >>> final = client.wait_for_command_completion(command["id"], timeout=3600,
+            ...     progress_callback=lambda s: print(command_status_name(s), s.get("statusText")))
         """
         import time
-        
-        # CommandStatus enum values from C# (serialized as integers)
-        # New=0, Assigned=1, SentToMachine=2, etc.
-        COMMAND_STATUS = {
-            0: 'New',
-            1: 'Assigned', 
-            2: 'SentToMachine',
-            3: 'SendToMachineForceCancellation',
-            4: 'SendToMachineForceDeleteTask',
-            5: 'RequestedForceCancellationInMachine',
-            6: 'RequestedForceStopTaskInMachine',
-            7: 'Cancelled',
-            8: 'Deleted',
-            9: 'Running',
-            10: 'Completed',
-            11: 'Failed',
-            12: 'FailedRemovedFromMachine'
-        }
-        
-        # Terminal states (by integer value and name)
-        TERMINAL_STATUS_INTS = {7, 8, 10, 11, 12}  # Cancelled, Deleted, Completed, Failed, FailedRemovedFromMachine
-        TERMINAL_STATUS_NAMES = {'Cancelled', 'Deleted', 'Completed', 'Failed', 'FailedRemovedFromMachine'}
-        
+
         start_time = time.time()
-        
         while True:
-            # Check timeout
-            if timeout and (time.time() - start_time) > timeout:
-                raise TimeoutError(f"Command {command_id} did not complete within {timeout} seconds")
-            
-            # Get current status
             status = self.get_command_status(command_id)
-            command_status_raw = status.get('commandStatus')
-            
-            # Handle both integer (from C# enum) and string formats
-            if isinstance(command_status_raw, int):
-                command_status = COMMAND_STATUS.get(command_status_raw, f'Unknown({command_status_raw})')
-                is_terminal = command_status_raw in TERMINAL_STATUS_INTS
-            else:
-                command_status = command_status_raw
-                is_terminal = command_status in TERMINAL_STATUS_NAMES
-            
-            # Call progress callback if provided
+            name = command_status_name(status)
+
             if progress_callback:
                 progress_callback(status)
-            
-            # Check if command reached terminal state
-            if is_terminal:
-                if command_status in ('Completed', 10):
+
+            if is_terminal_command_status(name):
+                if name == 'Completed':
                     return status
-                elif command_status in ('Failed', 'FailedRemovedFromMachine', 11, 12):
-                    error_msg = status.get('statusText', 'Command failed')
-                    raise RayfosAPIError(f"Command {command_id} failed: {error_msg}")
-                elif command_status in ('Cancelled', 7):
+                detail = status.get('statusText') or ''
+                if name in ('Failed', 'FailedRemovedFromMachine'):
+                    raise RayfosAPIError(f"Command {command_id} failed: {detail or name}")
+                if name == 'Cancelled':
                     raise RayfosAPIError(f"Command {command_id} was cancelled")
-                elif command_status in ('Deleted', 8):
-                    raise RayfosAPIError(f"Command {command_id} was deleted")
-            
-            # Wait before next poll
+                raise RayfosAPIError(f"Command {command_id} was deleted")
+
+            if timeout is not None and (time.time() - start_time) > timeout:
+                raise TimeoutError(f"Command {command_id} did not finish within {timeout:.0f} s (last status: {name})")
+
             time.sleep(poll_interval)
-    
+
     def create_command_and_wait(
         self,
         project_id: str,
         version_id: str,
         local_machine_service_id: Optional[str] = None,
         poll_interval: float = 2.0,
-        timeout: Optional[float] = None,
-        progress_callback: Optional[callable] = None
+        timeout: Optional[float] = 24 * 3600,
+        progress_callback: Optional[callable] = None,
+        engine_preference: str = 'Any',
+        use_gpu: Optional[bool] = None,
     ) -> Dict[str, Any]:
         """
         Create a command and wait for it to complete (synchronous execution)
@@ -1706,8 +1691,11 @@ class RayfosClient:
             ...     client.download_file(project_id, version_id, file_id, f"output/{file_id}")
         """
         # Create the command (async)
-        command_status = self.create_command(project_id, version_id, local_machine_service_id)
-        command_id = command_status.get('id')
+        # local_machine_service_id pins the run to that compute node (it used to be passed, by
+        # position, as the engine preference, which the server rejects).
+        command_status = self.create_command(project_id, version_id, engine_preference=engine_preference,
+                                             use_gpu=use_gpu, preferred_machine_id=local_machine_service_id)
+        command_id = command_status.get('id') or command_status.get('commandId')
         
         if not command_id:
             raise RayfosAPIError("Failed to create command: no command ID returned")
@@ -1898,46 +1886,7 @@ class RayfosClient:
         )
         return self._handle_response(response)
 
-    def parse_command_status(self, status_value: int) -> str:
-        """
-        Parse commandStatus from C# enum (integer) to string name
-        
-        Args:
-            status_value: Integer status code from CommandStatusDto
-        
-        Returns:
-            Human-readable status name
-        
-        CommandStatus enum values from C# RayfosCommandModels:
-            0 = New
-            1 = Assigned
-            2 = SentToMachine
-            3 = SendToMachineForceCancellation
-            4 = SendToMachineForceDeleteTask
-            5 = RequestedForceCancellationInMachine
-            6 = RequestedForceStopTaskInMachine
-            7 = Cancelled
-            8 = Deleted
-            9 = Running
-            10 = Completed
-            11 = Failed
-            12 = FailedRemovedFromMachine
-        """
-        status_map = {
-            0: "New",
-            1: "Assigned",
-            2: "SentToMachine",
-            3: "SendToMachineForceCancellation",
-            4: "SendToMachineForceDeleteTask",
-            5: "RequestedForceCancellationInMachine",
-            6: "RequestedForceStopTaskInMachine",
-            7: "Cancelled",
-            8: "Deleted",
-            9: "Running",
-            10: "Completed",
-            11: "Failed",
-            12: "FailedRemovedFromMachine",
-        }
-        
-        return status_map.get(status_value, f"Unknown({status_value})")
+    def parse_command_status(self, status_value) -> str:
+        """Command state name from an integer (legacy ``commandStatus``) or a name (current ``status``)."""
+        return command_status_name({"status": status_value})