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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aas-http-client
-Version: 0.1.4
+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.4 → aas_http_client-0.1.5}/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-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/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

aas_http_client-0.1.5/aas_http_client/demo/logging_handler.py

@@ -0,0 +1,177 @@
+"""
+Logging handler.
+
+This module contains all methods and functions to handle the logging.
+"""
+
+import json
+import logging
+import queue
+import sys
+import uuid
+from datetime import UTC, datetime
+from logging.handlers import QueueHandler
+from pathlib import Path
+from typing import ClassVar
+
+from pythonjsonlogger import jsonlogger
+
+LOG_FOLDER: str = "./_log"
+LOG_FILE_SUFFIX: str = "_log.json"
+
+
+class ColorCodes:
+    """Define the color codes for the console output."""
+
+    grey = "\x1b[38;21m"
+    green = "\x1b[1;32m"
+    yellow = "\x1b[33;21m"
+    red = "\x1b[31;21m"
+    bold_red = "\x1b[31;1m"
+    blue = "\x1b[1;34m"
+    light_blue = "\x1b[1;36m"
+    purple = "\x1b[1;35m"
+    reset = "\x1b[0m"
+
+
+class CustomConsoleFormatter(logging.Formatter):
+    """Custom console formatter for logging with colored level.
+
+    :param logging: formatter
+    """
+
+    FORMATS: ClassVar[dict] = {
+        logging.DEBUG: ColorCodes.blue + "%(levelname)s" + ColorCodes.reset + ":   %(message)s (%(filename)s:%(lineno)d)",
+        logging.INFO: ColorCodes.green + "%(levelname)s" + ColorCodes.reset + ":   %(message)s",
+        logging.WARNING: ColorCodes.yellow + "%(levelname)s" + ColorCodes.reset + ":   %(message)s",
+        logging.ERROR: ColorCodes.red + "%(levelname)s" + ColorCodes.reset + ":    %(message)s (%(filename)s:%(lineno)d)",
+        logging.CRITICAL: ColorCodes.bold_red + "%(levelname)s:  %(message)s (%(filename)s:%(lineno)d)" + ColorCodes.reset,
+    }
+
+    def format(self, record) -> str:
+        """Format the log record.
+
+        :param record: record to format
+        :return: formatted record
+        """
+        log_fmt = self.FORMATS.get(record.levelno)
+        formatter = logging.Formatter(log_fmt)
+        return formatter.format(record)
+
+
+def _handle_file_rotation(log_file_path: Path, max_file_count: int = 5) -> None:
+    log_folder: Path = log_file_path.resolve()
+
+    if max_file_count < 1:
+        return
+
+    if not log_folder.exists():
+        return
+
+    existing_log_files: list[Path] = [file for file in log_folder.iterdir() if file.name.endswith(LOG_FILE_SUFFIX)]
+
+    if len(existing_log_files) < max_file_count:
+        return
+
+    existing_log_files.sort(key=lambda x: x.stat().st_ctime)
+
+    files_to_delete: int = len(existing_log_files) - (max_file_count - 1)
+
+    for file in existing_log_files[:files_to_delete]:
+        file.unlink()
+
+    return
+
+
+def initialize_logging(console_level=logging.INFO) -> Path:
+    """Initialize the standard logging.
+
+    :param debug_mode_status: Status of the debug mode
+    :param log_file_name: Name of the (path and extension)
+    """
+    log_path = Path(LOG_FOLDER).resolve()
+    log_path.mkdir(parents=True, exist_ok=True)
+
+    log_file_path = log_path / "api.log"
+
+    log_file_format = "%(asctime)s %(levelname)s: %(message)s   (%(filename)s:%(lineno)d)"
+    logging.basicConfig(
+        filename=log_file_path,
+        level=logging.DEBUG,
+        format=log_file_format,
+        filemode="w",
+    )
+
+    # set console logging
+    console_handler = logging.StreamHandler()
+    console_handler.setLevel(console_level)
+    console_handler.setFormatter(CustomConsoleFormatter())
+    logging.getLogger("").addHandler(console_handler)
+
+    # set queue logging
+    log_queue: queue.Queue = queue.Queue(-1)  # Use default max size
+    queue_handler = QueueHandler(log_queue)
+    logging.getLogger("").addHandler(queue_handler)
+
+    logger = logging.getLogger(__name__)
+    script_path = Path(sys.argv[0])
+    python_version = sys.version.replace("\n", "")
+
+    print("")
+    logger.info(f"Run script '{script_path.name.replace('.py', '')}'")
+    logger.info(f"Script executed by Python v{python_version}")
+    logger.info("Logging initialized")
+
+    return log_file_path.resolve()
+
+
+def read_log_file_as_list(log_file_path: Path) -> list[dict]:
+    """Read the log file as a list of dictionaries (Json conform).
+
+    :param log_file_path: Path to the log file
+    :return: list of dictionaries (Json conform)
+    """
+    with Path.open(log_file_path, "r", encoding="utf-8") as f:
+        return [json.loads(line) for line in f if line.strip()]
+
+
+def set_log_file(
+    max_log_files: int = 10,
+) -> Path:
+    """Set the log file.
+
+    :param max_log_files: max number of log files in folder, defaults to 5
+    :return: log file path
+    """
+    logger = logging.getLogger()  # Get the root logger
+
+    # Remove all existing file handlers
+    for handler in logger.handlers[:]:
+        if isinstance(handler, logging.FileHandler):
+            logger.removeHandler(handler)
+            handler.close()
+
+    now = datetime.now(tz=UTC)
+    time_string = now.strftime("%Y-%m-%d_%H-%M-%S")
+
+    # handle log file and folder
+    log_path: Path = Path(LOG_FOLDER).resolve()
+    log_path = Path(LOG_FOLDER, "runtime").resolve()
+
+    log_path.mkdir(parents=True, exist_ok=True)
+    log_file_name = f"{uuid.uuid4().hex}{LOG_FILE_SUFFIX}"
+    log_file_path = log_path / f"{time_string}_{log_file_name}"
+
+    _handle_file_rotation(log_path, max_log_files)
+
+    # Add a new file handler with the new log file path
+    json_formatter = jsonlogger.JsonFormatter("%(asctime)s %(levelname)s %(name)s %(message)s %(filename)s %(lineno)d")
+    json_file_handler = logging.FileHandler(log_file_path, mode="w")
+    json_file_handler.setFormatter(json_formatter)
+    json_file_handler.setLevel(logging.DEBUG)
+    logger.addHandler(json_file_handler)
+
+    logging.info(f"Maximum log file number is: {max_log_files}")  # noqa: LOG015
+    logging.info(f"Write log file to: '{log_file_path}'")  # noqa: LOG015
+
+    return log_file_path.resolve()

aas_http_client-0.1.5/aas_http_client/utilities/model_builder.py

@@ -0,0 +1,114 @@
+"""Model builder module.
+
+Provides some helper methods for easier work with basyx sdk data model
+"""
+
+import uuid
+
+from basyx.aas.model import (
+    AssetAdministrationShell,
+    AssetInformation,
+    AssetKind,
+    Key,
+    ModelReference,
+    MultiLanguageTextType,
+    Submodel,
+)
+
+
+def create_unique_short_id(id_short: str) -> str:
+    """Generate a unique identifier string by appending a UUID to the provided ID short.
+
+    :param id_short: provided ID short
+    :return: unique identifier
+    """
+    return f"{id_short}_{str(uuid.uuid4()).replace('-', '_')}"
+
+
+def create_base_submodel(id_short: str, namespace: str = "basyx_python_aas_server", display_name: str = "", description: str = "") -> Submodel:
+    """Create a basic Submodel.
+
+    :param id_short: ID short of the Submodel
+    :param namespace: namespace of the Submodel , defaults to "basyx_python_aas_server"
+    :param display_name: display name of the Submodel, defaults to ""
+    :param description: description of the Submodel, defaults to ""
+    :return: Submodel instance
+    """
+    identifier = f"{namespace}/{id_short}"
+    sm = Submodel(identifier)
+    sm.id_short = id_short
+
+    if not description:
+        description = f"This is the submodel with ID short '{id_short}'"
+
+    description_text = {"en": f"{description}"}
+    sm.description = MultiLanguageTextType(description_text)
+
+    if not display_name:
+        display_name = "POC AAS"
+
+    display_name_text = {"en": f"{display_name}"}
+    sm.display_name = MultiLanguageTextType(display_name_text)
+
+    return sm
+
+
+def create_base_ass(
+    id_short: str, namespace: str = "basyx_python_aas_server", display_name: str = "", description: str = ""
+) -> AssetAdministrationShell:
+    """Create a basic AAS.
+
+    :param id_short: ID short of the AAS
+    :param namespace: namespace of the AAS, defaults to "basyx_python_aas_server"
+    :param display_name: display name of the AAS, defaults to ""
+    :param description: description of the AAS, defaults to ""
+    :return: AssetAdministrationShell instance
+    """
+    asset_info = create_base_asset_information(id_short, namespace)
+
+    aas = AssetAdministrationShell(id_=asset_info.global_asset_id, asset_information=asset_info)
+    aas.id_short = id_short
+
+    if not description:
+        description = f"This is the asset administration shell with ID short '{id_short}'"
+
+    description_text = {"en": f"{description}"}
+    aas.description = MultiLanguageTextType(description_text)
+
+    if not display_name:
+        display_name = "POC AAS"
+
+    display_name_text = {"en": f"{display_name}"}
+    aas.display_name = MultiLanguageTextType(display_name_text)
+
+    return aas
+
+
+def add_submodel_to_aas(aas: AssetAdministrationShell, submodel: Submodel) -> None:
+    """Add a given Submodel correctly to a provided AssetAdministrationShell.
+
+    :param aas: provided AssetAdministrationShell to which the Submodel should be added
+    :param submodel: given Submodel to add
+    """
+    # aas.submodel.add(submodel)
+    aas.submodel.add(ModelReference.from_referable(submodel))
+
+
+def create_base_asset_information(id_short: str, namespace: str = "basyx_python_aas_server") -> AssetInformation:
+    """Return a basic AssetInformation instance.
+
+    :param id_short: short ID of the AssetInformation
+    :param namespace: namespace of the AssetInformation, defaults to "basyx_python_aas_server"
+    :return: AssetInformation instance
+    """
+    identifier = f"{namespace}/{id_short}"
+    return AssetInformation(AssetKind.INSTANCE, identifier)
+
+
+def create_reference(id: str) -> ModelReference:
+    """Create a ModelReference.
+
+    :param id: ID of the Submodel to reference
+    :return: ModelReference instance
+    """
+    return ModelReference.from_referable(Submodel(id))

aas_http_client-0.1.5/aas_http_client/wrapper/sdk_wrapper.py

@@ -0,0 +1,272 @@
+"""BaSyx Server interface for REST API communication."""
+
+import json
+import logging
+from pathlib import Path
+
+import basyx.aas.adapter.json
+
+from basyx.aas.model import AssetAdministrationShell, Reference, Submodel
+from aas_http_client.client import AasHttpClient, _create_client
+logger = logging.getLogger(__name__)
+
+class SdkWrapper():
+    """Represents a SdkWrapper to communicate with a REST API."""
+    _client: AasHttpClient = None
+
+    def post_shells(self, aas: AssetAdministrationShell) -> dict | None:
+        """Post an Asset Administration Shell (AAS) to the REST API.
+
+        :param aas: Asset Administration Shell to post
+        :return: Response data as a dictionary or None if an error occurred
+        """
+        aas_data_string = json.dumps(aas, cls=basyx.aas.adapter.json.AASToJsonEncoder)
+        aas_data = json.loads(aas_data_string)
+
+        return self._client.post_shells(aas_data)
+
+    def put_shells(self, identifier: str, aas: AssetAdministrationShell) -> 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
+        :return: True if the update was successful, False otherwise
+        """
+        aas_data_string = json.dumps(aas, cls=basyx.aas.adapter.json.AASToJsonEncoder)
+        aas_data = json.loads(aas_data_string)
+
+        return self._client.put_shells(identifier, aas_data)
+
+    def put_shells_submodels(self, aas_id: str, submodel_id: str, submodel: Submodel) -> 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
+        :return: True if the update was successful, False otherwise
+        """
+        sm_data_string = json.dumps(submodel, cls=basyx.aas.adapter.json.AASToJsonEncoder)
+        sm_data = json.loads(sm_data_string)
+
+        return self._client.put_shells_submodels(aas_id, submodel_id, sm_data)
+
+    def get_shells(self) -> list[AssetAdministrationShell] | None:
+        """Get all Asset Administration Shells (AAS) from the REST API.
+
+        :return: AAS objects or None if an error occurred
+        """
+        content: dict = self._client.get_shells()
+        
+        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)
+
+        return aas_list
+
+    def get_shells_by_id(self, aas_id: str) -> AssetAdministrationShell | 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
+        """
+        content: dict = self._client.get_shells_by_id(aas_id)
+        return json.load(content, cls=basyx.aas.adapter.json.AASFromJsonDecoder)
+
+    def get_shells_reference_by_id(self, aas_id: str) -> Reference | None:
+        content: dict = self._client.get_shells_reference_by_id(aas_id)
+        return json.load(content, 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
+        """
+        content: dict = self._client.get_shells_by_id(aas_id)
+        return json.load(content, cls=basyx.aas.adapter.json.AASFromJsonDecoder)
+
+    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
+        """
+        return self._client.delete_shells_by_id(aas_id)
+
+    def post_submodels(self, submodel: Submodel) -> bool:
+        """Post a submodel to the REST API.
+
+        :param submodel: submodel data as a dictionary
+        :return: Response data as a dictionary or None if an error occurred
+        """
+        sm_data_string = json.dumps(submodel, cls=basyx.aas.adapter.json.AASToJsonEncoder)
+        sm_data = json.loads(sm_data_string)
+
+        return self._client.post_submodels(sm_data)
+
+    def put_submodels(self, identifier: str, submodel: Submodel) -> 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
+        :return: True if the update was successful, False otherwise
+        """
+        sm_data_string = json.dumps(submodel, cls=basyx.aas.adapter.json.AASToJsonEncoder)
+        sm_data = json.loads(sm_data_string)
+
+        return self._client.put_submodels(identifier, sm_data)
+
+    def get_submodel_by_id(self, submodel_id: str) -> Submodel | 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
+        """
+        content = self._client.get_submodel_by_id(submodel_id)
+        
+        if not content:
+            logger.warning(f"No submodel found with ID '{submodel_id}' in the REST API.")
+            return None
+
+        if not isinstance(content, dict):
+            logger.error(f"Invalid submodel data: {content}")
+            return None
+        
+        return json.loads(content, cls=basyx.aas.adapter.json.AASFromJsonDecoder)
+
+    def get_submodels(self) -> list[Submodel] | None:
+        """Get all submodels from the REST API.
+
+        :return: Submodel objects or None if an error occurred
+        """
+        content: list = self._client.get_submodels()
+
+        if not content:
+            logger.warning("No submodels found in the REST API.")
+            return []
+
+        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:
+        """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
+        """
+        content = self._client.get_submodels_by_id(submodel_id)
+
+        if not content:
+            logger.warning(f"No submodel found with ID '{submodel_id}' in the REST API.")
+            return None
+        
+        if not isinstance(content, dict):
+            logger.error(f"Invalid submodel data: {content}")
+            return None
+#
+        return json.loads(content, 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)
+
+        return self._client.patch_submodel_by_id(submodel_id, sm_dict)
+
+    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
+        """
+        return self._client.delete_submodels_by_id(submodel_id)
+
+def create_wrapper_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
+) -> SdkWrapper | None:
+    """Create a BaSyx server interface 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 HttpClient 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)
+    
+    wrapper = SdkWrapper()
+    wrapper._client = _create_client(config_string, password)                           
+    return wrapper
+    
+
+
+def create_wrapper_by_config(config_file: Path, password: str = "") -> AasHttpClient | None:
+    """Create a BaSyx server interface 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.")
+
+    wrapper = SdkWrapper()
+    wrapper._client = _create_client(config_string, password)                           
+    return wrapper

{aas_http_client-0.1.4 → aas_http_client-0.1.5}/aas_http_client.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aas-http-client
-Version: 0.1.4
+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.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+LICENSE
+README.md
+pyproject.toml
+aas_http_client/__init__.py
+aas_http_client/client.py
+aas_http_client.egg-info/PKG-INFO
+aas_http_client.egg-info/SOURCES.txt
+aas_http_client.egg-info/dependency_links.txt
+aas_http_client.egg-info/top_level.txt
+aas_http_client/core/encoder.py
+aas_http_client/core/version_check.py
+aas_http_client/demo/demo_process.py
+aas_http_client/demo/logging_handler.py
+aas_http_client/utilities/__init__.py
+aas_http_client/utilities/model_builder.py
+aas_http_client/wrapper/python_sdk_wrapper_tmp.py
+aas_http_client/wrapper/sdk_wrapper.py
+tests/test_client.py

{aas_http_client-0.1.4 → aas_http_client-0.1.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "aas-http-client"
-version = "0.1.4"
+version = "0.1.5"
 description = "Generic HTTP client for communicating with various types of AAS servers"
 readme = "README.md"
 license = { file = "LICENSE" }

aas_http_client-0.1.5/tests/test_client.py

@@ -0,0 +1,21 @@
+import pytest
+from pathlib import Path
+from aas_http_client.client import create_client_by_config, AasHttpClient
+
+@pytest.fixture(scope="module")
+def cloud_client() -> AasHttpClient:
+    try:
+        file = Path("./tests/test_server_config.json").resolve()
+        
+        if not file.exists():
+            raise FileNotFoundError(f"Configuration file {file} does not exist.")
+        
+        client = create_client_by_config(file, password="")
+    except Exception as e:
+        raise RuntimeError("Unable to connect to server.")
+
+    return client
+
+def test_001_connect(cloud_client: AasHttpClient):
+    print("Testing connection to the server...")
+    assert cloud_client is not None

aas_http_client-0.1.4/aas_http_client.egg-info/SOURCES.txt

@@ -1,11 +0,0 @@
-LICENSE
-README.md
-pyproject.toml
-aas_http_client/__init__.py
-aas_http_client/client.py
-aas_http_client.egg-info/PKG-INFO
-aas_http_client.egg-info/SOURCES.txt
-aas_http_client.egg-info/dependency_links.txt
-aas_http_client.egg-info/top_level.txt
-aas_http_client/core/encoder.py
-aas_http_client/core/version_check.py