cenos-py 0.1.1__tar.gz

cenos_py-0.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 CENOS
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

cenos_py-0.1.1/PKG-INFO

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: cenos-py
+Version: 0.1.1
+Summary: Python API for using CENOS applications
+Author: Rinalds
+Author-email: Rinalds <rp@cenos-platform.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Electronic Design Automation (EDA)
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: websocket-client>=1.9.0
+Requires-Python: >=3.10
+Project-URL: Homepage, https://cenos-platform.com
+Project-URL: Repository, https://github.com/CENOS-Platform/cenos-py
+Description-Content-Type: text/markdown
+
+# CENOS Python package
+
+This is a simple package that allows to interface with the cenos backend via a python API.
+
+## Quick-start
+
+Install this package 
+```
+pip install cenos-py
+```
+
+## How it works
+
+While you use CENOS normally using the GUI, most of your actions are written out to a `logs/python_trace_script.py` file inside of the case itself. It will look something like this:
+
+```python
+from cenos_py import CenosCase, setCenosLocation
+
+setCenosLocation(r"C:\source\cenos")
+
+case = CenosCase("INDUCTION")
+case.set_pre_processor('geomWizard', load_recent=True)
+case.update_template_shape_type(1, 'workpieceTube')
+case.update_template_property(1, 'diameter3', 32)
+case.update_template_property(1, 'diameter4', 10)
+case.update_tab_property('simulation', 'tend', 3)
+case.update_tab_property('simulation', 'isAdaptive', True)
+case.assign_group_material('workpiece', 'alloy_34Cr4')
+case.update_physics_property('physicsThermal', 'boundary', 'workpiece_surface', 'hr', 0.9)
+case.entered_meshing_window()
+case.set_meshing_global_density('rough')
+case.set_meshing_grading_surface(0.29)
+case.set_meshing_domain_element_size('workpiece', 2)
+case.set_meshing_domain_skin_layer('workpiece', True, 4.6, 10, 1.4)
+case.generate_mesh()
+case.calculate()
+```
+
+You can use this code in your script to create a CENOS case from scratch for every run.
+
+(Recommended) Alternatively you can use a script that simply opens an existing case and modifies only the variables that you wish to control, for example:
+
+```python
+from pathlib import Path
+
+from cenos_py import CenosCase, setCenosLocation
+
+setCenosLocation(r"C:\Users\user\AppData\Local\Programs\CENOS Induction Heating beta")
+
+case = CenosCase("INDUCTION")
+
+your_case_path = r"C:\Users\rp\CENOS\your_case"
+
+for i in [20, 30, 40, 50]:
+    case.open(your_case_path)
+
+    # Create a copy first
+    case.save_case_as(r"C:\Users\rp\CENOS\your_case_{i}")
+
+    case.update_template_property(1, "workpiece_height", i)
+    case.calculate()
+```
+
+
+
+
+

cenos_py-0.1.1/README.md

@@ -0,0 +1,67 @@
+# CENOS Python package
+
+This is a simple package that allows to interface with the cenos backend via a python API.
+
+## Quick-start
+
+Install this package 
+```
+pip install cenos-py
+```
+
+## How it works
+
+While you use CENOS normally using the GUI, most of your actions are written out to a `logs/python_trace_script.py` file inside of the case itself. It will look something like this:
+
+```python
+from cenos_py import CenosCase, setCenosLocation
+
+setCenosLocation(r"C:\source\cenos")
+
+case = CenosCase("INDUCTION")
+case.set_pre_processor('geomWizard', load_recent=True)
+case.update_template_shape_type(1, 'workpieceTube')
+case.update_template_property(1, 'diameter3', 32)
+case.update_template_property(1, 'diameter4', 10)
+case.update_tab_property('simulation', 'tend', 3)
+case.update_tab_property('simulation', 'isAdaptive', True)
+case.assign_group_material('workpiece', 'alloy_34Cr4')
+case.update_physics_property('physicsThermal', 'boundary', 'workpiece_surface', 'hr', 0.9)
+case.entered_meshing_window()
+case.set_meshing_global_density('rough')
+case.set_meshing_grading_surface(0.29)
+case.set_meshing_domain_element_size('workpiece', 2)
+case.set_meshing_domain_skin_layer('workpiece', True, 4.6, 10, 1.4)
+case.generate_mesh()
+case.calculate()
+```
+
+You can use this code in your script to create a CENOS case from scratch for every run.
+
+(Recommended) Alternatively you can use a script that simply opens an existing case and modifies only the variables that you wish to control, for example:
+
+```python
+from pathlib import Path
+
+from cenos_py import CenosCase, setCenosLocation
+
+setCenosLocation(r"C:\Users\user\AppData\Local\Programs\CENOS Induction Heating beta")
+
+case = CenosCase("INDUCTION")
+
+your_case_path = r"C:\Users\rp\CENOS\your_case"
+
+for i in [20, 30, 40, 50]:
+    case.open(your_case_path)
+
+    # Create a copy first
+    case.save_case_as(r"C:\Users\rp\CENOS\your_case_{i}")
+
+    case.update_template_property(1, "workpiece_height", i)
+    case.calculate()
+```
+
+
+
+
+

cenos_py-0.1.1/pyproject.toml

@@ -0,0 +1,45 @@
+[project]
+name = "cenos-py"
+version = "0.1.1"
+description = "Python API for using CENOS applications"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [
+    { name = "Rinalds", email = "rp@cenos-platform.com" }
+]
+requires-python = ">=3.10"
+dependencies = [
+    "websocket-client>=1.9.0",
+]
+
+classifiers = [
+  "Development Status :: 3 - Alpha",
+
+  "Intended Audience :: Science/Research",
+  "Topic :: Scientific/Engineering",
+  "Topic :: Scientific/Engineering :: Electronic Design Automation (EDA)",
+  "Topic :: Scientific/Engineering :: Physics",
+
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
+]
+
+[project.urls]
+Homepage = "https://cenos-platform.com"
+Repository = "https://github.com/CENOS-Platform/cenos-py"
+
+
+[build-system]
+requires = ["uv_build>=0.11.24,<0.12.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+    "pytest>=9.1.1",
+    "pytest-cov>=7.1.0",
+]

cenos_py-0.1.1/src/cenos_py/__init__.py

@@ -0,0 +1,33 @@
+from os import PathLike
+from typing import Literal
+
+from cenos_py import misc_functions
+from cenos_py._generated_case_methods import _GeneratedCaseMethods
+
+from .backend_service import BackendInstance, start_backend
+
+setCenosLocation = misc_functions.setCenosLocation
+
+
+class CenosCase(_GeneratedCaseMethods):
+    def _start_backend(self, app_name: str):
+        assert misc_functions._cenos_location is not None, (
+            "Please call setCenosLocation to specify the location of your cenos installation before creating a case."
+        )
+        if not app_name:
+            app_name = misc_functions.get_installed_app_name(
+                misc_functions._cenos_location
+            )
+        self.backend: BackendInstance = start_backend(
+            misc_functions._cenos_location, app_name
+        )
+
+    def __init__(self, app_name: str | None = None):
+        self._start_backend(app_name)
+        self.backend.call("newCase")
+
+    def open(self, case_path: str | PathLike[str]):
+        self.backend.call("openCase", {"caseDir": str(case_path)})
+
+    def stop(self) -> None:
+        self.backend.stop()

cenos_py-0.1.1/src/cenos_py/_generated_case_methods.py

@@ -0,0 +1,687 @@
+# This file is auto-generated using cenos_py_function_generator.py in the main cenos repo
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from cenos_py.property_data import build_property_data
+
+
+class _GeneratedCaseMethods:
+    """Auto-generated wrapper methods for CenosCase."""
+
+    def generate_template_geometry(self) -> None:
+        """Generates and returns geometryData.
+Kind of depricated now, because geometry is generated when update_template_properties is called."""
+        self.backend.call("generateTemplateGeometry")
+
+
+    def receive_pre_processor_geometry(self, pre_proc: str, geom_data_json: str, geom_package: str | None) -> None:
+        """FreeCAD/Salome calls this command then the user sends geometry/mesh to CENOS."""
+        self.backend.call(
+            "receivePreprocessorGeometry",
+            {"preprocessorName": pre_proc, "geometryDataFile": geom_data_json, "geom_package": geom_package},
+        )
+
+
+    def merge_groups(self, groups_to_merge: list[str]) -> None:
+        """Merge groups for role selection."""
+        self.backend.call(
+            "mergeGroups",
+            {"names": groups_to_merge},
+        )
+
+
+    def unmerge_groups(self, groups_to_unmerge: list[str]) -> None:
+        """Unmerge groups for role selection."""
+        self.backend.call(
+            "unmergeGroups",
+            {"names": groups_to_unmerge},
+        )
+
+
+    def set_object_label(self, obj_to_rename: str, label: str) -> None:
+        """Set the label of a boundary, domain or lumped element"""
+        self.backend.call(
+            "setLabel",
+            {"name": obj_to_rename, "label": label},
+        )
+
+
+    def scale_geometry(self, scale: float) -> None:
+        """Scale geometry by a factor. If mesh existed, then delete it."""
+        self.backend.call(
+            "scaleGeometry",
+            {"scale": scale},
+        )
+
+
+    def save_gerber_to_step(self) -> None:
+        """Save Gerber files to step"""
+        self.backend.call("saveGerberToStep")
+
+
+    def replace_cad_files(self, new_files: list[str]) -> None:
+        """Called when user re-import CAD files in the FromCAD workflow"""
+        self.backend.call(
+            "replaceCadFiles",
+            {"fileNames": new_files},
+        )
+
+
+    def replace_gerber_files(self, new_files: list[Path]) -> None:
+        """Called when user re-imports Gerber files."""
+        self.backend.call(
+            "replaceGerberFiles",
+            {"new_files": new_files},
+        )
+
+
+    def calculate(self, validate: bool = True) -> None:
+        """Called when user clicks 'RUN'"""
+        self.backend.call(
+            "calculate",
+            {"validate": validate},
+        )
+
+
+    def update_variables(self, new_variables: dict[str, float]) -> None:
+        """Called when user changes and updates 'geometry variables'"""
+        self.backend.call(
+            "updateGeometryVariables",
+            {"variables": new_variables},
+        )
+
+
+    def run_salome_as_mesher(self) -> None:
+        """Runs salome as mesher, waits for user to complete everything and close salome."""
+        self.backend.call("runSalomeAsMesher")
+
+
+    def new_case(self, test_mode: object = False) -> None:
+        """Creates a new case with empty physics block."""
+        self.backend.call(
+            "newCase",
+            {"test_mode": test_mode},
+        )
+
+
+    def save_case(self) -> None:
+        """Saves case at the current location"""
+        self.backend.call("saveCase")
+
+
+    def save_case_as(self, new_case_path: str | os.PathLike[str], without_results: bool = False) -> None:
+        """Moves and saves case to a new location."""
+        self.backend.call(
+            "saveCaseAs",
+            {"caseDir": str(new_case_path), "without_results": without_results},
+        )
+
+
+    def compress_case(self, should_include_results: bool = True, custom_filename: str | None = None) -> None:
+        """Compresses the case directory for sharing.
+
+Delegates to misc_worker.compress_case() for actual implementation."""
+        self.backend.call(
+            "compressCase",
+            {"shouldIncludeResults": should_include_results, "customFilename": custom_filename},
+        )
+
+
+    def compress_logs(self, custom_filename: str | None = None) -> None:
+        """Compresses log files for sharing.
+
+Delegates to misc_worker.compress_logs() for actual implementation."""
+        self.backend.call(
+            "compressLogs",
+            {"custom_filename": custom_filename},
+        )
+
+
+    def set_pre_processor(self, pre_proc_key: str, load_recent: object = False) -> None:
+        """Sets the preprocessor and in case of templates generates default geometry and physics."""
+        self.backend.call(
+            "setPreprocessor",
+            {"preProcessorKey": pre_proc_key, "load_recent": load_recent},
+        )
+
+
+    def read_cad_files(self, files: list[str]) -> None:
+        """FromCAD CAD file import function. Creates physics as well."""
+        self.backend.call(
+            "readCadFiles",
+            {"fileNames": files},
+        )
+
+
+    def load_parametric_cad_files(self, files: list[str]) -> None:
+        """When user imports many CAD files using the 'parametric' button"""
+        self.backend.call(
+            "loadParametricCadFiles",
+            {"fileNames": files},
+        )
+
+
+    def read_parametric_gerber_files(self, folders: list[str]) -> None:
+        """Reads parametric gerber files and returs layer data to be edited by user"""
+        self.backend.call(
+            "readParametricGerberFiles",
+            {"fileNames": folders},
+        )
+
+
+    def load_parametric_gerber_files(self, folders: list[str], layer_data: list[dict[str, float, str]]) -> None:
+        """Only adds the parametric case entries to the case."""
+        self.backend.call(
+            "loadParametricGerberFiles",
+            {"folders": folders, "layerData": layer_data},
+        )
+
+
+    def load_gerber_2(self, gdo_files: list[str | os.PathLike[str]]) -> None:
+        """Loads Gerber files."""
+        self.backend.call(
+            "readGerberFiles",
+            {"fileNames": str(gdo_files)},
+        )
+
+
+    def load_gerber_3(self, layer_data: list[dict[str, float, str]]) -> None:
+        """Performs the actual loading of Gerber files after user has done all the GUI part.
+Seperate for case trace."""
+        self.backend.call(
+            "loadGerberFiles",
+            {"layerData": layer_data},
+        )
+
+
+    def read_shape_from_python_script(self, python_file: str) -> None:
+        """FromPythonScript CAD file import function. Creates physics as well."""
+        self.backend.call(
+            "readPythonGeomFile",
+            {"python_file": python_file},
+        )
+
+
+    def add_air(self, add_air_choice: bool, terminals: list[str]) -> None:
+        """Adds air and updates physics."""
+        self.backend.call(
+            "addAir",
+            {"addAirChoice": add_air_choice, "terminals": terminals},
+        )
+
+
+    def set_geometry_type(self, geom_type_key: str) -> None:
+        """Sets the geometry type."""
+        self.backend.call(
+            "setGeometryType",
+            {"geometryTypeKey": geom_type_key},
+        )
+
+
+    def reset_geometry_type(self) -> None:
+        """When the user clicks the 'x' in the role window all roles, domain merges, etc. must be reset."""
+        self.backend.call("resetGeometryType")
+
+
+    def add_role_entry(self, role_key: str) -> None:
+        """Adds a new empty role entry in the role selection window and return the new id."""
+        self.backend.call(
+            "addRoleEntry",
+            {"key": role_key},
+        )
+
+
+    def remove_role_entry(self, role_entry_id: int) -> None:
+        """User deletes role entry in the role selection window."""
+        self.backend.call(
+            "removeRoleEntry",
+            {"id": role_entry_id},
+        )
+
+
+    def assign_role(self, entry_id: int, object_type: str, objects: list[str]) -> None:
+        """Assigns role in the role selection window."""
+        self.backend.call(
+            "assignRole",
+            {"id": entry_id, "type": object_type, "names": objects},
+        )
+
+
+    def assign_domain_role_py(self, domain_names: list[str], role_key: str) -> None:
+        """Role assignment function for python scripts."""
+        self.backend.call(
+            "assignDomainRolePy",
+            {"domainNames": domain_names, "roleKey": role_key},
+        )
+
+
+    def assign_boundary_role_py(self, boundary_names: list[str], role_key: str) -> None:
+        """Role assignment function for python scripts."""
+        self.backend.call(
+            "assignBoundaryRolePy",
+            {"boundaryNames": boundary_names, "roleKey": role_key},
+        )
+
+
+    def assign_lumped_element(self, entry_id: int, points: list[dict[str, list[float]]]) -> None:
+        """Specifies the points and edges for a given lumped element role entry."""
+        self.backend.call(
+            "assignLumpedElement",
+            {"id": entry_id, "points": points},
+        )
+
+
+    def unassign_lumped_element(self, entry_id: int) -> None:
+        """Unassigns the role entry and removes the lumped element from GeometryData"""
+        self.backend.call(
+            "unassignLumpedElement",
+            {"id": entry_id},
+        )
+
+
+    def entered_meshing_window(self) -> None:
+        """Called whenever user enters meshing window"""
+        self.backend.call("enteredMeshing")
+
+
+    def set_manual_meshing_params(self, mesh_params: dict) -> None:
+        """Called whenever the user changes any of the manual meshing parameters."""
+        self.backend.call(
+            "setMeshingParams",
+            {"meshParams": mesh_params},
+        )
+
+
+    def set_meshing_global_density(self, density: str) -> None:
+        """Called whenever the user changes the global density (rough, average, fine)"""
+        self.backend.call(
+            "setMeshingGlobalDensity",
+            {"density": density},
+        )
+
+
+    def set_meshing_global_netgen_param(self, param_key: str, param_value: int | float | str) -> None:
+        """Global netgen param"""
+        self.backend.call(
+            "setMeshingGlobalNetgenParam",
+            {"paramKey": param_key, "paramValue": param_value},
+        )
+
+
+    def set_meshing_grading_surface(self, value: float) -> None:
+        """Sets the slider value"""
+        self.backend.call(
+            "setMeshingGradingSurface",
+            {"value": value},
+        )
+
+
+    def set_meshing_grading_volume(self, value: float) -> None:
+        """Sets the slider value"""
+        self.backend.call(
+            "setMeshingGradingVolume",
+            {"value": value},
+        )
+
+
+    def set_meshing_curvature_safety(self, value: float) -> None:
+        """Sets the slider value"""
+        self.backend.call(
+            "setMeshingCurvatureSafety",
+            {"value": value},
+        )
+
+
+    def set_meshing_corner_mesh_refinement(self, value: float) -> None:
+        """Sets the corner mesh refinement value."""
+        self.backend.call(
+            "setMeshingCornerMeshRefinement",
+            {"value": value},
+        )
+
+
+    def set_meshing_domain_element_size(self, domain_name: str, value: float) -> None:
+        """Sets the domain element size value."""
+        self.backend.call(
+            "setMeshingDomainElementSize",
+            {"domainName": domain_name, "value": value},
+        )
+
+
+    def set_meshing_domain_skin_layer(self, domain_name: str, enabled: bool, total_thickness: float, layer_count: int, stretch_factor: float) -> None:
+        """Sets skin layer params"""
+        self.backend.call(
+            "setMeshingDomainSkinLayer",
+            {"domainName": domain_name, "enabled": enabled, "totalThickness": total_thickness, "layerCount": layer_count, "stretchFactor": stretch_factor},
+        )
+
+
+    def set_meshing_domain_refinement_size(self, domain_name: str, entity_name: str, value: float) -> None:
+        """Sets the element size for an existing refinement."""
+        self.backend.call(
+            "setMeshingDomainRefinementSize",
+            {"domainName": domain_name, "entityName": entity_name, "elemSize": value},
+        )
+
+
+    def add_meshing_domain_refinement(self, domain_name: str, entity_name: str, elem_size: float) -> None:
+        """Adds a new refinement to the domain"""
+        self.backend.call(
+            "addMeshingDomainRefinement",
+            {"domainName": domain_name, "entityName": entity_name, "elemSize": elem_size},
+        )
+
+
+    def remove_meshing_domain_refinement(self, domain_name: str, entity_name: str) -> None:
+        """Removes a refinement from the specified domain"""
+        self.backend.call(
+            "removeMeshingDomainRefinement",
+            {"domainName": domain_name, "entityName": entity_name},
+        )
+
+
+    def reset_manual_meshing_params(self) -> None:
+        """Resets all of the MeshParams to the defaults."""
+        self.backend.call("resetMeshingParams")
+
+
+    def reset_manual_meshing_domain_params(self, domain_name: str) -> None:
+        """Resets the parameters for the specified domain."""
+        self.backend.call(
+            "resetDomainMeshParams",
+            {"name": domain_name},
+        )
+
+
+    def generate_mesh(self) -> None:
+        """Generates mesh based on the case state."""
+        self.backend.call("generateMesh")
+
+
+    def use_existing_mesh(self) -> None:
+        """Specifies that the current mesh if fine despite changes in the physics which would affect the mesh."""
+        self.backend.call("useExistingMesh")
+
+
+    def generate_pdf_report(self) -> None:
+        """Generates a PDF report for the case. Returns path to the pdf file"""
+        self.backend.call("generatePdfReport")
+
+
+    def update_tab_property(self, tab_key: str, property_key: str, value: str | int | float | bool | list[tuple[float, float]], argument: str | None = None) -> None:
+        """Updates a single property on a physics tab (e.g. simulation tab)."""
+        _property_data = build_property_data(property_key, value, argument)
+        self.backend.call(
+            "updateTabProperty",
+            {"tabKey": tab_key, "property": _property_data},
+        )
+
+
+    def update_physics_property(self, physics_key: str, group_type: str, group_name: str, property_key: str, value: str | int | float | bool | list[tuple[float, float]], argument: str | None = None) -> None:
+        """Updates a single property on a physics domain or boundary."""
+        _property_data = build_property_data(property_key, value, argument)
+        self.backend.call(
+            "updatePhysicsProperty",
+            {"physicsKey": physics_key, "groupType": group_type, "groupName": group_name, "property": _property_data},
+        )
+
+
+    def update_domain_property(self, domain_name: str, property_key: str, value: str | int | float | bool | list[tuple[float, float]], argument: str | None = None) -> None:
+        """Updates a single domain property."""
+        _property_data = build_property_data(property_key, value, argument)
+        self.backend.call(
+            "updateDomainProperty",
+            {"domainName": domain_name, "property": _property_data},
+        )
+
+
+    def update_material_property(self, material_name: str, property_key: str, value: str | int | float | bool | list[tuple[float, float]], argument: str | None = None) -> None:
+        """Updates a single material property."""
+        _property_data = build_property_data(property_key, value, argument)
+        self.backend.call(
+            "updateMaterialProperty",
+            {"materialName": material_name, "property": _property_data},
+        )
+
+
+    def update_motion_property(self, motion_name: str, property_key: str, value: str | int | float | bool | list[tuple[float, float]], argument: str | None = None) -> None:
+        """Updates a single motion property."""
+        _property_data = build_property_data(property_key, value, argument)
+        self.backend.call(
+            "updateMotionProperty",
+            {"motionName": motion_name, "property": _property_data},
+        )
+
+
+    def clear_group_material(self, group_name: str) -> None:
+        """Clears the assigned material for a domain or boundary group."""
+        self.backend.call(
+            "clearGroupMaterial",
+            {"groupName": group_name},
+        )
+
+
+    def assign_group_material(self, group_name: str, material_key: str) -> None:
+        """Assigns a library material to a domain or boundary group."""
+        self.backend.call(
+            "assignGroupMaterial",
+            {"groupName": group_name, "materialKey": material_key},
+        )
+
+
+    def assign_group_material_custom(self, group_name: str, material_data: dict) -> None:
+        """Assigns a custom material to a domain or boundary group."""
+        self.backend.call(
+            "assignGroupMaterialCustom",
+            {"groupName": group_name, "material": material_data},
+        )
+
+
+    def set_domain_type(self, domain_name: str, physics_key: str, type_key: str) -> None:
+        """Sets the physics domain type for a domain."""
+        self.backend.call(
+            "setDomainType",
+            {"domainName": domain_name, "physicsKey": physics_key, "typeKey": type_key},
+        )
+
+
+    def set_boundary_type(self, boundary_name: str, physics_key: str, type_key: str) -> None:
+        """Sets the physics boundary type for a boundary."""
+        self.backend.call(
+            "setBoundaryType",
+            {"boundaryName": boundary_name, "physicsKey": physics_key, "typeKey": type_key},
+        )
+
+
+    def set_domain_physics_enabled(self, domain_name: str, physics_key: str, enabled: bool) -> None:
+        """Enables or disables physics for a domain."""
+        self.backend.call(
+            "setDomainPhysicsEnabled",
+            {"domainName": domain_name, "physicsKey": physics_key, "enabled": enabled},
+        )
+
+
+    def set_motion_enabled(self, motion_name: str, enabled: bool) -> None:
+        """Enables or disables a motion."""
+        self.backend.call(
+            "setMotionEnabled",
+            {"name": motion_name, "enabled": enabled},
+        )
+
+
+    def set_motion_type(self, motion_name: str, motion_type: str) -> None:
+        """Sets the motion type for a motion."""
+        self.backend.call(
+            "setMotionType",
+            {"name": motion_name, "type": motion_type},
+        )
+
+
+    def set_motion_domains(self, motion_name: str, domain_names: list[str]) -> None:
+        """Sets the domains associated with a motion."""
+        self.backend.call(
+            "setMotionDomains",
+            {"name": motion_name, "domains": domain_names},
+        )
+
+
+    def update_template_property(self, domain_id: int, property_key: str, value: str | int | float | bool | list[tuple[float, float]], argument: str | None = None) -> None:
+        """Updates a single template property value and regenerates geometry.
+If geometry was generated successfully, returns True, otherwise False."""
+        _property_data = build_property_data(property_key, value, argument)
+        self.backend.call(
+            "updateTemplateProperty",
+            {"domainId": domain_id, "property": _property_data},
+        )
+
+
+    def update_template_shape_type(self, domain_id: int, new_shape_type: str) -> None:
+        """Updates a template's shape type and regenerates geometry.
+If geometry was generated successfully, returns True, otherwise False."""
+        self.backend.call(
+            "updateTemplateShapeType",
+            {"domainId": domain_id, "type": new_shape_type},
+        )
+
+
+    def add_template_domain(self, template_tab_key: str) -> None:
+        """Called when user click the plus button in the template tabs row to create new template domain."""
+        self.backend.call(
+            "addTemplateDomain",
+            {"geometryGroupKey": template_tab_key},
+        )
+
+
+    def remove_template_domain(self, domain_id: int) -> None:
+        """Called when user clicks delete on of the template tabs."""
+        self.backend.call(
+            "removeTemplateDomain",
+            {"id": domain_id},
+        )
+
+
+    def enable_parametric_study(self) -> None:
+        """Enabled parametric study and adds the current case as one of the entries."""
+        self.backend.call("enableParametricStudy")
+
+
+    def disable_parametric_study(self) -> None:
+        """Disables parametric study. All the configuration that user entered is still present, just not visible."""
+        self.backend.call("disableParametricStudy")
+
+
+    def add_parametric_case(self) -> None:
+        """Adds a new parametric case entry with the same values as the last parametric entry."""
+        self.backend.call("addParametricCase")
+
+
+    def add_parametric_case_input_files(self, files: list[str]) -> None:
+        """User has decided to add some more files from the parametric study window."""
+        self.backend.call(
+            "addParametricCaseInputFiles",
+            {"files": files},
+        )
+
+
+    def remove_parametric_case(self, parametric_case_id: int) -> None:
+        """Remove parametric case."""
+        self.backend.call(
+            "removeParametricCase",
+            {"id": parametric_case_id},
+        )
+
+
+    def add_parametric_column(self, variable_name: str) -> None:
+        """Add a new parametric column for the variable and sets the base value for all cases."""
+        self.backend.call(
+            "addParametricColumn",
+            {"variableName": variable_name},
+        )
+
+
+    def remove_parametric_column(self, variable_name: str) -> None:
+        """Remove the parametric column and removed the property from all cases."""
+        self.backend.call(
+            "removeParametricColumn",
+            {"variableName": variable_name},
+        )
+
+
+    def update_parametric_case_properties(self, pcase_id: int, variable_name: str, value: float) -> None:
+        """Set the property value for a given parametric case."""
+        self.backend.call(
+            "updateParametricCaseProperty",
+            {"id": pcase_id, "variableName": variable_name, "variableValue": value},
+        )
+
+
+    def run_parametric_cases(self, recalculate_all: bool) -> None:
+        """Runs a single parametric study case."""
+        self.backend.call(
+            "runParametricCases",
+            {"recalculateAll": recalculate_all},
+        )
+
+
+    def add_motion(self) -> None:
+        """Adds motion to case."""
+        self.backend.call("addMotion")
+
+
+    def remove_motion(self, motion_name: str) -> None:
+        """Adds motion to case."""
+        self.backend.call(
+            "removeMotion",
+            {"name": motion_name},
+        )
+
+
+    def set_physics_block_key(self, block_key: str) -> None:
+        """Adds motion to case."""
+        self.backend.call(
+            "setPhysicsBlockKey",
+            {"blockKey": block_key},
+        )
+
+
+    def renormalize_results(self, new_port_data: dict[str, dict[str, float | int | str]], sub_case: str | None = None) -> None:
+        """In ANTENNAS, the results can be renormalized with different port parameters.
+Example new_port_data:
+{
+    "discrete_port1": {
+        "resistance": 50,
+        "reactance": 50,
+        "reactive_component": "reactance",
+        "capacitance": 0,
+        "capacitance_arrangement": "serial",
+        "phase": 0,
+        "power": 10,
+        "port_id": 1,
+    }
+}"""
+        self.backend.call(
+            "renormalizeResults",
+            {"portData": new_port_data, "sub_case": sub_case},
+        )
+
+
+    def periodic_array_calculation(self, periodic_array_data: dict[str, float | int | str]) -> None:
+        """In ANTENNAS, the periodic array farfield calculation is done here.
+Example:
+periodic_array_data = {
+    "first_direction": "X",
+    "second_direction": "Y",
+    "elements_x": 4,
+    "elements_y": 1,
+    "phase_shift_x": 0,
+    "phase_shift_y": 0,
+    "spacing_x": 0.1, # in meters
+    "spacing_y": 0.1, # in meters
+    "continuous": False
+}"""
+        self.backend.call(
+            "periodicArrayCalculation",
+            {"periodicArrayData": periodic_array_data},
+        )
+

cenos_py-0.1.1/src/cenos_py/backend_service.py

@@ -0,0 +1,197 @@
+import json
+import os
+import queue
+import socket
+import subprocess
+import threading
+import time
+import uuid
+from pathlib import Path
+from typing import Any
+
+import websocket
+
+from .logger import logger
+
+STARTUP_TIMEOUT = 60  # seconds
+
+
+def _find_free_port() -> int:
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        s.bind(("127.0.0.1", 0))
+        return s.getsockname()[1]
+
+
+def _build_env(cenos_location: Path, app_name: str) -> dict[str, str]:
+    platform_files = cenos_location / "platform-files"
+    backend_bin = cenos_location / "backend" / "bin"
+
+    python_path = os.pathsep.join(
+        [
+            str(platform_files),
+            str(
+                platform_files
+                / "cenos"
+                / "viewer"
+                / "cenos-viewer"
+                / "prod-build"
+                / "backend"
+            ),
+            str(cenos_location / "app" / app_name),
+            str(backend_bin / "pygetdp"),
+            str(backend_bin / "lib" / "netgen-root" / "lib" / "site-packages"),
+        ]
+    )
+
+    env = os.environ.copy()
+    env.update(
+        {
+            "CENOS_APP": app_name,
+            "PYTHONPATH": python_path,
+            "TEMP": env.get("TEMP") or env.get("TMP") or r"C:\temp",
+            "CENOS_PLATFORM_FILES": str(platform_files),
+            "PYTHONIOENCODING": "utf-8",
+            "PYTHONASYNCIODEBUG": "0",
+        }
+    )
+
+    return env
+
+
+def _pipe_reader(pipe, line_queue: queue.Queue) -> None:
+    """Read lines from a pipe in a background thread and push them onto a queue."""
+    try:
+        for line in pipe:
+            line_queue.put(line)
+    finally:
+        line_queue.put(None)
+
+
+class BackendInstance:
+    def __init__(self, process: subprocess.Popen, ws: websocket.WebSocket) -> None:
+        self._process = process
+        self._ws = ws
+
+    def call(self, command: str, args: dict[str, Any] | None = None) -> Any:
+        """Send a command and block until the response arrives. Returns response data."""
+        guid = str(uuid.uuid4())
+        message = {
+            "guid": guid,
+            "command": command,
+            "args": args or {},
+        }
+        self._ws.send(json.dumps(message))
+        logger.debug(f"Sent: {message}")
+
+        while True:
+            resp = self._ws.recv()
+            if not resp:
+                continue
+
+            response = json.loads(resp)
+
+            typ = response.get("type")
+
+            if typ == "log":
+                logger.info(f"Backend log: {response['data']['message']}")
+                if response["data"]["showToUser"]:
+                    print(response["data"]["message"])
+                continue
+            if typ == "progress":
+                logger.info(f"Backend progress: {response['data']['text']}")
+                continue
+            if typ == "popup":
+                leastChangeKey = response["data"]["leastChangeButtonKey"]
+                callback_message = {
+                    "guid": response["guid"],
+                    "command": "callback",
+                    "args": {"button": leastChangeKey},
+                }
+                self._ws.send(json.dumps(callback_message))
+                logger.info(
+                    f"Backend popup: leastChangeButtonKey enforced: '{leastChangeKey}'"
+                )
+                continue
+
+            if typ == "success":
+                return response.get("data")
+            elif typ == "cancel":
+                return None
+            elif typ == "error":
+                data = response.get("data") or {}
+                msg = data.get("message") or data.get("description") or "Unknown error"
+                raise RuntimeError(f"Backend error for '{command}': {msg}")
+            else:
+                raise RuntimeError(f"Unexpected response type '{typ}' for '{command}'")
+
+    def stop(self) -> None:
+        """Close the WebSocket and terminate the backend process."""
+        try:
+            self._ws.close()
+        except Exception:
+            pass
+        if self._process.poll() is None:
+            self._process.terminate()
+            self._process.wait()
+
+
+def start_backend(cenos_location: Path, app_name: str) -> BackendInstance:
+    python_exe = cenos_location / "backend" / "bin" / "python.exe"
+    server_script = cenos_location / "platform-files" / "cenos" / "server.py"
+    port = _find_free_port()
+
+    process = subprocess.Popen(
+        [str(python_exe), str(server_script), str(port)],
+        cwd=str(server_script.parent),
+        env=_build_env(cenos_location, app_name),
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+        encoding="utf-8",
+    )
+    logger.info(f"Backend process started (pid={process.pid}, port={port})")
+
+    # Read stdout in a background thread so readline() never blocks the main thread.
+    stdout_queue: queue.Queue[str | None] = queue.Queue()
+    threading.Thread(
+        target=_pipe_reader, args=(process.stdout, stdout_queue), daemon=True
+    ).start()
+
+    deadline = time.monotonic() + STARTUP_TIMEOUT
+    while True:
+        if time.monotonic() > deadline:
+            process.terminate()
+            raise TimeoutError(
+                f"Backend did not signal ready within {STARTUP_TIMEOUT}s"
+            )
+
+        if process.poll() is not None:
+            # Drain any remaining queued lines before giving up
+            remaining = []
+            try:
+                while True:
+                    remaining.append(stdout_queue.get_nowait() or "")
+            except queue.Empty:
+                pass
+            raise RuntimeError(
+                f"Backend exited (code {process.returncode}) before signalling ready.\n"
+                + "".join(remaining)
+                + process.stderr.read()
+            )
+
+        try:
+            line = stdout_queue.get(timeout=0.1)
+        except queue.Empty:
+            continue
+
+        if line is None:  # pipe closed
+            break
+        logger.debug(f"Backend stdout: {line.rstrip()}")
+        if "CENOS server is started" in line:
+            break
+
+    ws = websocket.WebSocket()
+    ws.connect(f"ws://localhost:{port}?id=gui")
+    logger.info(f"WebSocket connected on port {port}")
+
+    return BackendInstance(process, ws)

cenos_py-0.1.1/src/cenos_py/logger.py

@@ -0,0 +1,38 @@
+import logging
+import tempfile
+from datetime import datetime
+from pathlib import Path
+
+from cenos_py import misc_functions
+
+
+def setup_logger() -> logging.Logger:
+    logger = logging.getLogger(__name__)
+    logger.setLevel(logging.DEBUG)
+
+    if logger.hasHandlers():
+        logger.handlers.clear()
+
+    formatter = logging.Formatter(
+        "%(asctime)s - %(levelname)s - %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+    )
+
+    if misc_functions.is_editable_install():
+        console_handler = logging.StreamHandler()
+        console_handler.setLevel(logging.DEBUG)
+        console_handler.setFormatter(formatter)
+        logger.addHandler(console_handler)
+
+    log_dir = Path(tempfile.gettempdir()) / "cenos"
+    log_dir.mkdir(parents=True, exist_ok=True)
+    log_filename = log_dir / f"{datetime.now().strftime('%Y-%m-%d')}.cenos-py.log"
+    file_handler = logging.FileHandler(log_filename, encoding="utf-8")
+    file_handler.setLevel(logging.DEBUG)
+    file_handler.setFormatter(formatter)
+    logger.addHandler(file_handler)
+
+    return logger
+
+
+logger = setup_logger()

cenos_py-0.1.1/src/cenos_py/misc_functions.py

@@ -0,0 +1,66 @@
+import importlib.metadata
+import sys
+from os import PathLike
+from pathlib import Path
+
+_cenos_location: Path | None = None
+
+
+def is_editable_install() -> bool:
+    try:
+        dist = importlib.metadata.distribution("cenos-py")
+    except importlib.metadata.PackageNotFoundError:
+        return False
+
+    pkg_name = dist.metadata["Name"].replace("-", "_")
+
+    for p in sys.path:
+        path = Path(p).resolve()
+        if "site-packages" in path.parts:
+            continue
+        if (path / pkg_name).is_dir() or (path / f"{pkg_name}.py").exists():
+            return True
+
+    return False
+
+
+def is_dev_version(cenos_installation_path: Path) -> bool:
+    return not (cenos_installation_path / "resources").exists()
+
+
+def get_resources_path(cenos_installation_path: Path) -> Path:
+    if is_dev_version(cenos_installation_path):
+        return cenos_installation_path
+    else:
+        return cenos_installation_path / "resources"
+
+
+def setCenosLocation(path: str | PathLike) -> None:
+    """Set the Cenos software installation location."""
+    path = Path(path)
+    if not path.exists():
+        raise ValueError(f"Path '{path}' does not exist")
+    has_platform_files = (path / "platform-files").exists()
+    has_resources = (path / "resources").exists()
+
+    if not has_platform_files and not has_resources:
+        raise ValueError(
+            f"Path '{path}' does not appear to contains the expected cenos files, please check the path"
+        )
+
+    global _cenos_location
+    _cenos_location = get_resources_path(path)
+
+
+def get_installed_app_name(_cenos_location: Path):
+    available_apps = []
+    for dir in (_cenos_location / "app").iterdir():
+        if dir.is_dir():
+            available_apps.append(dir.name)
+
+    if len(available_apps) > 1:
+        # Dev mode
+        raise ValueError(
+            "Please specify the app that should be used in the CenosCase constructor."
+        )
+    return available_apps[0]

cenos_py-0.1.1/src/cenos_py/property_data.py

@@ -0,0 +1,68 @@
+"""Helpers for building PropertyDataDict payloads sent to the cenos backend.
+
+This module is hand-written (not generated) and is imported by the
+auto-generated `_generated_case_methods.py`. Keeping it separate avoids
+duplicating the same conversion logic in every generated property-setter
+method.
+"""
+
+from __future__ import annotations
+from typing import Literal, TypedDict
+
+# TODO: adjust this import path if case_worker's location changes.
+
+
+class PropertyDataDictValueTable(TypedDict):
+    arg: float
+    value: float
+
+
+class PropertyDataDict(TypedDict, total=False):
+    """The format in which physics, template or other property updates are called.
+    All possible structure examples:
+    {'key': 'I_3D', 'value': 2000}
+    {'key': 'I_3D', 'valueType': 'table', 'argument': 'Time'}
+    {'key': 'I_3D', 'valueTable': [{'arg': 0, 'value': 2000}, {'arg': 5, 'value': 4000}], 'argument': 'time'}
+    {'key': 'workpiece_diameter', 'valueType': 'scalar', 'value': 23}
+    {'key': 'isHollow', 'valueType': 'scalar', 'value': True}
+    {'key': 'algorithm', 'value': 'accurate'}
+    """
+
+    key: str
+    valueType: Literal["scalar", "table"]
+    value: str | int | float | bool
+    valueTable: list[PropertyDataDictValueTable]
+    argument: str
+
+
+def build_property_data(
+    key: str,
+    value: str | int | float | bool | list[tuple[float, float]],
+    argument: str | None = None,
+) -> PropertyDataDict:
+    """Build a PropertyDataDict from ergonomic (key, value, argument) arguments.
+
+    - argument is None:
+        -> {"key": key, "value": value}
+    - argument is set and value is a list of (arg, value) pairs:
+        -> {"key": key, "valueType": "table", "valueTable": [...], "argument": argument}
+    - argument is set and value is a scalar (str/int/float/bool):
+        -> {"key": key, "valueType": "scalar", "value": value, "argument": argument}
+    """
+    if argument is None:
+        return {"key": key, "value": value}
+
+    if isinstance(value, list):
+        return {
+            "key": key,
+            "valueType": "table",
+            "valueTable": [{"arg": arg, "value": val} for arg, val in value],
+            "argument": argument,
+        }
+
+    return {
+        "key": key,
+        "valueType": "scalar",
+        "value": value,
+        "argument": argument,
+    }

cenos_py-0.1.1/src/cenos_py/testing_utils.py

@@ -0,0 +1,27 @@
+import shutil
+import zipfile
+from pathlib import Path
+
+
+def unzip_case_to_temp(case_name: str) -> str:
+    zip_path = Path(__file__).parent.parent.parent / "examples" / "assets" / case_name
+
+    if not zip_path.exists():
+        raise FileNotFoundError(f"Zip file not found: {zip_path}")
+
+    temp_dir = Path(__file__).parent.parent.parent / "examples" / "temp"
+
+    if temp_dir.exists():
+        shutil.rmtree(temp_dir)
+
+    temp_dir.mkdir(parents=True, exist_ok=True)
+
+    with zipfile.ZipFile(zip_path, "r") as zip_ref:
+        zip_ref.extractall(temp_dir)
+
+    extracted_items = list(temp_dir.iterdir())
+    assert len(extracted_items) == 1 and extracted_items[0].is_dir(), (
+        "Expected exactly one directory in the extracted zip"
+    )
+
+    return str(extracted_items[0])