PySimultan 0.4.0__tar.gz → 0.4.1__tar.gz

{pysimultan-0.4.0 → pysimultan-0.4.1}/.gitignore

@@ -17,9 +17,9 @@ build
 ~*.simultan
 *.simultanbackup
 simultan_exception*
-/tests/resources/~*
+/PySimultan2/tests/resources/~*
 /tests/resources/*.codxf
-/tests/readme_examples/resources/~*
+/PySimultan2/tests/readme_examples/resources/~*
 /tests/readme_examples/resources/*.codxf
 
 *.AppImage

{pysimultan-0.4.0 → pysimultan-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: PySimultan
-Version: 0.4.0
+Version: 0.4.1
 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.4.1/src/PySimultan2/__about__.py

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

pysimultan-0.4.1/src/PySimultan2/__init__.py

@@ -0,0 +1,99 @@
+import os
+import sys
+import colorlog
+# from .config import *
+from ruamel.yaml import YAML, yaml_object, add_representer
+
+def setup_logging():
+    handler = colorlog.StreamHandler()
+    formatter = colorlog.ColoredFormatter(
+        "%(log_color)s%(levelname)-8s%(reset)s %(blue)s%(message)s",
+        datefmt=None,
+        reset=True,
+        log_colors={
+            'DEBUG':    'cyan',
+            'INFO':     'green',
+            'WARNING':  'yellow',
+            'ERROR':    'red',
+            'CRITICAL': 'red,bg_white',
+        },
+        secondary_log_colors={},
+        style='%'
+    )
+
+    handler.setFormatter(formatter)
+
+    logger = colorlog.getLogger('PySimultan')
+    logger.addHandler(handler)
+
+    return logger
+
+
+def setup():
+    import colorlog
+    try:
+        import importlib.resources as pkg_resources
+    except ImportError:
+        # Try backported to PY<37 importlib_resources.
+        import importlib_resources as pkg_resources
+
+    from . import resources
+    sys.path.append(str(pkg_resources.files(resources)))
+
+    logger = colorlog.getLogger('PySimultan')
+    logger.setLevel('DEBUG')
+
+    dll_path = os.environ.get('SIMULTAN_SDK_DIR', None)
+    if dll_path is None:
+        with pkg_resources.path(resources, 'SIMULTAN.dll') as r_path:
+            dll_path = str(r_path)
+    sys.path.append(dll_path)
+
+    from pythonnet import load
+    from pythonnet import clr_loader, set_runtime
+    list(clr_loader.find_runtimes())
+    load('coreclr')
+    import clr
+    test = clr.AddReference(
+        os.path.join(dll_path, 'SIMULTAN.dll') if not dll_path.endswith('SIMULTAN.dll') else dll_path)
+    clr.AddReference("System.Security.Cryptography")
+    # clr.AddReference(os.path.join(dll_path, 'SIMULTAN'))
+
+    from SIMULTAN.Data.Components import SimComponent
+
+    continue_on_error = True
+
+    def represent_none(self, _):
+        return self.represent_scalar('tag:yaml.org,2002:null', '')
+
+    add_representer(type(None), represent_none)
+    yaml = YAML()
+    yaml.default_flow_style = None
+    yaml.preserve_quotes = True
+    yaml.allow_unicode = True
+
+    return yaml
+
+
+logger = setup_logging()
+yaml = setup()
+
+
+class Config:
+    def __init__(self):
+        self._default_data_model = None
+        self._default_mapper = None
+        self.logger = logger
+
+    def get_default_data_model(self, *args, **kwargs):
+        return self._default_data_model
+
+    def get_default_mapper(self, *args, **kwargs):
+        return self._default_mapper
+
+
+config = Config()
+
+from .data_model import DataModel
+from .files import FileInfo
+from .object_mapper import PythonMapper

{pysimultan-0.4.0 → pysimultan-0.4.1}/src/PySimultan2/data_model.py

@@ -3,7 +3,6 @@ import os
 import shutil
 from uuid import uuid4
 from colorlog import getLogger
-from functools import lru_cache, reduce
 from weakref import WeakSet, WeakValueDictionary
 from . import config
 from .utils import *
@@ -46,6 +45,7 @@ from .files import add_tag_to_resource
 
 if TYPE_CHECKING:
     from .object_mapper import PythonMapper
+    from .geometry import GeometryModel
 
 
 logger = getLogger('PySimultan')
@@ -114,7 +114,7 @@ class DataModel:
         else:
             print("Failed to create project")
 
-        return cls(project_path=project_path, user_name=user_name, password=password)
+        return cls(project_path=project_path, user_name=user_name, password=password, project_data_manager=projectData)
 
     def __new__(cls, *args, **kwargs):
 
@@ -147,6 +147,8 @@ class DataModel:
         self._project = None
         self._zip_loader = None
 
+        self.project_data_manager = kwargs.get('project_data_manager', None)
+
         self.project_path = kwargs.get('project_path', None)
 
         self.service_provider = Utils.ServicesProvider()
@@ -156,38 +158,10 @@ class DataModel:
         self.i_aut_service.password = self.password
 
         self.service_provider.AddService[SimultanUsers.IAuthenticationService](self.i_aut_service())
-
-        # self.serv = GeometryViewerService([], self.service_provider)
-        # self.service_provider.AddService[IGeometryViewerService](self.serv)
-
         self.exch = self.project.AllProjectDataManagers.ComponentGeometryExchange
         # self.exch.ModelStore = self.serv
 
         self.resources = {}
-        # self.models_dict = {}
-        #
-        # if self.project_data_manager.AssetManager.Resources.__len__() > 0:
-        #     for resource in self.project_data_manager.AssetManager.Resources:
-        #         if resource is None:
-        #             continue
-        #         self.resources[resource.Key] = resource
-        #         self.models_dict[resource.Key] = None
-        #         current_full_path = resource.CurrentFullPath
-        #         if current_full_path == '?':
-        #             continue
-        #
-        #         if resource.Extension == '.simgeo':
-        #             error_list = NetList[SimGeoIOError]()
-        #
-        #             model = SimGeoIO.Load(resource, self.project_data_manager, error_list, OffsetAlgorithm.Full)
-        #             self.models_dict[resource.Key] = model
-        #             try:
-        #                 self.project_data_manager.GeometryModels.AddGeometryModel(model)
-        #             except Exception as e:
-        #                 logger.warning(f'Error while loading Model: {model} from {model.File}: {e}. Trying reload...')
-        #                 raise e
-
-        self.ValueFields = self.project_data_manager.ValueManager.Items
         self.import_data_model()
 
         self.__mongo_instance = None
@@ -197,40 +171,41 @@ class DataModel:
         return self.project_data_manager.AssetManager.Resources
 
     @property
-    def _mongo_instance(self):
-        if self.__mongo_instance is None:
-            self.create_mongo_instance()
-        return self.__mongo_instance
+    def models(self) -> dict[int, 'GeometryModel']:
+        """
+        Return the geometry models of the project
+        :return: dict[int, GeometryModel]
+        """
 
-    @_mongo_instance.setter
-    def _mongo_instance(self, value):
-        self.__mongo_instance = value
+        # if self.models_dict:
+        #     return self.models_dict
 
-    @property
-    def models(self):
         self.models_dict = {}
 
-        if self.project_data_manager.AssetManager.Resources.__len__() > 0:
-            for resource in self.project_data_manager.AssetManager.Resources:
-                if resource is None:
-                    continue
-                self.resources[resource.Key] = resource
+        # self.project_data_manager.Reset()
+
+        resources = self.project_data_manager.AssetManager.Resources
+
+        for resource in resources:
+            if resource is None:
+                continue
+            self.resources[resource.Key] = resource
 
-                current_full_path = resource.CurrentFullPath
-                if current_full_path == '?':
-                    continue
+            current_full_path = resource.CurrentFullPath
+            if current_full_path == '?':
+                continue
 
-                if resource.Extension == '.simgeo':
-                    self.models_dict[resource.Key] = None
-                    error_list = NetList[SimGeoIOError]()
+            if resource.Extension == '.simgeo':
+                self.models_dict[resource.Key] = None
+                error_list = NetList[SimGeoIOError]()
 
-                    model = SimGeoIO.Load(resource, self.project_data_manager, error_list, OffsetAlgorithm.Full)
-                    self.models_dict[resource.Key] = model
-                    try:
-                        self.project_data_manager.GeometryModels.AddGeometryModel(model)
-                    except Exception as e:
-                        logger.warning(f'Error while loading Model: {model} from {model.File}: {e}. Trying reload...')
-                        raise e
+                model = SimGeoIO.Load(resource, self.project_data_manager, error_list, OffsetAlgorithm.Full)
+                self.models_dict[resource.Key] = model
+                try:
+                    self.project_data_manager.GeometryModels.AddGeometryModel(model)
+                except Exception as e:
+                    logger.warning(f'Error while loading Model: {model} from {model.File}: {e}')
+                    raise e
 
         return self.models_dict
 
@@ -238,14 +213,20 @@ class DataModel:
     def taxonomies(self):
         return self.project_data_manager.Taxonomies
 
+    @property
+    def ValueFields(self):
+        return self.project_data_manager.ValueManager.Items
+
     @property
     def value_fields(self):
         return self.project_data_manager.ValueManager
 
     @property
     def project_data_manager(self):
-        if (self._project_data_manager) is None and (self.user is not None):
+
+        if self._project_data_manager is None:
             self._project_data_manager = ExtendedProjectData()
+
         return self._project_data_manager
 
     @project_data_manager.setter
@@ -261,7 +242,6 @@ class DataModel:
     @user.setter
     def user(self, value: SimultanUsers.SimUserRole):
         if value != self._user:
-            self.project_data_manager = None
             self._project = None
         self._user = value
 
@@ -306,7 +286,6 @@ class DataModel:
     def remove_field(self, field: SimMultiValueField3D):
         self.project_data_manager.ValueManager.Remove(field)
 
-    @lru_cache(maxsize=None)
     def get_geo_instance(self, file_id, type, id):
         geo_model = self.models[file_id]
         objects = getattr(geo_model.Geometry, type)
@@ -381,16 +360,28 @@ class DataModel:
         """
         logger.info('closing project...')
         try:
+
             self._project.DisableProjectUnpackFolderWatcher()
             if self._project is not None:
+                if self._project.IsOpened:
+                    ZipProjectIO.Close(self._project, True)
                 if self._project.IsLoaded:
                     ZipProjectIO.Unload(self._project)
-                if self._project.IsOpened:
-                    ZipProjectIO.Close(self._project, False, True)
 
-            self._project_data_manager.Reset()
         except Exception as e:
             pass
+        finally:
+            if self._project_data_manager is not None:
+                del self._project_data_manager
+            self._project_data_manager = None
+
+            data_models = WeakSet()
+            data_models_dict = WeakValueDictionary()
+
+            if config.default_data_model is self:
+                config.default_data_model = None
+
+            del self
 
     # def create_new_component(self):
     #
@@ -570,14 +561,13 @@ class DataModel:
         if isinstance(component, SimultanObject):
             component = component._wrapped_obj
 
-        if not component.Instances:
-            return []
-
         for instance in component.Instances:
             for placement in instance.Placements.Items:
                 geo_model = next((x for x in self.models.values() if x is not None and x.File.Key == placement.FileId), None)
                 if geo_model is not None:
                     ref_geometries.append((geo_model.Geometry.GeometryFromId(placement.GeometryId), geo_model))
+                if geo_model is None:
+                    logger.warning(f'Geometry model with id {placement.FileId} not found in project {self.project_path}')
 
         return ref_geometries
 
@@ -665,7 +655,6 @@ class DataModel:
                                            None)
         return model_to_work_with, resource_file
 
-    @lru_cache(maxsize=None)
     def get_or_create_taxonomy(self, taxonomy_key: str, taxonomy_name: str = None, description='', create=True):
         taxonomy = next((x for x in self.taxonomies if x.Key == taxonomy_key), None)
         if taxonomy is None:
@@ -676,7 +665,6 @@ class DataModel:
 
         return next((x for x in self.taxonomies if x.Key == taxonomy_key), None)
 
-    @lru_cache(maxsize=None)
     def get_or_create_taxonomy_entry(self,
                                      name: str,
                                      key: str,

{pysimultan-0.4.0 → pysimultan-0.4.1}/src/PySimultan2/default_types.py

@@ -113,7 +113,7 @@ class ComponentList(SimultanObject):
 
             try:
                 indices = sort_slots(slots)
-                return [self._object_mapper.create_python_object(x) for x in
+                return [self._object_mapper.create_python_object(x, data_model=self._data_model) for x in
                         [all_components[i] for i in np.argsort(indices)]]
             except TypeError as e:
                 logger.warning(f'Could not sort list {all_components}:\n{e}')
@@ -259,7 +259,7 @@ class ComponentList(SimultanObject):
         return f'List {self.name}: ' + repr(list(self.data))
 
     def __iter__(self):
-        return iter([self._object_mapper.create_python_object(x) for x in self.data])
+        return iter([self._object_mapper.create_python_object(x, data_model=self._data_model) for x in self.data])
 
     def __next__(self):
         try:

{pysimultan-0.4.0 → pysimultan-0.4.1}/src/PySimultan2/files.py

@@ -18,7 +18,9 @@ from SIMULTAN.Data.Assets import ResourceEntry, ResourceFileEntry, ContainedReso
 from SIMULTAN.Data.Taxonomy import SimTaxonomyEntry, SimTaxonomyEntryReference, SimTaxonomy
 from SIMULTAN.Data.Components import SimComponent, ComponentMapping
 
-from .config import default_data_model
+# from .config import default_data_model
+
+from . import config
 
 from typing import TYPE_CHECKING
 if TYPE_CHECKING:
@@ -195,7 +197,7 @@ class FileInfo(object, metaclass=MetaMock):
         :return: FileInfo
         """
 
-        data_model = kwargs.get('data_model', default_data_model)
+        data_model = kwargs.get('data_model', config.default_data_model)
         resource = create_asset_from_string(filename, content, *args, **kwargs)
 
         file_info = cls(resource_entry=resource,
@@ -239,7 +241,8 @@ class FileInfo(object, metaclass=MetaMock):
     def resource_entry(self) -> Union[ResourceFileEntry, ContainedResourceFileEntry, None]:
         if self._resource_entry is None:
             if self.data_model is None:
-                self.data_model = default_data_model
+                logger.warning(f'No data model provided. Using default data model: {config.default_data_model.id}.')
+                self.data_model = config.default_data_model
             if self.data_model is not None:
                 self.resource_entry = self.data_model.add_resource(self.file_path)
         return self._resource_entry

{pysimultan-0.4.0 → pysimultan-0.4.1}/src/PySimultan2/geometry/geometry_base.py

@@ -30,7 +30,7 @@ from SIMULTAN.Data.Geometry import VolumeAlgorithms
 # from ..utils import create_mapped_python_object, create_python_object
 # from ..files import create_asset_from_file, FileInfo, create_asset_from_string
 from .. import config
-from ..config import logger
+from .. import logger
 
 from typing import TYPE_CHECKING
 if TYPE_CHECKING:
@@ -538,11 +538,12 @@ class GeometryModel(object, metaclass=MetaMock):
     def create_simultan_instance(cls, *args, **kwargs):
 
         data_model: DataModel = kwargs.get('data_model', config.default_data_model)
-        name = kwargs.get('name', 'GeometryModel')
+        name: str = kwargs.get('name', 'GeometryModel')
 
         new_geo_model, resource = data_model.create_new_geometry_model(name=name)
         data_model.project_data_manager.GeometryModels.AddGeometryModel(new_geo_model)
         data_model.models_dict[resource.Key] = new_geo_model
+        data_model.save()
 
         return new_geo_model
 

{pysimultan-0.4.0 → pysimultan-0.4.1}/src/PySimultan2/geometry/utils.py

@@ -57,7 +57,7 @@ def create_cube(data_model,
                 scale: Optional[float] = 1):
 
     if obj_mapper is None:
-        obj_mapper = config.default_mapper
+        obj_mapper = config.get_default_mapper()
 
     new_layer = obj_mapper.registered_geometry_classes[Layer](geometry_model=geo_model,
                                                               data_model=data_model,

{pysimultan-0.4.0 → pysimultan-0.4.1}/src/PySimultan2/object_mapper.py

@@ -136,15 +136,18 @@ class PythonMapper(object):
             typed_data.append(typed_object)
         return typed_data
 
-    # @lru_cache(maxsize=None)
+    # @lru_cache(maxsize=500)
     def create_python_object(self, component, cls=None, data_model=None, *args, **kwargs):
 
         if component is None:
             return None
 
         if data_model is None:
-            data_model_id = list(data_models)[0].id
-            data_model = list(data_models)[0]
+            logger.warning(f'No data model provided. Using default data model: {config.default_data_model.id}.')
+            data_model = config.default_data_model
+            data_model_id = data_model.id
+            # data_model_id = list(data_models)[0].id
+            # data_model = list(data_models)[0]
         else:
             data_model_id = data_model.id
 
@@ -201,6 +204,7 @@ class PythonMapper(object):
         for prop in taxonomy_map.content:
 
             prop_dict[prop.property_name] = add_properties(prop_name=prop.property_name,
+                                                           text_or_key=prop.text_or_key,
                                                            content=prop,
                                                            taxonomy_map=taxonomy_map,
                                                            taxonomy=taxonomy)
@@ -213,6 +217,10 @@ class PythonMapper(object):
 
         for cls in self.mapped_classes.values():
             cls._cls_instances = WeakSet()
+            cls.__property_cache__ = {}
+
+        if config.default_mapper is self:
+            config.default_mapper = None
 
     def copy(self):
         new_mapper = PythonMapper()
@@ -222,5 +230,5 @@ class PythonMapper(object):
         return new_mapper
 
 
-if config.default_mapper is None:
-    config.default_mapper = PythonMapper()
+if config.get_default_mapper() is None:
+    config._default_mapper = PythonMapper()

{pysimultan-0.4.0 → pysimultan-0.4.1}/src/PySimultan2/simultan_object.py

@@ -6,7 +6,7 @@ from weakref import WeakSet, WeakValueDictionary
 from . import utils
 from numpy import ndarray
 import colorlog
-from typing import Union
+from typing import Union, Optional
 
 logger = colorlog.getLogger('PySimultan')
 
@@ -69,6 +69,8 @@ class MetaMock(type):
                     kwargs['data_model'] = data_model
                 else:
                     if config.default_data_model is not None:
+                        logger.warning(
+                            f'No data model provided. Using default data model: {config.default_data_model.id}.')
                         data_model = config.default_data_model
                         kwargs['data_model'] = data_model
                     else:
@@ -102,6 +104,11 @@ class SimultanObject(object, metaclass=MetaMock):
     _cls_instances_dict_cache = None
     __type_view__ = None      # ui view cls
 
+    @classmethod
+    def reset_cls(cls):
+        cls._cls_instances = WeakSet()
+        cls._cls_instances_dict_cache = None
+
     @classmethod
     def get_instance_by_id(cls, id: SimId) -> 'SimultanObject':
         return cls._cls_instances_dict.get(id, None)
@@ -147,11 +154,12 @@ class SimultanObject(object, metaclass=MetaMock):
 
         self._wrapped_obj: Union[SimComponent, None] = kwargs.get('wrapped_obj', None)
         self.__obj_init__ = kwargs.get('__obj_init__', False)
-        self._data_model_id = kwargs.get('data_model_id', None)
         self._data_model: Union[DataModel, None] = kwargs.get('data_model', config.default_data_model)
         self._object_mapper: Union[PythonMapper, None] = kwargs.get('object_mapper', config.default_mapper)
         self.name = kwargs.get('name', None)
 
+        self.__property_cache__ = {}
+
         self._slot = None
 
     def __getattribute__(self, attr):
@@ -328,8 +336,16 @@ class SimultanObject(object, metaclass=MetaMock):
         """
         other.associate(self)
 
-    def get_raw_attr(self, attr: str):
-        return utils.get_component_taxonomy_entry(self._wrapped_obj, attr)
+    def get_raw_attr(self, attr: Optional[str] = None, text_or_key: Optional[str] = None):
+        if attr is not None:
+            content = self._taxonomy_map.get_content_by_property_name(attr)
+            if content is None:
+                raise KeyError(f'No content found for attribute {attr}')
+
+            return utils.get_component_taxonomy_entry(self._wrapped_obj, content.text_or_key)
+
+        if text_or_key is not None:
+            return utils.get_component_taxonomy_entry(self._wrapped_obj, text_or_key)
 
     def set_attr_prop(self, attr: str, prop: str, value):
         """

{pysimultan-0.4.0 → pysimultan-0.4.1}/src/PySimultan2/taxonomy_maps.py

@@ -1,6 +1,7 @@
 import io
+from functools import cache
 from ruamel.yaml import YAML, yaml_object, add_representer
-from .config import yaml
+from . import yaml
 
 from typing import TYPE_CHECKING, Optional, Union, Literal
 if TYPE_CHECKING:
@@ -113,6 +114,9 @@ class TaxonomyMap(object):
             content._taxonomy_map = self
         self._content_dict = {}
 
+        self.get_content_by_property_name.cache_clear()
+        self.get_content_by_text_or_key.cache_clear()
+
     @property
     def content_dict(self):
         if self._content_dict == {}:
@@ -167,3 +171,11 @@ class TaxonomyMap(object):
 
     def get_slot(self, data_model: 'DataModel'):
         return SimTaxonomyEntryReference(self.get_or_create_simultan_taxonomy_entry(data_model=data_model, create=True))
+
+    @cache
+    def get_content_by_property_name(self, property_name: str):
+        return next((x for x in self.content if x.property_name == property_name), None)
+
+    @cache
+    def get_content_by_text_or_key(self, text_or_key: str):
+        return next((x for x in self.content if x.text_or_key == text_or_key), None)