gsim 0.0.2__py3-none-any.whl → 0.0.3__py3-none-any.whl

gsim/__init__.py

@@ -9,7 +9,7 @@ Currently includes:
 
 from __future__ import annotations
 
-__version__ = "0.0.2"
+__version__ = "0.0.3"
 
 __all__ = [
     "__version__",

gsim/common/__init__.py

@@ -35,27 +35,23 @@ from gsim.common.stack import (
 Stack = LayerStack
 
 __all__ = [
-    # Geometry
+    "MATERIALS_DB",
     "Geometry",
-    # Stack (LayerStack is the primary name, Stack is an alias)
+    "Layer",
     "LayerStack",
+    "MaterialProperties",
     "Stack",
-    "Layer",
     "StackLayer",
     "ValidationResult",
-    # Stack functions
-    "get_stack",
-    "load_stack_yaml",
     "extract_from_pdk",
     "extract_layer_stack",
-    "parse_layer_stack",
-    "print_stack",
-    "print_stack_table",
-    "plot_stack",
-    # Materials
-    "MATERIALS_DB",
-    "MaterialProperties",
     "get_material_properties",
+    "get_stack",
+    "load_stack_yaml",
     "material_is_conductor",
     "material_is_dielectric",
+    "parse_layer_stack",
+    "plot_stack",
+    "print_stack",
+    "print_stack_table",
 ]

gsim/common/stack/extractor.py

@@ -288,7 +288,7 @@ def _get_gds_layer_tuple(layer_level: LayerLevel) -> tuple[int, int]:
     if hasattr(layer, "layer"):
         inner = layer.layer
         if hasattr(inner, "layer") and hasattr(inner, "datatype"):
-            return (int(inner.layer), int(inner.datatype))
+            return (int(inner.layer), int(inner.datatype))  # type: ignore[arg-type]
         if isinstance(inner, int):
             datatype = getattr(layer, "datatype", 0)
             return (int(inner), int(datatype) if datatype else 0)
@@ -299,11 +299,11 @@ def _get_gds_layer_tuple(layer_level: LayerLevel) -> tuple[int, int]:
                 return (int(innermost), int(datatype) if datatype else 0)
 
     if hasattr(layer, "layer") and hasattr(layer, "datatype"):
-        return (int(layer.layer), int(layer.datatype))
+        return (int(layer.layer), int(layer.datatype))  # type: ignore[arg-type]
 
     if hasattr(layer, "value"):
         if isinstance(layer.value, tuple):
-            return (int(layer.value[0]), int(layer.value[1]))
+            return (int(layer.value[0]), int(layer.value[1]))  # type: ignore[arg-type]
         if isinstance(layer.value, int):
             return (int(layer.value), 0)
 
@@ -314,7 +314,7 @@ def _get_gds_layer_tuple(layer_level: LayerLevel) -> tuple[int, int]:
         return (0, 0)
 
     try:
-        return (int(layer), 0)
+        return (int(layer), 0)  # type: ignore[arg-type]
     except (TypeError, ValueError):
         logger.warning("Could not parse layer %s, using (0, 0)", layer)
         return (0, 0)

gsim/common/stack/materials.py

@@ -33,14 +33,14 @@ class MaterialProperties(BaseModel):
         return d
 
     @classmethod
-    def conductor(cls, conductivity: float = 5.8e7) -> "MaterialProperties":
+    def conductor(cls, conductivity: float = 5.8e7) -> MaterialProperties:
         """Create a conductor material."""
         return cls(type="conductor", conductivity=conductivity)
 
     @classmethod
     def dielectric(
         cls, permittivity: float, loss_tangent: float = 0.0
-    ) -> "MaterialProperties":
+    ) -> MaterialProperties:
         """Create a dielectric material."""
         return cls(
             type="dielectric", permittivity=permittivity, loss_tangent=loss_tangent

gsim/common/stack/visualization.py

@@ -43,15 +43,15 @@ def _get_gds_layer_number(layer_level: LayerLevel) -> int | None:
     if hasattr(layer, "layer"):
         inner = layer.layer
         if hasattr(inner, "layer"):
-            return int(inner.layer)
+            return int(inner.layer)  # type: ignore[arg-type]
         if isinstance(inner, int):
             return int(inner)
 
     # Handle enum with value
     if hasattr(layer, "value"):
         if isinstance(layer.value, tuple):
-            return int(layer.value[0])
-        return int(layer.value)
+            return int(layer.value[0])  # type: ignore[arg-type]
+        return int(layer.value)  # type: ignore[arg-type]
 
     return None
 

gsim/gcloud.py

@@ -16,17 +16,74 @@ Usage:
 
 from __future__ import annotations
 
-import zipfile
 from pathlib import Path
 from typing import TYPE_CHECKING
 
-from gdsfactoryplus import sim  # type: ignore[import-untyped]
+from gdsfactoryplus import sim
 
 if TYPE_CHECKING:
     from collections.abc import Callable
     from typing import Literal
 
 
+def _handle_failed_job(job, output_dir: Path, verbose: bool) -> None:
+    """Handle a failed simulation job by downloading logs and raising informative error.
+
+    Args:
+        job: The finished Job object with non-zero exit code
+        output_dir: Directory to download logs to
+        verbose: Whether to print progress
+
+    Raises:
+        RuntimeError: Always raised with detailed error information
+    """
+    error_parts = [
+        f"Simulation failed with exit code {job.exit_code}",
+        f"Status: {job.status.value}",
+    ]
+
+    if job.status_reason:
+        error_parts.append(f"Reason: {job.status_reason}")
+    if job.detail_reason:
+        error_parts.append(f"Details: {job.detail_reason}")
+
+    # Try to download logs even though job failed
+    try:
+        if job.download_urls:
+            if verbose:
+                print("Downloading logs from failed job...")  # noqa: T201
+
+            raw_results = sim.download_results(job, output_dir=output_dir)
+
+            # Flatten results to find all files
+            all_files: dict[str, Path] = {}
+            for result_path in raw_results.values():
+                if result_path.is_dir():
+                    for file_path in result_path.rglob("*"):
+                        if file_path.is_file() and not file_path.name.startswith("."):
+                            all_files[file_path.name] = file_path
+                else:
+                    all_files[result_path.name] = result_path
+
+            # Look for log files and display them
+            log_files = ["palace.log", "stdout.log", "stderr.log", "output.log"]
+            for log_name in log_files:
+                if log_name in all_files:
+                    content = all_files[log_name].read_text()
+                    error_parts.append(f"\n--- {log_name} (last 100 lines) ---")
+                    lines = content.strip().split("\n")
+                    error_parts.append("\n".join(lines[-100:]))
+                    break
+
+            if verbose and all_files:
+                print(f"Logs downloaded to {output_dir}")  # noqa: T201
+
+    except Exception as e:
+        error_parts.append(f"(Failed to download logs: {e})")
+
+    raise RuntimeError("\n".join(error_parts))
+
+
 def _get_job_definition(job_type: str):
     """Get JobDefinition enum value by name."""
     job_type_upper = job_type.upper()
@@ -37,7 +94,7 @@ def _get_job_definition(job_type: str):
 
 
 def upload_simulation_dir(input_dir: str | Path, job_type: str):
-    """Zip all files in a directory and upload for simulation.
+    """Upload a simulation directory for cloud execution.
 
     Args:
         input_dir: Directory containing simulation files
@@ -47,21 +104,8 @@ def upload_simulation_dir(input_dir: str | Path, job_type: str):
         PreJob object from gdsfactoryplus
     """
     input_dir = Path(input_dir)
-    zip_path = Path("_gsim_upload.zip")
-
-    try:
-        with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_STORED) as zf:
-            for file in input_dir.rglob("*"):
-                if file.is_file():
-                    zf.write(file, arcname=file.relative_to(input_dir))
-
-        job_definition = _get_job_definition(job_type)
-        pre_job = sim.upload_simulation(path=zip_path, job_definition=job_definition)
-    finally:
-        if zip_path.exists():
-            zip_path.unlink()
-
-    return pre_job
+    job_definition = _get_job_definition(job_type)
+    return sim.upload_simulation(path=input_dir, job_definition=job_definition)
 
 
 def run_simulation(
@@ -125,18 +169,27 @@ def run_simulation(
 
     # Check status
     if finished_job.exit_code != 0:
-        raise RuntimeError(
-            f"Simulation failed with exit code {finished_job.exit_code}. "
-            f"Status: {finished_job.status.value}"
-        )
+        _handle_failed_job(finished_job, output_dir, verbose)
 
     # Download
-    results = sim.download_results(finished_job)
+    raw_results = sim.download_results(finished_job)
+
+    # Flatten results: gdsfactoryplus returns extracted directories,
+    # but we want a dict of filename -> Path for individual files
+    results: dict[str, Path] = {}
+    for result_path in raw_results.values():
+        if result_path.is_dir():
+            # Recursively find all files in the extracted directory
+            for file_path in result_path.rglob("*"):
+                if file_path.is_file() and not file_path.name.startswith("."):
+                    results[file_path.name] = file_path
+        else:
+            results[result_path.name] = result_path
 
     if verbose and results:
+        # Find common parent directory for display
         first_path = next(iter(results.values()))
-        download_dir = first_path.parent
-        print(f"Downloaded {len(results)} files to {download_dir}")  # noqa: T201
+        print(f"Downloaded {len(results)} files to {first_path.parent}")  # noqa: T201
 
     return results
 

gsim/palace/__init__.py

@@ -29,12 +29,30 @@ from __future__ import annotations
 
 from functools import partial
 
-from gsim.gcloud import print_job_summary
-from gsim.gcloud import run_simulation as _run_simulation
-
 # Common components (shared with FDTD)
 from gsim.common import Geometry, LayerStack, Stack
 
+# Stack utilities (from common, shared with FDTD)
+from gsim.common.stack import (
+    MATERIALS_DB,
+    Layer,
+    MaterialProperties,
+    StackLayer,
+    extract_from_pdk,
+    extract_layer_stack,
+    get_material_properties,
+    get_stack,
+    load_stack_yaml,
+    material_is_conductor,
+    material_is_dielectric,
+    parse_layer_stack,
+    plot_stack,
+    print_stack,
+    print_stack_table,
+)
+from gsim.gcloud import print_job_summary
+from gsim.gcloud import run_simulation as _run_simulation
+
 # New simulation classes (composition, no inheritance)
 from gsim.palace.driven import DrivenSim
 from gsim.palace.eigenmode import EigenmodeSim
@@ -58,7 +76,6 @@ from gsim.palace.models import (
     GeometryConfig,
     MagnetostaticConfig,
     MaterialConfig,
-    MeshConfig as MeshConfigModel,
     NumericalConfig,
     PortConfig,
     SimulationResult,
@@ -67,6 +84,9 @@ from gsim.palace.models import (
     ValidationResult,
     WavePortConfig,
 )
+from gsim.palace.models import (
+    MeshConfig as MeshConfigModel,
+)
 
 # Port utilities
 from gsim.palace.ports import (
@@ -79,91 +99,60 @@ from gsim.palace.ports import (
     extract_ports,
 )
 
-# Stack utilities (from common, shared with FDTD)
-from gsim.common.stack import (
-    MATERIALS_DB,
-    Layer,
-    LayerStack,
-    MaterialProperties,
-    StackLayer,
-    ValidationResult as StackValidationResult,
-    extract_from_pdk,
-    extract_layer_stack,
-    get_material_properties,
-    get_stack,
-    load_stack_yaml,
-    material_is_conductor,
-    material_is_dielectric,
-    parse_layer_stack,
-    plot_stack,
-    print_stack,
-    print_stack_table,
-)
-
 # Visualization
 from gsim.viz import plot_mesh
 
-
 __all__ = [
-    # Primary simulation classes (new API)
+    "MATERIALS_DB",
+    "CPWPortConfig",
+    "DrivenConfig",
     "DrivenSim",
+    "EigenmodeConfig",
     "EigenmodeSim",
+    "ElectrostaticConfig",
     "ElectrostaticSim",
-    # Common components (shared with FDTD)
     "Geometry",
-    "Stack",
-    # Problem configs
-    "DrivenConfig",
-    "EigenmodeConfig",
-    "ElectrostaticConfig",
-    "MagnetostaticConfig",
-    "TransientConfig",
-    # Port configs
-    "CPWPortConfig",
-    "PortConfig",
-    "TerminalConfig",
-    "WavePortConfig",
-    # Other configs
     "GeometryConfig",
+    "GroundPlane",
+    "Layer",
+    "LayerStack",
+    "MagnetostaticConfig",
     "MaterialConfig",
+    "MaterialProperties",
+    "MeshConfig",
     "MeshConfigModel",
+    "MeshPreset",
+    "MeshResult",
     "NumericalConfig",
+    "PalacePort",
+    "PortConfig",
+    "PortGeometry",
+    "PortType",
     "SimulationResult",
+    "Stack",
+    "StackLayer",
+    "TerminalConfig",
+    "TransientConfig",
     "ValidationResult",
-    # Stack utilities
-    "MATERIALS_DB",
-    "Layer",
-    "LayerStack",
-    "MaterialProperties",
+    "WavePortConfig",
+    "configure_cpw_port",
+    "configure_inplane_port",
+    "configure_via_port",
     "extract_from_pdk",
     "extract_layer_stack",
+    "extract_ports",
+    "generate_mesh",
     "get_material_properties",
     "get_stack",
     "load_stack_yaml",
     "material_is_conductor",
     "material_is_dielectric",
     "parse_layer_stack",
+    "plot_mesh",
     "plot_stack",
+    "print_job_summary",
     "print_stack",
     "print_stack_table",
-    # Mesh utilities
-    "GroundPlane",
-    "MeshConfig",
-    "MeshPreset",
-    "MeshResult",
-    "generate_mesh",
-    "plot_mesh",
-    # Port utilities
-    "PalacePort",
-    "PortGeometry",
-    "PortType",
-    "StackLayer",
-    "configure_cpw_port",
-    "configure_inplane_port",
-    "configure_via_port",
-    "extract_ports",
-    # Cloud
-    "print_job_summary",
     "run_simulation",
 ]