PySimultan 0.5.9.5__tar.gz → 0.5.9.7__tar.gz

{pysimultan-0.5.9.5 → pysimultan-0.5.9.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PySimultan
-Version: 0.5.9.5
+Version: 0.5.9.7
 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
@@ -166,6 +166,10 @@ print(instances[0].param_1)
 
 
 # Change Log
+## [0.5.9.7] - 2025-01-09
+- Added default component support to Mapper: if a default component is not present in the datamodel, it is automatically added
+- Fixed content naming bug: Content.name is now used for the name of the TaxonomyEntry in SIMULTAN
+- Added typing for better code completion
 
 ## [0.5.9.4] - 2024-12-31
 - Fixed bug in DirectoryInfo where \_\_dir_helper_file__ was not found if already existing

{pysimultan-0.5.9.5 → pysimultan-0.5.9.7}/README.md

@@ -137,6 +137,10 @@ print(instances[0].param_1)
 
 
 # Change Log
+## [0.5.9.7] - 2025-01-09
+- Added default component support to Mapper: if a default component is not present in the datamodel, it is automatically added
+- Fixed content naming bug: Content.name is now used for the name of the TaxonomyEntry in SIMULTAN
+- Added typing for better code completion
 
 ## [0.5.9.4] - 2024-12-31
 - Fixed bug in DirectoryInfo where \_\_dir_helper_file__ was not found if already existing

{pysimultan-0.5.9.5 → pysimultan-0.5.9.7}/src/PySimultan2/CHANGELOG.md

@@ -1,3 +1,8 @@
+Version 0.5.9.7 (09.01.2024)
+- Added default component support to Mapper: if a default component is not present in the datamodel, it is automatically added
+- Fixed content naming bug: Content.name is now used for the name of the TaxonomyEntry in SIMULTAN
+- Added typing for better code completion
+
 Version 0.5.9.4 (31.12.2024)
 - Fixed bug in DirectoryInfo where __dir__helper_file__ was not found if already existing
 

pysimultan-0.5.9.7/src/PySimultan2/__about__.py

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

{pysimultan-0.5.9.5 → pysimultan-0.5.9.7}/src/PySimultan2/data_model.py

@@ -587,18 +587,33 @@ class DataModel:
 
             del_copy = False
 
-            existing_files = [x.Name for x in self.project_data_manager.AssetManager.Resources]
+            existing_files = [x.current_full_path 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:
+            if not act_filename.startswith(self.project.ProjectUnpackFolder.FullPath) and target_dir is None:
+                target_dir_str = self.project.ProjectUnpackFolder.FullPath
+            elif target_dir is not None:
+                if isinstance(target_dir, ResourceDirectoryEntry):
+                    target_dir_str = target_dir.CurrentFullPath
+                elif isinstance(target_dir, SystemFileInfo):
+                    target_dir_str = target_dir.FullPath
+                elif isinstance(target_dir, str):
+                    target_dir_str = target_dir
+                elif isinstance(target_dir, DirectoryInfo):
+                    target_dir_str = target_dir.FullPath
+
+            full_filename = os.path.join(target_dir_str, os.path.basename(act_filename))
+
+            if full_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):
+                    full_filename = os.path.join(target_dir_str, new_filename)
+                    if full_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))
@@ -776,7 +791,10 @@ class DataModel:
                                            None)
         return model_to_work_with, resource_file
 
-    def get_or_create_taxonomy(self, taxonomy_key: str, taxonomy_name: str = None, description='', create=True):
+    def get_or_create_taxonomy(self, taxonomy_key: str,
+                               taxonomy_name: str = None,
+                               description='',
+                               create=True) -> SimTaxonomy:
         taxonomy = next((x for x in self.taxonomies if x.Key == taxonomy_key), None)
         if taxonomy is None:
             if create:
@@ -784,7 +802,11 @@ class DataModel:
             else:
                 raise ValueError(f'Taxonomy {taxonomy_key} not found in project {self.project_path}')
 
-        return next((x for x in self.taxonomies if x.Key == taxonomy_key), None)
+        taxonomy = next((x for x in self.taxonomies if x.Key == taxonomy_key), None)
+
+        if create and taxonomy is None:
+            raise ValueError(f'Could not create taxonomy {taxonomy_key} in project {self.project_path}')
+        return taxonomy
 
     def get_or_create_taxonomy_entry(self,
                                      name: str,
@@ -860,7 +882,18 @@ class DataModel:
 
     @lru_cache()
     def get_file_infos(self) -> list[PythonFileInfo]:
-        return [PythonFileInfo(resource_entry=asset) for asset in self.assets]
+        file_infos = []
+        for asset in self.assets:
+            if isinstance(asset, ResourceFileEntry):
+                file_infos.append(PythonFileInfo(resource_entry=asset))
+        return file_infos
+
+    def get_directory_infos(self) -> list[PythonDirectoryInfo]:
+        dir_infos = []
+        for asset in self.assets:
+            if isinstance(asset, ResourceDirectoryEntry):
+                dir_infos.append(PythonDirectoryInfo(resource_entry=asset, data_model=self))
+        return dir_infos
 
     def get_file_info_by_key(self,
                              key: int) -> Optional[PythonFileInfo]:

{pysimultan-0.5.9.5 → pysimultan-0.5.9.7}/src/PySimultan2/default_types.py

@@ -17,6 +17,9 @@ from SIMULTAN.Data.Components import (ComponentWalker, SimComponent, SimBoolPara
                                       SimEnumParameter, SimIntegerParameter, SimStringParameter, ComponentMapping,
                                       SimSlot, SimComponentVisibility, SimChildComponentEntry, SimDefaultSlots,
                                       SimParameterOperations, SimComponentReference)
+
+from SIMULTAN.Data.Assets import DocumentAsset
+
 from .files import FileInfo
 
 from . import config
@@ -562,9 +565,14 @@ class ComponentDictionary(SimultanObject):
         for ref_asset in self._wrapped_obj.ReferencedAssets.Items:
             for tag in ref_asset.Resource.Tags:
                 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)
+                if isinstance(ref_asset, DocumentAsset):
+                    comp_dict[key] = get_obj_value(ref_asset.Resource,
+                                                   data_model=self._data_model,
+                                                   object_mapper=self._object_mapper)
+                else:
+                    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)
 

{pysimultan-0.5.9.5 → pysimultan-0.5.9.7}/src/PySimultan2/object_mapper.py

@@ -1,4 +1,4 @@
-from typing import Optional, Type, TYPE_CHECKING, Union, Any
+from typing import Optional, Type, TYPE_CHECKING, Union, Any, Dict, List
 from copy import copy
 from collections import UserList
 from colorlog import getLogger
@@ -74,6 +74,8 @@ class PythonMapper(object):
         self.re_register = False
         self.load_undefined = False
 
+        self.default_components: List[Any] = []
+
     @property
     def module(self):
         return self._module
@@ -147,7 +149,9 @@ class PythonMapper(object):
             self.taxonomy_maps.update(submodule.taxonomy_maps)
             self.registered_geometry_classes.update(submodule.registered_geometry_classes)
 
-    def create_mapped_class(self, taxonomy, cls):
+    def create_mapped_class(self,
+                            taxonomy: str,
+                            cls: Any):
 
         if any([issubclass(cls, x) for x in (SimultanObject, UserList)]):
             bases = (cls,)
@@ -179,7 +183,10 @@ class PythonMapper(object):
 
         return self.mapped_classes.get(taxonomy, None)
 
-    def get_typed_data(self, data_model=None, component_list=None, create_all=False):
+    def get_typed_data(self,
+                       data_model: 'DataModel' = None,
+                       component_list: List[SimComponent] = None,
+                       create_all: bool = False):
 
         typed_data = []
 
@@ -229,8 +236,27 @@ class PythonMapper(object):
             typed_object = self.create_python_object(component, data_model=data_model)
             if typed_object is not None:
                 typed_data.append(typed_object)
+
+        if create_all:
+            self.create_default_components(data_model)
+
         return typed_data
 
+    def create_default_components(self, data_model: 'DataModel'):
+        for instance in self.default_components:
+            key = list(filter(lambda x: self.registered_classes[x] == type(instance),
+                              self.registered_classes)
+                       )[0]
+            cls = self.get_mapped_class(key)
+            if not cls.cls_instances:
+                self.create_mapped_python_object(obj=instance,
+                                                 data_model=data_model)
+            else:
+                # check if default instance is already in data model
+                if not any([x.name == instance.name for x in cls.cls_instances]):
+                    self.create_mapped_python_object(obj=instance,
+                                                     data_model=data_model)
+
     def create_python_geometry_object(self,
                                       component: Union[Layer, Vertex, Edge, PEdge, Face, Volume, EdgeLoop],
                                       data_model: 'DataModel' = None,

{pysimultan-0.5.9.5 → pysimultan-0.5.9.7}/src/PySimultan2/taxonomy_maps.py

@@ -3,12 +3,12 @@ from functools import cache
 from ruamel.yaml import YAML, yaml_object, add_representer
 from . import yaml
 
-from typing import TYPE_CHECKING, Optional, Union, Literal
+from typing import TYPE_CHECKING, Optional, Union, Literal, Any, Dict
 
 if TYPE_CHECKING:
     from .data_model import DataModel
 
-from SIMULTAN.Data.Taxonomy import SimTaxonomyEntryReference
+from SIMULTAN.Data.Taxonomy import SimTaxonomyEntryReference, SimTaxonomyEntry, SimTaxonomyEntryReference, SimTaxonomy
 
 
 @yaml_object(yaml)
@@ -17,6 +17,14 @@ class Content(object):
     yaml_tag = u'!Content'
 
     def __init__(self,
+                 text_or_key: str,
+                 name: Optional[str] = None,
+                 property_name: Optional[str] = None,
+                 slot_extension: Optional[str] = None,
+                 type: Optional[Any] = None,
+                 unit: Optional[str] = None,
+                 documentation: Optional[str] = None,
+                 component_policy: Optional[Literal['reference', 'subcomponent']] = 'subcomponent',
                  *args,
                  **kwargs):
         """
@@ -24,6 +32,7 @@ class Content(object):
 
         :param args:
         :Keyword Arguments
+            * *name* (``str``) -- name of the Taxonomy Entry in SIMULTAN
             * *text_or_key* (``str``) -- text or key of the content/parameter/property
             * *property_name* (``str``) -- name of the generated property
             * *slot_extension* (``str``) -- slot extension of the content/parameter/property
@@ -33,20 +42,20 @@ class Content(object):
             * *component_policy* (``str``) -- component add policy of the content/parameter/property, 'reference' or 'subcomponent'
         """
 
-        self.name: str = kwargs.get('name', kwargs.get('text_or_key'))
-        self.text_or_key: str = kwargs.get('text_or_key')          # text or key of the content/parameter/property
-        self.property_name: str = kwargs.get('property_name')      # name of the generated property
-        self.slot_extension: str = kwargs.get('slot_extension')    # slot extension of the content/parameter/property
-        self.type = kwargs.get('type', None)                        # type of the content/parameter/property
-        self.unit: Optional[str] = kwargs.get('unit', None)                        # unit of the content/parameter/property
-        self.documentation: Optional[str] = kwargs.get('documentation', None)      # documentation of the content/parameter/property
-        self.component_policy: Literal['reference', 'subcomponent'] = kwargs.get('component_policy', 'reference')  # component add policy of the content/parameter/property, 'reference' or 'subcomponent'
+        self.name: str = name if name is not None else text_or_key # name of the Taxonomy Entry in SIMULTAN
+        self.text_or_key: str = text_or_key          # text or key of the content/parameter/property
+        self.property_name: str = property_name if property_name is not None else text_or_key  # name of the generated property in the python class
+        self.slot_extension: str = slot_extension    # slot extension of the content/parameter/property
+        self.type: Optional[Any] = type                        # type of the content/parameter/property
+        self.unit: Optional[str] = unit                       # unit of the content/parameter/property
+        self.documentation: Optional[str] = documentation       # documentation of the content/parameter/property
+        self.component_policy: Literal['reference', 'subcomponent'] = component_policy  # component add policy of the content/parameter/property, 'reference' or 'subcomponent'
 
         self._taxonomies = {}
         self._taxonomy_entries = {}
-        self._taxonomy_map = kwargs.get('taxonomy_map', None)
+        self._taxonomy_map: Optional['TaxonomyMap'] = kwargs.get('taxonomy_map', None)
 
-        self.taxonomy_key = kwargs.get('taxonomy_key')
+        self.taxonomy_key: Optional[SimTaxonomy] = kwargs.get('taxonomy_key')
 
         add_kwargs = kwargs.copy()
         _ = [add_kwargs.pop(key, None) for key in ['taxonomy_name', 'taxonomy_key', 'taxonomy_entry_name',
@@ -54,10 +63,10 @@ class Content(object):
                                                    'mapped_class', 'unit', 'type', 'component_policy',
                                                    'text_or_key', 'property_name', 'slot_extension']]
 
-        self.additional_attributes = add_kwargs
+        self.additional_attributes: dict[Any, Any] = add_kwargs
 
-        self.taxonomy_key = kwargs.get('taxonomy_key')
-        self.taxonomy_name = kwargs.get('taxonomy_name')
+        self.taxonomy_key: Optional[SimTaxonomy]  = kwargs.get('taxonomy_key')
+        self.taxonomy_name: str = kwargs.get('taxonomy_name')
 
 
     def get_taxonomie_entry(self, data_model: 'DataModel'):
@@ -70,7 +79,7 @@ class Content(object):
                                                              taxonomy_key=self.taxonomy_key,
                                                              create=True)
 
-            self._taxonomy_entries[data_model] = data_model.get_or_create_taxonomy_entry(name=self.text_or_key,
+            self._taxonomy_entries[data_model] = data_model.get_or_create_taxonomy_entry(name=self.name,
                                                                                          key=self.text_or_key,
                                                                                          description=self.documentation,
                                                                                          sim_taxonomy=taxonomy)
@@ -97,29 +106,38 @@ class TaxonomyMap(object):
             taxonomie_map = yaml.load(f)
         return taxonomie_map[0]
 
-    def __init__(self, *args, **kwargs):
+    def __init__(self,
+                 taxonomy_key: str,
+                 taxonomy_entry_key: str,
+                 taxonomy_name: Optional[str] = None,
+                 taxonomy_entry_name: Optional[str] = None,
+                 content: Optional[list[Content]] = None,
+                 documentation: Optional[str] = None,
+                 *args,
+                 **kwargs):
 
         self._content = []
         self._content_dict = {}
         self._parameter_taxonomy_entry_dict = {}
 
-        self.taxonomy_name = kwargs.get('taxonomy_name', kwargs.get('taxonomy_key'))
-        self.taxonomy_key = kwargs.get('taxonomy_key')
+        self.taxonomy_key = taxonomy_key
+        self.taxonomy_name = taxonomy_name if taxonomy_name is not None else taxonomy_key
 
-        if self.taxonomy_key == kwargs.get('taxonomy_entry_key'):
+
+        if self.taxonomy_key == taxonomy_entry_key:
             raise ValueError('taxonomy_key and taxonomy_entry_key must be different')
 
-        self.taxonomy_entry_name = kwargs.get('taxonomy_entry_name', kwargs.get('taxonomy_entry_key'))
-        self.taxonomy_entry_key = kwargs.get('taxonomy_entry_key')
+        self.taxonomy_entry_key = taxonomy_entry_key
+        self.taxonomy_entry_name = taxonomy_entry_name if taxonomy_entry_name is not None else taxonomy_entry_key
 
-        self.content = kwargs.get('content', [])
-        self.documentation = kwargs.get('documentation', '')
+        self.content = content if content is not None else []
+        self.documentation = documentation
 
         self.python_mapper = kwargs.get('python_mapper', None)
         self.mapped_class = kwargs.get('mapped_class', None)
 
-        self._taxonomies = {}
-        self._taxonomy_entries = {}
+        self._taxonomies: Dict[DataModel, SimTaxonomy] = {}
+        self._taxonomy_entries: Dict[DataModel, SimTaxonomyEntry] = {}
 
     @property
     def content(self):
@@ -187,7 +205,7 @@ class TaxonomyMap(object):
 
     def get_or_create_simultan_taxonomy(self,
                                         data_model: 'DataModel',
-                                        create=True):
+                                        create=True) -> SimTaxonomy:
         if self._taxonomies.get(data_model, None) is None:
             self._taxonomies[data_model] = data_model.get_or_create_taxonomy(
                 taxonomy_name=self.taxonomy_name,

{pysimultan-0.5.9.5 → pysimultan-0.5.9.7}/src/PySimultan2/utils.py

@@ -151,7 +151,7 @@ def create_taxonomy(name, key, description='', data_model=None) -> SimTaxonomy:
     :param data_model: data model; if not None, the taxonomy will be added to the data model
     :return: SimTaxonomy
     """
-    new_taxonomy = SimTaxonomy(key, name, description)
+    new_taxonomy = SimTaxonomy(key, name, description, None)
     if data_model is not None:
         data_model.taxonomies.Add(new_taxonomy)
     return new_taxonomy

pysimultan-0.5.9.7/tests/test_default_component.py

@@ -0,0 +1,105 @@
+import os
+
+project_dir = os.environ.get('PROJECT_DIR', '/simultan_projects')
+if not os.path.exists(project_dir):
+    os.makedirs(project_dir)
+
+try:
+    import importlib.resources as pkg_resources
+except ImportError:
+    # Try backported to PY<37 importlib_resources.
+    import importlib_resources as pkg_resources
+
+from PySimultan2.taxonomy_maps import Content, TaxonomyMap
+from PySimultan2 import PythonMapper
+from PySimultan2 import DataModel
+
+
+mapper = PythonMapper(module='test_default_component')
+
+class A:
+
+    def __init__(self,
+                 name: str = 'A',
+                 param_a: int = 0,
+                 param_b: float = 0.0,
+                 param_c: str = 'test_str',
+                 *args, **kwargs):
+
+        self.param_a = param_a
+        self.param_b = param_b
+        self.param_c = param_c
+
+
+# define content
+
+param_a_content = Content(text_or_key='param_a',
+                          property_name='param_a',
+                          type=None,
+                          unit='',
+                          documentation='',
+                          component_policy='subcomponent')
+
+param_b_content = Content(text_or_key='param_b',
+                          property_name='param_b',
+                          type=None,
+                          unit='',
+                          documentation='',
+                          component_policy='subcomponent')
+
+param_c_content = Content(name='This is the Name of the Content C',
+                          text_or_key='param_c',
+                          property_name='param_c',
+                          type=None,
+                          unit='',
+                          documentation='',
+                          component_policy='subcomponent')
+
+# define taxonomy maps
+a_map = TaxonomyMap(taxonomy_name='test_default_component',
+                    taxonomy_key='test_default_component',
+                    taxonomy_entry_name='A',
+                    taxonomy_entry_key='A',
+                    content=[param_a_content,
+                             param_b_content,
+                             param_c_content]
+                    )
+
+# register taxonomy maps
+mapper.register(a_map.taxonomy_entry_key,
+                A,
+                taxonomy_map=a_map,
+                re_register=True)
+
+
+mapper.default_components.append(A(name='default_A',
+                                   param_a=5,
+                                   param_b=8.0,
+                                   param_c='default_str'))
+
+
+data_model = DataModel.create_new_project(project_path=os.path.join(project_dir, 'test_default_component.simultan'),
+                                          user_name='admin',
+                                          password='admin')
+
+typed_data = data_model.get_typed_data(mapper=mapper,
+                                       create_all=True)
+
+MappedAClass = mapper.get_mapped_class('A')
+
+MappedAClass(name='test_A',
+             param_a=17,
+             param_b=8.0,
+             param_c='test_str',
+             data_model=data_model,
+             mapper=mapper)
+
+
+
+
+MappedAClass(name='test_A',
+             param_a=17,
+             param_b=8.0,
+             param_c='test_str')
+
+assert MappedAClass.cls_instances[0].param_a == 5

{pysimultan-0.5.9.5 → pysimultan-0.5.9.7}/tests/test_register_class.py

@@ -3,7 +3,7 @@ import os
 from PySimultan2.data_model import DataModel
 from PySimultan2.object_mapper import PythonMapper
 from PySimultan2.taxonomy_maps import TaxonomyMap, Content
-from src.PySimultan2.config import yaml
+
 # from bson.objectid import ObjectId
 
 
@@ -63,50 +63,6 @@ def create_material_taxonomie_map(filename=None):
     return material
 
 
-def save_data_model_in_mongodb(host, data_model, db='pysimultan2'):
-    from mongoengine import connect, disconnect
-    from src.PySimultan2.mongo_utils.base_classes import SimComponent, SimTaxonomyEntry
-
-    db = connect(db=db, host=host, alias='default')
-    data_model.save_in_mongodb(db)
-
-    # Execute the pipeline on the collection
-    results = list(SimComponent.objects(slots__contains=SimTaxonomyEntry.objects(key='undefined').first()))
-    for result in results:
-        print(result)
-
-    SimComponent.objects(slots__key='min_refinement_level')
-
-    for result in results:
-        print(result)
-
-    disconnect(db)
-
-
-def save_in_mongodb(component, host, db='pysimultan2'):
-    from mongoengine import connect, disconnect
-
-    db = connect(db, host=host, alias='default')
-    component.save_in_mongodb(db)
-    disconnect(db)
-
-
-def load_from_mongodb(host):
-    from src.PySimultan2.mongo_utils.base_classes import SimComponent, SimTaxonomyEntry
-    db = connect('pysimultan2', host=host, alias='default2')
-    # test_instances = TestClass.objects
-    # loaded_base_components = list(BaseMongoDocument.objects)
-    loaded_components = SimComponent.objects
-    disconnect(db)
-    return loaded_components
-
-
-def drop_mongodb(host):
-    db = connect('pysimultan2', host=host, alias='default')
-    db.drop_database('pysimultan2')
-    disconnect(db)
-
-
 class Undefined(object):
 
     def __init__(self, *args, **kwargs):

pysimultan-0.5.9.5/src/PySimultan2/__about__.py

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