PySimultan 0.4.22__py3-none-any.whl → 0.5.0__py3-none-any.whl

PySimultan2/default_types.py

@@ -7,6 +7,8 @@ import pandas as pd
 import colorlog
 from typing import Union, List, Type, Set, Tuple, Any, Optional
 
+from reactivex import return_value
+
 from .utils import (sort_slots, create_simultan_component_for_taxonomy, create_mapped_python_object,
                     set_property_to_sim_component, set_property_to_parameter, set_property_to_file_info,
                     set_property_to_list, set_property_to_value_field, set_property_to_unknown_type,
@@ -139,11 +141,19 @@ class ComponentList(SimultanObject):
 
     def append(self, values: Union[SimultanObject, List]):
 
+        return_val = []
+
+        as_list = True
         if not isinstance(values, Iterable):
+            as_list = False
             values = [values]
 
         for i, value in enumerate(values, start=len(self.data)):
-            self._set_value(value, i)
+            return_val.append(self._set_value(value, i))
+
+        if not as_list:
+            return return_val[0]
+        return return_val
 
     def _update_slot_extensions(self, index: int):
 
@@ -160,6 +170,9 @@ class ComponentList(SimultanObject):
 
     def _set_value(self, value, i):
 
+        if isinstance(value, FileInfo):
+            raise ValueError(f'FileInfos cannot be added to ComponentLists')
+
         if isinstance(value, SimultanObject):
             slot = value._wrapped_obj.Slots.Items[0]
 
@@ -171,6 +184,9 @@ class ComponentList(SimultanObject):
                 self.add_referenced_component(value._wrapped_obj,
                                               slot_extension=str(i),
                                               slot=slot)
+
+            return value
+
         else:
             new_val = create_mapped_python_object(value,
                                                   data_model=self._data_model,
@@ -193,6 +209,8 @@ class ComponentList(SimultanObject):
                                               slot_extension=str(i),
                                               slot=taxonomy_entry)
 
+            return new_val
+
     def __setitem__(self, i, value):
         if isinstance(i, slice):
             for j, val in enumerate(value):
@@ -210,7 +228,7 @@ class ComponentList(SimultanObject):
                 self._set_value(value, i)
 
     def extend(self, values: List):
-        self.append(values)
+        return self.append(values)
 
     def remove(self, value: SimultanObject):
         self.discard(value)
@@ -292,6 +310,41 @@ class ComponentList(SimultanObject):
         self._wrapped_obj.Components.Clear()
         self._wrapped_obj.ReferencedComponents.Clear()
 
+    def to_json(self) -> dict[Any: Any]:
+
+        return_val = [None] * len(self.data)
+
+        for i, val in enumerate(self.data):
+
+            if hasattr(val, 'json_ref'):
+                return_val[i] = val.json_ref()
+            elif isinstance(val, list):
+                return_val[i] = [v.json_ref() if hasattr(v, 'json_ref') else v for v in val]
+            elif isinstance(val, dict):
+                return_val[i] = {k: v.json_ref() if hasattr(v, 'json_ref') else v for k, v in val.items()}
+            elif isinstance(val, np.ndarray):
+                return_val[i] = val.tolist()
+            else:
+                return_val[i] = val
+
+        return {
+            str(self.id): {
+                'name': self.name,
+                'taxonomies': self.taxonomy_keys,
+                'items': return_val
+            }
+        }
+
+    def json_ref(self):
+        return {"$ref": {
+            "$type": 'ComponentList',
+            "$taxonomies": self.taxonomy_keys,
+            "$id": {'local_id': self.id.LocalId,
+                    'global_id': str(self.id.GlobalId)
+                    },
+            "length": len(self)
+        }
+        }
 
 component_list_map = TaxonomyMap(taxonomy_name='PySimultan',
                                  taxonomy_key='PySimultan',
@@ -319,9 +372,11 @@ class ComponentDictionary(SimultanObject):
         self._dict = {}
         super().__init__(*args, **kwargs)
         self.component_policy = kwargs.get('component_policy', 'subcomponent')  # component add policy of the content/parameter/property, 'reference' or 'subcomponent'
+        self._generate_internal_dict()
 
     def __load_init__(self, *args, **kwargs):
         self._dict = {}
+        self._generate_internal_dict()
 
     @classmethod
     def create_from_values(cls,
@@ -348,15 +403,20 @@ class ComponentDictionary(SimultanObject):
         for key, value in values.items():
             new_component_dict[key] = value
 
+        new_component_dict._generate_internal_dict()
+
         return new_component_dict
 
     def __getitem__(self, key, *args, **kwargs):
 
         comp_dict = object.__getattribute__(self, '_dict')
 
-        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').get(key, None)
+        if (kwargs.get('check_dict', False) and comp_dict is not None and
+                (key in comp_dict.keys() or '__dict_key__' + key in comp_dict.keys())):
+            if key in comp_dict.keys():
+                return comp_dict.get(key, None)
+            else:
+                return comp_dict.get('__dict_key__' + key, None)
         else:
             # data_model = config.default_data_model
             # obj = get_component_taxonomy_entry(self._wrapped_obj, key)
@@ -406,6 +466,8 @@ class ComponentDictionary(SimultanObject):
                                 object_mapper=object_mapper)
 
             if val is not None:
+                if key.startswith('__dict_key__'):
+                    key = key.replace('__dict_key__', '')
                 self._dict[key] = val
 
         return self._dict.get(key, None)
@@ -454,27 +516,32 @@ class ComponentDictionary(SimultanObject):
             return
 
         from .type_setter_lookup import type_setter_fcn_lookup_dict
-        setter_fcn = type_setter_fcn_lookup_dict.get(type(value), set_property_to_unknown_type)
+        setter_fcn = type_setter_fcn_lookup_dict.get(value, set_property_to_unknown_type)
 
         setter_fcn(*fcn_arg_list)
         item = self.__getitem__(key, check_dict=False)
 
-        self._dict[key] = item
+        if key.startswith('__dict_key__'):
+            self._dict[key.replace('__dict_key__', '')] = item
+        else:
+            self._dict[key] = item
 
     def __delitem__(self, key):
         self[key] = None
         del self._dict[key]
 
     def items(self):
+        if self._dict is None or not self._dict:
+            self._generate_internal_dict()
         return self._dict.items()
 
     def keys(self):
-        if not self._dict:
+        if not self._dict or not self._dict:
             self._generate_internal_dict()
         return self._dict.keys()
 
     def values(self):
-        if not self._dict:
+        if not self._dict or not self._dict:
             self._generate_internal_dict()
         return self._dict.values()
 
@@ -482,22 +549,26 @@ class ComponentDictionary(SimultanObject):
         comp_dict = {}
 
         for parameter in self._wrapped_obj.Parameters.Items:
-            comp_dict[parameter.NameTaxonomyEntry.TextOrKey] = get_obj_value(parameter,
-                                                                             data_model=self._data_model,
-                                                                             object_mapper=self._object_mapper)
+            key = parameter.NameTaxonomyEntry.TextOrKey.replace('__dict_key__', '')
+            comp_dict[key] = get_obj_value(parameter,
+                                           data_model=self._data_model,
+                                           object_mapper=self._object_mapper)
         for component in self._wrapped_obj.Components.Items:
-            comp_dict[component.Slot.SlotBase.Target.Key] = get_obj_value(component.Component,
-                                                                          data_model=self._data_model,
-                                                                          object_mapper=self._object_mapper)
+            key = component.Slot.SlotBase.Target.Key.replace('__dict_key__', '')
+            comp_dict[key] = get_obj_value(component.Component,
+                                           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.Key] = get_obj_value(ref_component.Target,
-                                                                               data_model=self._data_model,
-                                                                               object_mapper=self._object_mapper)
+            key = ref_component.Slot.SlotBase.Target.Key.replace('__dict_key__', '')
+            comp_dict[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:
             for tag in ref_asset.Resource.Tags:
-                comp_dict[tag.Target.Key] = get_obj_value(ref_asset.Target,
-                                                          data_model=self._data_model,
-                                                          object_mapper=self._object_mapper)
+                key = tag.Target.Key.replace('__dict_key__', '')
+                comp_dict[key] = get_obj_value(ref_asset.Target,
+                                               data_model=self._data_model,
+                                               object_mapper=self._object_mapper)
 
         object.__setattr__(self, '_dict', comp_dict)
 
@@ -529,5 +600,40 @@ class ComponentDictionary(SimultanObject):
         for key, value in other.items():
             self[key] = value
 
+    def to_json(self) -> dict:
+
+        return_value = {}
+
+        for key, value in self.items():
+            if isinstance(value, SimultanObject):
+                return_value[key] = value.to_json()
+            elif isinstance(value, list):
+                return_value[key] = [v.json_ref() if hasattr(v, 'json_ref') else v for v in value]
+            elif isinstance(value, dict):
+                return_value[key] = {k: v.json_ref() if hasattr(v, 'json_ref') else v for k, v in value.items()}
+            elif isinstance(value, np.ndarray):
+                return_value[key] = value.tolist()
+            else:
+                return_value[key] = value
+
+        return {
+            str(self.id): {
+                'name': self.name,
+                'taxonomies': self.taxonomy_keys,
+                'items': return_value
+            }
+        }
+
+    def json_ref(self):
+        return {"$ref": {
+            "$type": 'ComponentDictionary',
+            "$taxonomies": self.taxonomy_keys,
+            "$id": {'local_id': self.id.LocalId,
+                    'global_id': str(self.id.GlobalId)
+                    },
+            "length": len(self)
+        }
+        }
+
 
 component_dict_map = ComponentDictionary._taxonomy_map

PySimultan2/files.py

@@ -81,9 +81,17 @@ def add_asset_to_component(comp: [SimComponent, SimultanObject],
     wrapped_obj = comp if isinstance(comp, SimComponent) else comp._wrapped_obj
 
     if tag is not None:
-        add_tag_to_resource(asset, tag)
+        try:
+            add_tag_to_resource(asset, tag)
+        except Exception as e:
+            logger.error(f'Error adding tag to asset {asset}: {e} ')
+            raise e
 
-    return ComponentMapping.AddAsset(wrapped_obj, asset, content_id)
+    try:
+        return ComponentMapping.AddAsset(wrapped_obj, asset, content_id)
+    except Exception as e:
+        logger.error(f'Error adding asset {asset} to component: {e}')
+        raise e
 
 
 def remove_asset_from_component(comp: Union[SimComponent, SimultanObject],
@@ -187,7 +195,9 @@ class FileInfo(object, metaclass=MetaMock):
     _cls_instances = {}
 
     @classmethod
-    def from_string(cls, filename: str, content: str, *args, **kwargs) -> FileInfo:
+    def from_string(cls,
+                    filename: str,
+                    content: str, *args, **kwargs) -> FileInfo:
         """
         Create a file info object from a string.
         :param filename: Name of the file to be created. E.g. 'new_file.txt'
@@ -237,6 +247,13 @@ class FileInfo(object, metaclass=MetaMock):
         self.args = args
         self.kwargs = kwargs
 
+    @property
+    def key(self) -> int:
+        try:
+            return self.resource_entry.Key
+        except Exception as e:
+            return None
+
     @property
     def resource_entry(self) -> Union[ResourceFileEntry, ContainedResourceFileEntry, None]:
         if self._resource_entry is None:
@@ -258,8 +275,13 @@ class FileInfo(object, metaclass=MetaMock):
         self._resource_entry = value
 
     @property
-    def file_size(self) -> int:
-        return os.path.getsize(self.file_path)
+    def file_size(self) -> Optional[int]:
+        try:
+            return os.path.getsize(self.file_path)
+        except FileNotFoundError:
+            raise FileNotFoundError(f'File not found: {self.file_path}')
+        except Exception as e:
+            raise e
 
     @property
     def last_modified(self) -> datetime:
@@ -269,6 +291,10 @@ class FileInfo(object, metaclass=MetaMock):
     def resource_entry(self, value):
         self._resource_entry = value
 
+    @property
+    def filename(self) -> str:
+        return self.resource_entry.File.Name
+
     @property
     def name(self) -> str:
         return os.path.basename(self.file_path)
@@ -317,6 +343,9 @@ class FileInfo(object, metaclass=MetaMock):
     def __exit__(self, *args):
         self.file_obj.close()
 
+    def __repr__(self):
+        return f'FileInfo({self.file_path})'
+
     def get_content(self, encoding='utf-8') -> Optional[Union[str, dict[str, str]]]:
         """
         Get the content of the file.
@@ -373,3 +402,24 @@ class FileInfo(object, metaclass=MetaMock):
         if self.resource_entry is not None:
             self.data_model.delete_resource(self.resource_entry)
         os.remove(self.file_path)
+
+    def to_json(self) -> dict:
+
+        obj_dict = {
+            'key': self.key,
+            'name': self.name,
+            'file_path': self.file_path,
+            'file_size': self.file_size,
+            'last_modified': self.last_modified,
+            'encoding': self.encoding,
+            'is_zip': self.is_zip,
+        }
+
+        return obj_dict
+
+    def json_ref(self):
+        return {"$ref": {
+            "$type": 'FileInfo',
+            "$key": str(self.key)
+        }
+        }

PySimultan2/object_mapper.py

@@ -1,4 +1,4 @@
-from typing import Optional, Type, TYPE_CHECKING, Union
+from typing import Optional, Type, TYPE_CHECKING, Union, Any
 from copy import copy
 from collections import UserList
 from colorlog import getLogger
@@ -72,10 +72,20 @@ class PythonMapper(object):
     def mapped_classes(self, value):
         self._mapped_classes = value
 
-    def register(self, taxonomy, cls, taxonomy_map=None):
-        if not self.re_register and taxonomy in self.registered_classes.keys():
+    def register(self,
+                 taxonomy,
+                 cls,
+                 re_register=False,
+                 taxonomy_map=None):
+        if not (self.re_register or re_register) and taxonomy in self.registered_classes.keys():
             return
 
+        if taxonomy in self.mapped_classes.keys():
+            try:
+                del self.mapped_classes[taxonomy]
+            except KeyError:
+                pass
+
         if taxonomy_map is None:
             taxonomy_map = TaxonomyMap(taxonomy_name='PySimultan',
                                        taxonomy_key='PySimultan',
@@ -171,7 +181,11 @@ class PythonMapper(object):
                 typed_data.append(typed_object)
         return typed_data
 
-    def create_python_geometry_object(self, component, data_model=None, *args, **kwargs):
+    def create_python_geometry_object(self,
+                                      component: Union[Layer, Vertex, Edge, PEdge, Face, Volume, EdgeLoop],
+                                      data_model: 'DataModel' = None,
+                                      *args,
+                                      **kwargs):
 
         if component is None:
             return None
@@ -191,7 +205,7 @@ class PythonMapper(object):
             self.create_python_object(component, data_model, *args, **kwargs)
 
     def get_mapped_class_from_component(self,
-                                        component,
+                                        component: Union[SimComponent, Layer, Vertex, Edge, PEdge, Face, Volume, EdgeLoop],
                                         data_model: Optional['DataModel'] = None,
                                         *args,
                                         **kwargs) -> Optional[Type[SimultanObject]]:
@@ -205,7 +219,10 @@ class PythonMapper(object):
         if isinstance(component,
                       (Layer, Vertex, Edge, PEdge, Face, Volume, EdgeLoop)
                       ):
-            self.create_python_geometry_object(component, data_model, *args, **kwargs)
+            self.create_python_geometry_object(component,
+                                               data_model,
+                                               *args,
+                                               **kwargs)
 
         c_slots = [x.Target.Key for x in component.Slots.Items]
         c_slot = list(set(c_slots) & set(self.registered_classes.keys()))
@@ -266,6 +283,21 @@ class PythonMapper(object):
                                         *args,
                                         **kwargs)
 
+    def create_mapped_python_object(self,
+                                    obj: Any,
+                                    data_model=None,
+                                    add_to_data_model=True,
+                                    *args,
+                                    **kwargs) -> Optional[SimultanObject]:
+
+        from .utils import create_mapped_python_object
+        return create_mapped_python_object(obj,
+                                           object_mapper=self,
+                                           data_model=data_model,
+                                           add_to_data_model=add_to_data_model,
+                                           *args,
+                                           **kwargs)
+
     def get_typed_data_with_taxonomy(self, taxonomy: str, data_model=None, first=False):
 
         tax_components = data_model.find_components_with_taxonomy(taxonomy=taxonomy, first=first)
@@ -307,7 +339,9 @@ class PythonMapper(object):
         new_val = create_mapped_python_object(obj, self, data_model)
         return new_val
 
-    def copy(self):
+    def copy(self,
+             *args,
+             **kwargs) -> 'PythonMapper':
         new_mapper = PythonMapper()
         new_mapper.registered_classes = self.registered_classes
         new_mapper.taxonomy_maps = self.taxonomy_maps
@@ -315,6 +349,23 @@ class PythonMapper(object):
         new_mapper.load_undefined = self.load_undefined
         return new_mapper
 
+    def __add__(self, other: 'PythonMapper') -> 'PythonMapper':
+        new_mapper = self.copy()
+        new_mapper.registered_classes.update(other.registered_classes)
+        new_mapper.taxonomy_maps.update(other.taxonomy_maps)
+        new_mapper.registered_geometry_classes.update(other.registered_geometry_classes)
+        return new_mapper
+
+    def get_mapped_class_for_python_type(self, python_type: type) -> Optional[Type[SimultanObject]]:
+        try:
+            key = list(filter(lambda x: self.registered_classes[x] == python_type,
+                              self.registered_classes)
+                       )[0]
+            mapped_cls = self.get_mapped_class(key)
+            return mapped_cls
+        except IndexError:
+            return None
+
 
 if config.get_default_mapper() is None:
     config.set_default_mapper(PythonMapper())

PySimultan2/resources/ComponentBuilder.runtimeconfig.json

@@ -12,7 +12,8 @@
       }
     ],
     "configProperties": {
-      "System.Reflection.Metadata.MetadataUpdater.IsSupported": false
+      "System.Reflection.Metadata.MetadataUpdater.IsSupported": false,
+      "System.Runtime.Serialization.EnableUnsafeBinaryFormatterSerialization": true
     }
   }
 }

PySimultan2/resources/ComponentBuilder.xml

@@ -2875,6 +2875,12 @@
             Invoked when the selection in this list has changed
             </summary>
         </member>
+        <member name="E:ComponentBuilder.ViewNEW.Components.ComponentListVM.TreeViewContextMenuOpening">
+            <summary>
+            Context menu opening event on all the elements in the component list.
+            Useful to inject custom menu items in plugins.
+            </summary>
+        </member>
         <member name="P:ComponentBuilder.ViewNEW.Components.ComponentListVM.SuperviseCommand">
             <summary>
             Command for supervising a component (only available when user has supervise privilege)
@@ -10206,11 +10212,21 @@
             Command for exporting the project as JSON
             </summary>
         </member>
-        <member name="P:ComponentBuilder.ViewNEW.JSONExportRibbon.JSONExportRibbonVM.ExportSelectedNetworksCommand">
+        <member name="P:ComponentBuilder.ViewNEW.JSONExportRibbon.JSONExportRibbonVM.ExportJSONSelectedNetworksCommand">
             <summary>
             Command for selection networks to export
             </summary>
         </member>
+        <member name="P:ComponentBuilder.ViewNEW.JSONExportRibbon.JSONExportRibbonVM.ExportXMICommand">
+            <summary>
+            Command for exporting the whole project in XMI format
+            </summary>
+        </member>
+        <member name="P:ComponentBuilder.ViewNEW.JSONExportRibbon.JSONExportRibbonVM.ExportXMISelectedNetworksCommand">
+            <summary>
+            Command for selecting a network and exporting it to XMI
+            </summary>
+        </member>
         <member name="M:ComponentBuilder.ViewNEW.JSONExportRibbon.JSONExportRibbonVM.#ctor(ComponentBuilder.ViewNEW.MainWindowContent.MainWindowVM,SIMULTAN.Utils.IServicesProvider)">
             <summary>
             Initializes a new instance of the ExcelToolsRibbonVM class
@@ -19163,5 +19179,35 @@
         <member name="P:ComponentBuilder.WinUtils.WinSynchronizationContext.InvokeRequired">
             <inheritdoc/>
         </member>
+        <member name="T:XamlGeneratedNamespace.GeneratedInternalTypeHelper">
+            <summary>
+            GeneratedInternalTypeHelper
+            </summary>
+        </member>
+        <member name="M:XamlGeneratedNamespace.GeneratedInternalTypeHelper.CreateInstance(System.Type,System.Globalization.CultureInfo)">
+            <summary>
+            CreateInstance
+            </summary>
+        </member>
+        <member name="M:XamlGeneratedNamespace.GeneratedInternalTypeHelper.GetPropertyValue(System.Reflection.PropertyInfo,System.Object,System.Globalization.CultureInfo)">
+            <summary>
+            GetPropertyValue
+            </summary>
+        </member>
+        <member name="M:XamlGeneratedNamespace.GeneratedInternalTypeHelper.SetPropertyValue(System.Reflection.PropertyInfo,System.Object,System.Object,System.Globalization.CultureInfo)">
+            <summary>
+            SetPropertyValue
+            </summary>
+        </member>
+        <member name="M:XamlGeneratedNamespace.GeneratedInternalTypeHelper.CreateDelegate(System.Type,System.Object,System.String)">
+            <summary>
+            CreateDelegate
+            </summary>
+        </member>
+        <member name="M:XamlGeneratedNamespace.GeneratedInternalTypeHelper.AddEventHandler(System.Reflection.EventInfo,System.Object,System.Delegate)">
+            <summary>
+            AddEventHandler
+            </summary>
+        </member>
     </members>
 </doc>