Extract server apps and funcs from sdk into server (#388)

This separates server functionalities (Repository apps, in the future 
also Discovery, and Registries) from the core SDK to improve modularity 
and maintainability. It also includes some refactoring to avoid code 
duplication in future.

Changes:
- Moved all server-related classes and functions from `sdk` to `server`
- Splitted `http.py` into `repository.py`, `base.py` and 
  `util/converters.py`
- Created parent classes `BaseWSGIApp` and `ObjectStoreWSGIApp` for 
  repository app class, which will also be used for discovery and 
  registry apps in the future
- Added an initial pyproject.toml for the server app
- Refactored  `object_hook()` by extracting the mapping dict into 
  `_get_aas_class_parsers()`
- Refactored  `default()` by extracting the mapping dict into 
  `_get_aas_class_serializers()`
- Refactored `_create_dict()`
- Created a JSON_AAS_TOP_LEVEL_KEYS_TO_TYPES tuple with top-level JSON 
  keys and the corresponding SDK types to reuse it in JSON 
  de-/serialization methods

Author: zrgt

.github/workflows/ci.yml

@@ -254,13 +254,13 @@ jobs:
         pip install .[dev]
     - name: Check typing with MyPy
       run: |
-        mypy ./aas_compliance_tool test
+        mypy aas_compliance_tool test
     - name: Check code style with PyCodestyle
       run: |
-        pycodestyle --count --max-line-length 120 ./aas_compliance_tool test
+        pycodestyle --count --max-line-length 120 aas_compliance_tool test
 
-  compliance-tool-readme-codeblocks:
-    # This job runs the same static code analysis (mypy and pycodestyle) on the codeblocks in our docstrings.
+  compliance-tool-package:
+    # This job checks if we can build our compliance_tool package
     runs-on: ubuntu-latest
 
     defaults:
@@ -272,42 +272,43 @@ jobs:
       uses: actions/setup-python@v5
       with:
         python-version: ${{ env.X_PYTHON_MIN_VERSION }}
-    - name: Install Python dependencies
-      # install the local sdk in editable mode so it does not get overwritten
+    - name: Install dependencies
       run: |
         python -m pip install --upgrade pip
-        pip install -e ../sdk[dev]
-        pip install .[dev]
-    - name: Check typing with MyPy
-      run: |
-        mypy <(codeblocks python README.md)
-    - name: Check code style with PyCodestyle
-      run: |
-        codeblocks --wrap python README.md | pycodestyle --count --max-line-length 120 -
-    - name: Run readme codeblocks with Python
+        pip install build
+    - name: Create source and wheel dist
       run: |
-        codeblocks python README.md | python
+        python -m build
 
-  compliance-tool-package:
-    # This job checks if we can build our compliance_tool package
+ #server-test:
+    # TODO: This job runs the unittests on the python versions specified down at the matrix
+    #   and aas-test-engines on the server
+
+
+  server-static-analysis:
+    # This job runs static code analysis, namely pycodestyle and mypy
     runs-on: ubuntu-latest
 
     defaults:
       run:
-        working-directory: ./compliance_tool
+        working-directory: ./server/app
     steps:
     - uses: actions/checkout@v4
     - name: Set up Python ${{ env.X_PYTHON_MIN_VERSION }}
       uses: actions/setup-python@v5
       with:
         python-version: ${{ env.X_PYTHON_MIN_VERSION }}
-    - name: Install dependencies
+    - name: Install Python dependencies
       run: |
         python -m pip install --upgrade pip
-        pip install build
-    - name: Create source and wheel dist
+        pip install ../../sdk
+        pip install .[dev]
+    - name: Check typing with MyPy
       run: |
-        python -m build
+        mypy .
+    - name: Check code style with PyCodestyle
+      run: |
+        pycodestyle --count --max-line-length 120 .
 
   server-package:
     # This job checks if we can build our server package

.gitignore

@@ -29,6 +29,7 @@ sdk/test/adapter/schemas
 # Ignore dynamically generated version file
 sdk/basyx/version.py
 compliance_tool/aas_compliance_tool/version.py
+server/app/version.py
 
 # ignore the content of the server storage
 server/storage/

sdk/README.md

@@ -42,8 +42,7 @@ The BaSyx Python SDK requires the following Python packages to be installed for
 * `lxml` (BSD 3-clause License, using `libxml2` under MIT License)
 * `python-dateutil` (BSD 3-clause License)
 * `pyecma376-2` (Apache License v2.0)
-* `urllib3` (MIT License)
-* `Werkzeug` (BSD 3-clause License)
+
 
 Development/testing/documentation/example dependencies:
 * `mypy` (MIT License)

sdk/basyx/aas/adapter/_generic.py

@@ -19,6 +19,13 @@
 PathOrBinaryIO = Union[Path, BinaryIO]
 PathOrIO = Union[Path, IO]  # IO is TextIO or BinaryIO
 
+# JSON top-level keys and their corresponding model classes
+JSON_AAS_TOP_LEVEL_KEYS_TO_TYPES = (
+    ('assetAdministrationShells', model.AssetAdministrationShell),
+    ('submodels', model.Submodel),
+    ('conceptDescriptions', model.ConceptDescription),
+)
+
 # XML Namespace definition
 XML_NS_MAP = {"aas": "https://admin-shell.io/aas/3/0"}
 XML_NS_AAS = "{" + XML_NS_MAP["aas"] + "}"

sdk/basyx/aas/adapter/json/json_deserialization.py

@@ -34,12 +34,13 @@
 import json
 import logging
 import pprint
-from typing import Dict, Callable, ContextManager, TypeVar, Type, List, IO, Optional, Set, get_args
+from typing import (Dict, Callable, ContextManager, TypeVar, Type,
+                    List, IO, Optional, Set, get_args, Tuple, Iterable, Any)
 
 from basyx.aas import model
 from .._generic import MODELLING_KIND_INVERSE, ASSET_KIND_INVERSE, KEY_TYPES_INVERSE, ENTITY_TYPES_INVERSE, \
     IEC61360_DATA_TYPES_INVERSE, IEC61360_LEVEL_TYPES_INVERSE, KEY_TYPES_CLASSES_INVERSE, REFERENCE_TYPES_INVERSE, \
-    DIRECTION_INVERSE, STATE_OF_EVENT_INVERSE, QUALIFIER_KIND_INVERSE, PathOrIO, Path
+    DIRECTION_INVERSE, STATE_OF_EVENT_INVERSE, QUALIFIER_KIND_INVERSE, PathOrIO, Path, JSON_AAS_TOP_LEVEL_KEYS_TO_TYPES
 
 logger = logging.getLogger(__name__)
 
@@ -154,19 +155,20 @@ def __init__(self, *args, **kwargs):
         json.JSONDecoder.__init__(self, object_hook=self.object_hook, *args, **kwargs)
 
     @classmethod
-    def object_hook(cls, dct: Dict[str, object]) -> object:
-        # Check if JSON object seems to be a deserializable AAS object (i.e. it has a modelType). Otherwise, the JSON
-        #   object is returned as is, so it's possible to mix AAS objects with other data within a JSON structure.
-        if 'modelType' not in dct:
-            return dct
+    def _get_aas_class_parsers(cls) -> Dict[str, Callable[[Dict[str, object]], object]]:
+        """
+        Returns the dictionary of AAS class parsers.
+
+        The following dict specifies a constructor method for all AAS classes that may be identified using the
+        ``modelType`` attribute in their JSON representation. Each of those constructor functions takes the JSON
+        representation of an object and tries to construct a Python object from it. Embedded objects that have a
+        modelType themselves are expected to be converted to the correct PythonType already. Additionally, each
+        function takes a bool parameter ``failsafe``, which indicates weather to log errors and skip defective objects
+        instead of raising an Exception.
 
-        # The following dict specifies a constructor method for all AAS classes that may be identified using the
-        # ``modelType`` attribute in their JSON representation. Each of those constructor functions takes the JSON
-        # representation of an object and tries to construct a Python object from it. Embedded objects that have a
-        # modelType themselves are expected to be converted to the correct PythonType already. Additionally, each
-        # function takes a bool parameter ``failsafe``, which indicates weather to log errors and skip defective objects
-        # instead of raising an Exception.
-        AAS_CLASS_PARSERS: Dict[str, Callable[[Dict[str, object]], object]] = {
+        :return: The dictionary of AAS class parsers
+        """
+        aas_class_parsers: Dict[str, Callable[[Dict[str, object]], object]] = {
             'AssetAdministrationShell': cls._construct_asset_administration_shell,
             'AssetInformation': cls._construct_asset_information,
             'SpecificAssetId': cls._construct_specific_asset_id,
@@ -189,6 +191,16 @@ def object_hook(cls, dct: Dict[str, object]) -> object:
             'ReferenceElement': cls._construct_reference_element,
             'DataSpecificationIec61360': cls._construct_data_specification_iec61360,
         }
+        return aas_class_parsers
+
+    @classmethod
+    def object_hook(cls, dct: Dict[str, object]) -> object:
+        # Check if JSON object seems to be a deserializable AAS object (i.e. it has a modelType). Otherwise, the JSON
+        #   object is returned as is, so it's possible to mix AAS objects with other data within a JSON structure.
+        if 'modelType' not in dct:
+            return dct
+
+        AAS_CLASS_PARSERS = cls._get_aas_class_parsers()
 
         # Get modelType and constructor function
         if not isinstance(dct['modelType'], str):
@@ -799,7 +811,9 @@ def _select_decoder(failsafe: bool, stripped: bool, decoder: Optional[Type[AASFr
 
 def read_aas_json_file_into(object_store: model.AbstractObjectStore, file: PathOrIO, replace_existing: bool = False,
                             ignore_existing: bool = False, failsafe: bool = True, stripped: bool = False,
-                            decoder: Optional[Type[AASFromJsonDecoder]] = None) -> Set[model.Identifier]:
+                            decoder: Optional[Type[AASFromJsonDecoder]] = None,
+                            keys_to_types: Iterable[Tuple[str, Any]] = JSON_AAS_TOP_LEVEL_KEYS_TO_TYPES) \
+        -> Set[model.Identifier]:
     """
     Read an Asset Administration Shell JSON file according to 'Details of the Asset Administration Shell', chapter 5.5
     into a given object store.
@@ -817,6 +831,7 @@ def read_aas_json_file_into(object_store: model.AbstractObjectStore, file: PathO
                      See https://git.rwth-aachen.de/acplt/pyi40aas/-/issues/91
                      This parameter is ignored if a decoder class is specified.
     :param decoder: The decoder class used to decode the JSON objects
+    :param keys_to_types: A dictionary of JSON keys to expected types. This is used to check the type of the objects
     :raises KeyError: **Non-failsafe**: Encountered a duplicate identifier
     :raises KeyError: Encountered an identifier that already exists in the given ``object_store`` with both
                      ``replace_existing`` and ``ignore_existing`` set to ``False``
@@ -843,45 +858,43 @@ def read_aas_json_file_into(object_store: model.AbstractObjectStore, file: PathO
     with cm as fp:
         data = json.load(fp, cls=decoder_)
 
-    for name, expected_type in (('assetAdministrationShells', model.AssetAdministrationShell),
-                                ('submodels', model.Submodel),
-                                ('conceptDescriptions', model.ConceptDescription)):
+    for name, expected_type in keys_to_types:
         try:
             lst = _get_ts(data, name, list)
         except (KeyError, TypeError):
             continue
 
         for item in lst:
-            error_message = "Expected a {} in list '{}', but found {}".format(
-                expected_type.__name__, name, repr(item))
+            error_msg = f"Expected a {expected_type.__name__} in list '{name}', but found {repr(item)}."
             if isinstance(item, model.Identifiable):
                 if not isinstance(item, expected_type):
-                    if decoder_.failsafe:
-                        logger.warning("{} was in wrong list '{}'; nevertheless, we'll use it".format(item, name))
-                    else:
-                        raise TypeError(error_message)
+                    if not decoder_.failsafe:
+                        raise TypeError(f"{item} was in the wrong list '{name}'")
+                    logger.warning(f"{item} was in the wrong list '{name}'; nevertheless, we'll use it")
+
                 if item.id in ret:
-                    error_message = f"{item} has a duplicate identifier already parsed in the document!"
+                    error_msg = f"{item} has a duplicate identifier already parsed in the document!"
                     if not decoder_.failsafe:
-                        raise KeyError(error_message)
-                    logger.error(error_message + " skipping it...")
+                        raise KeyError(error_msg)
+                    logger.error(f"{error_msg} Skipping it...")
                     continue
+
                 existing_element = object_store.get(item.id)
                 if existing_element is not None:
                     if not replace_existing:
-                        error_message = f"object with identifier {item.id} already exists " \
-                                        f"in the object store: {existing_element}!"
+                        error_msg = f"Object with id '{item.id}' already exists in store: {existing_element}!"
                         if not ignore_existing:
-                            raise KeyError(error_message + f" failed to insert {item}!")
-                        logger.info(error_message + f" skipping insertion of {item}...")
+                            raise KeyError(f"{error_msg} Failed to insert {item}!")
+                        logger.info(f"{error_msg} Skipping {item}...")
                         continue
                     object_store.discard(existing_element)
+
                 object_store.add(item)
                 ret.add(item.id)
             elif decoder_.failsafe:
-                logger.error(error_message)
+                logger.error(f"{error_msg} Skipping it...")
             else:
-                raise TypeError(error_message)
+                raise TypeError(error_msg)
     return ret