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

PySimultan2/geometry/utils.py

@@ -0,0 +1,181 @@
+from typing import List, Type, Union, Optional
+from numpy import array
+from .. import config
+from .geometry_base import (GeometryModel, SimultanLayer, SimultanVertex, SimultanEdge, SimultanEdgeLoop, SimultanFace,
+                            SimultanVolume, BaseGeometry)
+
+from SIMULTAN.Data.Geometry import (Layer, Vertex, Edge, PEdge, Face, Volume, EdgeLoop, OperationPermission,
+                                    GeometryModelOperationPermissions, GeometryOperationPermissions,
+                                    LayerOperationPermissions, GeometryModelData, GeometricOrientation,
+                                    BaseEdgeContainer)
+
+from SIMULTAN.Data.Geometry import GeometryModel as NetGeometryModel
+
+
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from ..default_types import ComponentList
+    from ..simultan_object import SimultanObject
+    from ..data_model import DataModel
+    from ..object_mapper import PythonMapper
+
+
+python_map_dict = {Layer: SimultanLayer,
+                   Vertex: SimultanVertex,
+                   Edge: SimultanEdge,
+                   EdgeLoop: SimultanEdgeLoop,
+                   Face: SimultanFace,
+                   Volume: SimultanVolume}
+
+
+def create_python_geometry(cls,
+                           sim_geometry: Union[Layer, Vertex, Edge, Face, Volume, EdgeLoop],
+                           data_model: 'DataModel',
+                           python_mapper: 'PythonMapper',
+                           geometry_model: Union[GeometryModel, NetGeometryModel] = None,
+                           ) -> Union[SimultanLayer, SimultanVertex, SimultanEdge, SimultanEdgeLoop, SimultanFace, SimultanVolume]:
+
+    if isinstance(geometry_model, NetGeometryModel):
+        geometry_model = GeometryModel(wrapped_object=geometry_model,
+                                       data_model=data_model,
+                                       python_mapper=python_mapper)
+
+    if type(sim_geometry) in python_map_dict:
+        if cls is None:
+            cls = python_map_dict.get(type(sim_geometry))
+        return cls(wrapped_object=sim_geometry,
+                   data_model=data_model,
+                   geometry_model=geometry_model,
+                   python_mapper=python_mapper)
+    else:
+        raise ValueError(f'Could not create python object for {sim_geometry}')
+
+
+def create_cube(data_model,
+                geo_model: GeometryModel,
+                obj_mapper: Optional['PythonMapper'] = None,
+                scale: Optional[float] = 1):
+
+    if obj_mapper is None:
+        obj_mapper = config.default_mapper
+
+    new_layer = obj_mapper.registered_geometry_classes[Layer](geometry_model=geo_model,
+                                                              data_model=data_model,
+                                                              name='new_layer')
+
+    def create_vertex(layer, x, y, z, name, geo_model):
+        new_vertex = obj_mapper.registered_geometry_classes[Vertex](geometry_model=geo_model,
+                                                                    x=x,
+                                                                    y=y,
+                                                                    z=z,
+                                                                    data_model=data_model,
+                                                                    name=name,
+                                                                    layer=layer)
+        assert isinstance(new_vertex, SimultanVertex)
+        return new_vertex
+
+    def create_edge(layer, vertices, name, geo_model):
+        new_edge = obj_mapper.registered_geometry_classes[Edge](geometry_model=geo_model,
+                                                                data_model=data_model,
+                                                                name=name,
+                                                                layer=layer,
+                                                                vertices=vertices)
+        assert isinstance(new_edge, SimultanEdge)
+        return new_edge
+
+    def create_edge_loop(layer, edges, name, geo_model):
+        new_edge_loop = obj_mapper.registered_geometry_classes[EdgeLoop](geometry_model=geo_model,
+                                                                         data_model=data_model,
+                                                                         name=name,
+                                                                         layer=layer,
+                                                                         edges=edges)
+        assert isinstance(new_edge_loop, SimultanEdgeLoop)
+        return new_edge_loop
+
+    def create_face(layer, edge_loop, name, geo_model):
+        new_face = obj_mapper.registered_geometry_classes[Face](geometry_model=geo_model,
+                                                                data_model=data_model,
+                                                                name=name,
+                                                                layer=layer,
+                                                                edge_loop=edge_loop)
+        assert isinstance(new_face, SimultanFace)
+        return new_face
+
+    # create a cube
+    vertex_pos = array([(0, 0, 0), (0.707, 0.707, 0), (0, 1.414, 0), (-0.707, 0.707, 0),
+                        (0, 0, 1), (0.707, 0.707, 1), (0, 1.414, 1), (-0.707, 0.707, 1)]) * scale
+
+    vertices = []
+    for i, pos in enumerate(vertex_pos.tolist()):
+        vertices.append(create_vertex(new_layer,
+                                      *pos,
+                                      'new_vertex_{}'.format(i),
+                                      geo_model
+                                      )
+                        )
+
+    edges_vertices = [(vertices[0], vertices[1]),
+                      (vertices[1], vertices[2]),
+                      (vertices[2], vertices[3]),
+                      (vertices[3], vertices[0]),
+                      (vertices[4], vertices[5]),
+                      (vertices[5], vertices[6]),
+                      (vertices[6], vertices[7]),
+                      (vertices[7], vertices[4]),
+                      (vertices[0], vertices[4]),
+                      (vertices[1], vertices[5]),
+                      (vertices[2], vertices[6]),
+                      (vertices[3], vertices[7])
+                      ]
+    edges = []
+
+    for i, edge_vertices in enumerate(edges_vertices):
+        edges.append(create_edge(new_layer,
+                                 edge_vertices,
+                                 'new_edge_{}'.format(i),
+                                 geo_model
+                                 ))
+
+    # create 6 edge loops as boundary for the cube
+    edge_loop_edges = [
+        # Front face loop
+        [edges[0], edges[1], edges[2], edges[3]],
+        # Back face loop
+        [edges[4], edges[5], edges[6], edges[7]],
+        # Top face loop
+        [edges[1], edges[10], edges[5], edges[9]],
+        # Bottom face loop
+        [edges[3], edges[11], edges[7], edges[8]],
+        # Left face loop
+        [edges[0], edges[9], edges[4], edges[8]],
+        # Right face loop
+        [edges[2], edges[11], edges[6], edges[10]]
+    ]
+
+    edge_loops = []
+    for i, edge_loop_edge in enumerate(edge_loop_edges):
+        edge_loops.append(create_edge_loop(new_layer,
+                                           edge_loop_edge,
+                                           'new_edge_loop_{}'.format(i),
+                                           geo_model),
+                          )
+
+    # create faces
+    faces = []
+    for i, edge_loop in enumerate(edge_loops):
+        faces.append(create_face(new_layer,
+                                 edge_loop,
+                                 'new_face_{}'.format(i),
+                                 geo_model
+                                 )
+                     )
+
+    # create a volume
+
+    volume = obj_mapper.registered_geometry_classes[Volume](geometry_model=geo_model,
+                                                            data_model=data_model,
+                                                            name='new_volume',
+                                                            layer=new_layer,
+                                                            faces=faces)
+
+    return volume

PySimultan2/multi_values.py

@@ -0,0 +1,277 @@
+from __future__ import annotations
+from typing import Union
+from itertools import product
+
+import numpy as np
+import pandas as pd
+from SIMULTAN.Data.Components import SimDoubleParameter, SimParameterOperations
+from SIMULTAN.Data.MultiValues import (SimMultiValueField3D, SimMultiValueField3DParameterSource, SimMultiValueBigTable,
+                                       SimMultiValueBigTableHeader, SimMultiValueBigTableParameterSource)
+from SIMULTAN.Data.Taxonomy import SimTaxonomyEntry
+from System import Array, Double, Object, Boolean, String
+from System.Collections.Generic import List as NetList
+from System.Collections.Generic import ICollection as NetICollection
+from pandas import DataFrame
+
+import System
+
+
+def numpy_to_simultan_multi_value_field_3d(array: np.ndarray,
+                                           name: str = 'UnnamedField',
+                                           x_axis: list = None,
+                                           y_axis: list = None,
+                                           z_axis: list = None,
+                                           unit_x: str = '',
+                                           unit_y: str = '',
+                                           unit_z: str = '',
+                                           can_interpolate: bool = True) -> SimMultiValueField3D:
+    """
+    Convert a numpy array to a SimMultiValueField3D object. The x, y, and z axes can be provided as lists.
+    If not provided, the axes will be generated based on the shape of the input array.
+    :param array: The input numpy array
+    :param name: The name of the field, default is 'UnnamedField'
+    :param x_axis: The x-axis of the field, default is None
+    :param y_axis: The y-axis of the field, default is None
+    :param z_axis: The z-axis of the field, default is None
+    :param unit_x: The unit of the x-axis, default is ''
+    :param unit_y: The unit of the y-axis, default is ''
+    :param unit_z: The unit of the z-axis, default is ''
+    :param can_interpolate: If True, the field can be interpolated. Default is True.
+    data_model = None
+    :return:
+    """
+    if not isinstance(array, np.ndarray):
+        raise ValueError('The input array must be a numpy array.')
+
+    if array.ndim < 3:
+        if array.ndim == 1:
+            array = np.expand_dims(array, axis=(1, 2))
+        elif array.ndim == 2:
+            array = np.expand_dims(array, axis=2)
+        else:
+            raise ValueError('The input array must be at least 2-dimensional.')
+
+    if x_axis is None:
+        x_axis = NetList[Double](Array[Double](list(range(array.astype(float).shape[0]))))
+
+    if y_axis is None:
+        y_axis = NetList[Double](Array[Double](list(range(array.astype(float).shape[1]))))
+
+    if z_axis is None:
+        z_axis = NetList[Double](Array[Double](list(range(array.astype(float).shape[2]))))
+
+    data = NetList[Double](Array[Double](array.astype(float).flatten(order='F')))
+
+    field = SimMultiValueField3D(name, x_axis, unit_x, y_axis, unit_y, z_axis, unit_z, data, can_interpolate)
+
+    return field
+
+
+def pandas_to_simultan_multi_value_big_table(df: pd.DataFrame,
+                                             name: str = 'UnnamedField',
+                                             unit_columns: str = '',
+                                             unit_rows: str = '',
+                                             column_headers: SimMultiValueBigTableHeader = None,
+                                             row_headers: SimMultiValueBigTableHeader = None) -> SimMultiValueBigTable:
+    """
+    Convert a pandas DataFrame to a SimMultiValueField3D object. The x, y, and z axes can be provided as lists. If not
+    provided, the axes will be generated based on the shape of the input DataFrame.
+    :param df:
+    :param name:
+    :param unit_columns: The unit of the columns
+    :param unit_rows: The unit of the rows
+    :param column_headers: The column headers
+    :param row_headers: The row headers
+    :return: SimMultiValueBigTable
+    """
+
+    if not isinstance(df, DataFrame):
+        raise ValueError('The input df must be a pandas DataFrame.')
+
+    if column_headers is None:
+        column_headers = NetICollection[SimMultiValueBigTableHeader](
+            Array[SimMultiValueBigTableHeader]([SimMultiValueBigTableHeader(str(x), '') for x in df.columns]))
+
+    if row_headers is None:
+        row_headers = NetICollection[SimMultiValueBigTableHeader](
+            Array[SimMultiValueBigTableHeader]([SimMultiValueBigTableHeader(str(x), '') for x in df.index]))
+
+    #
+    data = NetList[NetList[Double]]()
+    for i in range(len(df.index)):
+        data.Add(NetList[Double](Array[Double](df.values[i].astype(float))))
+
+    field = SimMultiValueBigTable(name,
+                                  unit_columns,
+                                  unit_rows,
+                                  column_headers,
+                                  row_headers,
+                                  data,
+                                  True)
+    return field
+
+
+def simultan_multi_value_big_table_to_pandas(field: SimMultiValueBigTable) -> pd.DataFrame:
+    """
+    Convert a SimMultiValueBigTable object to a pandas DataFrame.
+    :param field:
+    :return:
+    """
+    if not isinstance(field, SimMultiValueBigTable):
+        raise ValueError('The input field must be a SimMultiValueBigTable object.')
+
+    data = np.ndarray((field.RowHeaders.Count, field.ColumnHeaders.Count))
+    for i in range(field.RowHeaders.Count):
+        data[i, :] = list(field.GetRow(i))
+
+    df = pd.DataFrame(data, columns=[x.Name for x in field.ColumnHeaders], index=[x.Name for x in field.RowHeaders])
+
+    return df
+
+
+def simultan_multi_value_field_3d_to_numpy(field: SimMultiValueField3D, assert_ordered=False) -> np.ndarray:
+    """
+    Convert a SimMultiValueField3D object to a numpy array.
+    :param field:
+    :param assert_ordered: If True, the function will check if the field is ordered. Default is True.
+    :return:
+    """
+    if not isinstance(field, SimMultiValueField3D):
+        raise ValueError('The input field must be a SimMultiValueField3D object.')
+
+    if assert_ordered:
+        data = [x.Value for x in field.Field]
+        x_axis = list(field.XAxis)
+        y_axis = list(field.YAxis)
+        z_axis = list(field.ZAxis)
+        array = np.array(data).reshape(len(x_axis), len(y_axis), len(z_axis))
+    else:
+        array = np.empty((len(field.XAxis), len(field.YAxis), len(field.ZAxis)))
+        for comb in product(range(len(field.XAxis)), range(len(field.YAxis)), range(len(field.ZAxis)), repeat=1):
+            array[comb[0], comb[1], comb[2]] = field[comb[0], comb[1], comb[2]]
+
+    return np.squeeze(array)
+
+
+def add_field_to_data_model(field: SimMultiValueField3D, data_model: 'SimultanObject') -> SimMultiValueField3D:
+    """
+    Add a SimMultiValueField3D object to a data model.
+    :param field: The SimMultiValueField3D object
+    :param data_model: The data model
+    :return: SimMultiValueField3D
+    """
+    if not isinstance(field, SimMultiValueField3D):
+        raise ValueError('The input field must be a SimMultiValueField3D object.')
+
+    if data_model is None:
+        raise ValueError('The data model must not be None.')
+    data_model.add_field(field)
+
+
+def set_parameter_to_value_field(parameter: SimDoubleParameter,
+                                 value: Union[SimMultiValueField3D, np.ndarray, DataFrame],
+                                 field_name: str = None,
+                                 x_ax_val: float = None,
+                                 y_ax_val: float = None,
+                                 z_ax_val: float = None,
+                                 data_model=None) -> SimDoubleParameter:
+    """
+    Set the value of a field parameter to a SimMultiValueField3D object. The value can be a SimMultiValueField3D object,
+    a numpy array, or a DataFrame.
+    :param parameter: The field parameter
+    :param value: The value of the parameter (SimMultiValueField3D, numpy array, or DataFrame)
+    :param field_name: The name of the field, default is None
+    :param x_ax_val: The value on the X-Axis (NOT the index/position)
+    :param y_ax_val: The value on the Y-Axis (NOT the index/position)
+    :param z_ax_val: The value on the Z-Axis (NOT the index/position)
+    :param data_model: The data model, default is None. If data_model is not None, the SimMultiValueField3D will be
+    added to the data model (if SimMultiValueField3D is created).
+    :return: SimDoubleParameter
+    """
+
+    if not isinstance(parameter, SimDoubleParameter):
+        raise ValueError('The input parameter must be a SimDoubleParameter object.')
+
+    if isinstance(value, SimMultiValueField3D):
+        source = value
+    elif isinstance(value, np.ndarray):
+        value_field = numpy_to_simultan_multi_value_field_3d(value,
+                                                             name=field_name if field_name is not None else str(
+                                                                 parameter.Id) + '_field')
+        if data_model is not None:
+            data_model.add_field(value_field)
+
+        x_ax_val = x_ax_val if x_ax_val is not None else value_field.XAxis[0]
+        y_ax_val = y_ax_val if y_ax_val is not None else value_field.YAxis[0]
+        z_ax_val = z_ax_val if z_ax_val is not None else value_field.ZAxis[0]
+
+        source = SimMultiValueField3DParameterSource(value_field, x_ax_val, y_ax_val, z_ax_val)
+
+    elif isinstance(value, pd.DataFrame):
+        value_field = pandas_to_simultan_multi_value_big_table(value,
+                                                               name=field_name if field_name is not None else str(
+                                                                   parameter.Id) + '_field')
+        if data_model is not None:
+            data_model.add_field(value_field)
+
+        source = SimMultiValueBigTableParameterSource(value_field, 0, 0)
+
+    else:
+        raise ValueError('The value of the field parameter must be a numpy array or a DataFrame.')
+
+    parameter.set_ValueSource(source)
+    return parameter
+
+
+def create_field_parameter(value: Union[SimMultiValueField3D, np.ndarray, DataFrame],
+                           name: str = 'unnamed parameter',
+                           field_name: str = None,
+                           unit: str = '',
+                           slot: SimTaxonomyEntry = None,
+                           min_value: float = None,
+                           max_value: float = None,
+                           allowed_operations: int = SimParameterOperations(0).All,
+                           x_ax_val: float = None,
+                           y_ax_val: float = None,
+                           z_ax_val: float = None,
+                           data_model=None
+                           ) -> SimDoubleParameter:
+    """
+    Create a field parameter with a SimMultiValueField3D as value.  The value can be a SimMultiValueField3D object, a
+    numpy array, or a DataFrame.
+    :param value: The value of the parameter (SimMultiValueField3D, numpy array, or DataFrame)
+    :param name: The name of the parameter, default is 'unnamed parameter'
+    :param field_name: The name of the field, default is None
+    :param unit: The unit of the parameter, default is ''
+    :param slot: SimTaxonomyEntry
+    :param min_value: The minimum value for the parameter, default is None
+    :param max_value: The maximum value for the parameter, default is None
+    :param allowed_operations: The allowed operations for the parameter (e.g. SimParameterOperations(0).All)
+    :param x_ax_val: The value on the X-Axis (NOT the index/position)
+    :param y_ax_val: The value on the Y-Axis (NOT the index/position)
+    :param z_ax_val: The value on the Z-Axis (NOT the index/position)
+    :param data_model: The data model, default is None. If data_model is not None, the SimMultiValueField3D will be
+    added to the data model.
+    :return: SimDoubleParameter
+    """
+
+    from .utils import create_sim_double_parameter
+
+    param_init_dict = {'value': 0}
+
+    for key in ['name', 'unit', 'slot', 'min_value', 'max_value', 'allowed_operations']:
+        if locals()[key] is not None:
+            param_init_dict[key] = locals()[key]
+
+    param = create_sim_double_parameter(**param_init_dict)
+
+    set_parameter_to_value_field(param,
+                                 value,
+                                 field_name=field_name,
+                                 x_ax_val=x_ax_val,
+                                 y_ax_val=y_ax_val,
+                                 z_ax_val=z_ax_val,
+                                 data_model=data_model
+                                 )
+
+    return param

PySimultan2/object_mapper.py

@@ -0,0 +1,200 @@
+from collections import UserList
+from weakref import WeakSet
+from typing import Type
+from colorlog import getLogger
+
+from . import config
+from .data_model import data_models
+from .utils import *
+from .default_types import ComponentList, component_list_map, ComponentDictionary, component_dict_map
+
+from .simultan_object import SimultanObject
+from .geometry.utils import create_python_geometry
+
+from SIMULTAN.Data.Geometry import (Layer, Vertex, Edge, PEdge, Face, Volume, EdgeLoop)
+from .geometry.geometry_base import (SimultanLayer, SimultanVertex, SimultanEdge, SimultanEdgeLoop, SimultanFace,
+                                     SimultanVolume)
+
+logger = getLogger('PySimultan')
+
+default_registered_classes = {'ComponentList': ComponentList,
+                              'ComponentDict': ComponentDictionary}
+default_mapped_classes = {}
+default_taxonomy_maps = {'ComponentList': component_list_map,
+                         'ComponentDict': component_dict_map}
+
+
+class PythonMapper(object):
+
+    def __new__(cls, *args, **kwargs):
+        instance = super(PythonMapper, cls).__new__(cls)
+        config.default_mapper = instance
+        return instance
+
+    def __init__(self, *args, **kwargs):
+        self.registered_classes = default_registered_classes   # dict with all registered classes: {taxonomy: class}
+        self.mapped_classes = default_mapped_classes           # dict with all mapped classes: {taxonomy: class}
+        self.taxonomy_maps = default_taxonomy_maps             # dict with all taxonomie maps: {taxonomy: taxonomie_map}
+
+        self.registered_geometry_classes = {Layer: SimultanLayer,
+                                            Vertex: SimultanVertex,
+                                            Edge: SimultanEdge,
+                                            Face: SimultanFace,
+                                            Volume: SimultanVolume,
+                                            EdgeLoop: SimultanEdgeLoop}
+
+        self.re_register = False
+
+    def register(self, taxonomy, cls, taxonomy_map=None):
+        if not self.re_register and taxonomy in self.registered_classes.keys():
+            return
+
+        self.registered_classes[taxonomy] = cls
+        self.taxonomy_maps[taxonomy] = taxonomy_map
+
+    def create_mapped_class(self, taxonomy, cls):
+
+        if any([issubclass(cls, x) for x in (SimultanObject, UserList)]):
+            bases = (cls,)
+        else:
+            bases = (SimultanObject,) + (cls,)
+
+        def new_init(self, *args, **kwargs):
+            for base in self.__class__.__bases__:
+                base.__init__(self, *args, **kwargs)
+
+        new_class_dict = {'__init__': new_init,
+                          '__name__': cls.__name__,
+                          '_taxonomy': taxonomy,
+                          '_taxonomy_map': self.taxonomy_maps.get(taxonomy, None),
+                          '_base': bases,
+                          '_object_mapper': self}
+
+        new_class_dict.update(self.get_properties(taxonomy))
+        new_class = type(cls.__name__, bases, new_class_dict)
+
+        self.mapped_classes[taxonomy] = new_class
+
+        return new_class
+
+    def get_mapped_class(self, taxonomy) -> Type[SimultanObject]:
+        if self.mapped_classes.get(taxonomy, None) is None:
+            self.create_mapped_class(taxonomy, self.registered_classes[taxonomy])
+
+        return self.mapped_classes.get(taxonomy, None)
+
+    def get_typed_data(self, data_model=None, component_list=None, create_all=False):
+
+        typed_data = []
+
+        if component_list is None:
+            component_list = list(data_model.data.Items)
+
+        if data_model is None:
+            data_model = list(data_models)[0]
+
+        for component in component_list:
+            typed_object = self.create_python_object(component, data_model=data_model)
+            typed_data.append(typed_object)
+            if create_all:
+
+                def get_content(typed_object):
+                    if isinstance(typed_object, SimultanObject):
+                        for content in typed_object.__class__._taxonomy_map.content:
+                            val = getattr(typed_object, content.property_name)
+                            if isinstance(val, (SimultanObject, ComponentList, ComponentDictionary)):
+                                typed_data.append(val)
+                                get_content(val)
+                    elif isinstance(typed_object, ComponentList):
+                        for item in typed_object:
+                            if isinstance(item, (SimultanObject, ComponentList, ComponentDictionary)):
+                                typed_data.append(item)
+                                get_content(item)
+                    elif isinstance(typed_object, ComponentDictionary):
+                        for item in typed_object.values():
+                            if isinstance(item, (SimultanObject, ComponentList, ComponentDictionary)):
+                                typed_data.append(item)
+                                get_content(item)
+
+                get_content(typed_object)
+
+        return typed_data
+
+    # @lru_cache(maxsize=None)
+    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]
+        else:
+            data_model_id = data_model.id
+
+        if isinstance(component, (Layer, Vertex, Edge, PEdge, Face, Volume, EdgeLoop)):
+            if isinstance(component, Layer):
+                geometry_model = component.Model.Model
+            else:
+                geometry_model = component.Layer.Model.Model
+            cls = self.registered_geometry_classes[type(component)]
+            return create_python_geometry(cls, component, data_model_id, self, geometry_model)
+
+        if cls is None:
+            c_slots = [x.Target.Key for x in component.Slots.Items]
+            c_slot = list(set(c_slots) & set(self.registered_classes.keys()))
+            if len(c_slot) == 0:
+                if c_slots[0] not in self.registered_classes.keys():
+                    self.register(c_slots[0], SimultanObject)
+                    c_slot = [c_slots[0]]
+            elif len(c_slot) > 1:
+                num_superclasses = [len(self.registered_classes[x].__mro__) for x in c_slot]
+                c_slot = [c_slot[num_superclasses.index(max(num_superclasses))]]
+                # raise Warning(f'Component {component} has more than one registered taxonomy: {c_slot}')
+
+            if c_slot[0] not in self.mapped_classes.keys():
+                self.create_mapped_class(c_slot[0], self.registered_classes[c_slot[0]])
+
+            cls = self.mapped_classes[c_slot[0]]
+
+        if component is not None and component.Id in cls._cls_instances_dict.keys():
+            return cls._cls_instances_dict[component.Id]
+        else:
+            return create_python_object(component,
+                                        cls,
+                                        data_model_id=data_model_id,
+                                        object_mapper=self,
+                                        data_model=data_model,
+
+                                        *args,
+                                        **kwargs)
+
+    def get_typed_data_with_taxonomy(self, taxonomy: str, data_model=None, first=False):
+
+        tax_components = data_model.find_components_with_taxonomy(taxonomy=taxonomy, first=first)
+        return self.get_typed_data(component_list=tax_components)
+
+    def get_properties(self, taxonomy):
+
+        prop_dict = {}
+        taxonomy_map = self.taxonomy_maps.get(taxonomy, None)
+
+        if taxonomy_map is None:
+            return prop_dict
+
+        for prop in taxonomy_map.content:
+
+            prop_dict[prop.property_name] = add_properties(prop_name=prop.property_name,
+                                                           content=prop,
+                                                           taxonomy_map=taxonomy_map,
+                                                           taxonomy=taxonomy)
+
+        return prop_dict
+
+    def clear(self):
+        for cls in self.mapped_classes.values():
+            cls._cls_instances = WeakSet()
+
+
+if config.default_mapper is None:
+    config.default_mapper = PythonMapper()