aas-http-client 0.1.4__py3-none-any.whl → 0.1.5__py3-none-any.whl

aas_http_client/__init__.py

@@ -4,13 +4,17 @@ import importlib.metadata
 __copyright__ = f"Copyright (C) {datetime.now().year} :em engineering methods AG. All rights reserved."
 __author__ = "Daniel Klein"
 
-__version__ = importlib.metadata.version(__name__)
+try:
+    __version__ = importlib.metadata.version(__name__)
+except importlib.metadata.PackageNotFoundError:
+    __version__ = "0.0.0-dev"
+    
 __project__ = "aas-http-client"
 __package__ = "aas-http-client"
 
 from aas_http_client.core.version_check import check_for_update
-from aas_http_client.client import create_client_by_config, create_client_by_url, AasxServerInterface
+from aas_http_client.client import create_client_by_config, create_client_by_url, AasHttpClient
 
 check_for_update()
 
-__all__ = ["create_client_by_config", "create_client_by_url", "AasxServerInterface"]
+__all__ = ["create_client_by_config", "create_client_by_url", "AasHttpClient"]

aas_http_client/client.py

@@ -1,16 +1,14 @@
-"""BaSyx Server interface for REST API communication."""
-
+"""Client for HTTP API communication with AAS server."""
 import json
 import logging
-import re
 import time
 from pathlib import Path
 
 import basyx.aas.adapter.json
 import basyx.aas.adapter.json.json_serialization as js
 import requests
-from basyx.aas.model import AssetAdministrationShell, Reference, Submodel
-from aas_http_client.core.encoder import decode_base_64, encode_base_64
+from basyx.aas.model import Reference, Submodel
+from aas_http_client.core.encoder import decode_base_64
 from pydantic import BaseModel, PrivateAttr, ValidationError
 from requests import Session
 from requests.auth import HTTPBasicAuth
@@ -65,10 +63,11 @@ def log_response_errors(response: Response):
         logger.error(result_error_message)
 
 
-class AasxServerInterface(BaseModel):
-    """Represents a AasxServerInterface to communicate with a REST API."""
+class AasHttpClient(BaseModel):
+    """Represents a AasHttpClient to communicate with a REST API."""
 
-    base_url: str = "http://basyx_aas_server:80/"
+    base_url: str = "http://javaaasserver:5060/"
+    api_base_path: str = ""
     username: str | None = None
     _password: str | None = PrivateAttr(default=None)
     https_proxy: str | None = None
@@ -77,10 +76,9 @@ class AasxServerInterface(BaseModel):
     connection_time_out: int = 100
     ssl_verify: bool = True
     _session: Session = PrivateAttr(default=None)
-    namespace: str | None = None
 
     def initialize(self, password: str):
-        """Initialize the AasxServerInterface with the given URL, username and password.
+        """Initialize the AasHttpClient with the given URL, username and password.
 
         :param password: password
         """
@@ -98,21 +96,6 @@ class AasxServerInterface(BaseModel):
         if self.http_proxy:
             self._session.proxies.update({"http": self.http_proxy})
 
-        if not self.namespace:
-            self.namespace = re.sub(r":\d+", "", self.base_url)
-
-    def _get_namespace(self) -> str:
-        """Get the address of the REST API.
-
-        :return: address as a string
-        """
-        match = re.search(r"^https?://([^:/]+)", self.base_url)
-
-        if match:
-            return match.group(1)
-
-        raise ValueError(f"Invalid URL format: {self.base_url}")
-
     def get_root(self) -> dict | None:
         """Get the root of the REST API.
 
@@ -132,22 +115,20 @@ class AasxServerInterface(BaseModel):
             logger.error(f"Error call REST API: {e}")
             return None
 
-        return json.loads(response.content)
+        content = response.content.decode("utf-8")
+        return json.loads(content)
 
-    def post_shells(self, aas: AssetAdministrationShell) -> dict | None:
+    def post_shells(self, aas_data: dict) -> dict | None:
         """Post an Asset Administration Shell (AAS) to the REST API.
 
-        :param aas: Asset Administration Shell to post
+        :param aas_data: Json data of the Asset Administration Shell to post
         :return: Response data as a dictionary or None if an error occurred
         """
-        aas_dict_string = json.dumps(aas, cls=basyx.aas.adapter.json.AASToJsonEncoder)
-        aas_dict = json.loads(aas_dict_string)
-
         url = f"{self.base_url}/shells"
         logger.debug(f"Call REST API url '{url}'")
 
         try:
-            response = self._session.post(url, headers=HEADERS, json=aas_dict, timeout=self.time_out)
+            response = self._session.post(url, headers=HEADERS, json=aas_data, timeout=self.time_out)
             logger.debug(f"Call REST API url '{response.url}'")
 
             if response.status_code not in (STATUS_CODE_201, STATUS_CODE_202):
@@ -158,24 +139,21 @@ class AasxServerInterface(BaseModel):
             logger.error(f"Error call REST API: {e}")
             return None
 
-        content = json.loads(response.content)
-        return dict(sorted(content.items()))
+        content = response.content.decode("utf-8")
+        return json.loads(content)
 
-    def put_shells(self, identifier: str, aas: AssetAdministrationShell) -> bool:
+    def put_shells(self, identifier: str, aas_data: dict) -> bool:
         """Update an Asset Administration Shell (AAS) by its ID in the REST API.
 
         :param identifier: Identifier of the AAS to update
-        :param aas: Asset Administration Shell data to update
+        :param aas_data: Json data of the Asset Administration Shell data to update
         :return: True if the update was successful, False otherwise
         """
-        aas_dict_string = json.dumps(aas, cls=basyx.aas.adapter.json.AASToJsonEncoder)
-        aas_dict = json.loads(aas_dict_string)
-
         decoded_identifier: str = decode_base_64(identifier)
         url = f"{self.base_url}/shells/{decoded_identifier}"
 
         try:
-            response = self._session.put(url, headers=HEADERS, json=aas_dict, timeout=self.time_out)
+            response = self._session.put(url, headers=HEADERS, json=aas_data, timeout=self.time_out)
             logger.debug(f"Call REST API url '{response.url}'")
 
             if response.status_code is not STATUS_CODE_204:
@@ -188,22 +166,19 @@ class AasxServerInterface(BaseModel):
 
         return True
 
-    def put_shells_submodels(self, aas_id: str, submodel_id: str, submodel: Submodel) -> bool:
+    def put_shells_submodels(self, aas_id: str, submodel_id: str, submodel_data: dict) -> bool:
         """Update a submodel by its ID for a specific Asset Administration Shell (AAS).
 
         :param aas_id: ID of the AAS to update the submodel for
-        :param submodel: Submodel data to update
+        :param submodel_data: Json data to the Submodel to update
         :return: True if the update was successful, False otherwise
         """
-        sm_dict_string = json.dumps(submodel, cls=basyx.aas.adapter.json.AASToJsonEncoder)
-        sm_dict = json.loads(sm_dict_string)
-
         decoded_aas_id: str = decode_base_64(aas_id)
         decoded_submodel_id: str = decode_base_64(submodel_id)
         url = f"{self.base_url}/shells/{decoded_aas_id}/submodels/{decoded_submodel_id}"
 
         try:
-            response = self._session.put(url, headers=HEADERS, json=sm_dict, timeout=self.time_out)
+            response = self._session.put(url, headers=HEADERS, json=submodel_data, timeout=self.time_out)
             logger.debug(f"Call REST API url '{response.url}'")
 
             if response.status_code != STATUS_CODE_204:
@@ -216,10 +191,10 @@ class AasxServerInterface(BaseModel):
 
         return True
 
-    def get_shells(self) -> list[AssetAdministrationShell] | None:
+    def get_shells(self) -> list[dict] | None:
         """Get all Asset Administration Shells (AAS) from the REST API.
 
-        :return: AAS objects or None if an error occurred
+        :return: List of paginated Asset Administration Shells data or None if an error occurred
         """
         url = f"{self.base_url}/shells"
 
@@ -235,35 +210,14 @@ class AasxServerInterface(BaseModel):
             logger.error(f"Error call REST API: {e}")
             return None
 
-        content: list = json.loads(response.content)
-
-        if not content:
-            logger.warning("No AAS found in the REST API.")
-            return []
-
-        results: list = content.get("result", [])
-        if not results:
-            logger.warning("No AAS found in the REST API results.")
-            return []
-
-        aas_list: list[AssetAdministrationShell] = []
-
-        for result in results:
-            if not isinstance(result, dict):
-                logger.error(f"Invalid AAS data: {result}")
-                return None
-
-            aas_dict_string = json.dumps(result)
-            aas = json.loads(aas_dict_string, cls=basyx.aas.adapter.json.AASFromJsonDecoder)
-            aas_list.append(aas)
+        content = response.content.decode("utf-8")
+        return json.loads(content)
 
-        return aas_list
-
-    def get_shells_by_id(self, aas_id: str) -> AssetAdministrationShell | None:
+    def get_shells_by_id(self, aas_id: str) -> dict | None:
         """Get an Asset Administration Shell (AAS) by its ID from the REST API.
 
         :param aas_id: ID of the AAS to retrieve
-        :return: AAS object or None if an error occurred
+        :return: Asset Administration Shells data or None if an error occurred
         """
         decoded_aas_id: str = decode_base_64(aas_id)
         url = f"{self.base_url}/shells/{decoded_aas_id}"
@@ -280,8 +234,9 @@ class AasxServerInterface(BaseModel):
             logger.error(f"Error call REST API: {e}")
             return None
 
-        aas_dict_string = response.content.decode("utf-8")
-        return json.loads(aas_dict_string, cls=basyx.aas.adapter.json.AASFromJsonDecoder)
+        content = response.content.decode("utf-8")
+        return json.loads(content)
+
 
     def get_shells_reference_by_id(self, aas_id: str) -> Reference | None:
         decoded_aas_id: str = decode_base_64(aas_id)
@@ -326,8 +281,8 @@ class AasxServerInterface(BaseModel):
             logger.error(f"Error call REST API: {e}")
             return None
 
-        submodel_dict_string = response.content.decode("utf-8")
-        return json.loads(submodel_dict_string, cls=basyx.aas.adapter.json.AASFromJsonDecoder)
+        content = response.content.decode("utf-8")
+        return json.loads(content)
 
     def delete_shells_by_id(self, aas_id: str) -> bool:
         """Get an Asset Administration Shell (AAS) by its ID from the REST API.
@@ -352,19 +307,16 @@ class AasxServerInterface(BaseModel):
 
         return True
 
-    def post_submodels(self, submodel: Submodel) -> bool:
+    def post_submodels(self, submodel_data: dict) -> bool:
         """Post a submodel to the REST API.
 
-        :param submodel: submodel data as a dictionary
+        :param submodel_data: Json data of the Submodel to post
         :return: Response data as a dictionary or None if an error occurred
         """
-        sm_dict_string = json.dumps(submodel, cls=basyx.aas.adapter.json.AASToJsonEncoder)
-        sm_dict = json.loads(sm_dict_string)
-
         url = f"{self.base_url}/submodels"
 
         try:
-            response = self._session.post(url, headers=HEADERS, json=sm_dict, timeout=self.time_out)
+            response = self._session.post(url, headers=HEADERS, json=submodel_data, timeout=self.time_out)
             logger.debug(f"Call REST API url '{response.url}'")
 
             if response.status_code not in (STATUS_CODE_201, STATUS_CODE_202):
@@ -377,21 +329,18 @@ class AasxServerInterface(BaseModel):
 
         return True
 
-    def put_submodels(self, identifier: str, submodel: Submodel) -> bool:
+    def put_submodels(self, identifier: str, submodel_data: dict) -> bool:
         """Update a submodel by its ID in the REST API.
 
         :param identifier: Identifier of the submodel to update
-        :param submodel: Submodel data to update
+        :param submodel_data: Json data of the Submodel to update
         :return: True if the update was successful, False otherwise
         """
-        sm_dict_string = json.dumps(submodel, cls=basyx.aas.adapter.json.AASToJsonEncoder)
-        sm_dict = json.loads(sm_dict_string)
-
         decoded_identifier: str = decode_base_64(identifier)
         url = f"{self.base_url}/submodels/{decoded_identifier}"
 
         try:
-            response = self._session.put(url, headers=HEADERS, json=sm_dict, timeout=self.time_out)
+            response = self._session.put(url, headers=HEADERS, json=submodel_data, timeout=self.time_out)
             logger.debug(f"Call REST API url '{response.url}'")
 
             if response.status_code != STATUS_CODE_204:
@@ -404,7 +353,7 @@ class AasxServerInterface(BaseModel):
 
         return True
 
-    def get_submodel_by_id(self, submodel_id: str) -> Submodel | None:
+    def get_submodel_by_id(self, submodel_id: str) -> dict | None:
         """Get a submodel by its ID from the REST API.
 
         :param submodel_id: ID of the submodel to retrieve
@@ -425,10 +374,10 @@ class AasxServerInterface(BaseModel):
             logger.error(f"Error call REST API: {e}")
             return None
 
-        sm_dict_string = response.content.decode("utf-8")
-        return json.loads(sm_dict_string, cls=basyx.aas.adapter.json.AASFromJsonDecoder)
+        content = response.content.decode("utf-8")
+        return json.loads(content)
 
-    def get_submodels(self) -> list[Submodel] | None:
+    def get_submodels(self) -> list[dict] | None:
         """Get all submodels from the REST API.
 
         :return: Submodel objects or None if an error occurred
@@ -447,31 +396,10 @@ class AasxServerInterface(BaseModel):
             logger.error(f"Error call REST API: {e}")
             return None
 
-        content: list = json.loads(response.content)
-
-        if not content:
-            logger.warning("No submodels found in the REST API.")
-            return []
+        content = response.content.decode("utf-8")
+        return json.loads(content)
 
-        results: list = content.get("result", [])
-        if not results:
-            logger.warning("No submodels found in the REST API results.")
-            return []
-
-        submodels: list[Submodel] = []
-
-        for result in results:
-            if not isinstance(result, dict):
-                logger.error(f"Invalid submodel data: {result}")
-                return None
-
-            sm_dict_string = json.dumps(result)
-            submodel = json.loads(sm_dict_string, cls=basyx.aas.adapter.json.AASFromJsonDecoder)
-            submodels.append(submodel)
-
-        return submodels
-
-    def get_submodels_by_id(self, submodel_id: str) -> Submodel | None:
+    def get_submodels_by_id(self, submodel_id: str) -> dict | None:
         """Get a submodel by its ID from the REST API.
 
         :param submodel_id: ID of the submodel to retrieve
@@ -492,18 +420,15 @@ class AasxServerInterface(BaseModel):
             logger.error(f"Error call REST API: {e}")
             return None
 
-        sm_dict_string = response.content.decode("utf-8")
-        return json.loads(sm_dict_string, cls=basyx.aas.adapter.json.AASFromJsonDecoder)
-
-    def patch_submodel_by_id(self, submodel_id: str, submodel: Submodel):
-        sm_dict_string = json.dumps(submodel, cls=basyx.aas.adapter.json.AASToJsonEncoder)
-        sm_dict = json.loads(sm_dict_string)
+        content = response.content.decode("utf-8")
+        return json.loads(content)
 
+    def patch_submodel_by_id(self, submodel_id: str, submodel_data: dict):
         decoded_submodel_id: str = decode_base_64(submodel_id)
         url = f"{self.base_url}/submodels/{decoded_submodel_id}"
 
         try:
-            response = self._session.patch(url, headers=HEADERS, json=sm_dict, timeout=self.time_out)
+            response = self._session.patch(url, headers=HEADERS, json=submodel_data, timeout=self.time_out)
             logger.debug(f"Call REST API url '{response.url}'")
 
             if response.status_code != STATUS_CODE_204:
@@ -542,6 +467,7 @@ class AasxServerInterface(BaseModel):
 
 def create_client_by_url(
     base_url: str,
+    api_base_path: str = "",
     username: str = "",
     password: str = "",
     http_proxy: str = "",
@@ -549,9 +475,8 @@ def create_client_by_url(
     time_out: int = 200,
     connection_time_out: int = 60,
     ssl_verify: str = True,  # noqa: FBT002
-    namespace: str = "",
-) -> AasxServerInterface | None:
-    """Create a BaSyx server interface client from the given parameters.
+) -> AasHttpClient | None:
+    """Create a AAS HTTP client from the given parameters.
 
     :param base_url: base URL of the BaSyx server, e.g. "http://basyx_python_server:80/"_
     :param username: username for the BaSyx server interface client, defaults to ""_
@@ -561,28 +486,28 @@ def create_client_by_url(
     :param time_out: timeout for the API calls, defaults to 200
     :param connection_time_out: timeout for the connection to the API, defaults to 60
     :param ssl_verify: whether to verify SSL certificates, defaults to True
-    :return: An instance of AasxServerInterface initialized with the provided parameters.
+    :return: An instance of AasHttpClient initialized with the provided parameters.
     """
     logger.info(f"Create BaSyx server interface client from URL '{base_url}'")
     config_dict: dict[str, str] = {}
     config_dict["base_url"] = base_url
+    config_dict["api_base_path"] = api_base_path
     config_dict["username"] = username
     config_dict["http_proxy"] = http_proxy
     config_dict["https_proxy"] = https_proxy
     config_dict["time_out"] = time_out
     config_dict["connection_time_out"] = connection_time_out
     config_dict["ssl_verify"] = ssl_verify
-    config_dict["namespace"] = namespace
     config_string = json.dumps(config_dict, indent=4)
     return _create_client(config_string, password)
 
 
-def create_client_by_config(config_file: Path, password: str = "") -> AasxServerInterface | None:
-    """Create a BaSyx server interface client from the given parameters.
+def create_client_by_config(config_file: Path, password: str = "") -> AasHttpClient | None:
+    """Create a AAS HTTP client from the given parameters.
 
     :param config_file: Path to the configuration file containing the BaSyx server connection settings.
     :param password: password for the BaSyx server interface client, defaults to ""_
-    :return: An instance of AasxServerInterface initialized with the provided parameters.
+    :return: An instance of HttpClient initialized with the provided parameters.
     """
     logger.info(f"Create BaSyx server interface client from config file '{config_file}'")
     if not config_file.exists():
@@ -595,15 +520,16 @@ def create_client_by_config(config_file: Path, password: str = "") -> AasxServer
     return _create_client(config_string, password)
 
 
-def _create_client(config_string: str, password) -> AasxServerInterface | None:
+def _create_client(config_string: str, password) -> AasHttpClient | None:
     try:
-        connection_settings = AasxServerInterface.model_validate_json(config_string)
-        client = AasxServerInterface(**connection_settings.model_dump())
+        connection_settings = AasHttpClient.model_validate_json(config_string)
+        client = AasHttpClient(**connection_settings.model_dump())
     except ValidationError as ve:
         raise ValidationError(f"Invalid BaSyx server connection file: {ve}") from ve
 
     logger.info(
         f"Using server configuration: '{client.base_url}' | "
+        f"API base path: '{client.api_base_path}' | "
         f"timeout: '{client.time_out}' | "
         f"username: '{client.username}' | "
         f"https_proxy: '{client.https_proxy}' | "
@@ -621,7 +547,7 @@ def _create_client(config_string: str, password) -> AasxServerInterface | None:
     return client
 
 
-def _connect_to_api(client: AasxServerInterface) -> bool:
+def _connect_to_api(client: AasHttpClient) -> bool:
     start_time = time.time()
     logger.debug(f"Try to connect to REST API '{client.base_url}' for {client.connection_time_out} seconds")
     counter: int = 0

aas_http_client/demo/demo_process.py

@@ -0,0 +1,74 @@
+import logging
+import aas_http_client.utilities.model_builder as model_builder
+from aas_http_client.client import create_client_by_config, AasHttpClient
+from aas_http_client.wrapper.sdk_wrapper import SdkWrapper, create_wrapper_by_config
+from pathlib import Path
+import json
+import basyx.aas.adapter.json
+from basyx.aas.model import AssetAdministrationShell
+
+logger = logging.getLogger(__name__)
+
+def start():
+    """Start the demo process."""
+
+    aas_1 = _create_shell()
+    aas_2 = _create_shell()
+    
+    client = _create_client()
+    sdk_wrapper = _create_sdk_wrapper()
+
+    exist_shells = sdk_wrapper.get_shells()
+    
+    for shell in exist_shells:
+        logger.warning(f"Delete shell '{shell.id}'")
+        sdk_wrapper.delete_shells_by_id(shell.id)
+
+    sdk_wrapper.post_shells(aas_1)
+
+
+    aas_dict_string = json.dumps(aas_2, cls=basyx.aas.adapter.json.AASToJsonEncoder)
+    aas_dict = json.loads(aas_dict_string)
+    client.post_shells(aas_dict)
+    
+    shells = client.get_shells()
+
+    logger.info(f"Client created successfully. {shells}")
+
+def _create_shell() -> AssetAdministrationShell:
+    # create an AAS
+    aas_short_id: str = model_builder.create_unique_short_id("poc_aas")
+    aas = model_builder.create_base_ass(aas_short_id)
+
+    # create a Submodel
+    sm_short_id: str = model_builder.create_unique_short_id("poc_sm")
+    submodel = model_builder.create_base_submodel(sm_short_id)
+
+    # add Submodel to AAS
+    model_builder.add_submodel_to_aas(aas, submodel)
+    
+    return aas
+
+def _create_client() -> AasHttpClient:
+    """Create client for java servers."""
+
+    try:
+        file = Path("./demo/server_config.json")
+        client = create_client_by_config(file, password="")
+    except Exception as e:
+        logger.error(f"Failed to create client for {file}: {e}")
+        pass
+
+    return client
+        
+def _create_sdk_wrapper() -> SdkWrapper:
+    """Create client for java servers."""
+
+    try:
+        file = Path("./demo/server_config.json")
+        client = create_wrapper_by_config(file, password="")
+    except Exception as e:
+        logger.error(f"Failed to create client for {file}: {e}")
+        pass
+
+    return client