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

PySimultan2/__about__.py

@@ -1 +1 @@
-version = '0.4.22'
+version = '0.5.0'

PySimultan2/__init__.py

@@ -48,6 +48,7 @@ def setup():
     logger.setLevel('DEBUG')
 
     dll_path = os.environ.get('SIMULTAN_SDK_DIR', None)
+    dll_path = None
     if dll_path is None:
         with pkg_resources.path(resources, 'SIMULTAN.dll') as r_path:
             dll_path = str(r_path)

PySimultan2/data_model.py

@@ -2,6 +2,8 @@ import atexit
 import os
 import shutil
 from uuid import uuid4
+from functools import lru_cache
+from time import sleep
 from colorlog import getLogger
 from . import config
 from .utils import *
@@ -11,7 +13,7 @@ from typing import Union, Tuple, TYPE_CHECKING
 
 # from SIMULTAN import Projects
 # noinspection PyUnresolvedReferences
-from SIMULTAN.Projects import ExtendedProjectData
+from SIMULTAN.Projects import ExtendedProjectData, CompactProject
 # noinspection PyUnresolvedReferences
 from SIMULTAN import Utils
 # noinspection PyUnresolvedReferences
@@ -19,7 +21,7 @@ from SIMULTAN.Data import Users as SimultanUsers
 # from SIMULTAN.Serializer import Projects
 from SIMULTAN.Serializer.SimGeo import *
 from SIMULTAN.Serializer.Projects import *
-from SIMULTAN.Data.Components import SimComponent
+from SIMULTAN.Data.Components import SimComponent, SimComponentCollection
 from SIMULTAN.Data.MultiValues import SimMultiValueBigTable, SimMultiValueField3D
 from SIMULTAN.Data.Assets import ResourceEntry
 from SIMULTAN.Data.Geometry import OffsetAlgorithm
@@ -33,13 +35,14 @@ from SIMULTAN.Data.Geometry import GeometryModel as NetGeometryModel
 from SIMULTAN.Data.Geometry import Layer, Vertex, Edge, PEdge, Face, Volume, EdgeLoop
 
 from System.Security import SecureString
+from SIMULTAN.Data import SimId
 from System import Guid
 from System.IO import *
 from System.Security import *
 from System.Security.Cryptography import *
 from System.Text import *
 
-from .files import add_tag_to_resource
+from .files import add_tag_to_resource, FileInfo as PythonFileInfo
 
 
 if TYPE_CHECKING:
@@ -72,19 +75,6 @@ class IAuthenticationServiceNew(SimultanUsers.IAuthenticationService):
         return user.Item1
 
 
-# data_models = WeakSet()
-# data_models_dict = WeakValueDictionary()
-
-
-# def get_default_data_model():
-#     return data_models[0]
-#
-#
-# def add_data_model(data_model):
-#     data_models.add(data_model)
-
-
-# noinspection PyUnresolvedReferences
 class DataModel:
 
     @classmethod
@@ -143,17 +133,17 @@ class DataModel:
         atexit.register(self.cleanup)
 
         self.id = uuid4()
-        self.data = None
-        self._project_data_manager = None
+        self.data: Optional[SimComponentCollection] = None
+        self._project_data_manager: Optional[ExtendedProjectData] = None
         self._user = None
-        self._project = None
+        self._project: Optional[CompactProject] = None
         self._zip_loader = None
 
-        self.project_data_manager = kwargs.get('project_data_manager', None)
+        self.project_data_manager: Optional[ExtendedProjectData] = kwargs.get('project_data_manager', None)
 
-        self.project_path = kwargs.get('project_path', None)
+        self.project_path: Optional[str] = kwargs.get('project_path', None)
 
-        self.service_provider = Utils.ServicesProvider()
+        self.service_provider: Utils.ServicesProvider = Utils.ServicesProvider()
 
         self.i_aut_service = IAuthenticationServiceNew
         self.i_aut_service.user_name = self.user_name
@@ -168,6 +158,8 @@ class DataModel:
 
         self.__mongo_instance = None
 
+        self.component_dict: dict[SimId, SimComponent] = {}
+
     @property
     def assets(self):
         return self.project_data_manager.AssetManager.Resources
@@ -282,6 +274,10 @@ class DataModel:
 
     def import_data_model(self):
         self.data = self.project_data_manager.Components
+
+        self.create_component_dict.cache_clear()
+        self.get_component_by_id.cache_clear()
+
         return self.data
 
     def add_field(self, field: SimMultiValueField3D):
@@ -313,6 +309,7 @@ class DataModel:
             return
 
         self.data.Add(component)
+        self.create_component_dict.cache_clear()
         # logger.info(
         #     f'Added component {component.Id} {component.Name} {type(component)} to project {self.project_path}')
 
@@ -351,6 +348,32 @@ class DataModel:
         elif index is not None:
             self.data.RemoveItem(index)
 
+        self.create_component_dict.cache_clear()
+        self.get_component_by_id.cache_clear()
+
+    def remove_component(self,
+                         component: Union[SimComponent, SimultanObject] = None,
+                         index: int = None):
+        """
+        Remove a component from the project
+        :param component:
+        :param index:
+        :return:
+        """
+        if hasattr(component, '_wrapped_obj'):
+            component = component._wrapped_obj
+
+        if component.Parent is not None:
+            scce = next((x for x in component.Parent.Components if component.Id.Equals(x.Component.Id)), None)
+            if scce is not None:
+                component.Parent.Components.Remove(scce)
+        else:
+            index = self.data.Items.IndexOf(component)
+            self.data.RemoveItem(index)
+
+        self.create_component_dict.cache_clear()
+        self.get_component_by_id.cache_clear()
+
     def save(self):
         """
         Save the project
@@ -423,6 +446,7 @@ class DataModel:
         slot = SimSlot(slot_name, str(slot_extension))
         ComponentManagement.AddReferencedComponentSlot(comp, slot, self.user)
         ComponentManagement.AddReferencedComponent(comp, slot, ref_comp, self.user)
+        self.create_component_dict.cache_clear()
 
     def remove_referenced_component(self, comp: SimComponent, index: int):
         if index is not None:
@@ -431,6 +455,9 @@ class DataModel:
             index = self.data.Items.IndexOf(comp)
             self.data.RemoveItem(index)
 
+        self.create_component_dict.cache_clear()
+        self.get_component_by_id.cache_clear()
+
     def add_new_geometry_model(self, file_name: str, model_name: str = None, return_resource=False):
         """
         Create and add a new fc_geometry model
@@ -439,6 +466,7 @@ class DataModel:
         :param return_resource: return the resource
         :return: GeometryViewer.Model.GeometryModel, geo_resource
         """
+        self.get_file_infos.cache_clear()
         geo_resource = self.add_geometry_resource(file_name)
         file_info = FileInfo(geo_resource.CurrentFullPath)
         try:
@@ -469,6 +497,7 @@ class DataModel:
                                                              model_name,
                                                              self.service_provider)
 
+        self.get_file_infos.cache_clear()
         return new_resource
 
     def add_empty_resource(self, filename: str):
@@ -479,6 +508,7 @@ class DataModel:
         """
         # return self.project.AddResourceFile(FileInfo(str(filename)))
 
+        self.get_file_infos.cache_clear()
         return self.project.AddEmptyResource(FileInfo(str(filename)))
 
     def add_resource(self,
@@ -490,43 +520,50 @@ class DataModel:
         :param tag: tag to add to the resource
         :return:
         """
-
-        del_copy = False
-
-        existing_files = [x.Name for x in self.project_data_manager.AssetManager.Resources]
         try:
-            act_filename = filename.replace('\\', os.sep)
-        except TypeError:
-            act_filename = filename
-
-        if os.path.basename(act_filename) in existing_files:
-            # create copy with running counter in temp dir and use this file:
-            counter = 1
-            while True:
-                new_filename = os.path.basename(filename) + f'({str(counter)})'
-                if new_filename not in existing_files and not os.path.exists(new_filename):
-                    break
-                counter += 1
-            shutil.copy(filename, os.path.join(os.path.dirname(filename),  new_filename))
-            filename = os.path.join(os.path.dirname(filename),  new_filename)
-            del_copy = True
-
-        if isinstance(filename, (str, PosixPath, WindowsPath)):
-            filename = FileInfo(str(filename))
-
-        resource = self.project.CopyResourceAsContainedFileEntry(filename,
-                                                                 self.project.ProjectUnpackFolder,
-                                                                 '1')
-
-        if del_copy:
-            os.remove(str(filename))
-
-        # file_id = self.project_data_manager.AssetManager.AddResourceEntry(FileInfo(filename))
-        # return self.project_data_manager.AssetManager.Resources[file_id]
-        if tag is not None:
-            add_tag_to_resource(resource, tag)
-
-        return resource
+
+            del_copy = False
+
+            existing_files = [x.Name for x in self.project_data_manager.AssetManager.Resources]
+            try:
+                act_filename = filename.replace('\\', os.sep)
+            except TypeError:
+                act_filename = filename
+
+            if os.path.basename(act_filename) in existing_files:
+                # create copy with running counter in temp dir and use this file:
+                counter = 1
+                while True:
+                    new_filename = os.path.basename(filename) + f'({str(counter)})'
+                    if new_filename not in existing_files and not os.path.exists(new_filename):
+                        break
+                    counter += 1
+                shutil.copy(filename, os.path.join(os.path.dirname(filename),  new_filename))
+                filename = os.path.join(os.path.dirname(filename),  new_filename)
+                del_copy = True
+
+            if isinstance(filename, (str, PosixPath, WindowsPath)):
+                filename = FileInfo(str(filename))
+
+            resource = self.project.CopyResourceAsContainedFileEntry(filename,
+                                                                     self.project.ProjectUnpackFolder,
+                                                                     '1')
+
+            if del_copy:
+                os.remove(str(filename))
+
+            # file_id = self.project_data_manager.AssetManager.AddResourceEntry(FileInfo(filename))
+            # return self.project_data_manager.AssetManager.Resources[file_id]
+            if tag is not None:
+                add_tag_to_resource(resource, tag)
+
+            # sleep(0.2) # this is necessary to avoid race conditions System.ArgumentException: An item with the same
+            # key has already been added. Key: at System.Collections.Generic.Dictionary`2.TryInsert(TKey key,
+            # TValue value, InsertionBehavior behavior)
+            return resource
+        except Exception as e:
+            logger.error(f'Error while adding resource {filename} to project {self.project_path}: {e}')
+            raise e
 
     def delete_resource(self, resource: Union[ResourceEntry, FileInfo, ContainedResourceFileEntry]):
         """
@@ -543,6 +580,7 @@ class DataModel:
             logger.info(f'Deleted resource {resource.Name} from project {self.project_path}')
         else:
             logger.error(f'Could not delete resource {resource.Name} from project {self.project_path}')
+        self.get_file_infos.cache_clear()
         return success
 
     def add_table(self, table: SimMultiValueBigTable):
@@ -584,6 +622,9 @@ class DataModel:
         # else:
         #     return get_component_geometry(self, geometry_model, component)
 
+    def get_taxonomy_by_key(self, key: str):
+        return next((x for x in self.taxonomies if x.Key == key), None)
+
     def create_taxonomy(self, name: str, key: str, description: str = ''):
         """
         Create a new taxonomy and add it to the project
@@ -594,21 +635,16 @@ class DataModel:
         """
         return create_taxonomy(name, key, description, data_model=self)
 
-    def get_taxonomy_entry(self, key):
-        for entry in self.taxonomies:
-            if entry.Key == key:
-                return entry
+    def get_taxonomy_entry(self,
+                           key,
+                           taxonomy: Union[SimTaxonomy, str] = None) -> SimTaxonomyEntry:
 
-    def create_mongo_instance(self):
-        from .mongo_utils.base_classes import DataModel as MongoDataModel
-        from .redis_utils.base_classes import save_in_redis
+        taxonomy = self.get_taxonomy_by_key(taxonomy) if isinstance(taxonomy, str) else taxonomy
+        taxonomies = [taxonomy] if taxonomy is not None else self.taxonomies
 
-        logger.info(f'Creating mongo instance for project {self.project_data_manager.Project.Name}')
-        self._mongo_instance, created = MongoDataModel.get_or_create(self)
-        if created:
-            logger.info(f'Created new mongo instance for {self.project_data_manager.Project.Name}')
-        else:
-            logger.info(f'Found existing mongo instance for {self.project_data_manager.Project.Name}')
+        for entry in taxonomies:
+            if entry.Key == key:
+                return entry
 
     def save_in_mongodb(self, db):
         """
@@ -618,14 +654,8 @@ class DataModel:
         """
         self._mongo_instance.save(db)
 
-    def save_in_redis(self):
-        """
-        save the object in the redis database
-        :return: None
-        """
-        save_in_redis(self)
-
-    def get_taxonomy_entries(self):
+    def get_taxonomy_entries(self,
+                             taxonomy: Union[SimTaxonomy, str] = None) -> dict[str, SimTaxonomyEntry]:
 
         def add_sub_entries(tax_entry, tax_entries_dict):
             for sub_entry in tax_entry.Children:
@@ -634,7 +664,9 @@ class DataModel:
             return tax_entries_dict
 
         taxonomy_entries = {}
-        for taxonomy in self.taxonomies:
+        taxonomies = [taxonomy] if isinstance(taxonomy, SimTaxonomy) else self.taxonomies
+
+        for taxonomy in taxonomies:
             taxonomy_entries[taxonomy.Key] = taxonomy
             for entry in list(taxonomy.Entries):
                 taxonomy_entries[entry.Key] = entry
@@ -677,6 +709,79 @@ class DataModel:
         mapper.current_data_model = self
         return mapper.get_typed_data(self, component_list=self.data.Items, create_all=False)
 
+    @lru_cache()
+    def create_component_dict(self):
+        new_component_list = set()
+
+        def get_subcomponents(sim_component: SimComponent):
+            new_subcomponents = set()
+            if isinstance(sim_component, SimultanObject):
+                sim_component = sim_component._wrapped_obj
+
+            if sim_component in new_component_list:
+                return
+            else:
+                new_component_list.add(sim_component)
+
+            if sim_component is None:
+                return []
+
+            for sub_component in sim_component.Components.Items:
+                if sub_component is None:
+                    continue
+                new_subcomponents.add(sub_component.Component)
+            for ref_component in sim_component.ReferencedComponents.Items:
+                if ref_component is None:
+                    continue
+                new_subcomponents.add(ref_component.Target)
+
+            for new_subcomponent in new_subcomponents:
+                get_subcomponents(new_subcomponent)
+
+            new_component_list.update(new_subcomponents)
+
+        for component in self.data.Items:
+            if component is None:
+                continue
+            get_subcomponents(component)
+        component_list = list(new_component_list)
+
+        self.component_dict = {x.Id: x for x in component_list}
+        return self.component_dict
+
+    @lru_cache()
+    def get_component_by_id(self,
+                            item_id: SimId,
+                            search_subcomponents=False) -> Union[SimComponent, None]:
+
+        # print(item_id.GlobalId, item_id.LocalId)
+        # _ = [print((x.Id.GlobalId, x.Id.LocalId)) for x in self.data.Items]
+
+        component = next((x for x in self.data.Items if x.Id.Equals(item_id)), None)
+
+        if component is None and search_subcomponents:
+            component = self.component_dict.get(item_id, None)
+            if component is None:
+                self.create_component_dict()
+                component = self.component_dict.get(item_id, None)
+
+        return component
+
+    def get_component_by_name(self, name: str) -> list[SimComponent]:
+        return [x for x in self.create_component_dict.values() if x.Name == name]
+
+    @lru_cache()
+    def get_file_infos(self) -> list[PythonFileInfo]:
+        return [PythonFileInfo(resource_entry=asset) for asset in self.assets]
+
+    def get_file_info_by_key(self,
+                             key: int) -> Optional[PythonFileInfo]:
+
+        if isinstance(key, str):
+            key = int(key)
+
+        return next((PythonFileInfo(resource_entry=asset) for asset in self.assets if asset.Key == key), None)
+
     def __del__(self):
         self.cleanup()