OpenSimula 0.8.0__tar.gz → 0.8.5__tar.gz

{opensimula-0.8.0 → opensimula-0.8.5}/PKG-INFO

@@ -1,14 +1,13 @@
 Metadata-Version: 2.4
 Name: opensimula
-Version: 0.8.0
+Version: 0.8.5
 Summary: Component-based time simulation environment in Python
 Author-email: "Juan F. Coronel" <jfc@us.es>
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: dash>=3.2.0
-Requires-Dist: dash-ag-grid>=32.3.2
-Requires-Dist: dash-bootstrap-components>=2.0.4
+Requires-Dist: anywidget>=0.11.0
+Requires-Dist: jsonschema>=4.26.0
 Requires-Dist: nbformat>=5.10.4
 Requires-Dist: numpy>=2.3.3
 Requires-Dist: openpyxl>=3.1.5

{opensimula-0.8.0 → opensimula-0.8.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "opensimula"
-version = "0.8.0"
+version = "0.8.5"
 requires-python = ">=3.12"
 authors = [
   { name="Juan F. Coronel", email="jfc@us.es" },
@@ -8,9 +8,8 @@ authors = [
 description = "Component-based time simulation environment in Python"
 readme = "README.md"
 dependencies = [
-    "dash>=3.2.0",
-    "dash-ag-grid>=32.3.2",
-    "dash-bootstrap-components>=2.0.4",
+    "anywidget>=0.11.0",
+    "jsonschema>=4.26.0",
     "nbformat>=5.10.4",
     "numpy>=2.3.3",
     "openpyxl>=3.1.5",
@@ -20,7 +19,7 @@ dependencies = [
     "scipy>=1.16.2",
     "shapely>=2.1.1",
     "tqdm>=4.67.1",
-"vedo>=2025.5.4",
+    "vedo>=2025.5.4",
 ]
 
 [dependency-groups]
@@ -31,6 +30,10 @@ dev = [
     "marimo>=0.19.0",
 ]
 
+[tool.setuptools.package-data]
+# The widget loads these at runtime; without this they are left out of the wheel.
+"opensimula.editor" = ["static/*.js", "static/*.css"]
+
 [build-system]
 requires = ["setuptools>=61.2", "wheel"]
 

{opensimula-0.8.0 → opensimula-0.8.5}/src/OpenSimula/Component.py

@@ -82,36 +82,43 @@ class Component(Parameter_container):
 
     # ____________ Functions that must be overwriten for time simulation _________________
 
-    def get_all_referenced_components(self):
+    def get_all_referenced_components(self, _seen=None):
         """Get list of all referenced components, first itself. Look recursively at the referenced components
 
+        Args:
+            _seen (set, optional): components already walked, used internally.
+                References can form a cycle, if only because a wrong name gets
+                typed into a reference, and without remembering where it has
+                been the walk follows it until the stack runs out.
+
         Returns:
             component_list (component[])
         """
+        if _seen is None:
+            _seen = set()
+        if id(self) in _seen:
+            return []
+        _seen.add(id(self))
+
         comp_list = []
+
+        def walk(component):
+            if component is not None:
+                comp_list.extend(component.get_all_referenced_components(_seen))
+
         for key, value in self.parameter_dict().items():
             if value.type == "Parameter_component":
-                if value.component is not None:
-                    sublist = value.component.get_all_referenced_components()
-                    for subcomp in sublist:
-                        comp_list.append(subcomp)
+                walk(value.component)
             elif value.type == "Parameter_component_list":
                 for comp in value.component:
-                    if comp is not None:
-                        sublist = comp.get_all_referenced_components()
-                        for subcomp in sublist:
-                            comp_list.append(subcomp)
+                    walk(comp)
             if value.type == "Parameter_variable":
                 if value.variable is not None:
-                    sublist = value.variable.parent.get_all_referenced_components()
-                    for subcomp in sublist:
-                        comp_list.append(subcomp)
+                    walk(value.variable.parent)
             elif value.type == "Parameter_variable_list":
                 for var in value.variable:
                     if var is not None:
-                        sublist = var.parent.get_all_referenced_components()
-                        for subcomp in sublist:
-                            comp_list.append(subcomp)
+                        walk(var.parent)
         comp_list.append(self)
         return comp_list
 

{opensimula-0.8.0 → opensimula-0.8.5}/src/OpenSimula/Parameters.py

@@ -184,7 +184,9 @@ class Parameter_string_list(Parameter):
         else:
             for el in value:
                 el = str(el)
-            self._value_ = value
+            # Own copy: keeping the caller list would let it be mutated from
+            # outside, and would be shared by every parameter assigned from it
+            self._value_ = list(value)
 
 
 # _____________ Parameter_int ___________________________
@@ -201,6 +203,14 @@ class Parameter_int(Parameter):
     def unit(self):
         return self._unit_
 
+    @property
+    def min(self):
+        return self._min_
+
+    @property
+    def max(self):
+        return self._max_
+
     @property
     def value(self):
         return self._value_
@@ -235,6 +245,14 @@ class Parameter_int_list(Parameter):
     def unit(self):
         return self._unit_
 
+    @property
+    def min(self):
+        return self._min_
+
+    @property
+    def max(self):
+        return self._max_
+
     @property
     def value(self):
         return self._value_
@@ -389,7 +407,9 @@ class Parameter_options_list(Parameter):
         else:
             for el in value:
                 el = str(el)
-            self._value_ = value
+            # Own copy: keeping the caller list would let it be mutated from
+            # outside, and would be shared by every parameter assigned from it
+            self._value_ = list(value)
 
     @property
     def options(self):
@@ -484,7 +504,9 @@ class Parameter_component_list(Parameter):
         # Is a list
         for el in value:
             el = str(el)
-        self._value_ = value
+        # Own copy: keeping the caller list would let it be mutated from
+        # outside, and would be shared by every parameter assigned from it
+        self._value_ = list(value)
 
         self._external_ = []
         for el in self.value:
@@ -622,7 +644,9 @@ class Parameter_variable_list(Parameter):
         # Is a list
         for el in value:
             el = str(el)
-        self._value_ = value
+        # Own copy: keeping the caller list would let it be mutated from
+        # outside, and would be shared by every parameter assigned from it
+        self._value_ = list(value)
 
         format_error = False
         self._symbol_ = []
@@ -744,7 +768,9 @@ class Parameter_math_exp_list(Parameter):
         # Is a list
         for el in value:
             el = str(el)
-        self._value_ = value
+        # Own copy: keeping the caller list would let it be mutated from
+        # outside, and would be shared by every parameter assigned from it
+        self._value_ = list(value)
 
     def evaluate(self, i, values_dic):
         try:

{opensimula-0.8.0 → opensimula-0.8.5}/src/OpenSimula/Project.py

@@ -2,9 +2,6 @@ import json
 import datetime as dt
 import numpy as np
 import pandas as pd
-from dash import Dash, callback, Input, Output, html, State
-import dash_ag_grid as dag
-import dash_bootstrap_components as dbc
 import psychrolib as sicro
 from tqdm import trange
 from opensimula.Message import Message
@@ -59,13 +56,14 @@ class Project(Parameter_container):
         )
         self.add_parameter(
             Parameter_options(
-                "shadow_calculation", "INSTANT", ["NO", "INSTANT", "INTERPOLATION"]
+                "shadow_calculation", "INTERPOLATION", ["NO", "INSTANT", "INTERPOLATION"]
             )
         )
         self.add_parameter(Parameter_float("albedo", 0.2, "frac", min=0, max=1))
 
         self._sim_ = sim
         self._components_ = []
+        self._components_dict_ = {}  # name -> component index, see component()
         sicro.SetUnitSystem(sicro.SI)
         atm_p = sicro.GetStandardAtmPressure(0)
         w_50 = sicro.GetHumRatioFromRelHum(22.5, 0.5, atm_p)
@@ -93,6 +91,18 @@ class Project(Parameter_container):
             "RHOCP_W": rhocp_water,
         }
 
+    def clear(self):
+        """Remove every component from the Project
+
+        The parameters of the project itself keep their values; only its
+        components are dropped. Needed before reloading a definition into a
+        project that already holds one, because read_dict() and read_json()
+        add components, they do not replace them.
+        """
+        self._components_ = []
+        self._components_dict_ = {}
+        self._ordered_component_list_ = []
+
     def del_component(self, component):
         """Delete component from Project
 
@@ -100,6 +110,13 @@ class Project(Parameter_container):
             component (Component): Component to be removed from the project
         """
         self._components_.remove(component)
+        # Drop every index entry pointing at it, so a later component reusing
+        # its name cannot resolve to the deleted one.
+        self._components_dict_ = {
+            key: comp
+            for key, comp in self._components_dict_.items()
+            if comp is not component
+        }
 
     def component(self, name):
         """Find and return component with its name
@@ -110,8 +127,16 @@ class Project(Parameter_container):
         Returns:
             component (Component): component found, None if not found.
         """
+        # Components are looked up by name millions of times during a
+        # simulation, so hits are served from an index. The cached component is
+        # revalidated against its current name because components can be
+        # renamed after being indexed; a stale entry falls back to the scan.
+        comp = self._components_dict_.get(name)
+        if comp is not None and comp.parameter("name").value == name:
+            return comp
         for comp in self._components_:
             if comp.parameter("name").value == name:
+                self._components_dict_[name] = comp
                 return comp
         return None
 
@@ -586,100 +611,76 @@ class Project(Parameter_container):
     def simulation_dataframe(self):
         return self._sim_df
 
-    def component_editor(self, comp_type="all"):
-        editor = Dash(external_stylesheets=[dbc.themes.BOOTSTRAP])
-        df = self.component_dataframe(comp_type=comp_type, string_format=True)
-        self._n_clicks_new_comp_ = 0
-        self._n_clicks_del_comp_ = 0
-        disabled_new = False
-        if comp_type == "all":
-            disabled_new = True
-
-        column_definition = [
-            {
-                "field": "name",
-                "checkboxSelection": True,
-                "headerCheckboxSelection": True,
-            }
-        ]
-        for i in df.columns:
-            if i != "name":
-                column_definition.append({"field": i})
-
-        editor.layout = html.Div(
-            [
-                dbc.Label("Components editor:"),
-                html.Br(),
-                dbc.Button(
-                    "New component",
-                    id="btn-new-comp",
-                    disabled=disabled_new,
-                    n_clicks=0,
-                ),
-                dbc.Button(
-                    "Delete selected components",
-                    id="btn-del-comp",
-                    n_clicks=0,
-                    style={"margin-left": "15px"},
-                ),
-                html.Br(),
-                html.Br(),
-                dag.AgGrid(
-                    id="comp-table",
-                    rowData=df.to_dict("records"),
-                    columnDefs=column_definition,
-                    columnSize="sizeToFit",
-                    defaultColDef={"filter": True, "editable": True},
-                    style={"height": "500px"},
-                    dashGridOptions={
-                        "rowSelection": "multiple",
-                        "suppressRowClickSelection": True,
-                        "pagination": True,
-                    },
-                ),
-            ]
-        )
+    def editor(self):
+        """Interactive editor for the whole project definition.
 
-        @callback(
-            Output("comp-table", "rowData"),
-            Input("comp-table", "cellValueChanged"),
-            Input("btn-new-comp", "n_clicks"),
-            Input("btn-del-comp", "n_clicks"),
-            State("comp-table", "selectedRows"),
-            prevent_initial_call=True,
-        )
-        def update_data(changed, n_clicks_new, n_clicks_del, selectedRows):
-            if self._n_clicks_new_comp_ < n_clicks_new:
-                self.new_component(comp_type, "new_comp_" + str(n_clicks_new))
-                self._n_clicks_new_comp_ = n_clicks_new
-            elif self._n_clicks_del_comp_ < n_clicks_del:
-                for row in selectedRows:
-                    self.del_component(self.component(row["name"]))
-                self._n_clicks_del_comp_ = n_clicks_del
-            else:
-                if changed is not None:
-                    if changed[0]["colId"] == "name":
-                        self.component(changed[0]["oldValue"]).parameter(
-                            "name"
-                        ).value = changed[0]["value"]
-                    else:
-                        self.component(changed[0]["data"]["name"]).parameter(
-                            changed[0]["colId"]
-                        ).value = changed[0]["value"]
-            df_end = self.component_dataframe(comp_type=comp_type, string_format=True)
-            return df_end.to_dict("records")
+        Returns an anywidget that works in Jupyter and, wrapped in
+        mo.ui.anywidget(), in Marimo. The document is read with write_dict();
+        the widget does not write back to this project.
 
-        editor.run(jupyter_height=600)
+        Returns:
+            ProjectEditor: widget holding the project document in .value
+        """
+        # Imported here: opensimula.editor reaches Project through Simulation,
+        # so a module level import would close the cycle.
+        from opensimula.editor import ProjectEditor
+
+        return ProjectEditor(self)
 
     def create_3D_environment(self, env_3D):
         for component in self.component_list("all"):
-            if hasattr(component, "get_polygon_3D"):
-                env_3D.add_polygon_3D(component.get_polygon_3D())
+            if not hasattr(component, "get_polygon_3D"):
+                continue
+            try:
+                polygon = component.get_polygon_3D()
+            except (AttributeError, IndexError, TypeError):
+                # A surface whose space, or an opening whose surface, does not
+                # resolve has no place to be. It is left out rather than
+                # bringing the whole view down; check() names the reference.
+                continue
+            self._set_polygon_origin_(polygon, component)
+            env_3D.add_polygon_3D(polygon)
+
+    def _set_polygon_origin_(self, polygon, component):
+        """Record which component a polygon came from, and which spaces it bounds.
+
+        Polygon_3D is geometry and knows nothing of the model, so the link is
+        made here, where the component is still at hand. It is what lets a
+        viewer show one space at a time; an interior partition belongs to the
+        two spaces on either side of it.
+        """
+        polygon.component = component.parameter("name").value
+        polygon.component_type = component.parameter("type").value
+
+        surface = component
+        if polygon.component_type == "Opening":
+            surface = component.get_surface()
+        if surface is None:
+            return
+
+        parameters = surface.parameter_dict()
+        if "surface_type" in parameters:
+            polygon.surface_type = parameters["surface_type"].value
+        if "spaces" in parameters:
+            polygon.spaces = [
+                name for name in parameters["spaces"].value if name != "not_defined"
+            ]
            
+    def geometry_dict(self):
+        """Geometry of the project as plain data, for a 3D viewer
+
+        Returns:
+            dict: {"meshes": [...], "spaces": [...]}, one mesh per polygon with
+                its triangles and the component and spaces it belongs to
+        """
+        env_3D = Environment_3D()
+        self.create_3D_environment(env_3D)
+        return env_3D.geometry_dict()
+
     def show_3D(self, jupyter=False):
         env_3D = Environment_3D()
         self.create_3D_environment(env_3D)
-        env_3D.show(polygons_type="initial", jupyter=jupyter)
+        return env_3D.show(polygons_type="initial", jupyter=jupyter)
 
     def show_3D_shadows(self, date, jupyter=False):
         env_3D = Environment_3D()

{opensimula-0.8.0 → opensimula-0.8.5}/src/OpenSimula/Simulation.py

@@ -2,9 +2,6 @@ from opensimula.Project import Project
 import pandas as pd
 import plotly.express as px
 from plotly.subplots import make_subplots
-from dash import Dash, callback, Input, Output, html, State
-import dash_ag_grid as dag
-import dash_bootstrap_components as dbc
 
 
 class Simulation:
@@ -163,63 +160,3 @@ class Simulation:
         # fig.update_traces(showlegend=True)
         subfig.show()
 
-    def project_editor(self):
-        editor = Dash(external_stylesheets=[dbc.themes.BOOTSTRAP])
-        df = self.project_dataframe(string_format=True)
-        self._n_clicks_new_project_ = 0
-        self._n_clicks_del_project_ = 0
-        column_definition = [
-            {"field": "name", "checkboxSelection": True, "headerCheckboxSelection": True}]
-        for i in df.columns:
-            if i != "name":
-                column_definition.append({"field": i})
-
-        editor.layout = html.Div([
-            dbc.Label("Projects editor:  "),
-            html.Br(),
-            dbc.Button('New project', id='btn-new-project', n_clicks=0),
-            dbc.Button('Delete selected projects',
-                       id='btn-del-project', n_clicks=0, style={"margin-left": "15px"}),
-            html.Br(),
-            html.Br(),
-            dag.AgGrid(
-                id="project-table",
-                rowData=df.to_dict("records"),
-                columnDefs=column_definition,
-                columnSize="sizeToFit",
-                defaultColDef={"filter": True, "editable": True},
-                style={"height": '250px'},
-                dashGridOptions={
-                    "rowSelection": "multiple",
-                    "suppressRowClickSelection": True,
-                    "pagination": True,
-                })
-        ])
-
-        @callback(
-            Output('project-table', 'rowData'),
-            Input('project-table', 'cellValueChanged'),
-            Input('btn-new-project', 'n_clicks'),
-            Input('btn-del-project', 'n_clicks'),
-            State('project-table', 'selectedRows'),
-            prevent_initial_call=True)
-        def update_data(changed, n_clicks_new, n_clicks_del, selectedRows):
-            if (self._n_clicks_new_project_ < n_clicks_new):
-                self.new_project("new_project_"+str(n_clicks_new))
-                self._n_clicks_new_project_ = n_clicks_new
-            elif (self._n_clicks_del_project_ < n_clicks_del):
-                for row in selectedRows:
-                    self.del_project(self.project(row["name"]))
-                self._n_clicks_del_project_ = n_clicks_del
-            else:
-                if changed is not None:
-                    if changed[0]["colId"] == "name":
-                        self.project(changed[0]['oldValue']).parameter(
-                            "name").value = changed[0]["value"]
-                    else:
-                        self.project(changed[0]['data']["name"]).parameter(
-                            changed[0]["colId"]).value = changed[0]["value"]
-            df_end = self.project_dataframe(string_format=True)
-            return df_end.to_dict("records")
-
-        editor.run(jupyter_height=350)

{opensimula-0.8.0 → opensimula-0.8.5}/src/OpenSimula/components/Building_surface.py

@@ -1,4 +1,5 @@
 import math
+from shapely.validation import explain_validity
 from opensimula.Message import Message
 from opensimula.components.Surface import Surface
 from opensimula.Parameters import (
@@ -106,10 +107,49 @@ class Building_surface(Surface):
         # Create openings list
         if self._surface_type_ == "EXTERIOR" or self._surface_type_ == "INTERIOR":
             self._create_openings_list_()
+            errors.extend(self._check_polygon_validity_())
+        return errors
+
+    def _check_polygon_validity_(self):
+        """Warn when the surface outline with its openings has no valid single-piece shape.
+
+        get_polygon_3D() already recovers an opening flush with the surface
+        edge (a door reaching the floor, a window flush with a wall edge, usual
+        in imported geometry), see Polygon_3D._build_shapely_polygon_, so that
+        alone is not worth a warning. What it cannot recover from is an opening
+        that splits the surface into disconnected pieces, or geometry that
+        stays invalid after that recovery.
+        """
+        errors = []
+        if len(self.openings) == 0:
+            return errors
+        polygon = Polygon_3D._build_shapely_polygon_(
+            self.get_polygon_2D(), [op.get_polygon_2D() for op in self.openings]
+        )
+        if not polygon.is_valid:
+            msg = (
+                f"{self.parameter('name').value}, the surface outline with its openings "
+                f"is not a valid polygon ({explain_validity(polygon)}). Shadow results "
+                "for this surface may be unreliable."
+            )
+            errors.append(Message(msg, "WARNING"))
+        elif polygon.geom_type != "Polygon":
+            msg = (
+                f"{self.parameter('name').value}, its openings split the surface outline "
+                "into disconnected pieces. Shadow results for this surface may be unreliable."
+            )
+            errors.append(Message(msg, "WARNING"))
         return errors
 
     def get_building(self):
-        return self.parameter("spaces").component[0].get_building()
+        space = self.get_space()
+        # Only a Space knows its building directly. Following anything else
+        # chases its get_building() in turn, and a name that points back here,
+        # which "spaces" accepts because it is only checked later, would run
+        # the stack out before check() could report it.
+        if space is None or space.parameter("type").value != "Space":
+            return None
+        return space.get_building()
 
     def get_space(self, side=0):
         return self.parameter("spaces").component[side]

{opensimula-0.8.0 → opensimula-0.8.5}/src/OpenSimula/components/Chiller_heat_pump.py

@@ -5,7 +5,7 @@ from opensimula.Component import Component
 class Chiller_heat_pump(Component):
     def __init__(self, name, project):
         Component.__init__(self, name, project)
-        self.parameter("type").value = "Chiller"
+        self.parameter("type").value = "Chiller_heat_pump"
         self.parameter("description").value = "Chiller equipment manufacturer information"
         self.add_parameter(Parameter_options("chiller_type", "CHILLER", ["CHILLER", "HEAT_PUMP", "CHILLER_HEAT_PUMP"]))
         self.add_parameter(Parameter_options("condensation_type", "AIR_CONDENSED", ["AIR_CONDENSED", "WATER_CONDENSED"]))

{opensimula-0.8.0 → opensimula-0.8.5}/src/OpenSimula/components/Construction.py

@@ -17,7 +17,7 @@ class Construction(Component):
         self.add_parameter(Parameter_float_list(
             "lw_epsilon", [0.9, 0.9], "frac", min=0, max=1))
         self.add_parameter(Parameter_component_list(
-            "materials", [], "Material"))
+            "materials", [], ["Material"]))
         self.add_parameter(Parameter_float_list("thicknesses", [], "m", min=0))
 
     def check(self):
@@ -35,8 +35,10 @@ class Construction(Component):
             material_name (str): Name of the material component to add
             thickness (float): Thickness of the layer in meters
         """
-        materials = self.parameter("materials").value
-        thicknesses = self.parameter("thicknesses").value
+        # Copies, because the getter returns the parameter own list and
+        # inserting into it would modify the construction before validation
+        materials = list(self.parameter("materials").value)
+        thicknesses = list(self.parameter("thicknesses").value)
         materials.insert(0, material_name)
         thicknesses.insert(0, thickness)
         self.parameter("materials").value = materials

{opensimula-0.8.0 → opensimula-0.8.5}/src/OpenSimula/components/Opening.py

@@ -93,7 +93,8 @@ class Opening(Component):
         return errors
 
     def get_building(self):
-        return self.get_surface().get_building()
+        surface = self.get_surface()
+        return None if surface is None else surface.get_building()
 
     def get_space(self, side=0):
         return self.get_surface().get_space(side)

{opensimula-0.8.0 → opensimula-0.8.5}/src/OpenSimula/components/Opening_type.py

@@ -11,11 +11,11 @@ class Opening_type(Component):
             "description").value = "Window or doors with glazing, construction, frame and shading."
 
         self.add_parameter(Parameter_component(
-            "glazing", "not_defined", "Glazing"))
+            "glazing", "not_defined", ["Glazing"]))
         self.add_parameter(Parameter_component(
-            "frame", "not_defined", "Frame"))
+            "frame", "not_defined", ["Frame"]))
         self.add_parameter(Parameter_component(
-            "construction", "not_defined", "Construction"))
+            "construction", "not_defined", ["Construction"]))
         self.add_parameter(Parameter_float(
             "glazing_fraction", 0.9, "frac", min=0, max=1))
         self.add_parameter(Parameter_float(