Merge branch 'main' into 2.1.x

Author: atextor

CONTRIBUTING.md

@@ -16,8 +16,6 @@ It is based on the Semantic Aspect Meta Model (SAMM) and supports its use.
 # Contributing Source Code (using GitHub)
 
 * We use this GitHub repository to track issues and feature requests.
-* For general discussions of the ESMF, modeling questions etc. we use
-  the [community forum](https://www.eclipse.org/forums/index.php/f/617/).
 * For discussions specific to development, the preferred way is
   the [developer mailing list](https://accounts.eclipse.org/mailing-list/esmf-dev).
 

core/esmf-aspect-meta-model-python/README.md

@@ -9,6 +9,7 @@ https://projects.eclipse.org/projects/dt.esmf).
     * [Download SAMM files](#download-samm-files)
       * [Download SAMM release](#download-samm-release)
       * [Download SAMM branch](#download-samm-branch)
+  * [Input data handler usage](#input-data-handler-usage)
   * [Aspect Meta Model Loader usage](#aspect-meta-model-loader-usage)
   * [Samm Units](#samm-units)
   * [SAMM CLI wrapper class](#samm-cli-wrapper-class)
@@ -84,14 +85,47 @@ poetry run download-samm-branch
 ```
 Link to all branches: [SAMM Releases](https://github.com/eclipse-esmf/esmf-semantic-aspect-meta-model/branches)
 
+## Input data handler usage
+
+The InputHandler is a general-purpose class designed for loading input data into an RDF graph. 
+It easily accommodates different input sources such as local files (.ttl) or direct data strings containing 
+RDF formatted data.
+
+```python
+from esmf_aspect_meta_model_python.resolver.handler import InputHandler
+
+# Instantiating the Handler
+# The InputHandler requires a path or data string upon instantiation, which defines the source of RDF data
+# local file
+model_path = "path/to/local/file/AspectName.ttl"
+handler = InputHandler(model_path)
+graph, aspect_urn = handler.get_rdf_graph()
+
+# returns a tuple containing the RDF graph and the aspect URN derived from the provided data source
+```
+
+```python
+from esmf_aspect_meta_model_python.resolver.handler import InputHandler
+
+# Alternatively, if you have RDF data in a string format, you can directly pass it as follows:
+rdf_data_string = "your RDF data string here"
+handler = InputHandler(rdf_data_string)
+graph, aspect_urn = handler.get_rdf_graph()
+```
+
 ## Aspect Meta Model Loader usage
 
 An Aspect of the Meta Model can be loaded as follows:
 ```python
 from esmf_aspect_meta_model_python import AspectLoader
+from esmf_aspect_meta_model_python.resolver.handler import InputHandler
+
+model_path = "absolute/path/to/turtle.ttl"
+handler = InputHandler(model_path)
+graph, aspect_urn = handler.get_rdf_graph()
 
 loader = AspectLoader()
-model_elements = loader.load_aspect_model("absolute/path/to/turtle.ttl")
+model_elements = loader.load_aspect_model(graph, aspect_urn)
 aspect = model_elements[0]
 
 # or you can provide an Aspect URN

core/esmf-aspect-meta-model-python/esmf_aspect_meta_model_python/__init__.py

@@ -87,3 +87,4 @@
 )
 from .loader.aspect_loader import AspectLoader
 from .loader.samm_graph import SAMMGraph
+from .resolver.handler import InputHandler

core/esmf-aspect-meta-model-python/esmf_aspect_meta_model_python/loader/aspect_loader.py

@@ -9,10 +9,11 @@
 #
 #   SPDX-License-Identifier: MPL-2.0
 
-from pathlib import Path
-from typing import Union
+from typing import List
 
-from esmf_aspect_meta_model_python.loader.default_element_cache import DefaultElementCache
+from rdflib import Graph, URIRef
+
+from esmf_aspect_meta_model_python.base.aspect import Aspect
 from esmf_aspect_meta_model_python.loader.samm_graph import SAMMGraph
 
 
@@ -24,55 +25,37 @@ class AspectLoader:
     The default cache strategy ignores inline defined elements.
     """
 
-    def __init__(self) -> None:
-        self._cache = DefaultElementCache()
-        self._graph = SAMMGraph()
-
-    def get_graph(self) -> SAMMGraph:
-        """Get SAMM graph.
+    def __init__(self):
+        self.graph = None
 
-        :return: parsed SAMM Aspect model Graph.
+    def load_aspect_model(self, rdf_graph: Graph, aspect_urn: URIRef | str = "") -> List[Aspect]:
         """
-        return self._graph
-
-    def get_samm_version(self) -> str:
-        """Get SAMM version of the graph."""
-        return self._graph.get_samm_version()
+        Creates a python object(s) to represent the Aspect model graph.
 
-    @staticmethod
-    def convert_file_path(file_path: Union[str, Path]) -> str:
-        """Convert file_path to the string.
-
-        :param file_path: path to model file
-        """
-        if isinstance(file_path, Path):
-            file_path = str(file_path)
+        This function takes an RDF graph and a URN for an Aspect node and converts it into
+        a set of structured and connected Python objects that represents the Aspect model graph. The output is a
+        list of Python objects derived from the RDF graph centered around the specified Aspect node.
 
-        tmp_path = Path(file_path)
-        if not tmp_path.exists():
-            raise FileNotFoundError(f"Could not found the file {tmp_path}")
+        Args:
+            rdf_graph (RDFGraph): The RDF graph from which to create the model.
+            aspect_urn (str): The URN identifier for the main Aspect node in the RDF graph.
 
-        return file_path
+        Returns:
+            list: A list of Python objects that represent the Aspect elements of the Aspect model graph.
 
-    def _reset_graph(self):
-        """Reset graph and cache data."""
-        if self._graph:
-            self._graph = SAMMGraph()
+        Examples:
+            # Assuming 'graph' is a predefined RDFGraph object and 'aspect_urn' is defined:
+            aspect_model = create_aspect_model_graph(graph, "urn:example:aspectNode")
+            print(aspect_model)  # This prints the list of Python objects.
 
-        if self._cache:
-            self._cache = DefaultElementCache()
-
-    def load_aspect_model(self, file_path: Union[Path, str]):
-        """Load aspect model to RDF GRAPH.
-
-        Create an aspect object with all the including properties and operations with the turtle file
-
-        :param file_path: path to the turtle file. Can be either a string or a Path object
-        :return: instance of the aspect
+        Notes:
+            It's crucial that the aspect_urn corresponds to a valid Aspect node within the RDF graph;
+            otherwise, the function may not perform as expected.
         """
-        file_path = self.convert_file_path(file_path)
-        self._reset_graph()
-        _ = self._graph.parse(file_path)
-        loaded_aspect_model = self._graph.to_python()
+        self.graph = SAMMGraph(graph=rdf_graph)
+        loaded_aspect_model = self.graph.to_python(aspect_urn)
+
+        # Add check that loaded_aspect_model is not empty
+        # Add check that aspect_urn is ref to an Aspect node
 
         return loaded_aspect_model

core/esmf-aspect-meta-model-python/esmf_aspect_meta_model_python/loader/instantiator/state_instantiator.py

@@ -0,0 +1,86 @@
+#  Copyright (c) 2023 Robert Bosch Manufacturing Solutions GmbH
+#
+#  See the AUTHORS file(s) distributed with this work for additional
+#  information regarding authorship.
+#
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+#
+#   SPDX-License-Identifier: MPL-2.0
+
+from typing import Any, Dict, Optional
+
+import rdflib  # type: ignore
+
+from rdflib.term import Node
+
+from esmf_aspect_meta_model_python.base.characteristics.state import State
+from esmf_aspect_meta_model_python.impl.characteristics.default_state import DefaultState
+from esmf_aspect_meta_model_python.loader.instantiator.constants import DATA_TYPE_ERROR_MSG
+from esmf_aspect_meta_model_python.loader.instantiator.enumeration_instantiator import EnumerationInstantiator
+from esmf_aspect_meta_model_python.loader.rdf_helper import RdfHelper
+from esmf_aspect_meta_model_python.vocabulary.SAMM import SAMM
+from esmf_aspect_meta_model_python.vocabulary.SAMMC import SAMMC
+
+
+class StateInstantiator(EnumerationInstantiator):
+    def _create_instance(self, element_node: Node) -> State:
+        data_type = self._get_data_type(element_node)
+        if data_type is None:
+            raise TypeError(DATA_TYPE_ERROR_MSG)
+
+        meta_model_base_attributes = self._get_base_attributes(element_node)
+        value_collection_node = self._aspect_graph.value(
+            subject=element_node,
+            predicate=self._sammc.get_urn(SAMMC.values),
+        )
+        value_nodes = RdfHelper.get_rdf_list_values(value_collection_node, self._aspect_graph)
+        values = [self.__to_state_node_value(value_node) for value_node in value_nodes]
+
+        defaultValue = self._aspect_graph.value(
+            subject=element_node,
+            predicate=self._sammc.get_urn(SAMMC.default_value),
+        )
+        default = self.__to_state_node_value(defaultValue)
+
+        return DefaultState(meta_model_base_attributes, data_type, values, default)
+
+    def __to_state_node_value(self, value_node: Optional[Node]) -> Dict:
+        """
+        This method instantiates one possible value of a state.
+        :param value_node:  Node of the Graph that represents one state value.
+        The Argument can either be a Literal or a URIRef.
+        - If value_node is a Literal it will represent e.g. a string or an integer value
+        - If value_node is a URIRef it will represent a value of a ComplexType
+        :return: the one generated value of the state
+        """
+        if isinstance(value_node, rdflib.Literal):
+            # value represents a simple data type
+            return value_node.toPython()
+
+        elif isinstance(value_node, rdflib.URIRef):
+            # value represents a complex data type
+            value = {}
+            value_node_properties = self._aspect_graph.predicate_objects(value_node)
+            for property_urn, property_value in value_node_properties:
+                if property_urn != rdflib.RDF.type and isinstance(property_urn, str):
+                    property_name = property_urn.split("#")[1]
+                    actual_value: Optional[Any]
+                    if self.__is_collection_value(property_urn):
+                        actual_value = self.__instantiate_enum_collection(property_value)
+                    else:
+                        actual_value = self.__to_state_node_value(property_value)
+                    value[property_name] = actual_value
+
+            value_node_name = value_node.split("#")[1]
+            value_key = self._samm.get_urn(SAMM.name).toPython()
+            value[value_key] = value_node_name  # type: ignore
+            return value
+
+        else:
+            # illegal node type for state value (e.g., Blank Node)
+            raise TypeError(
+                f"Every value of an state must either be a Literal (string, int, etc.) or "
+                f"a URI reference to a ComplexType. Values of type {type(value_node).__name__} are not allowed"
+            )