PySimultan 0.5.3__tar.gz → 0.5.5__tar.gz

{pysimultan-0.5.3 → pysimultan-0.5.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: PySimultan
-Version: 0.5.3
+Version: 0.5.5
 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

pysimultan-0.5.5/src/PySimultan2/__about__.py

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

{pysimultan-0.5.3 → pysimultan-0.5.5}/src/PySimultan2/data_model.py

@@ -43,7 +43,7 @@ from System.Security import *
 from System.Security.Cryptography import *
 from System.Text import *
 
-from .files import add_tag_to_resource, FileInfo as PythonFileInfo
+from .files import add_tag_to_resource, FileInfo as PythonFileInfo, DirectoryInfo as PythonDirectoryInfo
 
 
 if TYPE_CHECKING:
@@ -165,6 +165,11 @@ class DataModel:
     def assets(self):
         return self.project_data_manager.AssetManager.Resources
 
+    @property
+    def file_directories(self):
+        return [PythonDirectoryInfo(resource_entry=x,
+                              data_model=self) for x in self.project_data_manager.AssetManager.Resources if isinstance(x, ResourceDirectoryEntry)]
+
     @property
     def models(self) -> dict[int, 'GeometryModel']:
         """
@@ -503,7 +508,7 @@ class DataModel:
 
     def add_empty_resource(self,
                            filename: str,
-                           target_dir: Union[ResourceDirectoryEntry, DirectoryInfo, str] = None) -> ResourceEntry:
+                           target_dir: Union[ResourceDirectoryEntry, FileInfo, str] = None) -> ResourceEntry:
         """
         Add an empty resource to the project
         :param filename: name of the new resource
@@ -519,7 +524,7 @@ class DataModel:
 
             if isinstance(target_dir, ResourceDirectoryEntry):
                 target_dir = target_dir.CurrentFullPath
-            if isinstance(target_dir, DirectoryInfo):
+            if isinstance(target_dir, FileInfo):
                 target_dir = target_dir.FullPath
 
             return self.project.AddEmptyResource(FileInfo(
@@ -571,7 +576,7 @@ class DataModel:
                     target_dir = DirectoryInfo(target_dir)
                 elif isinstance(target_dir, ResourceDirectoryEntry):
                     target_dir = DirectoryInfo(target_dir.CurrentFullPath)
-                elif isinstance(target_dir, DirectoryInfo):
+                elif isinstance(target_dir, FileInfo):
                     pass
 
                 resource = self.project.CopyResourceAsContainedFileEntry(filename,

{pysimultan-0.5.3 → pysimultan-0.5.5}/src/PySimultan2/files.py

@@ -69,7 +69,7 @@ def add_tag_to_resource(resource: Union[ResourceFileEntry, ContainedResourceFile
 
 
 def add_asset_to_component(comp: [SimComponent, SimultanObject],
-                           asset: Union[ResourceFileEntry, ContainedResourceFileEntry],
+                           asset: Union[ResourceFileEntry, ContainedResourceFileEntry, ResourceDirectoryEntry],
                            content_id: str = '',
                            tag: SimTaxonomyEntry = None) -> Asset:
     """
@@ -127,8 +127,14 @@ def create_asset_from_string(filename: str,
         with open(filepath, 'w') as f:
             f.write(content)
 
-        resource = data_model.add_resource(filepath,
-                                           target_dir=target_dir)
+        if target_dir is not None:
+            if isinstance(target_dir, DirectoryInfo):
+                target_dir = target_dir.full_path
+
+            resource = data_model.add_resource(filepath,
+                                               target_dir=target_dir)
+        else:
+            resource = data_model.add_resource(filepath)
 
     if tag is not None:
         add_tag_to_resource(resource,
@@ -225,6 +231,22 @@ class MetaMock(type):
         return obj
 
 
+class DirectoryInfoMetaMock(type):
+
+    def __call__(cls, *args, **kwargs):
+        resource_entry: Optional[ResourceDirectoryEntry] = kwargs.get('resource_entry', None)
+        if resource_entry is not None and hasattr(resource_entry, 'Key'):
+            obj = cls._cls_instances.get(resource_entry.Key, None)
+            if obj is not None:
+                return obj
+
+        obj = cls.__new__(cls)
+        obj.__init__(*args, **kwargs)
+        if obj.resource_entry is not None:
+            cls._cls_instances[obj.resource_entry.Key] = obj
+        return obj
+
+
 class FileInfo(object, metaclass=MetaMock):
 
     _cls_instances = {}
@@ -302,6 +324,11 @@ class FileInfo(object, metaclass=MetaMock):
         except Exception as e:
             return None
 
+    @property
+    def directory(self) -> DirectoryInfo:
+        return DirectoryInfo(resource_entry=self.resource_entry.Parent,
+                             data_model=self.data_model)
+
     @property
     def resource_entry(self) -> Union[ResourceFileEntry, ContainedResourceFileEntry, None]:
         if self._resource_entry is None:
@@ -471,3 +498,136 @@ class FileInfo(object, metaclass=MetaMock):
             "$key": str(self.key)
         }
         }
+
+
+class DirectoryInfo(object, metaclass=DirectoryInfoMetaMock):
+
+    _cls_instances = {}
+
+    @classmethod
+    def get_by_key(cls, key: int) -> Optional[DirectoryInfo]:
+        return cls._cls_instances.get(key, None)
+
+    def __init__(self,
+                 path: Optional[str] = None,
+                 helper_file: Optional[FileInfo] = None,
+                 resource_entry: Optional[ResourceDirectoryEntry] = None,
+                 *args,
+                 **kwargs):
+
+        self._resource_entry: Optional[ResourceDirectoryEntry] = None
+        self._helper_file: Optional[FileInfo] = None
+        self.data_model: Optional[DataModel] = kwargs.get('data_model', None)
+        self.path: str = path
+
+        self.resource_entry = resource_entry
+        self.helper_file = helper_file
+
+    @property
+    def tags(self) -> List[SimTaxonomyEntry]:
+        return list(self.resource_entry.Tags)
+
+    @property
+    def full_path(self) -> str:
+        return self.resource_entry.CurrentFullPath
+
+    @property
+    def relative_path(self) -> str:
+        return self.resource_entry.CurrentRelativePath
+
+    @property
+    def helper_file(self) -> Optional[FileInfo]:
+        if self._helper_file is None:
+            self._helper_file = self.add_file('__dir_helper_file__')
+
+        return self._helper_file
+
+    @helper_file.setter
+    def helper_file(self, value):
+        self._helper_file = value
+
+    @property
+    def resource_entry(self) -> Optional[ResourceDirectoryEntry]:
+        if self._resource_entry is None:
+            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()
+            if self.data_model is not None:
+                self.resource_entry = self.data_model.create_resource_directory(self.path)
+                self._cls_instances[self.resource_entry.Key] = self
+                self.path = self.resource_entry.CurrentFullPath
+        return self._resource_entry
+
+    @resource_entry.setter
+    def resource_entry(self, value):
+
+        orig_value = self._resource_entry
+        self._resource_entry = value
+
+        if self._resource_entry is None:
+            if orig_value is not None:
+                del self._cls_instances[orig_value.Key]
+            return
+
+        if self.key is not None:
+            if value is not None:
+                self._cls_instances[value.Key] = self
+            else:
+                del self._cls_instances[self._resource_entry.Key]
+            self._resource_entry = value
+
+    @property
+    def parent(self) -> Optional[ResourceDirectoryEntry]:
+        if self.resource_entry.Parent is not None:
+            if self.resource_entry.Parent.Key in self._cls_instances:
+                return self.get_by_key(self.resource_entry.Parent.Key)
+            return DirectoryInfo(resource_entry=self.resource_entry.Parent)
+        else:
+            return self.resource_entry.Parent
+
+    @property
+    def sub_directories(self) -> List[DirectoryInfo]:
+        return [DirectoryInfo(resource_entry=entry,
+                              data_model=self.data_model) for entry in self.resource_entry.Children if isinstance(entry, ResourceDirectoryEntry)]
+
+    @property
+    def files(self) -> List[FileInfo]:
+        return [FileInfo(resource_entry=entry,
+                         data_model=self.data_model) for entry in self.resource_entry.Children if isinstance(entry,
+                                                                                                             (
+                                                                                                             ResourceFileEntry,
+                                                                                                             ContainedResourceFileEntry)
+                                                                                                             ) and entry.Name != '__dir_helper_file__'
+                ]
+
+    @property
+    def key(self) -> Optional[int]:
+        if self.resource_entry is not None:
+            return self.resource_entry.Key
+        else:
+            return None
+
+    def add_sub_directory(self, name: str) -> DirectoryInfo:
+        return DirectoryInfo(path=os.path.join(self.resource_entry.current_relative_path, name),
+                             data_model=self.data_model)
+
+    def add_file(self,
+                 filename: str,
+                 content: Optional[str] = None) -> FileInfo:
+
+        if content is not None:
+            return FileInfo.from_string(filename=filename,
+                                        content=content,
+                                        target_dir=self.resource_entry,
+                                        data_model=self.data_model)
+        else:
+            new_resource = self.data_model.add_empty_resource(filename=os.path.join(self.full_path, filename))
+            return FileInfo(resource_entry=new_resource,
+                            data_model=self.data_model)
+
+    def add_tag(self, tag: SimTaxonomyEntry) -> None:
+        add_tag_to_resource(self.resource_entry, tag)
+
+    def __repr__(self):
+        return f'DirectoryInfo(key:{self.key}, hash: {hash(self)}; {self.full_path})'

{pysimultan-0.5.3 → pysimultan-0.5.5}/src/PySimultan2/type_setter_lookup.py

@@ -5,9 +5,9 @@ import inspect
 import enum
 
 from .utils import (SimComponent, SimDoubleParameter, SimIntegerParameter, SimStringParameter,
-                    SimBoolParameter, SimEnumParameter, SimMultiValueField3D, SimMultiValueBigTable, FileInfo,
+                    SimBoolParameter, SimEnumParameter, SimMultiValueField3D, SimMultiValueBigTable, FileInfo, DirectoryInfo,
                     set_property_to_sim_component, set_property_to_parameter, set_property_to_value_field,
-                    set_property_to_file_info, set_property_to_list, set_property_to_dict)
+                    set_property_to_file_info, set_property_to_list, set_property_to_dict, set_property_to_directory_info)
 
 from .simultan_object import SimultanObject, MetaMock
 
@@ -36,6 +36,7 @@ class TypeSetterFcnLookupDict(object):
                    str: set_property_to_parameter,
                    bool: set_property_to_parameter,
                    FileInfo: set_property_to_file_info,
+                   DirectoryInfo: set_property_to_directory_info,
                    list: set_property_to_list,
                    tuple: set_property_to_list,
                    set: set_property_to_list,

{pysimultan-0.5.3 → pysimultan-0.5.5}/src/PySimultan2/utils.py

@@ -20,12 +20,13 @@ from SIMULTAN.Data.Components import SimDefaultSlotKeys
 from SIMULTAN.Data.MultiValues import (SimMultiValueField3D, SimMultiValueField3DParameterSource, SimMultiValueBigTable,
                                        SimMultiValueBigTableHeader, SimMultiValueBigTableParameterSource)
 
-from SIMULTAN.Data.Assets import ResourceEntry, ResourceFileEntry, ContainedResourceFileEntry, Asset, LinkedResourceFileEntry
+from SIMULTAN.Data.Assets import (ResourceEntry, ResourceFileEntry, ContainedResourceFileEntry, Asset,
+                                  LinkedResourceFileEntry, ResourceDirectoryEntry)
 from SIMULTAN.Data.Geometry import Face, Edge, Vertex, Volume
 
 from .multi_values import (simultan_multi_value_field_3d_to_numpy, set_parameter_to_value_field,
                            create_field_parameter, simultan_multi_value_big_table_to_pandas)
-from .files import FileInfo, remove_asset_from_component, add_asset_to_component
+from .files import FileInfo, remove_asset_from_component, add_asset_to_component, DirectoryInfo
 
 if TYPE_CHECKING:
     from .default_types import ComponentList, ComponentDictionary
@@ -767,10 +768,22 @@ def get_sim_double_parameter_value(obj: SimDoubleParameter,
 
 def get_resource_entry_value(obj: ResourceEntry,
                              data_model: DataModel = None,
-                             object_mapper: PythonMapper = None) -> FileInfo:
-    return FileInfo(file_path=obj.File.FullPath,
-                    resource_entry=obj,
-                    data_model=data_model)
+                             object_mapper: PythonMapper = None) -> Union[FileInfo, DirectoryInfo]:
+    if isinstance(obj, (ResourceFileEntry, ContainedResourceFileEntry, LinkedResourceFileEntry)):
+
+        if obj.Name == '__dir_helper_file__':
+            return DirectoryInfo(file_path=obj.Parent.CurrentFullPath,
+                                 resource_entry=obj.Parent,
+                                 helper_file=obj,
+                                 data_model=data_model)
+
+        return FileInfo(file_path=obj.File.FullPath,
+                        resource_entry=obj,
+                        data_model=data_model)
+    elif isinstance(obj, ResourceDirectoryEntry):
+        return DirectoryInfo(file_path=obj.CurrentFullPath,
+                             resource_entry=obj,
+                             data_model=data_model)
 
 
 type_convert_dict = {SimComponent: get_sim_component_value,
@@ -780,13 +793,16 @@ type_convert_dict = {SimComponent: get_sim_component_value,
                      SimBoolParameter: get_parameter_value,
                      SimEnumParameter: get_parameter_value,
                      ResourceEntry: get_resource_entry_value,
+                     ResourceFileEntry: get_resource_entry_value,
+                     ResourceDirectoryEntry: get_resource_entry_value,
                      ContainedResourceFileEntry: get_resource_entry_value,
                      LinkedResourceFileEntry: get_resource_entry_value
                      }
 
 
 def get_obj_value(obj: Union[SimComponent, SimDoubleParameter, SimIntegerParameter, SimStringParameter,
-                             SimBoolParameter, SimEnumParameter, ResourceEntry, ContainedResourceFileEntry, None],
+                             SimBoolParameter, SimEnumParameter, ResourceEntry, ResourceFileEntry, ContainedResourceFileEntry,
+                             ResourceDirectoryEntry, None],
                   data_model: DataModel,
                   object_mapper: PythonMapper) -> Union[SimultanObject, int, float, str, FileInfo, None, pd.DataFrame,
                                                         np.ndarray]:
@@ -1161,6 +1177,44 @@ def set_property_to_file_info(value: FileInfo,
                            tag=taxonomy_entry)
 
 
+def set_property_to_directory_info(value: DirectoryInfo,
+                                   component: SimultanObject,
+                                   prop_name: str,
+                                   taxonomy_entry: SimTaxonomyEntry,
+                                   slot_extension: Union[str, int, float],
+                                   component_idx: int = None,
+                                   ref_component_idx: int = None,
+                                   parameter_idx: int = None,
+                                   ref_asset_idx: int = None,
+                                   content: Content = None) -> None:
+
+    remove_prop_from_sim_component(component=component,
+                                   component_idx=component_idx,
+                                   ref_component_idx=ref_component_idx,
+                                   parameter_idx=parameter_idx,
+                                   ref_asset_idx=ref_asset_idx,
+                                   keep=['ref_asset_idx'])
+
+    value.data_model = component._data_model
+
+    if ref_asset_idx is not None:
+        asset = component._wrapped_obj.ReferencedAssets.Items[ref_asset_idx]
+
+        if hasattr(value, 'resource_entry'):
+            if asset.Resource.Key == value.resource_entry.Key:
+                return
+        elif asset.Resource.CurrentFullPath == str(value.file_path):
+            return
+
+        remove_asset_from_component(component._wrapped_obj, asset)
+        ref_asset_idx = None
+
+    add_asset_to_component(component._wrapped_obj,
+                           value.helper_file.resource_entry,
+                           '0',
+                           tag=taxonomy_entry)
+
+
 def set_property_to_parameter(value: Union[int, float, str, Enum, bool],
                               component: SimultanObject,
                               prop_name: str,

pysimultan-0.5.5/tests/test_directory_and_files.py

@@ -0,0 +1,154 @@
+import os
+from PySimultan2.src.PySimultan2 import DataModel, TaxonomyMap, Content, PythonMapper
+from PySimultan2.src.PySimultan2.files import FileInfo, DirectoryInfo
+
+
+project_dir = os.environ.get('PROJECT_DIR', '/simultan_projects')
+if not os.path.exists(project_dir):
+    os.makedirs(project_dir)
+
+
+def test_files_and_directory_creation():
+    new_data_model = DataModel.create_new_project(project_path=os.path.join(project_dir, 'test_dir_files.simultan'),
+                                                  user_name='admin',
+                                                  password='admin')
+
+    print(new_data_model.file_directories)
+
+
+    new_directory_info = DirectoryInfo(path='directory_info_dir',
+                                       data_model=new_data_model)
+
+    print(new_data_model.file_directories)
+
+    print(new_directory_info.resource_entry)
+    print(new_directory_info.parent)
+
+    new_file1 = new_directory_info.add_file('test_add_file.txt', 'This is a test file')
+    new_file2 = new_directory_info.add_file('test_add_file2.txt')
+
+    sub_directory_info = new_directory_info.add_sub_directory('sub_dir')
+    print(sub_directory_info.parent)
+
+    print(new_directory_info.sub_directories)
+
+
+    new_directory = new_data_model.create_resource_directory('test_dir')
+    new_directory2 = new_data_model.create_resource_directory('test_dir2')
+    new_directory4 = new_data_model.create_resource_directory('test_dir3')
+
+    new_data_model.add_empty_resource(filename=os.path.join(new_directory.CurrentFullPath, 'test_empty_file.txt'))
+
+    new_data_model.add_empty_resource(filename='test_empty_file2.txt',
+                                      target_dir=new_directory)
+
+    new_file_info0 = FileInfo.from_string(filename='test_file.txt',
+                                          content='This is a test file',
+                                          data_model=new_data_model)
+
+    new_file_info = FileInfo.from_string(filename='test_file.txt',
+                                         content='This is a test file',
+                                         target_dir=new_directory,
+                                         data_model=new_data_model)
+
+    new_file_info2 = FileInfo.from_string(filename='test_file2.txt',
+                                         content='This is a test file 2',
+                                         target_dir=new_directory2.current_full_path,
+                                         data_model=new_data_model)
+
+    # create just a file in the directory
+    with open(os.path.join(new_directory2.current_full_path, 'not_contained_test_file3.txt'), 'w') as f:
+        f.write('This is a test file 3')
+
+
+    new_data_model.save()
+    new_data_model.cleanup()
+
+
+def create_mapper():
+    mapper = PythonMapper()
+
+    class TestComponent(object):
+        def __init__(self, *args, **kwargs):
+            self.file = kwargs.get('file')
+            self.directory = kwargs.get('directory')
+            self.param_1 = kwargs.get('param_1')
+            self.param_2 = kwargs.get('param_2')
+
+    content0 = Content(text_or_key='file',  # text or key of the content/parameter/property
+                       property_name='file',  # name of the generated property
+                       type='file',  # type of the content/parameter/property
+                       unit=None,  # unit of the content/parameter/property
+                       documentation='file_value to test')
+
+    content1 = Content(text_or_key='directory',  # text or key of the content/parameter/property
+                       property_name='directory',  # name of the generated property
+                       type='file',  # type of the content/parameter/property
+                       unit=None,  # unit of the content/parameter/property
+                       documentation='file_value_2 to test')
+
+    content2 = Content(text_or_key='param_1',  # text or key of the content/parameter/property
+                       property_name='param_1',  # name of the generated property
+                       type=None,  # type of the content/parameter/property
+                       unit=None,  # unit of the content/parameter/property
+                       documentation='param_1 to test')
+
+    content3 = Content(text_or_key='param_2',  # text or key of the content/parameter/property
+                       property_name='param_2',  # name of the generated property
+                       type=None,  # type of the content/parameter/property
+                       unit=None,  # unit of the content/parameter/property
+                       documentation='param_2 to test')
+
+    test_component_map = TaxonomyMap(taxonomy_name='PySimultan',
+                                     taxonomy_key='Test',
+                                     taxonomy_entry_name='test_component',
+                                     taxonomy_entry_key='test_component',
+                                     content=[content0, content1, content2, content3],
+                                     )
+
+    mapper.register(test_component_map.taxonomy_entry_key, TestComponent, taxonomy_map=test_component_map)
+
+    return mapper
+
+
+def test_component_with_directory():
+
+    new_data_model = DataModel.create_new_project(project_path=os.path.join(project_dir, 'test_dir_component.simultan'),
+                                                  user_name='admin',
+                                                  password='admin')
+
+    mapper = create_mapper()
+    mapped_test_component_cls = mapper.get_mapped_class('test_component')
+
+    new_component = mapped_test_component_cls(file=FileInfo.from_string(filename='test_file.txt',
+                                                                                    content='This is a test file',
+                                                                                    data_model=new_data_model),
+                                                directory=DirectoryInfo(path='test_dir',
+                                                                        data_model=new_data_model),
+                                                param_1='param_1_value',
+                                                param_2=2)
+
+    print(new_component.directory)
+
+    new_data_model.save()
+    new_data_model.cleanup()
+    mapper.clear()
+
+
+def test_load_component_with_directory():
+    new_data_model = DataModel(project_path=os.path.join(project_dir, 'test_dir_component.simultan'))
+
+    mapper = create_mapper()
+    typed_data = new_data_model.get_typed_data(mapper=mapper)
+    mapped_test_component_cls = mapper.get_mapped_class('test_component')
+
+    assert isinstance(mapped_test_component_cls.cls_instances[0].directory,  DirectoryInfo)
+
+    new_data_model.cleanup()
+    mapper.clear()
+
+
+if __name__ == '__main__':
+    # test_files_and_directory_creation()
+    test_component_with_directory()
+    test_load_component_with_directory()

pysimultan-0.5.3/src/PySimultan2/__about__.py

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

pysimultan-0.5.3/tests/test_directory_and_files.py

@@ -1,44 +0,0 @@
-import os
-from PySimultan2.src.PySimultan2 import DataModel
-from PySimultan2.src.PySimultan2.files import FileInfo
-
-
-project_dir = os.environ.get('PROJECT_DIR', '/simultan_projects')
-if not os.path.exists(project_dir):
-    os.makedirs(project_dir)
-
-new_data_model = DataModel.create_new_project(project_path=os.path.join(project_dir, 'test_dir_files.simultan'),
-                                              user_name='admin',
-                                              password='admin')
-
-
-new_directory = new_data_model.create_resource_directory('test_dir')
-new_directory2 = new_data_model.create_resource_directory('test_dir2')
-new_directory4 = new_data_model.create_resource_directory('test_dir3')
-
-new_data_model.add_empty_resource(filename=os.path.join(new_directory.CurrentFullPath, 'test_empty_file.txt'))
-
-new_data_model.add_empty_resource(filename='test_empty_file2.txt',
-                                  target_dir=new_directory)
-
-new_file_info0 = FileInfo.from_string(filename='test_file.txt',
-                                      content='This is a test file',
-                                      data_model=new_data_model)
-
-new_file_info = FileInfo.from_string(filename='test_file.txt',
-                                     content='This is a test file',
-                                     target_dir=new_directory,
-                                     data_model=new_data_model)
-
-new_file_info2 = FileInfo.from_string(filename='test_file2.txt',
-                                     content='This is a test file 2',
-                                     target_dir=new_directory2.current_full_path,
-                                     data_model=new_data_model)
-
-# create just a file in the directory
-with open(os.path.join(new_directory2.current_full_path, 'not_contained_test_file3.txt'), 'w') as f:
-    f.write('This is a test file 3')
-
-
-new_data_model.save()
-new_data_model.cleanup()