aas-http-client 0.1.3__tar.gz → 0.1.5__tar.gz

{aas_http_client-0.1.3 → aas_http_client-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aas-http-client
-Version: 0.1.3
+Version: 0.1.5
 Summary: Generic HTTP client for communicating with various types of AAS servers
 Author-email: Daniel Klein <daniel.klein@em.ag>
 License: MIT License

aas_http_client-0.1.5/aas_http_client/__init__.py

@@ -0,0 +1,20 @@
+from datetime import datetime
+import importlib.metadata
+
+__copyright__ = f"Copyright (C) {datetime.now().year} :em engineering methods AG. All rights reserved."
+__author__ = "Daniel Klein"
+
+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, AasHttpClient
+
+check_for_update()
+
+__all__ = ["create_client_by_config", "create_client_by_url", "AasHttpClient"]

aas_http_client-0.1.5/aas_http_client/client.py

@@ -0,0 +1,567 @@
+"""Client for HTTP API communication with AAS server."""
+import json
+import logging
+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 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
+from requests.models import Response
+
+logger = logging.getLogger(__name__)
+
+STATUS_CODE_200 = 200
+STATUS_CODE_201 = 201
+STATUS_CODE_202 = 202
+STATUS_CODE_204 = 204
+HEADERS = {"Content-Type": "application/json"}
+
+
+def log_response_errors(response: Response):
+    """Create error messages from the response and log them.
+
+    :param response: response
+    """
+    result_error_messages: list[str] = []
+
+    try:
+        response_content_dict: dict = json.loads(response.content)
+
+        if "detail" in response_content_dict:
+            detail: dict = response_content_dict.get("detail", {})
+            if "error" in detail:
+                error: str = detail.get("error", "")
+                result_error_messages.append(f"{error}")
+            else:
+                result_error_messages.append(f"{detail}")
+
+        elif "messages" in response_content_dict or "Messages" in response_content_dict:
+            messages: list = response_content_dict.get("messages", [])
+
+            if not messages:
+                messages = response_content_dict.get("Messages", [])
+
+            for message in messages:
+                if isinstance(message, dict) and "message" in message:
+                    result_error_messages.append(message["message"])
+                else:
+                    result_error_messages.append(str(message))
+        elif "error" in response_content_dict:
+            result_error_messages.append(response_content_dict.get("error", ""))
+
+    except json.JSONDecodeError:
+        result_error_messages.append(response.content)
+
+    logger.error(f"Status code: {response.status_code}")
+    for result_error_message in result_error_messages:
+        logger.error(result_error_message)
+
+
+class AasHttpClient(BaseModel):
+    """Represents a AasHttpClient to communicate with a REST API."""
+
+    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
+    http_proxy: str | None = None
+    time_out: int = 200
+    connection_time_out: int = 100
+    ssl_verify: bool = True
+    _session: Session = PrivateAttr(default=None)
+
+    def initialize(self, password: str):
+        """Initialize the AasHttpClient with the given URL, username and password.
+
+        :param password: password
+        """
+        self._password = password
+
+        if self.base_url.endswith("/"):
+            self.base_url = self.base_url[:-1]
+
+        self._session = requests.Session()
+        self._session.auth = HTTPBasicAuth(self.username, self._password)
+        self._session.verify = self.ssl_verify
+
+        if self.https_proxy:
+            self._session.proxies.update({"https": self.https_proxy})
+        if self.http_proxy:
+            self._session.proxies.update({"http": self.http_proxy})
+
+    def get_root(self) -> dict | None:
+        """Get the root of the REST API.
+
+        :return: root data as a dictionary or None if an error occurred
+        """
+        url = f"{self.base_url}/shells"
+
+        try:
+            response = self._session.get(url, headers=HEADERS, timeout=2)
+            logger.debug(f"Call REST API url '{response.url}'")
+
+            if response.status_code != STATUS_CODE_200:
+                log_response_errors(response)
+                return None
+
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Error call REST API: {e}")
+            return None
+
+        content = response.content.decode("utf-8")
+        return json.loads(content)
+
+    def post_shells(self, aas_data: dict) -> dict | None:
+        """Post an Asset Administration Shell (AAS) to the REST API.
+
+        :param aas_data: Json data of the Asset Administration Shell to post
+        :return: Response data as a dictionary or None if an error occurred
+        """
+        url = f"{self.base_url}/shells"
+        logger.debug(f"Call REST API url '{url}'")
+
+        try:
+            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):
+                log_response_errors(response)
+                return None
+
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Error call REST API: {e}")
+            return None
+
+        content = response.content.decode("utf-8")
+        return json.loads(content)
+
+    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_data: Json data of the Asset Administration Shell data to update
+        :return: True if the update was successful, False otherwise
+        """
+        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_data, timeout=self.time_out)
+            logger.debug(f"Call REST API url '{response.url}'")
+
+            if response.status_code is not STATUS_CODE_204:
+                log_response_errors(response)
+                return False
+
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Error call REST API: {e}")
+            return False
+
+        return True
+
+    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_data: Json data to the Submodel to update
+        :return: True if the update was successful, False otherwise
+        """
+        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=submodel_data, timeout=self.time_out)
+            logger.debug(f"Call REST API url '{response.url}'")
+
+            if response.status_code != STATUS_CODE_204:
+                log_response_errors(response)
+                return False
+
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Error call REST API: {e}")
+            return False
+
+        return True
+
+    def get_shells(self) -> list[dict] | None:
+        """Get all Asset Administration Shells (AAS) from the REST API.
+
+        :return: List of paginated Asset Administration Shells data or None if an error occurred
+        """
+        url = f"{self.base_url}/shells"
+
+        try:
+            response = self._session.get(url, headers=HEADERS, timeout=self.time_out)
+            logger.debug(f"Call REST API url '{response.url}'")
+
+            if response.status_code != STATUS_CODE_200:
+                log_response_errors(response)
+                return None
+
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Error call REST API: {e}")
+            return None
+
+        content = response.content.decode("utf-8")
+        return json.loads(content)
+
+    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: 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}"
+
+        try:
+            response = self._session.get(url, headers=HEADERS, timeout=self.time_out)
+            logger.debug(f"Call REST API url '{response.url}'")
+
+            if response.status_code != STATUS_CODE_200:
+                log_response_errors(response)
+                return None
+
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Error call REST API: {e}")
+            return None
+
+        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)
+        url = f"{self.base_url}/shells/{decoded_aas_id}/$reference"
+
+        try:
+            response = self._session.get(url, headers=HEADERS, timeout=self.time_out)
+            logger.debug(f"Call REST API url '{response.url}'")
+
+            if response.status_code != STATUS_CODE_200:
+                log_response_errors(response)
+                return None
+
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Error call REST API: {e}")
+            return None
+
+        ref_dict_string = response.content.decode("utf-8")
+        return json.loads(ref_dict_string, cls=basyx.aas.adapter.json.AASFromJsonDecoder)
+
+    def get_shells_submodels(self, aas_id: str, submodel_id: str) -> Submodel | None:
+        """Get a submodel by its ID for a specific Asset Administration Shell (AAS).
+
+        :param aas_id: ID of the AAS to retrieve the submodel from
+        :param submodel_id: ID of the submodel to retrieve
+        :return: Submodel object or None if an error occurred
+        """
+        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.get(url, headers=HEADERS, timeout=self.time_out)
+            logger.debug(f"Call REST API url '{response.url}'")
+
+            if response.status_code != STATUS_CODE_200:
+                log_response_errors(response)
+                return None
+
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Error call REST API: {e}")
+            return None
+
+        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.
+
+        :param aas_id: ID of the AAS to retrieve
+        :return: True if the deletion was successful, False otherwise
+        """
+        decoded_aas_id: str = decode_base_64(aas_id)
+        url = f"{self.base_url}/shells/{decoded_aas_id}"
+
+        try:
+            response = self._session.delete(url, headers=HEADERS, timeout=self.time_out)
+            logger.debug(f"Call REST API url '{response.url}'")
+
+            if response.status_code != STATUS_CODE_204:
+                log_response_errors(response)
+                return False
+
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Error call REST API: {e}")
+            return False
+
+        return True
+
+    def post_submodels(self, submodel_data: dict) -> bool:
+        """Post a submodel to the REST API.
+
+        :param submodel_data: Json data of the Submodel to post
+        :return: Response data as a dictionary or None if an error occurred
+        """
+        url = f"{self.base_url}/submodels"
+
+        try:
+            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):
+                log_response_errors(response)
+                return False
+
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Error call REST API: {e}")
+            return False
+
+        return True
+
+    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_data: Json data of the Submodel to update
+        :return: True if the update was successful, False otherwise
+        """
+        decoded_identifier: str = decode_base_64(identifier)
+        url = f"{self.base_url}/submodels/{decoded_identifier}"
+
+        try:
+            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:
+                log_response_errors(response)
+                return False
+
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Error call REST API: {e}")
+            return False
+
+        return True
+
+    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
+        :return: Submodel object or None if an error occurred
+        """
+        decoded_submodel_id: str = decode_base_64(submodel_id)
+        url = f"{self.base_url}/submodels/{decoded_submodel_id}"
+
+        try:
+            response = self._session.get(url, headers=HEADERS, timeout=self.time_out)
+            logger.debug(f"Call REST API url '{response.url}'")
+
+            if response.status_code != STATUS_CODE_200:
+                log_response_errors(response)
+                return None
+
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Error call REST API: {e}")
+            return None
+
+        content = response.content.decode("utf-8")
+        return json.loads(content)
+
+    def get_submodels(self) -> list[dict] | None:
+        """Get all submodels from the REST API.
+
+        :return: Submodel objects or None if an error occurred
+        """
+        url = f"{self.base_url}/submodels"
+
+        try:
+            response = self._session.get(url, headers=HEADERS, timeout=self.time_out)
+            logger.debug(f"Call REST API url '{response.url}'")
+
+            if response.status_code != STATUS_CODE_200:
+                log_response_errors(response)
+                return None
+
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Error call REST API: {e}")
+            return None
+
+        content = response.content.decode("utf-8")
+        return json.loads(content)
+
+    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
+        :return: Submodel object or None if an error occurred
+        """
+        decoded_submodel_id: str = decode_base_64(submodel_id)
+        url = f"{self.base_url}/submodels/{decoded_submodel_id}"
+
+        try:
+            response = self._session.get(url, headers=HEADERS, timeout=self.time_out)
+            logger.debug(f"Call REST API url '{response.url}'")
+
+            if response.status_code != STATUS_CODE_200:
+                log_response_errors(response)
+                return None
+
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Error call REST API: {e}")
+            return None
+
+        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=submodel_data, timeout=self.time_out)
+            logger.debug(f"Call REST API url '{response.url}'")
+
+            if response.status_code != STATUS_CODE_204:
+                log_response_errors(response)
+                return False
+
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Error call REST API: {e}")
+            return False
+
+        return True
+
+    def delete_submodels_by_id(self, submodel_id: str) -> bool:
+        """Delete a submodel by its ID from the REST API.
+
+        :param submodel_id: ID of the submodel to delete
+        :return: True if the deletion was successful, False otherwise
+        """
+        decoded_submodel_id: str = decode_base_64(submodel_id)
+        url = f"{self.base_url}/submodels/{decoded_submodel_id}"
+
+        try:
+            response = self._session.delete(url, headers=HEADERS, timeout=self.time_out)
+            logger.debug(f"Call REST API url '{response.url}'")
+
+            if response.status_code != STATUS_CODE_204:
+                log_response_errors(response)
+                return False
+
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Error call REST API: {e}")
+            return False
+
+        return True
+
+
+def create_client_by_url(
+    base_url: str,
+    api_base_path: str = "",
+    username: str = "",
+    password: str = "",
+    http_proxy: str = "",
+    https_proxy: str = "",
+    time_out: int = 200,
+    connection_time_out: int = 60,
+    ssl_verify: str = True,  # noqa: FBT002
+) -> 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 ""_
+    :param password: password for the BaSyx server interface client, defaults to ""_
+    :param http_proxy: http proxy URL, defaults to ""_
+    :param https_proxy: https proxy URL, defaults to ""_
+    :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 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_string = json.dumps(config_dict, indent=4)
+    return _create_client(config_string, password)
+
+
+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 HttpClient initialized with the provided parameters.
+    """
+    logger.info(f"Create BaSyx server interface client from config file '{config_file}'")
+    if not config_file.exists():
+        config_string = "{}"
+        logger.warning(f"Server config file '{config_file}' not found. Using default config.")
+    else:
+        config_string = config_file.read_text(encoding="utf-8")
+        logger.debug(f"Server config  file '{config_file}' found.")
+
+    return _create_client(config_string, password)
+
+
+def _create_client(config_string: str, password) -> AasHttpClient | None:
+    try:
+        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}' | "
+        f"http_proxy: '{client.http_proxy}' | "
+        f"connection_timeout: '{client.connection_time_out}'"
+    )
+    client.initialize(password)
+
+    # test the connection to the REST API
+    connected = _connect_to_api(client)
+
+    if not connected:
+        return None
+
+    return client
+
+
+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
+    while True:
+        try:
+            root = client.get_root()
+            if root:
+                logger.info(f"Connected to REST API at '{client.base_url}' successfully.")
+                return True
+        except requests.exceptions.ConnectionError:
+            pass
+        if time.time() - start_time > client.connection_time_out:
+            raise TimeoutError(f"Connection to REST API timed out after {client.connection_time_out} seconds.")
+
+        counter += 1
+        logger.warning(f"Retrying connection (attempt: {counter})")
+        time.sleep(1)

aas_http_client-0.1.5/aas_http_client/core/version_check.py

@@ -0,0 +1,17 @@
+import requests
+import importlib.metadata
+
+def check_for_update(package_name="aas-http-client"):
+    try:
+        current_version = importlib.metadata.version(package_name)
+        pypi_url = f"https://pypi.org/pypi/{package_name}/json"
+        latest_version = requests.get(pypi_url, timeout=3).json()["info"]["version"]
+
+        if current_version != latest_version:
+            print(
+                f"⚠️  A new version for package '{package_name}' is available: "
+                f"{latest_version} (currently installed: {current_version}). "
+                f"Use the following command to update the package: pip install --upgrade {package_name}"
+            )
+    except Exception:
+        pass

aas_http_client-0.1.5/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