PySimultan 0.1.54__py3-none-any.whl → 0.2.1__py3-none-any.whl

PySimultan2/simultan_object.py

@@ -0,0 +1,366 @@
+import hashlib
+import json
+
+from copy import copy
+from weakref import WeakSet, WeakValueDictionary
+from . import utils
+from numpy import ndarray
+import colorlog
+from typing import Union
+
+logger = colorlog.getLogger('PySimultan')
+
+from SIMULTAN.Data.Taxonomy import SimTaxonomyEntry, SimTaxonomyEntryReference, SimTaxonomy
+from SIMULTAN.Data.Components import (ComponentWalker, SimComponent, SimBoolParameter, SimDoubleParameter,
+                                      SimEnumParameter, SimIntegerParameter, SimStringParameter, ComponentMapping,
+                                      SimSlot, ComponentMapping)
+from SIMULTAN.Data.Assets import ResourceEntry, ResourceFileEntry, ContainedResourceFileEntry, Asset
+from SIMULTAN.Data import SimId
+
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from .data_model import DataModel
+    from .object_mapper import PythonMapper
+    from .geometry.geometry_base import ExtendedBaseGeometry
+
+from .geometry.utils import create_python_geometry
+
+from . import config
+
+
+class ComplexEncoder(json.JSONEncoder):
+    def default(self, obj):
+        if isinstance(obj, SimultanObject):
+            return obj.to_json()
+        # Let the base class default method raise the TypeError
+        return json.JSONEncoder.default(self, obj)
+
+
+class classproperty(object):
+
+    def __init__(self, getter):
+        self.getter = getter
+
+    def __get__(self, instance, owner):
+        return self.getter(owner)
+
+
+class MetaMock(type):
+    def __call__(cls: 'SimultanObject', *args, **kwargs) -> 'SimultanObject':
+        """
+        Metaclass to implement object initialization either with wrapped_obj or keywords.
+
+        If a wrapped_obj is defined, create new SimultanObject which wraps a SIMULTAN component (wrapped_obj).
+
+        If no 'wrapped_obj' is defined, a new SimComponent is created with the content defined in the template and the
+        values are set to the values defined in kwargs.
+        """
+
+        obj = cls.__new__(cls, *args, **kwargs)
+
+        wrapped_obj = kwargs.get('wrapped_obj', None)
+        if wrapped_obj is None:
+
+            data_model = kwargs.get('data_model', None)
+            if data_model is None:
+                from .data_model import data_models
+                if list(data_models.data).__len__() == 1:
+                    data_model = list(data_models.data)[0]()
+                    kwargs['data_model'] = data_model
+                else:
+                    if config.default_data_model is not None:
+                        data_model = config.default_data_model
+                        kwargs['data_model'] = data_model
+                    else:
+                        raise TypeError((f'Error creating new instance of class {cls.__name__}:\n'
+                                         f'Any data model was defined. Tried to use default data model but there are multiple datamodels.\n'
+                                         f'Define the data model to use with the key: data_model'))
+
+            wrapped_obj = cls.create_simultan_component(*args, **kwargs)
+
+            init_dict = kwargs.copy()
+            init_dict['data_model_id'] = data_model.id
+            init_dict['object_mapper'] = cls._object_mapper
+            init_dict['data_model'] = data_model
+            init_dict['wrapped_obj'] = wrapped_obj
+            obj.__init__(*args, **init_dict)
+
+            # for key, value in kwargs.items():
+            #     if key in ['data_model', 'wrapped_obj', 'object_mapper']:
+            #         continue
+            #     setattr(obj, key, value)
+
+        else:
+            obj.__init__(*args, **kwargs)
+        return obj
+
+
+class SimultanObject(object, metaclass=MetaMock):
+
+    _cls_instances = WeakSet()  # weak set with all created objects
+    _create_all = False  # if true all properties are evaluated to create python objects when initialized
+    _cls_instances_dict_cache = None
+    __type_view__ = None      # ui view cls
+
+    @classproperty
+    def _cls_instances_dict(cls) -> dict[SimId, 'SimultanObject']:
+        return dict(zip([x.id for x in cls._cls_instances], [x for x in cls._cls_instances]))
+
+    @classproperty
+    def cls_instances(cls) -> list['SimultanObject']:
+        try:
+            _ = cls._cls_instances
+            return list(cls._cls_instances)
+        except Exception as e:
+            logger.error(f'Error getting cls_instances: {e}')
+            return []
+
+    @classmethod
+    def create_simultan_component(cls, *args, **kwargs) -> SimComponent:
+        wrapped_obj = utils.create_simultan_component_for_taxonomy(cls, *args, **kwargs)
+        wrapped_obj.Name = kwargs.get('name', 'UnnamedComponent')
+        return wrapped_obj
+
+    def __new__(cls, *args, **kwargs):
+        instance = super().__new__(cls)
+        if not hasattr(cls, '_cls_instances'):
+            cls._cls_instances = WeakSet()
+        try:
+            cls._cls_instances.add(instance)
+        except Exception as e:
+            logger.error(f'Error adding instance {instance} to _cls_instances: {e}')
+
+        return instance
+
+    def __init__(self, *args, **kwargs):
+        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.__ui_element__ = None    # view object for the object
+
+        self._slot = None
+
+    def __getattribute__(self, attr):
+
+        try:
+            return object.__getattribute__(self, attr)
+        except AttributeError:
+            wrapped = object.__getattribute__(self, '_wrapped_obj')
+            if wrapped is not None:
+                return object.__getattribute__(wrapped, attr)
+            else:
+                raise KeyError
+
+    def __setattr__(self, attr, value):
+        if hasattr(self, '_wrapped_obj'):
+            if hasattr(self._wrapped_obj, attr) and (self._wrapped_obj is not None) and not self.__obj_init__:
+                object.__setattr__(self._wrapped_obj, attr, value)
+                return
+        # object.__setattr__(self, attr, value)
+        super().__setattr__(attr, value)
+
+        # if hasattr(super(self.__class__), attr):
+        #     super(self.__class__).__setattr__(attr, value)
+
+    @property
+    def id(self) -> SimId:
+        if self._wrapped_obj is not None:
+            return self._wrapped_obj.Id
+
+    @property
+    def id_str(self) -> str:
+        return '_'.join((str(self.id.GlobalId), str(self.id.LocalId)))
+
+    @property
+    def json_ref(self):
+        return {"_ref": {
+            "$ref": self.__class__.__name__,
+            "$id": {
+                "$oid": self.id_str
+            }
+        }}
+
+    @property
+    def name(self) -> str:
+        if self._wrapped_obj is not None:
+            return self._wrapped_obj.Name
+
+    @name.setter
+    def name(self, value: str):
+        if self._wrapped_obj is not None:
+            self._wrapped_obj.Name = value
+
+    @property
+    def parent(self) -> 'SimultanObject':
+        if not hasattr(self._wrapped_obj, 'Parent'):
+            return None
+
+        if self._wrapped_obj.Parent is not None:
+            return self._object_mapper.create_python_object(self._wrapped_obj.Parent)
+        else:
+            return None
+
+    @property
+    def slots(self):
+        if self._wrapped_obj is not None:
+            return list(self._wrapped_obj.Slots.Items)
+
+    @property
+    def primary_slot(self):
+        if self._wrapped_obj is not None:
+            return self._wrapped_obj.Slots.Items[0]
+
+    @property
+    def referenced_by(self) -> set['SimultanObject']:
+        return set([self._object_mapper.create_python_object(x.Target) for x in self._wrapped_obj.ReferencedBy if
+                    x.Target != self._wrapped_obj])
+
+    @property
+    def _parameters(self) -> dict[str, Union[str, int, float, bool, ndarray]]:
+        return {x.NameTaxonomyEntry.get_TextOrKey(): utils.get_obj_value(x,
+                                                                         data_model=self._data_model,
+                                                                         object_mapper=self._object_mapper) for x in
+                self._wrapped_obj.Parameters}
+
+    @property
+    def associated_geometry(self):
+        ref_geometries = self._data_model.get_associated_geometry(self)
+
+        return [create_python_geometry(None, geo, self._data_model, self._object_mapper, geo_model) for geo, geo_model in
+                ref_geometries]
+
+    def get_subcomponents(self) -> dict[[str, str], Union['SimultanObject', SimComponent]]:
+        subcomponents = {}
+        for comp in self._wrapped_obj.Components:
+            subcomponents[(comp.Slot.SlotBase.Target.Key, comp.Slot.SlotExtension)] = self._object_mapper.create_python_object(comp.Component)
+        return subcomponents
+
+    def get_subcomponent_list(self) -> list[Union['SimultanObject', SimComponent]]:
+        return list(self.get_subcomponents().values())
+
+    def get_referenced_components(self) -> list['SimultanObject']:
+        return [self._object_mapper.create_python_object(x) for x in self._wrapped_obj.ReferencedComponents]
+
+    def add_taxonomy_entry_reference(self,
+                                     taxonomy_entry_reference: SimTaxonomyEntryReference,
+                                     index: int = None):
+        if index is None:
+            index = self._wrapped_obj.Slots.Items.__len__()
+        self._wrapped_obj.Slots.InsertItem(index, taxonomy_entry_reference)
+
+    def add_subcomponent(self, subcomponent: Union['SimultanObject', SimComponent],
+                         slot: SimTaxonomyEntryReference = None,
+                         slot_extension: str = None):
+
+        if isinstance(subcomponent, SimComponent):
+            comp_to_add = subcomponent
+        elif isinstance(subcomponent, SimultanObject):
+            comp_to_add = subcomponent._wrapped_obj
+        else:
+            comp_to_add = utils.create_mapped_python_object(subcomponent,
+                                                            object_mapper=self._object_mapper,
+                                                            data_model=self._data_model,
+                                                            add_to_data_model=True)
+
+        utils.add_sub_component(self._wrapped_obj,
+                                comp_to_add,
+                                slot_extension,
+                                slot)
+
+    def remove_subcomponent(self, subcomponent: Union['SimultanObject', SimComponent]):
+        if isinstance(subcomponent, SimComponent):
+            utils.remove_sub_component(self._wrapped_obj, subcomponent)
+        elif isinstance(subcomponent, SimultanObject):
+            utils.remove_sub_component(self._wrapped_obj, subcomponent._wrapped_obj)
+        else:
+            raise TypeError(f'Unknown type for subcomponent: {type(subcomponent)}')
+
+    def add_referenced_component(self,
+                                 referenced_component: Union['SimultanObject', SimComponent],
+                                 slot: SimTaxonomyEntryReference = None,
+                                 slot_extension: str = None):
+
+        referenced_wrapped_obj = referenced_component if isinstance(referenced_component,
+                                                                    SimComponent) else referenced_component._wrapped_obj
+
+        # logger.debug(f'Adding referenced component {referenced_component} to {self}')
+        utils.add_referenced_component(self._wrapped_obj,
+                                       referenced_wrapped_obj,
+                                       slot_extension,
+                                       slot)
+
+    def remove_referenced_component(self, referenced_component: 'SimultanObject'):
+        utils.remove_referenced_component(self._wrapped_obj, referenced_component._wrapped_obj)
+
+    def add_asset(self,
+                  resource_file_entry: 'ResourceFileEntry',
+                  _id_contained: str = '') -> Asset:
+
+        return ComponentMapping.AddAsset(self, resource_file_entry, _id_contained)
+
+    def __repr__(self):
+        return f'{self.name}: ' + object.__repr__(self)
+
+    def associate(self, other: 'ExtendedBaseGeometry'):
+        """
+        Associate this object with another object
+        :param other: geometry object to associate with
+        :return: None
+        """
+        other.associate(self)
+
+    def get_raw_attr(self, attr: str):
+        return utils.get_component_taxonomy_entry(self._wrapped_obj, attr)
+
+    def set_attr_prop(self, attr: str, prop: str, value):
+        """
+        Set attribute of the mapped property
+
+        Example:
+
+        class TestComponent(object):
+            def __init__(self, *args, **kwargs):
+                self.value = kwargs.get('value')
+
+        content0 = Content(text_or_key='value',  # text or key of the content/parameter/property
+                           property_name='value',  # name of the generated property
+                           type=float,  # type of the content/parameter/property
+                           unit=None,  # unit of the content/parameter/property
+                           documentation='value to test',
+                           component_policy='subcomponent')
+
+        test_component_map = TaxonomyMap(taxonomy_name='PySimultan',
+                                         taxonomy_key='PySimultan',
+                                         taxonomy_entry_name='TestComponent',
+                                         taxonomy_entry_key='TestComponent',
+                                         content=[content0]
+                                         )
+
+        mapper.register(test_component_map.taxonomy_entry_key, TestComponent, taxonomy_map=test_component_map)
+        cls1 = mapper.get_mapped_class(test_component_map.taxonomy_entry_key)
+
+        test_component = cls1(name='test_component',
+                                value=None)
+
+        test_component.set_attr_prop('value', 'MinValue, 0)
+        test_component.set_attr_prop('value', 'MaxValue, 1)
+
+        :param attr:
+        :param value:
+        :return:
+        """
+        comp_prop = utils.get_component_taxonomy_entry(self._wrapped_obj, attr)
+        if comp_prop is not None:
+            setattr(comp_prop, prop, value)
+        return comp_prop
+
+
+    # def to_json(self):
+    #
+    #     super().to_json(self)
+
+        # return {str(self.id): {'name': self.name}}

PySimultan2/taxonomy_maps.py

@@ -0,0 +1,169 @@
+import io
+from ruamel.yaml import YAML, yaml_object, add_representer
+from .config import yaml
+
+from typing import TYPE_CHECKING, Optional, Union, Literal
+if TYPE_CHECKING:
+    from .data_model import DataModel
+
+from SIMULTAN.Data.Taxonomy import SimTaxonomyEntryReference
+
+
+@yaml_object(yaml)
+class Content(object):
+
+    yaml_tag = u'!Content'
+
+    def __init__(self, *args, **kwargs):
+        """
+        Define a content/parameter/property of a taxonomy entry in the taxonomy map.
+
+        :param args:
+        :Keyword Arguments
+            * *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
+            * *type* (``str``) -- type of the content/parameter/property
+            * *unit* (``str``) -- unit of the content/parameter/property
+            * *documentation* (``str``) -- documentation of the content/parameter/property
+            * *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._taxonomies = {}
+        self._taxonomy_entries = {}
+        self._taxonomy_map = kwargs.get('taxonomy_map', None)
+
+        add_kwargs = kwargs.copy()
+        _ = [add_kwargs.pop(key, None) for key in ['taxonomy_name', 'taxonomy_key', 'taxonomy_entry_name',
+                                                   'taxonomy_entry_key', 'content', 'documentation', 'python_mapper',
+                                                   'mapped_class', 'unit', 'type', 'component_policy',
+                                                   'text_or_key', 'property_name', 'slot_extension']]
+
+        self.additional_attributes = add_kwargs
+
+    def get_taxonomie_entry(self, data_model: 'DataModel'):
+        if self._taxonomy_entries.get(data_model, None) is None:
+
+            taxonomy = self._taxonomy_map.get_or_create_simultan_taxonomy(data_model=data_model, create=True)
+            self._taxonomy_entries[data_model] = data_model.get_or_create_taxonomy_entry(name=self.text_or_key,
+                                                                                         key=self.text_or_key,
+                                                                                         description=self.documentation,
+                                                                                         sim_taxonomy=taxonomy)
+        return self._taxonomy_entries[data_model]
+
+    def __repr__(self):
+        return (f"Content({self.name}, {self.text_or_key}, "
+                f"{self.property_name}, {self.slot_extension}, "
+                f"{self.type}, {self.unit}, "
+                f"{self.documentation}, {self.component_policy})")
+
+
+verbose_output = False
+
+
+@yaml_object(yaml)
+class TaxonomyMap(object):
+
+    yaml_tag = u'!TaxonomyMap'
+
+    @classmethod
+    def from_yaml_file(cls, filename):
+        with open(filename, mode='r') as f:
+            taxonomie_map = yaml.load(f)
+        return taxonomie_map[0]
+
+    def __init__(self, *args, **kwargs):
+
+        self._content = []
+        self._content_dict = {}
+
+        self.taxonomy_name = kwargs.get('taxonomy_name', kwargs.get('taxonomy_key', None))
+        self.taxonomy_key = kwargs.get('taxonomy_key', None)
+
+        self.taxonomy_entry_name = kwargs.get('taxonomy_entry_name', kwargs.get('taxonomy_entry_key', None))
+        self.taxonomy_entry_key = kwargs.get('taxonomy_entry_key', None)
+
+        self.content = kwargs.get('content', [])
+        self.documentation = kwargs.get('documentation', '')
+
+        self.python_mapper = kwargs.get('python_mapper', None)
+        self.mapped_class = kwargs.get('mapped_class', None)
+
+        self._taxonomies = {}
+        self._taxonomy_entries = {}
+
+    @property
+    def content(self):
+        return self._content
+
+    @content.setter
+    def content(self, value: list[Content]):
+        self._content = value
+        for content in self._content:
+            content._taxonomy_map = self
+        self._content_dict = {}
+
+    @property
+    def content_dict(self):
+        if self._content_dict == {}:
+            for content in self._content:
+                self._content_dict[content.text_or_key] = content
+        return self._content_dict
+
+    def write(self, filename=None):
+        if filename is not None:
+            with open(filename, mode='w') as f:
+                yaml.dump([self], f)
+        else:
+            f = io.StringIO()
+            yaml.dump([self], f)
+            return f.getvalue()
+
+    def __getstate__(self):
+        data = self.__dict__.copy()
+        del data['python_mapper']
+        del data['mapped_class']
+        return data
+
+    def add_content(self, content: Content):
+        self._content.append(content)
+        content._taxonomy_map = self
+        self._content_dict = {}
+
+    def get_or_create_simultan_taxonomy_entry(self, data_model: 'DataModel', create=True):
+
+        if self._taxonomy_entries.get(data_model, None) is None:
+
+            taxonomy_entries = data_model.get_taxonomy_entries()
+            if self.taxonomy_entry_key in taxonomy_entries.keys():
+                self._taxonomy_entries[data_model] = taxonomy_entries[self.taxonomy_entry_key]
+            elif create:
+                self._taxonomy_entries[data_model] = data_model.get_or_create_taxonomy_entry(
+                    key=self.taxonomy_entry_key,
+                    name=self.taxonomy_entry_name,
+                    sim_taxonomy=self.get_or_create_simultan_taxonomy(data_model=data_model,
+                                                                      create=create))
+        return self._taxonomy_entries[data_model]
+
+    def get_or_create_simultan_taxonomy(self, data_model: 'DataModel', create=True):
+        if self._taxonomies.get(data_model, None) is None:
+            self._taxonomies[data_model] = data_model.get_or_create_taxonomy(
+                taxonomy_name=self.taxonomy_name,
+                taxonomy_key=self.taxonomy_key,
+                description=self.documentation,
+                create=create)
+
+        return self._taxonomies[data_model]
+
+    def get_slot(self, data_model: 'DataModel'):
+        return SimTaxonomyEntryReference(self.get_or_create_simultan_taxonomy_entry(data_model=data_model, create=True))