PySimultan 0.6.0.4__py3-none-any.whl → 0.6.0.8__py3-none-any.whl

PySimultan2/CHANGELOG.md

@@ -1,3 +1,9 @@
+Version 0.6.0.7 (16.02.2024)
+- Fixed Asset creation and deletion bugs
+
+Version 0.6.0.3 (23.01.2024)
+- Added sub_classes and super_classes to SimultanObject
+
 Version 0.6.0.2 (16.01.2024)
 - Added __delitem__ method to default_types.ComponentList
 

PySimultan2/__about__.py

@@ -1 +1 @@
-version = '0.6.0.4'
+version = '0.6.0.8'

PySimultan2/data_model.py

@@ -655,6 +655,18 @@ class DataModel:
             logger.error(f'Error while adding resource {filename} to project {self.project_path}: {e}')
             raise e
 
+    def get_resource(self, key: Union[str, int, SystemFileInfo, DirectoryInfo]):
+
+        if isinstance(key, (int, SystemFileInfo, DirectoryInfo)):
+            return self.project_data_manager.AssetManager.GetResource(key)
+        elif isinstance(key, str):
+            if os.path.isfile(key):
+                return self.project_data_manager.AssetManager.GetResource(SystemFileInfo(key))
+            elif os.path.isdir(key):
+                return self.project_data_manager.AssetManager.GetResource(DirectoryInfo(key))
+            else:
+                return None
+
     def delete_resource(self, resource: Union[ResourceEntry, SystemFileInfo, ContainedResourceFileEntry]):
         """
         Delete a resource from the project and the project folder
@@ -678,9 +690,31 @@ class DataModel:
                                   parent_directory: DirectoryInfo=None,
                                   collision_name_format: str = '{0} ({1})') -> ResourceEntry:
 
+        # check if directory already exists
         if parent_directory is None:
-            new_directory = self.project.CreateResourceDirIn(name, None, collision_name_format)
+            full_path = os.path.join(self.project.ProjectUnpackFolder.FullPath, name)
         else:
+            full_path = os.path.join(parent_directory.FullPath, name)
+
+        def get_existing(full_file_path: str):
+            new_directory = self.project_data_manager.AssetManager.GetResource(DirectoryInfo(full_path))
+            if new_directory is None:
+                res = self.project_data_manager.AssetManager.CreateResourceDirIn(os.path.basename(full_path),
+                                                                                 DirectoryInfo(
+                                                                                     os.path.dirname(
+                                                                                         full_path)),
+                                                                                 '0')
+
+                new_directory = self.project_data_manager.AssetManager.GetResource(res.Item1)
+            return new_directory
+
+        if os.path.exists(full_path):
+            new_directory = get_existing(full_path)
+            return new_directory
+
+        if parent_directory is None:
+            new_directory = self.project.CreateResourceDirIn(name, None, collision_name_format)
+        if parent_directory is not None:
             new_directory = self.project.CreateResourceDirIn(name, parent_directory, collision_name_format)
 
         return new_directory

PySimultan2/default_types.py

@@ -5,6 +5,7 @@ import numpy as np
 import colorlog
 from typing import Union, List, Type, Set, Tuple, Any, Optional
 
+from .geometry.geometry_base import classproperty
 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,
@@ -32,6 +33,10 @@ class ComponentList(SimultanObject):
     _create_all = False     # if true all properties are evaluated to create python objects when initialized
     _taxonomy = 'ComponentList'
 
+    @classproperty
+    def _original_class(cls) -> Type[ComponentList]:
+        return cls
+
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.component_policy = kwargs.get('component_policy', 'subcomponent')  # component add policy of the content/parameter/property, 'reference' or 'subcomponent'
@@ -405,6 +410,10 @@ class ComponentDictionary(SimultanObject):
 
     _taxonomy = 'ComponentDict'
 
+    @classproperty
+    def _original_class(cls) -> Type[ComponentList]:
+        return cls
+
     def __init__(self, *args, **kwargs):
         self._dict = {}
         super().__init__(*args, **kwargs)

PySimultan2/files.py

@@ -3,10 +3,12 @@ This module contains classes and functions to handle files and directories.
 """
 from __future__ import annotations
 from datetime import datetime
+import glob
 
 import contextlib
 import os
 import io
+import re
 import shutil
 import tempfile
 from typing import List, Union, Optional
@@ -124,6 +126,13 @@ def create_asset_from_string(filename: str,
     :param tag: Tag to be added to the asset.
     :return: ResourceFileEntry
     """
+
+    # check if file already exists
+    if target_dir is not None:
+        if isinstance(target_dir, DirectoryInfo):
+            target_dir = target_dir.full_path
+
+
     with tempdir() as dirpath:
         filepath = os.path.join(dirpath, filename)
         with open(filepath, 'w') as f:
@@ -290,11 +299,30 @@ class FileInfo(object, metaclass=MetaMock):
         """
 
         data_model = kwargs.get('data_model', config.get_default_data_model())
-        resource = create_asset_from_string(filename,
-                                            content,
-                                            target_dir=target_dir,
-                                            *args,
-                                            **kwargs)
+
+        if target_dir is not None:
+            full_path = os.path.join(target_dir.full_path, filename)
+        else:
+            full_path = os.path.join(data_model.project.ProjectUnpackFolder, filename)
+
+
+
+
+        if os.path.isfile(full_path):
+            # check if resource entry exists
+            resource = data_model.get_resource(full_path)
+            if resource is None:
+                resource = create_asset_from_string(filename,
+                                                    content,
+                                                    target_dir=target_dir,
+                                                    *args,
+                                                    **kwargs)
+        else:
+            resource = create_asset_from_string(filename,
+                                                content,
+                                                target_dir=target_dir,
+                                                *args,
+                                                **kwargs)
 
         file_info = cls(resource_entry=resource,
                         data_model=data_model)
@@ -332,6 +360,7 @@ class FileInfo(object, metaclass=MetaMock):
         :param kwargs:
         """
         # do custom stuff here
+        self.deleted = False
         self._resource_entry: Union[ResourceFileEntry, ContainedResourceFileEntry, None] = None
 
         if file_path is not None:
@@ -365,7 +394,7 @@ class FileInfo(object, metaclass=MetaMock):
 
     @property
     def resource_entry(self) -> Union[ResourceFileEntry, ContainedResourceFileEntry, None]:
-        if self._resource_entry is None:
+        if self._resource_entry is None and not self.deleted:
             if self.data_model is None:
                 logger.warning(f'No data model provided. Using default data model: {config.get_default_data_model().id}.')
                 self.data_model = config.get_default_data_model()
@@ -453,7 +482,10 @@ class FileInfo(object, metaclass=MetaMock):
         self.file_obj.close()
 
     def __repr__(self):
-        return f'FileInfo({self.file_path})'
+        if not self.deleted:
+            return f'FileInfo({self.file_path})'
+        else:
+            return f'FileInfo({self.file_path}) (deleted)'
 
     def move(self, new_directory_path: Union[str, DirectoryInfo]) -> FileInfo:
 
@@ -533,7 +565,11 @@ class FileInfo(object, metaclass=MetaMock):
                 del self._cls_instances[self.resource_entry.Key]
             self.data_model.delete_resource(self.resource_entry)
 
-        os.remove(self.file_path)
+        try:
+            os.remove(self.file_path)
+        except FileNotFoundError:
+            pass
+        self.deleted = True
 
     def to_json(self) -> dict:
 
@@ -613,6 +649,8 @@ class DirectoryInfo(object, metaclass=DirectoryInfoMetaMock):
                  *args,
                  **kwargs):
 
+        self.deleted = False
+
         self._resource_entry: Optional[ResourceDirectoryEntry] = None
         self._helper_file: Optional[FileInfo] = None
         self.data_model: Optional[DataModel] = kwargs.get('data_model', None)
@@ -635,7 +673,7 @@ class DirectoryInfo(object, metaclass=DirectoryInfoMetaMock):
 
     @property
     def helper_file(self) -> Optional[FileInfo]:
-        if self._helper_file is None or not isinstance(self._helper_file, FileInfo):
+        if (self._helper_file is None or not isinstance(self._helper_file, FileInfo)) and not self.deleted:
             self._helper_file = self.add_file('__dir_helper_file__')
 
         return self._helper_file
@@ -646,7 +684,7 @@ class DirectoryInfo(object, metaclass=DirectoryInfoMetaMock):
 
     @property
     def resource_entry(self) -> Optional[ResourceDirectoryEntry]:
-        if self._resource_entry is None:
+        if self._resource_entry is None and not self.deleted:
             if self.data_model is None:
                 logger.warning(
                     f'No data model provided. Using default data model: {config.get_default_data_model().id}.')
@@ -795,5 +833,63 @@ class DirectoryInfo(object, metaclass=DirectoryInfoMetaMock):
     def add_tag(self, tag: SimTaxonomyEntry) -> None:
         add_tag_to_resource(self.resource_entry, tag)
 
+    def delete(self):
+
+        for file in self.files:
+            file.delete()
+
+        # delete helper file
+        if self.helper_file is not None:
+            self.helper_file.delete()
+
+        if self.resource_entry is not None:
+            if self.resource_entry.Key in self._cls_instances:
+                del self._cls_instances[self.resource_entry.Key]
+            self.data_model.delete_resource(self.resource_entry)
+
+        shutil.rmtree(self.full_path)
+        self.deleted = True
+
+    def delete_files(self,
+                     pattern: Optional[str] = None,
+                     recursive: bool = False) -> None:
+        """
+        Delete files by pattern.
+        :param pattern: Pattern to match files. Default is None. if None, all files are deleted.
+        :param recursive: If True, delete files recursively.
+        :return:
+        """
+
+        if pattern:
+            matching = glob.glob(self.full_path + f'/{pattern}', recursive=recursive)
+
+        for file in self.files:
+            if pattern is None or file.file_path in matching:
+                logger.debug(f'Deleting file: {file.filename}')
+                file.delete()
+
+        if recursive:
+            for sub_dir in self.sub_directories:
+                sub_dir.delete_files(pattern=pattern, recursive=recursive)
+
+    def delete_subdirectories(self,
+                              pattern: Optional[str] = None,
+                                recursive: bool = False) -> None:
+
+        """
+        Delete subdirectories by pattern.
+        :param pattern: Regex pattern to match subdirectories. Default is None. If None, all subdirectories are deleted.
+        :param recursive: If True, delete subdirectories recursively.
+        :return:
+        """
+
+        for sub_dir in self.sub_directories:
+            if pattern is None or re.match(pattern, sub_dir.relative_path):
+                logger.debug(f'Deleting subdirectory: {sub_dir.relative_path}')
+                sub_dir.delete()
+
     def __repr__(self):
-        return f'DirectoryInfo(key:{self.key}, hash: {hash(self)}; {self.full_path})'
+        if not self.deleted:
+            return f'DirectoryInfo(key:{self.key}, hash: {hash(self)}; {self.full_path})'
+        else:
+            return f'(Deleted) DirectoryInfo(key:{self.key}, hash: {hash(self)}; {self.full_path}) (deleted)'

PySimultan2/object_mapper.py

@@ -168,6 +168,7 @@ class PythonMapper(object):
                           '_cls_instances': WeakSet(),
                           '_taxonomy_map': self.taxonomy_maps.get(taxonomy, None),
                           '_base': bases,
+                          '_original_cls': cls,
                           '_object_mapper': self}
 
         new_class_dict.update(self.get_properties(taxonomy))

PySimultan2/simultan_object.py

@@ -130,6 +130,42 @@ class SimultanObject(object, metaclass=MetaMock):
             logger.error(f'Error getting cls_instances: {e}')
             return []
 
+    @classproperty
+    def super_classes(cls):
+        superclasses = []
+        for key, mcls in cls._object_mapper.mapped_classes.items():
+            if mcls is cls:
+                continue
+            if set(cls._original_cls.__mro__) & set(mcls._original_cls.__mro__) - set([object]) and \
+                    set(mcls._original_cls.__mro__) - set(cls._original_cls.__mro__) - set((SimultanObject,
+                                                           object)):
+                superclasses.append(mcls)
+        return superclasses
+
+    @classproperty
+    def sub_classes(cls):
+        subclasses = []
+        for key, mcls in cls._object_mapper.mapped_classes.items():
+            if mcls is cls:
+                continue
+            if set(cls._original_cls.__mro__) & set(mcls._original_cls.__mro__) - set([object]) and \
+                    set(cls._original_cls.__mro__) - set(mcls._original_cls.__mro__) - set((SimultanObject,
+                                                                                            object)):
+                subclasses.append(mcls)
+        return subclasses
+
+    @classproperty
+    def super_class_instances(cls) -> set['SimultanObject']:
+        instances = set()
+        _ = [instances.update(x.cls_instances) for x in cls.super_classes]
+        return instances
+
+    @classproperty
+    def sub_class_instances(cls) -> set['SimultanObject']:
+        instances = set()
+        _ = [instances.update(x.cls_instances) for x in cls.sub_classes]
+        return instances
+
     @classmethod
     def create_simultan_component(cls, *args, **kwargs) -> SimComponent:
         wrapped_obj = utils.create_simultan_component_for_taxonomy(cls, *args, **kwargs)