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

PySimultan2/default_types.py

@@ -1,9 +1,7 @@
 from __future__ import annotations
 
-import xxsubtype
 from collections.abc import Iterable
 import numpy as np
-import pandas as pd
 import colorlog
 from typing import Union, List, Type, Set, Tuple, Any, Optional
 
@@ -139,11 +137,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 +166,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 +180,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 +205,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 +224,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 +306,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 +368,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 +399,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 +462,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 +512,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 +545,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 +596,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
@@ -32,9 +32,21 @@ default_taxonomy_maps = {'ComponentList': component_list_map,
 
 class PythonMapper(object):
 
+    mappers = {}
+
     def __new__(cls, *args, **kwargs):
         instance = super(PythonMapper, cls).__new__(cls)
         config.set_default_mapper(instance)
+
+        if kwargs.get('add_to_mappers', True):
+            initial_module_name = kwargs.get('module', 'unknown_module')
+            module_name = initial_module_name
+            i = 0
+            while module_name in cls.mappers.keys():
+                module_name = f'{initial_module_name}_{i}'
+                i+=1
+            cls.mappers[module_name] = instance
+
         return instance
 
     def __init__(self, *args, **kwargs):
@@ -42,6 +54,9 @@ class PythonMapper(object):
         self._mapped_classes = {}
 
         self.name = kwargs.get('name', 'PythonMapper')
+        self._module = kwargs.get('module', 'unknown_module')
+        self.submodules = kwargs.get('submodules', {})
+
         self.registered_classes: dict[str: SimultanObject] = copy(default_registered_classes)  # dict with all registered classes: {taxonomy: class}
 
         self.undefined_registered_classes: dict[str: SimultanObject] = {}  # dict with all registered classes: {taxonomy: class}
@@ -59,6 +74,18 @@ class PythonMapper(object):
         self.re_register = False
         self.load_undefined = False
 
+    @property
+    def module(self):
+        return self._module
+
+    @module.setter
+    def module(self, value):
+        if self._module != value:
+            del self.mappers[self._module]
+
+        self._module = value
+        self.mappers[value] = self
+
     @property
     def mapped_classes(self):
         if len(self.registered_classes) > len(self._mapped_classes):
@@ -72,10 +99,24 @@ 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: str,
+                 cls: Type[Any],
+                 re_register=True,
+                 update_in_other_mappers=False,
+                 taxonomy_map=None):
+
+        # print(f'Registering {taxonomy} with {cls} {hash(cls)}')
+
+        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',
@@ -85,8 +126,28 @@ class PythonMapper(object):
         self.registered_classes[taxonomy] = cls
         self.taxonomy_maps[taxonomy] = taxonomy_map
 
+        if update_in_other_mappers:
+            self.update_from_other_mappers()
+
         return self.get_mapped_class(taxonomy)
 
+    def update_from_other_mappers(self):
+        for mapper in self.mappers.values():
+            if mapper is not self:
+                for cls, taxonomy in mapper.registered_classes.items():
+                    if cls in self.registered_classes.values():
+                        key = list(filter(lambda x: mapper.registered_classes[x] == cls,
+                                          mapper.registered_classes)
+                                   )[0]
+                        mapper.registered_classes[key] = cls
+                        print(f'Updated {cls} in {mapper.module} with {taxonomy}')
+
+    def update_from_submodules(self):
+        for submodule in self.submodules.values():
+            self.registered_classes.update(submodule.registered_classes)
+            self.taxonomy_maps.update(submodule.taxonomy_maps)
+            self.registered_geometry_classes.update(submodule.registered_geometry_classes)
+
     def create_mapped_class(self, taxonomy, cls):
 
         if any([issubclass(cls, x) for x in (SimultanObject, UserList)]):
@@ -171,7 +232,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 +256,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 +270,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 +334,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,14 +390,68 @@ class PythonMapper(object):
         new_val = create_mapped_python_object(obj, self, data_model)
         return new_val
 
-    def copy(self):
-        new_mapper = PythonMapper()
+    def copy(self,
+             *args,
+             **kwargs) -> 'PythonMapper':
+
+        orig_new_module_name = kwargs.get('module', self.module)
+        new_module_name = orig_new_module_name
+        i = 0
+        while new_module_name in self.mappers.keys():
+            new_module_name = f'copy_{i}_of_{new_module_name}'
+            i+=1
+
+        new_mapper = PythonMapper(add_to_mappers=kwargs.get('add_to_mappers', True),
+                                  module=new_module_name)
         new_mapper.registered_classes = self.registered_classes
         new_mapper.taxonomy_maps = self.taxonomy_maps
         new_mapper.registered_geometry_classes = self.registered_geometry_classes
         new_mapper.load_undefined = self.load_undefined
+
         return new_mapper
 
+    def __add__(self, other: 'PythonMapper') -> 'PythonMapper':
+        # new_mapper = self.copy(add_to_mappers=True)
+        self.submodules[other.module] = other
+        self.submodules.update(other.submodules)
+        self.registered_classes.update(other.registered_classes)
+        self.taxonomy_maps.update(other.taxonomy_maps)
+        self.registered_geometry_classes.update(other.registered_geometry_classes)
+        return self
+
+    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
+
+    def __repr__(self):
+        return f'PythonMapper(module={self.module}, {len(self.registered_classes)} registered classes)'
+
 
 if config.get_default_mapper() is None:
-    config.set_default_mapper(PythonMapper())
+    config.set_default_mapper(PythonMapper(module='default'))
+
+
+def register(taxonomy: str,
+             taxonomy_map: TaxonomyMap,
+             re_register=True,
+             module: str = 'unknown_module') -> Any:
+
+    if module not in PythonMapper.mappers.keys():
+        PythonMapper(module=module)
+
+    mapper = PythonMapper.mappers[module]
+
+    def decorator(cls):
+        mapper.register(taxonomy,
+                        cls,
+                        re_register=re_register,
+                        taxonomy_map=taxonomy_map)
+        return cls
+
+    return decorator

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
     }
   }
 }