PySimultan 0.5.0__tar.gz → 0.5.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: PySimultan
-Version: 0.5.0
+Version: 0.5.3
 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.3/src/PySimultan2/CHANGELOG.md

@@ -0,0 +1,7 @@
+Version 0.5.3 (01.12.2024)
+- Added support for directories (Assets and FileInfo)
+
+Version 0.5.1 (25.11.2024)
+
+- setting re-register default in Mapper to True
+- added uncache method to utils for monkey patching

pysimultan-0.5.3/src/PySimultan2/__about__.py

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

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

@@ -23,7 +23,7 @@ from SIMULTAN.Serializer.SimGeo import *
 from SIMULTAN.Serializer.Projects import *
 from SIMULTAN.Data.Components import SimComponent, SimComponentCollection
 from SIMULTAN.Data.MultiValues import SimMultiValueBigTable, SimMultiValueField3D
-from SIMULTAN.Data.Assets import ResourceEntry
+from SIMULTAN.Data.Assets import ResourceEntry, ResourceDirectoryEntry, ResourceFileEntry, ContainedResourceFileEntry
 from SIMULTAN.Data.Geometry import OffsetAlgorithm
 # from GeometryViewer.Service import *
 # from SIMULTAN.UI.Services import *
@@ -37,6 +37,7 @@ from SIMULTAN.Data.Geometry import Layer, Vertex, Edge, PEdge, Face, Volume, Edg
 from System.Security import SecureString
 from SIMULTAN.Data import SimId
 from System import Guid
+from System.IO import DirectoryInfo
 from System.IO import *
 from System.Security import *
 from System.Security.Cryptography import *
@@ -500,19 +501,35 @@ class DataModel:
         self.get_file_infos.cache_clear()
         return new_resource
 
-    def add_empty_resource(self, filename: str):
+    def add_empty_resource(self,
+                           filename: str,
+                           target_dir: Union[ResourceDirectoryEntry, DirectoryInfo, str] = None) -> ResourceEntry:
         """
         Add an empty resource to the project
-        :param file_name: name of the new resource
+        :param filename: name of the new resource
+        :param target_dir: directory to add the resource
         :return:
         """
         # return self.project.AddResourceFile(FileInfo(str(filename)))
 
         self.get_file_infos.cache_clear()
-        return self.project.AddEmptyResource(FileInfo(str(filename)))
+        if target_dir is None:
+            return self.project.AddEmptyResource(FileInfo(str(filename)))
+        else:
+
+            if isinstance(target_dir, ResourceDirectoryEntry):
+                target_dir = target_dir.CurrentFullPath
+            if isinstance(target_dir, DirectoryInfo):
+                target_dir = target_dir.FullPath
+
+            return self.project.AddEmptyResource(FileInfo(
+                os.path.join(target_dir, str(filename))
+                                                          )
+                                                 )
 
     def add_resource(self,
                      filename: Union[str, FileInfo],
+                     target_dir: Optional[Union[DirectoryInfo, ResourceDirectoryEntry, str]] = None,
                      tag: Union[SimTaxonomyEntry, SimTaxonomyEntryReference] = None) -> ResourceEntry:
         """
         Add a new resource to the project. The resource will be copied to the project folder and added to the project
@@ -545,9 +562,21 @@ class DataModel:
             if isinstance(filename, (str, PosixPath, WindowsPath)):
                 filename = FileInfo(str(filename))
 
-            resource = self.project.CopyResourceAsContainedFileEntry(filename,
-                                                                     self.project.ProjectUnpackFolder,
-                                                                     '1')
+            if target_dir is None:
+                resource = self.project.CopyResourceAsContainedFileEntry(filename,
+                                                                         self.project.ProjectUnpackFolder,
+                                                                         '1')
+            else:
+                if isinstance(target_dir, str):
+                    target_dir = DirectoryInfo(target_dir)
+                elif isinstance(target_dir, ResourceDirectoryEntry):
+                    target_dir = DirectoryInfo(target_dir.CurrentFullPath)
+                elif isinstance(target_dir, DirectoryInfo):
+                    pass
+
+                resource = self.project.CopyResourceAsContainedFileEntry(filename,
+                                                                         target_dir,
+                                                                         '1')
 
             if del_copy:
                 os.remove(str(filename))
@@ -583,6 +612,19 @@ class DataModel:
         self.get_file_infos.cache_clear()
         return success
 
+    def create_resource_directory(self,
+                                  name: str,
+                                  parent_directory: DirectoryInfo=None,
+                                  collision_name_format: str = '{0} ({1})') -> ResourceEntry:
+
+        if parent_directory is None:
+            new_directory = self.project.CreateResourceDirIn(name, None, collision_name_format)
+        else:
+            new_directory = self.project.CreateResourceDirIn(name, parent_directory, collision_name_format)
+
+        return new_directory
+
+
     def add_table(self, table: SimMultiValueBigTable):
         self.project_data_manager.ValueManager.Add(table)
 

{pysimultan-0.5.0 → pysimultan-0.5.3}/src/PySimultan2/default_types.py

@@ -1,14 +1,10 @@
 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
 
-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,

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

@@ -14,10 +14,12 @@ import shutil
 import zipfile
 # from System.IO import FileInfo  # public FileInfo (string fileName);
 
-from SIMULTAN.Data.Assets import ResourceEntry, ResourceFileEntry, ContainedResourceFileEntry, Asset
+from SIMULTAN.Data.Assets import ResourceEntry, ResourceFileEntry, ContainedResourceFileEntry, Asset, ResourceDirectoryEntry
 from SIMULTAN.Data.Taxonomy import SimTaxonomyEntry, SimTaxonomyEntryReference, SimTaxonomy
 from SIMULTAN.Data.Components import SimComponent, ComponentMapping
 
+from System.IO import DirectoryInfo
+
 # from .config import default_data_model
 
 from . import config, logger
@@ -50,7 +52,7 @@ def tempdir():
         yield dir_path
 
 
-def add_tag_to_resource(resource: Union[ResourceFileEntry, ContainedResourceFileEntry],
+def add_tag_to_resource(resource: Union[ResourceFileEntry, ContainedResourceFileEntry, ResourceDirectoryEntry],
                         tag: Union[SimTaxonomyEntry, SimTaxonomyEntryReference]):
     """
     Add a tag to an asset.
@@ -109,12 +111,14 @@ def remove_asset_from_component(comp: Union[SimComponent, SimultanObject],
 def create_asset_from_string(filename: str,
                              content: str,
                              data_model: DataModel,
+                             target_dir: Optional[Union[DirectoryInfo, ResourceDirectoryEntry, str]] = None,
                              tag: Optional[Union[SimTaxonomyEntry, SimTaxonomyEntryReference]] = None) -> ResourceFileEntry:
     """
     Create a new asset from a string. The asset is added to the data model.
     :param filename: Name of the file to be created. E.g. 'new_file.txt'
     :param content:  Content of the file. E.g. 'This is the content of the file.'
     :param data_model:  Data model to add the asset to.
+    :param target_dir: Target directory to add the asset to.
     :param tag: Tag to be added to the asset.
     :return: ResourceFileEntry
     """
@@ -123,10 +127,12 @@ def create_asset_from_string(filename: str,
         with open(filepath, 'w') as f:
             f.write(content)
 
-        resource = data_model.add_resource(filepath)
+        resource = data_model.add_resource(filepath,
+                                           target_dir=target_dir)
 
     if tag is not None:
-        add_tag_to_resource(resource, tag)
+        add_tag_to_resource(resource,
+                            tag)
 
     return resource
 
@@ -134,12 +140,14 @@ def create_asset_from_string(filename: str,
 def create_asset_from_str_io(filename: str,
                              content: io.StringIO,
                              data_model: DataModel,
+                             target_dir: Optional[Union[DirectoryInfo, ResourceDirectoryEntry, str]] = None,
                              tag: Union[SimTaxonomyEntry, SimTaxonomyEntryReference] = None) -> ResourceFileEntry:
     """
     Create a new asset from a string io. The asset is added to the data model.
     :param filename: Name of the file to be created. E.g. 'new_file.txt'
     :param content:  Content of the file. E.g. 'This is the content of the file.'
     :param data_model:  Data model to add the asset to.
+    :param target_dir: Target directory to add the asset to.
     :param tag: Tag to be added to the asset.
     :return: ResourceFileEntry
     """
@@ -148,7 +156,8 @@ def create_asset_from_str_io(filename: str,
         with open(filepath, 'w') as f:
             f.write(content.getvalue())
 
-        resource = data_model.add_resource(filepath)
+        resource = data_model.add_resource(filepath,
+                                           target_dir=target_dir)
 
     if tag is not None:
         add_tag_to_resource(resource, tag)
@@ -175,6 +184,32 @@ def create_asset_from_file(file_info: FileInfo,
     return resource
 
 
+def add_directory(data_model: DataModel,
+                  directory: str,
+                  parent_directory: Optional[Union[DirectoryInfo, ResourceDirectoryEntry, str]] = None,
+                  tag: Union[SimTaxonomyEntry, SimTaxonomyEntryReference] = None) -> ResourceDirectoryEntry:
+
+    """
+    Add a directory to the data model.
+    :param data_model:
+    :param target_dir:
+    :param tag:
+    :return:
+    """
+
+    # create the directory
+    resource_directory_entry = data_model.create_resource_directory(parent_directory=parent_directory)
+
+    for filename in os.listdir(directory):
+        file_path = os.path.join(directory, filename)
+        resource = data_model.add_resource(file_path)
+        if tag is not None:
+            add_tag_to_resource(resource, tag)
+
+
+
+
+
 class MetaMock(type):
     def __call__(cls, *args, **kwargs):
         resource_entry = kwargs.get('resource_entry', None)
@@ -197,18 +232,27 @@ class FileInfo(object, metaclass=MetaMock):
     @classmethod
     def from_string(cls,
                     filename: str,
-                    content: str, *args, **kwargs) -> FileInfo:
+                    content: str,
+                    target_dir: Optional[Union[DirectoryInfo, ResourceDirectoryEntry, str]] = None,
+                    *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'
         :param content:  Content of the file. E.g. 'This is the content of the file.'
+        :param target_dir: Target directory to add the asset to.
         :param args:
         :param kwargs:
         :return: FileInfo
         """
 
         data_model = kwargs.get('data_model', config.get_default_data_model())
-        resource = create_asset_from_string(filename, content, *args, **kwargs)
+        resource = create_asset_from_string(filename,
+                                            content,
+                                            target_dir=target_dir,
+                                            *args,
+                                            **kwargs)
 
         file_info = cls(resource_entry=resource,
                         data_model=data_model)
@@ -247,6 +291,10 @@ class FileInfo(object, metaclass=MetaMock):
         self.args = args
         self.kwargs = kwargs
 
+    @property
+    def parent(self):
+        return self.resource_entry.Parent
+
     @property
     def key(self) -> int:
         try:

{pysimultan-0.5.0 → pysimultan-0.5.3}/src/PySimultan2/object_mapper.py

@@ -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):
@@ -73,10 +100,14 @@ class PythonMapper(object):
         self._mapped_classes = value
 
     def register(self,
-                 taxonomy,
-                 cls,
-                 re_register=False,
+                 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
 
@@ -95,8 +126,27 @@ 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
+
+    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)]):
@@ -342,19 +392,31 @@ class PythonMapper(object):
     def copy(self,
              *args,
              **kwargs) -> 'PythonMapper':
-        new_mapper = 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()
-        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
+        # 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:
@@ -366,6 +428,29 @@ class PythonMapper(object):
         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

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

@@ -373,18 +373,27 @@ def create_parameter(value: Union[int, float, str, SimTaxonomyEntry] = 0,
             raise ValueError(f'Parameter type {type(value)} not supported.')
 
     if parameter_type == float:
+        if isinstance(value, (str, int)):
+            value = float(value)
+
         return create_sim_double_parameter(name=name,
                                            value=value,
                                            slot=taxonomy_entry,
                                            unit=kwargs.pop('unit', ''),
                                            **kwargs)
     elif parameter_type == int:
+        if isinstance(value, (str, float)):
+            value = int(value)
+
         return create_sim_integer_parameter(name=name,
                                             value=value,
                                             slot=taxonomy_entry,
                                             unit=kwargs.pop('unit', ''),
                                             **kwargs)
     elif parameter_type == str:
+        if isinstance(value, (int, float)):
+            value = str(value)
+
         return create_sim_string_parameter(name=name,
                                            value=value,
                                            slot=taxonomy_entry,
@@ -1448,3 +1457,33 @@ def add_properties(prop_name: str,
     delx.__taxonomy__ = taxonomy
 
     return property(getx, setx, delx, "automatic created property")
+
+
+def uncache(exclude):
+    """Remove package modules from cache except excluded ones.
+    On next import they will be reloaded.
+
+    Args:
+        exclude (iter<str>): Sequence of module paths.
+    """
+    pkgs = []
+    for mod in exclude:
+        pkg = mod.split('.', 1)[0]
+        pkgs.append(pkg)
+
+    to_uncache = []
+    for mod in sys.modules:
+        if mod in exclude:
+            continue
+
+        if mod in pkgs:
+            to_uncache.append(mod)
+            continue
+
+        for pkg in pkgs:
+            if mod.startswith(pkg + '.'):
+                to_uncache.append(mod)
+                break
+
+    for mod in to_uncache:
+        del sys.modules[mod]

pysimultan-0.5.3/tests/test_directory_and_files.py

@@ -0,0 +1,44 @@
+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()

pysimultan-0.5.3/tests/test_register_decorator.py

@@ -0,0 +1,41 @@
+from PySimultan2.taxonomy_maps import TaxonomyMap, Content
+from PySimultan2.object_mapper import register
+from PySimultan2 import PythonMapper
+
+
+content_a = Content(text_or_key='a',
+                    property_name='a',
+                    type=None,
+                    unit=None,
+                    documentation='Property a',)
+
+content_b = Content(text_or_key='b',
+                    property_name='b',
+                    type=None,
+                    unit=None,
+                    documentation='Property a',)
+
+test_map = TaxonomyMap(taxonomy_name='Test',
+                       taxonomy_key='Test',
+                       taxonomy_entry_name='TestClass',
+                       taxonomy_entry_key='TestClass',
+                       content=[content_a, content_b],
+                       )
+
+@register(test_map.taxonomy_entry_key, taxonomy_map=test_map, re_register=True, module='test_mapper')
+class TestClass(object):
+
+    def __init__(self, *args, **kwargs):
+        self.a = kwargs.get('a', 1)
+        self.b = kwargs.get('b', 2)
+
+    def add(self):
+        return self.a + self.b
+
+    def __repr__(self):
+        return f'TestClass(a={self.a}, b={self.b})'
+
+
+
+mapped_test_cls = PythonMapper.mappers['test_mapper'].get_mapped_class('TestClass')
+print(mapped_test_cls)

pysimultan-0.5.0/src/PySimultan2/__about__.py

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