PySimultan 0.4.18__tar.gz → 0.4.20__tar.gz

{pysimultan-0.4.18 → pysimultan-0.4.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: PySimultan
-Version: 0.4.18
+Version: 0.4.20
 Project-URL: Documentation, https://github.com/Bühler Maximilian/PySimultan2#readme
 Project-URL: Issues, https://github.com/Bühler Maximilian/PySimultan2/issues
 Project-URL: Source, https://github.com/Bühler Maximilian/PySimultan2
@@ -78,3 +78,12 @@ C:\Program Files\FreeCAD
 │
 
 ```
+
+
+# Change Log
+
+## [0.4.20] - 2024-07-01
+- Fixed Bug in nested dictionary creation
+
+## [0.4.19] - 2024-07-01
+- Refactored dictionaries 

{pysimultan-0.4.18 → pysimultan-0.4.20}/README.md

@@ -49,3 +49,12 @@ C:\Program Files\FreeCAD
 │
 
 ```
+
+
+# Change Log
+
+## [0.4.20] - 2024-07-01
+- Fixed Bug in nested dictionary creation
+
+## [0.4.19] - 2024-07-01
+- Refactored dictionaries 

pysimultan-0.4.20/src/PySimultan2/__about__.py

@@ -0,0 +1 @@
+version = '0.4.20'

{pysimultan-0.4.18 → pysimultan-0.4.20}/src/PySimultan2/default_types.py

@@ -341,6 +341,9 @@ class ComponentDictionary(SimultanObject):
         super().__init__(*args, **kwargs)
         self.component_policy = kwargs.get('component_policy', 'subcomponent')  # component add policy of the content/parameter/property, 'reference' or 'subcomponent'
 
+    def __load_init__(self, *args, **kwargs):
+        self._dict = {}
+
     @classmethod
     def create_from_values(cls,
                            values: dict[str, Any],
@@ -374,13 +377,54 @@ class ComponentDictionary(SimultanObject):
 
         if kwargs.get('check_dict', True) and comp_dict is not None and key in object.__getattribute__(self,
                                                                                                        '_dict').keys():
-            return object.__getattribute__(self, '_dict')[key]
+            return object.__getattribute__(self, '_dict').get(key, None)
         else:
             # data_model = config.default_data_model
-            obj = get_component_taxonomy_entry(self._wrapped_obj, key)
-            if obj is not None:
-                val = get_obj_value(obj, data_model=self._data_model, object_mapper=self._object_mapper)
-                self._dict[key] = val
+            # obj = get_component_taxonomy_entry(self._wrapped_obj, key)
+            # if obj is not None:
+            # val = get_obj_value(obj, data_model=self._data_model, object_mapper=self._object_mapper)
+            data_model = self._data_model
+            object_mapper = self._object_mapper
+            wrapped_obj = self._wrapped_obj
+
+            if key in self._taxonomy_map.parameter_taxonomy_entry_dict.keys():
+                text_or_key = self._taxonomy_map.parameter_taxonomy_entry_dict[key]
+            else:
+                content = Content(text_or_key=f'__dict_key__{key}',
+                                  property_name=key,
+                                  type=None,
+                                  unit=None,
+                                  documentation=f'Property {key} in ComponentDictionary',
+                                  component_policy=self.component_policy)
+                self._taxonomy_map.add_content(content)
+                text_or_key = content.text_or_key
+
+            try:
+                components = list(wrapped_obj.Components.Items)
+                val = next((get_obj_value(x.Component,
+                                          data_model=data_model,
+                                          object_mapper=object_mapper) for x in components if
+                            x.Slot.SlotBase.Target.Key == text_or_key), None)
+                if val is None:
+                    ref_components = list(wrapped_obj.ReferencedComponents.Items)
+                    val = next((get_obj_value(x.Target,
+                                              data_model=data_model,
+                                              object_mapper=object_mapper) for x in ref_components
+                                if x.Slot.SlotBase.Target.Key == text_or_key), None)
+                if val is None:
+                    parameters = list(wrapped_obj.Parameters.Items)
+                    val = next((get_obj_value(x,
+                                              data_model=data_model,
+                                              object_mapper=object_mapper) for x in parameters if
+                                x.NameTaxonomyEntry.TextOrKey == text_or_key), None)
+
+            except Exception as e:
+                logger.error(f'Could not get value for key {key} ({text_or_key}) in {self}:\n{e}')
+                raise ValueError(f'Could not get value for key {key} ({text_or_key}) in {self}:\n{e}')
+
+            self._dict[key] = get_obj_value(val,
+                                            data_model=data_model,
+                                            object_mapper=object_mapper)
         return self._dict[key]
 
     def __setitem__(self, key, value):
@@ -391,7 +435,7 @@ class ComponentDictionary(SimultanObject):
         if key in self._taxonomy_map.content_dict.keys():
             content = self._taxonomy_map.content_dict[key]
         else:
-            content = Content(text_or_key=key,
+            content = Content(text_or_key=f'__dict_key__{key}',
                               property_name=key,
                               type=None,
                               unit=None,
@@ -399,7 +443,6 @@ class ComponentDictionary(SimultanObject):
                               component_policy=self.component_policy)
             self._taxonomy_map.add_content(content)
         taxonomy_entry = content.get_taxonomie_entry(self._data_model)
-
         component_idx, ref_component_idx, parameter_idx, ref_asset_idx = get_param_indices(self._wrapped_obj,
                                                                                            taxonomy_entry)
 
@@ -425,6 +468,7 @@ class ComponentDictionary(SimultanObject):
                                            ref_component_idx=ref_component_idx,
                                            parameter_idx=parameter_idx,
                                            keep=[])
+            return
 
         if isinstance(value, (list, tuple, set, ComponentList)):
             setter_fcn = set_property_to_list
@@ -436,11 +480,7 @@ class ComponentDictionary(SimultanObject):
         setter_fcn(*fcn_arg_list)
         item = self.__getitem__(key, check_dict=False)
 
-        # self._object_mapper.create_python_object(self._wrapped_obj)
-        #
-        # if isinstance(value, ):
-
-        self._dict[key] = self.__getitem__(key, check_dict=False)
+        self._dict[key] = item
 
     def __delitem__(self, key):
         self[key] = None
@@ -471,7 +511,7 @@ class ComponentDictionary(SimultanObject):
                                                                           data_model=self._data_model,
                                                                           object_mapper=self._object_mapper)
         for ref_component in self._wrapped_obj.ReferencedComponents.Items:
-            comp_dict[ref_component.Slot.SlotBase.Target.Name] = get_obj_value(ref_component.Target,
+            comp_dict[ref_component.Slot.SlotBase.Target.Key] = get_obj_value(ref_component.Target,
                                                                                data_model=self._data_model,
                                                                                object_mapper=self._object_mapper)
         for ref_asset in self._wrapped_obj.ReferencedAssets.Items:

{pysimultan-0.4.18 → pysimultan-0.4.20}/src/PySimultan2/taxonomy_maps.py

@@ -87,6 +87,7 @@ class TaxonomyMap(object):
 
         self._content = []
         self._content_dict = {}
+        self._parameter_taxonomy_entry_dict = {}
 
         self.taxonomy_name = kwargs.get('taxonomy_name', kwargs.get('taxonomy_key', None))
         self.taxonomy_key = kwargs.get('taxonomy_key', None)
@@ -124,6 +125,13 @@ class TaxonomyMap(object):
                 self._content_dict[content.text_or_key] = content
         return self._content_dict
 
+    @property
+    def parameter_taxonomy_entry_dict(self):
+        if not self._parameter_taxonomy_entry_dict:
+            for content in self._content:
+                self._parameter_taxonomy_entry_dict[content.property_name] = content.text_or_key
+        return self._parameter_taxonomy_entry_dict
+
     def write(self, filename=None):
         if filename is not None:
             with open(filename, mode='w') as f:

{pysimultan-0.4.18 → pysimultan-0.4.20}/src/PySimultan2/utils.py

@@ -1,10 +1,16 @@
 from __future__ import annotations
 
+import sys
+import traceback
+
 from enum import Enum
 from weakref import WeakSet
 import numpy as np
 import pandas as pd
 from typing import List as TypeList, Union, Optional, Type, Any, TYPE_CHECKING
+
+from System import ArgumentException, NotSupportedException
+
 from SIMULTAN.Data.Components import (ComponentWalker, SimComponent, SimBoolParameter, SimDoubleParameter,
                                       SimEnumParameter, SimIntegerParameter, SimStringParameter, ComponentMapping,
                                       SimSlot, SimComponentVisibility, SimChildComponentEntry, SimDefaultSlots,
@@ -417,8 +423,31 @@ def add_sub_component(comp: SimComponent,
         new_slot = SimSlot(sub_comp.Slots[0].Target, str(slot_extension))
 
     entry = SimChildComponentEntry(new_slot, sub_comp)
+
+    error = None
+    new_slot_extension = 0
+
     if entry not in comp.Components.Items:
-        comp.Components.InsertItem(len(comp.Components.Items), entry)
+        try:
+            comp.Components.InsertItem(len(comp.Components.Items), entry)
+        except (ArgumentException, NotSupportedException) as e:
+            error = e
+
+            while error is not None and new_slot_extension < 100:
+                try:
+                    try:
+                        slot_extension += 1
+                        if slot_extension > 1000:
+                            break
+                    except Exception as e:
+                        new_slot_extension += 1
+                        slot_extension = slot_extension + f'_{new_slot_extension}'
+                    new_slot = SimSlot(sub_comp.Slots[0].Target, str(slot_extension))
+                    entry = SimChildComponentEntry(new_slot, sub_comp)
+                    comp.Components.InsertItem(len(comp.Components.Items), entry)
+                    error = None
+                except (ArgumentException, NotSupportedException) as e:
+                    error = e
     return True
 
 
@@ -727,7 +756,8 @@ type_convert_dict = {SimComponent: get_sim_component_value,
                      SimEnumParameter: get_parameter_value,
                      ResourceEntry: get_resource_entry_value,
                      ContainedResourceFileEntry: get_resource_entry_value,
-                     LinkedResourceFileEntry: get_resource_entry_value}
+                     LinkedResourceFileEntry: get_resource_entry_value
+                     }
 
 
 def get_obj_value(obj: Union[SimComponent, SimDoubleParameter, SimIntegerParameter, SimStringParameter,
@@ -738,6 +768,8 @@ def get_obj_value(obj: Union[SimComponent, SimDoubleParameter, SimIntegerParamet
 
     if obj is None:
         return
+    elif isinstance(obj, (int, float, str)):
+        return obj
     elif type(obj) in type_convert_dict.keys():
         return type_convert_dict[type(obj)](obj, data_model=data_model, object_mapper=object_mapper)
     else:

pysimultan-0.4.20/tests/test_set_dictionary.py

@@ -0,0 +1,163 @@
+from PySimultan2.src.PySimultan2.data_model import DataModel
+from PySimultan2.src.PySimultan2.object_mapper import PythonMapper
+from PySimultan2.src.PySimultan2.taxonomy_maps import TaxonomyMap, Content
+
+import resources
+
+try:
+    import importlib.resources as pkg_resources
+except ImportError:
+    # Try backported to PY<37 importlib_resources.
+    import importlib_resources as pkg_resources
+
+
+with pkg_resources.path(resources, 'test_set_dictionary.simultan') as r_path:
+    project_path = str(r_path)
+
+data_model = DataModel.create_new_project(project_path=project_path,
+                                          user_name='admin',
+                                          password='admin')
+
+mapper = PythonMapper()
+
+
+def map_classes():
+    class TestComponent(object):
+        def __init__(self, *args, **kwargs):
+            self.mapped_property = kwargs.get('mapped_property')
+            self.value2 = kwargs.get('value2')
+
+    content0 = Content(text_or_key='value',  # text or key of the content/parameter/property
+                       property_name='mapped_property',  # name of the generated property
+                       type=None,  # type of the content/parameter/property
+                       unit=None,  # unit of the content/parameter/property
+                       documentation='mapped_property to test',
+                       component_policy='subcomponent')
+
+    content1 = Content(text_or_key='value2',  # text or key of the content/parameter/property
+                       property_name='value2',  # name of the generated property
+                       type=None,  # type of the content/parameter/property
+                       unit=None,  # unit of the content/parameter/property
+                       documentation='value2',
+                       component_policy='reference')
+
+    test_component_map = TaxonomyMap(taxonomy_name='PySimultan',
+                                     taxonomy_key='PySimultan',
+                                     taxonomy_entry_name='TestComponent',
+                                     taxonomy_entry_key='TestComponent',
+                                     content=[content0, content1],
+                                     )
+
+    mapper.register(test_component_map.taxonomy_entry_key, TestComponent, taxonomy_map=test_component_map)
+    cls1 = mapper.get_mapped_class(test_component_map.taxonomy_entry_key)
+
+    test_component_map_2 = TaxonomyMap(taxonomy_name='PySimultan',
+                                       taxonomy_key='PySimultan',
+                                       taxonomy_entry_name='TestComponent2',
+                                       taxonomy_entry_key='TestComponent2',
+                                       content=[content0],
+                                       )
+
+    mapper.register(test_component_map_2.taxonomy_entry_key, TestComponent, taxonomy_map=test_component_map_2)
+    cls2 = mapper.get_mapped_class(test_component_map_2.taxonomy_entry_key)
+
+    return cls1, cls2
+
+
+mapped_cls_1, mapped_cls_2 = map_classes()
+component = mapped_cls_1(name='test_component',
+                         mapped_property=None)
+
+
+def test_set_dictionary_param(component):
+
+    other_component = mapped_cls_2(name='other_component',
+                                   mapped_property=None)
+    other_component_2 = mapped_cls_2(name='other_component_2',
+                                     mapped_property=None)
+    other_component_3 = mapped_cls_2(name='other_component_3',
+                                     mapped_property=None)
+    other_component_4 = mapped_cls_2(name='other_component_4',
+                                     mapped_property=None)
+
+    new_test = mapped_cls_1(name='test_component_2',
+                            mapped_property={'val_a': 1,
+                                             'val_b': 2.0,
+                                             'val_c': 'test',
+                                             'val_d': True,
+                                             'val_e': [other_component, other_component_2, other_component_3],
+                                             'val_f': {'a': other_component_2, 'b': other_component_3},
+                                             'val_g': None,
+                                             'val_h': other_component,
+                                             'val_i': other_component_4,
+                                             })
+
+    test_dict = {'val_a': 1,
+                 'val_b': 2.0,
+                 'val_c': 'test',
+                 'val_d': True,
+                 'val_e': [other_component, other_component_2, other_component_3],
+                 'val_f': {'a': other_component_2, 'b': other_component_3},
+                 'val_g': None,
+                 'val_h': other_component,
+                 'val_i': 5,
+                 'val_j': new_test
+                 }
+
+    component.mapped_property = test_dict
+    component.mapped_property['val_a'] = 222
+
+    assert component.mapped_property['val_j'].mapped_property['val_a'] == 1
+    component.mapped_property['val_j'].mapped_property._generate_internal_dict()
+
+    component.mapped_property['val_i'] = other_component_4
+
+    print(component.mapped_property)
+
+
+def load_data_model(data_model: DataModel):
+    data_model = DataModel(project_path=project_path,
+                           user_name='admin',
+                           password='admin')
+    typed_data = data_model.get_typed_data(mapper=mapper,
+                                           create_all=True)
+
+    TestComponent = mapper.get_mapped_class('TestComponent')
+    test_component = TestComponent.cls_instances[0]
+
+    TestComponent2 = mapper.get_mapped_class('TestComponent2')
+    other_component = next(x for x in TestComponent2.cls_instances if x.name == 'other_component')
+    other_component_2 = next(x for x in TestComponent2.cls_instances if x.name == 'other_component_2')
+    other_component_3 = next(x for x in TestComponent2.cls_instances if x.name == 'other_component_3')
+    other_component_4 = next(x for x in TestComponent2.cls_instances if x.name == 'other_component_4')
+
+    assert test_component.mapped_property['val_a'] == 222
+    assert test_component.mapped_property['val_b'] == 2.0
+    assert test_component.mapped_property['val_c'] == 'test'
+    assert test_component.mapped_property['val_d'] is True
+    assert test_component.mapped_property['val_g'] is None
+    assert test_component.mapped_property['val_h'] == other_component
+    assert len(test_component.mapped_property['val_e']) == 3
+    assert test_component.mapped_property['val_e'][0] == other_component
+    assert test_component.mapped_property['val_e'][1] == other_component_2
+    assert test_component.mapped_property['val_e'][2] == other_component_3
+    assert test_component.mapped_property['val_f']['a'] == other_component_2
+    assert test_component.mapped_property['val_f']['b'] == other_component_3
+    assert test_component.mapped_property['val_i'] == other_component_4
+
+    return data_model
+
+
+if __name__ == '__main__':
+    test_set_dictionary_param(component)
+    data_model.save()
+    mapper.clear()
+    data_model.cleanup()
+    data_model = DataModel(project_path=project_path,
+                           user_name='admin',
+                           password='admin')
+    load_data_model(data_model)
+
+
+data_model.cleanup()
+print('Test passed')

pysimultan-0.4.18/src/PySimultan2/__about__.py

@@ -1 +0,0 @@
-version = '0.4.18'

pysimultan-0.4.18/tests/test_set_dictionary.py

@@ -1,88 +0,0 @@
-from PySimultan2.data_model import DataModel
-from PySimultan2.object_mapper import PythonMapper
-from PySimultan2.taxonomy_maps import TaxonomyMap, Content
-
-import resources
-
-try:
-    import importlib.resources as pkg_resources
-except ImportError:
-    # Try backported to PY<37 importlib_resources.
-    import importlib_resources as pkg_resources
-
-
-with pkg_resources.path(resources, 'test_set_dictionary.simultan') as r_path:
-    project_path = str(r_path)
-
-data_model = DataModel.create_new_project(project_path=project_path,
-                                          user_name='admin',
-                                          password='admin')
-
-mapper = PythonMapper()
-
-
-def map_classes():
-    class TestComponent(object):
-        def __init__(self, *args, **kwargs):
-            self.mapped_property = kwargs.get('mapped_property')
-            self.value2 = kwargs.get('value2')
-
-    content0 = Content(text_or_key='value',  # text or key of the content/parameter/property
-                       property_name='mapped_property',  # name of the generated property
-                       type=None,  # type of the content/parameter/property
-                       unit=None,  # unit of the content/parameter/property
-                       documentation='mapped_property to test',
-                       component_policy='subcomponent')
-
-    content1 = Content(text_or_key='value2',  # text or key of the content/parameter/property
-                       property_name='value2',  # name of the generated property
-                       type=None,  # type of the content/parameter/property
-                       unit=None,  # unit of the content/parameter/property
-                       documentation='value2',
-                       component_policy='reference')
-
-    test_component_map = TaxonomyMap(taxonomy_name='PySimultan',
-                                     taxonomy_key='PySimultan',
-                                     taxonomy_entry_name='TestComponent',
-                                     taxonomy_entry_key='TestComponent',
-                                     content=[content0, content1],
-                                     )
-
-    mapper.register(test_component_map.taxonomy_entry_key, TestComponent, taxonomy_map=test_component_map)
-    cls1 = mapper.get_mapped_class(test_component_map.taxonomy_entry_key)
-
-    test_component_map_2 = TaxonomyMap(taxonomy_name='PySimultan',
-                                       taxonomy_key='PySimultan',
-                                       taxonomy_entry_name='TestComponent2',
-                                       taxonomy_entry_key='TestComponent2',
-                                       content=[content0],
-                                       )
-
-    mapper.register(test_component_map_2.taxonomy_entry_key, TestComponent, taxonomy_map=test_component_map_2)
-    cls2 = mapper.get_mapped_class(test_component_map_2.taxonomy_entry_key)
-
-    return cls1, cls2
-
-
-mapped_cls_1, mapped_cls_2 = map_classes()
-component = mapped_cls_1(name='test_component',
-                         mapped_property=None)
-
-
-def test_set_dictionary_param(component):
-    test_dict = {'val_a': 1,
-                 'val_b': 2.0,
-                 'val_c': 'test'}
-    component.mapped_property = test_dict
-
-    component.mapped_property['val_a'] = 222
-
-    print(component.mapped_property)
-
-
-if __name__ == '__main__':
-    test_set_dictionary_param(component)
-    data_model.save()
-
-data_model.cleanup()
-print('Test passed')