aas-http-client 0.4.1__tar.gz → 0.4.3__tar.gz

{aas_http_client-0.4.1 → aas_http_client-0.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aas-http-client
-Version: 0.4.1
+Version: 0.4.3
 Summary: Generic python HTTP client for communication with various types of AAS servers
 Author-email: Daniel Klein <daniel.klein@em.ag>
 License: # :em engineering methods AG Software License

aas_http_client-0.4.3/aas_http_client/classes/auth_classes.py

@@ -0,0 +1,21 @@
+from pydantic import BaseModel, PrivateAttr, ValidationError
+
+
+class BasicAuthConfig(BaseModel):
+    username: str
+
+
+class ServiceProviderAuthConfig(BaseModel):
+    token_url: str
+    client_id: str
+    grant_type: str = "client_credentials"
+    header_name: str = "Authorization"
+    _client_secret: str = PrivateAttr(default=None)
+
+    def set_client_secret(self, client_secret: str) -> None:
+        self._client_secret = client_secret
+
+    def get_client_secret(self) -> str:
+        if self._client_secret is None:
+            raise ValueError("Client secret has not been set.")
+        return self._client_secret

{aas_http_client-0.4.1 → aas_http_client-0.4.3}/aas_http_client/client.py

@@ -4,10 +4,8 @@ import json
 import logging
 import time
 from pathlib import Path
-from typing import Any
 
 import basyx.aas.adapter.json
-import basyx.aas.adapter.json.json_serialization as js
 import requests
 from basyx.aas.model import Reference, Submodel
 from pydantic import BaseModel, PrivateAttr, ValidationError
@@ -15,6 +13,7 @@ from requests import Session
 from requests.auth import HTTPBasicAuth
 from requests.models import Response
 
+from aas_http_client.classes.auth_classes import BasicAuthConfig, ServiceProviderAuthConfig
 from aas_http_client.core.encoder import decode_base_64
 
 logger = logging.getLogger(__name__)
@@ -74,16 +73,22 @@ class AasHttpClient(BaseModel):
     """Represents a AasHttpClient to communicate with a REST API."""
 
     base_url: str = "http://javaaasserver:5060/"
-    username: str | None = None
+    basic_auth: BasicAuthConfig | None = None
+    service_provider_auth: ServiceProviderAuthConfig | None = None
     https_proxy: str | None = None
     http_proxy: str | None = None
     time_out: int = 200
     connection_time_out: int = 100
     ssl_verify: bool = True
     trust_env: bool = True
+    auth_service_provider: str | None = None
     _session: Session = PrivateAttr(default=None)
 
-    def initialize(self, password: str):
+    def initialize(
+        self,
+        basic_auth_password: str,
+        service_provider_auth_client_secret: str,
+    ):
         """Initialize the AasHttpClient with the given URL, username and password.
 
         :param password: password
@@ -92,10 +97,17 @@ class AasHttpClient(BaseModel):
             self.base_url = self.base_url[:-1]
 
         self._session = requests.Session()
-        self._session.auth = HTTPBasicAuth(self.username, password)
+
+        self._session.auth = HTTPBasicAuth("", "")
+        if self.basic_auth:
+            self._session.auth = HTTPBasicAuth(self.basic_auth.username, basic_auth_password)
+
         self._session.verify = self.ssl_verify
         self._session.trust_env = self.trust_env
 
+        if self.service_provider_auth:
+            self.service_provider_auth.set_client_secret(service_provider_auth_client_secret)
+
         if self.https_proxy:
             self._session.proxies.update({"https": self.https_proxy})
         if self.http_proxy:
@@ -108,6 +120,9 @@ class AasHttpClient(BaseModel):
         """
         url = f"{self.base_url}/shells"
 
+        if self.service_provider_auth:
+            self._set_token_by_client_credentials()
+
         try:
             response = self._session.get(url, headers=HEADERS, timeout=10)
             logger.debug(f"Call REST API url '{response.url}'")
@@ -123,6 +138,29 @@ class AasHttpClient(BaseModel):
         content = response.content.decode("utf-8")
         return json.loads(content)
 
+    def _set_token_by_client_credentials(self) -> dict | None:
+        if self.service_provider_auth is None:
+            logger.error("Service provider authentication is not configured.")
+            return None
+
+        if self.service_provider_auth.grant_type == "password":
+            token = get_token_by_password(
+                self.service_provider_auth.token_url,
+                self.service_provider_auth.client_id,
+                self.service_provider_auth.get_client_secret(),
+                self.time_out,
+            )
+        else:
+            token = get_token_by_basic_auth(
+                self.service_provider_auth.token_url,
+                self.service_provider_auth.client_id,
+                self.service_provider_auth.get_client_secret(),
+                self.time_out,
+            )
+
+        if token:
+            self._session.headers.update({self.service_provider_auth.auth_header_name: f"Bearer {token}"})
+
     # region shells
 
     def post_asset_administration_shell(self, aas_data: dict) -> dict | None:
@@ -134,6 +172,9 @@ class AasHttpClient(BaseModel):
         url = f"{self.base_url}/shells"
         logger.debug(f"Call REST API url '{url}'")
 
+        if self.service_provider_auth:
+            self._set_token_by_client_credentials()
+
         try:
             response = self._session.post(url, headers=HEADERS, json=aas_data, timeout=self.time_out)
             logger.debug(f"Call REST API url '{response.url}'")
@@ -159,6 +200,9 @@ class AasHttpClient(BaseModel):
         decoded_identifier: str = decode_base_64(identifier)
         url = f"{self.base_url}/shells/{decoded_identifier}"
 
+        if self.service_provider_auth:
+            self._set_token_by_client_credentials()
+
         try:
             response = self._session.put(url, headers=HEADERS, json=aas_data, timeout=self.time_out)
             logger.debug(f"Call REST API url '{response.url}'")
@@ -184,6 +228,9 @@ class AasHttpClient(BaseModel):
         decoded_submodel_id: str = decode_base_64(submodel_id)
         url = f"{self.base_url}/shells/{decoded_aas_id}/submodels/{decoded_submodel_id}"
 
+        if self.service_provider_auth:
+            self._set_token_by_client_credentials()
+
         try:
             response = self._session.put(url, headers=HEADERS, json=submodel_data, timeout=self.time_out)
             logger.debug(f"Call REST API url '{response.url}'")
@@ -205,6 +252,9 @@ class AasHttpClient(BaseModel):
         """
         url = f"{self.base_url}/shells"
 
+        if self.service_provider_auth:
+            self._set_token_by_client_credentials()
+
         try:
             response = self._session.get(url, headers=HEADERS, timeout=self.time_out)
             logger.debug(f"Call REST API url '{response.url}'")
@@ -229,6 +279,9 @@ class AasHttpClient(BaseModel):
         decoded_aas_id: str = decode_base_64(aas_id)
         url = f"{self.base_url}/shells/{decoded_aas_id}"
 
+        if self.service_provider_auth:
+            self._set_token_by_client_credentials()
+
         try:
             response = self._session.get(url, headers=HEADERS, timeout=self.time_out)
             logger.debug(f"Call REST API url '{response.url}'")
@@ -253,6 +306,9 @@ class AasHttpClient(BaseModel):
         decoded_aas_id: str = decode_base_64(aas_id)
         url = f"{self.base_url}/shells/{decoded_aas_id}/$reference"
 
+        if self.service_provider_auth:
+            self._set_token_by_client_credentials()
+
         try:
             response = self._session.get(url, headers=HEADERS, timeout=self.time_out)
             logger.debug(f"Call REST API url '{response.url}'")
@@ -279,7 +335,9 @@ class AasHttpClient(BaseModel):
         decoded_submodel_id: str = decode_base_64(submodel_id)
 
         url = f"{self.base_url}/shells/{decoded_aas_id}/submodels/{decoded_submodel_id}"
-        # /shells/{aasIdentifier}/submodels/{submodelIdentifier}
+
+        if self.service_provider_auth:
+            self._set_token_by_client_credentials()
 
         try:
             response = self._session.get(url, headers=HEADERS, timeout=self.time_out)
@@ -305,6 +363,9 @@ class AasHttpClient(BaseModel):
         decoded_aas_id: str = decode_base_64(aas_id)
         url = f"{self.base_url}/shells/{decoded_aas_id}"
 
+        if self.service_provider_auth:
+            self._set_token_by_client_credentials()
+
         try:
             response = self._session.delete(url, headers=HEADERS, timeout=self.time_out)
             logger.debug(f"Call REST API url '{response.url}'")
@@ -331,6 +392,9 @@ class AasHttpClient(BaseModel):
         """
         url = f"{self.base_url}/submodels"
 
+        if self.service_provider_auth:
+            self._set_token_by_client_credentials()
+
         try:
             response = self._session.post(url, headers=HEADERS, json=submodel_data, timeout=self.time_out)
             logger.debug(f"Call REST API url '{response.url}'")
@@ -356,6 +420,9 @@ class AasHttpClient(BaseModel):
         decoded_identifier: str = decode_base_64(identifier)
         url = f"{self.base_url}/submodels/{decoded_identifier}"
 
+        if self.service_provider_auth:
+            self._set_token_by_client_credentials()
+
         try:
             response = self._session.put(url, headers=HEADERS, json=submodel_data, timeout=self.time_out)
             logger.debug(f"Call REST API url '{response.url}'")
@@ -377,6 +444,9 @@ class AasHttpClient(BaseModel):
         """
         url = f"{self.base_url}/submodels"
 
+        if self.service_provider_auth:
+            self._set_token_by_client_credentials()
+
         try:
             response = self._session.get(url, headers=HEADERS, timeout=self.time_out)
             logger.debug(f"Call REST API url '{response.url}'")
@@ -401,6 +471,9 @@ class AasHttpClient(BaseModel):
         decoded_submodel_id: str = decode_base_64(submodel_id)
         url = f"{self.base_url}/submodels/{decoded_submodel_id}"
 
+        if self.service_provider_auth:
+            self._set_token_by_client_credentials()
+
         try:
             response = self._session.get(url, headers=HEADERS, timeout=self.time_out)
             logger.debug(f"Call REST API url '{response.url}'")
@@ -425,6 +498,9 @@ class AasHttpClient(BaseModel):
         decoded_submodel_id: str = decode_base_64(submodel_id)
         url = f"{self.base_url}/submodels/{decoded_submodel_id}"
 
+        if self.service_provider_auth:
+            self._set_token_by_client_credentials()
+
         try:
             response = self._session.patch(url, headers=HEADERS, json=submodel_data, timeout=self.time_out)
             logger.debug(f"Call REST API url '{response.url}'")
@@ -448,6 +524,9 @@ class AasHttpClient(BaseModel):
         decoded_submodel_id: str = decode_base_64(submodel_id)
         url = f"{self.base_url}/submodels/{decoded_submodel_id}"
 
+        if self.service_provider_auth:
+            self._set_token_by_client_credentials()
+
         try:
             response = self._session.delete(url, headers=HEADERS, timeout=self.time_out)
             logger.debug(f"Call REST API url '{response.url}'")
@@ -471,6 +550,9 @@ class AasHttpClient(BaseModel):
         decoded_submodel_id: str = decode_base_64(submodel_id)
         url = f"{self.base_url}/submodels/{decoded_submodel_id}/submodel-elements"
 
+        if self.service_provider_auth:
+            self._set_token_by_client_credentials()
+
         try:
             response = self._session.get(url, headers=HEADERS, timeout=self.time_out)
             logger.debug(f"Call REST API url '{response.url}'")
@@ -495,6 +577,38 @@ class AasHttpClient(BaseModel):
         decoded_submodel_id: str = decode_base_64(submodel_id)
         url = f"{self.base_url}/submodels/{decoded_submodel_id}/submodel-elements"
 
+        if self.service_provider_auth:
+            self._set_token_by_client_credentials()
+
+        try:
+            response = self._session.post(url, headers=HEADERS, json=submodel_element_data, timeout=self.time_out)
+            logger.debug(f"Call REST API url '{response.url}'")
+
+            if response.status_code != STATUS_CODE_201:
+                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_submodel_element_by_path_submodel_repo(self, submodel_id: str, submodel_element_path: str, submodel_element_data: dict) -> dict | None:
+        """Creates a new submodel element at a specified path within submodel elements hierarchy.
+
+        :param submodel_id: Encoded ID of the Submodel to create elements for
+        :param submodel_element_path: Path within the Submodel elements hierarchy
+        :param submodel_element_data: Data for the new Submodel element
+        :return: Submodel element data or None if an error occurred
+        """
+        decoded_submodel_id: str = decode_base_64(submodel_id)
+        url = f"{self.base_url}/submodels/{decoded_submodel_id}/submodel-elements/{submodel_element_path}"
+
+        if self.service_provider_auth:
+            self._set_token_by_client_credentials()
+
         try:
             response = self._session.post(url, headers=HEADERS, json=submodel_element_data, timeout=self.time_out)
             logger.debug(f"Call REST API url '{response.url}'")
@@ -521,6 +635,9 @@ class AasHttpClient(BaseModel):
 
         url = f"{self.base_url}/submodels/{decoded_submodel_id}/submodel-elements/{submodel_element_path}"
 
+        if self.service_provider_auth:
+            self._set_token_by_client_credentials()
+
         try:
             response = self._session.get(url, headers=HEADERS, timeout=self.time_out)
             logger.debug(f"Call REST API url '{response.url}'")
@@ -547,6 +664,9 @@ class AasHttpClient(BaseModel):
 
         url = f"{self.base_url}/submodels/{decoded_submodel_id}/submodel-elements/{submodel_element_path}"
 
+        if self.service_provider_auth:
+            self._set_token_by_client_credentials()
+
         try:
             response = self._session.delete(url, headers=HEADERS, timeout=self.time_out)
             logger.debug(f"Call REST API url '{response.url}'")
@@ -573,6 +693,9 @@ class AasHttpClient(BaseModel):
 
         url = f"{self.base_url}/submodels/{decoded_submodel_id}/submodel-elements/{submodel_element_path}/$value"
 
+        if self.service_provider_auth:
+            self._set_token_by_client_credentials()
+
         try:
             response = self._session.patch(url, headers=HEADERS, json=value, timeout=self.time_out)
             logger.debug(f"Call REST API url '{response.url}'")
@@ -593,10 +716,68 @@ class AasHttpClient(BaseModel):
 # region client
 
 
+def get_token_by_basic_auth(endpoint: str, username: str, password: str, timeout=200) -> dict | None:
+    """Get token from a specific authentication service provider by basic authentication.
+
+    :param endpoint: Get token endpoint for the authentication service provider
+    :param username: Username for the authentication service provider
+    :param password: Password for the authentication service provider
+    :param timeout: Timeout for the API calls, defaults to 200
+    :return: Access token or None if an error occurred
+    """
+    data = {"grant_type": "client_credentials"}
+
+    auth = HTTPBasicAuth(username, password)
+
+    try:
+        response = requests.post(endpoint, auth=auth, data=data, timeout=timeout)
+        logger.info(f"Request URL: {response.url}")
+        response.raise_for_status()
+        return response.json().get("access_token")
+    except requests.RequestException as e:
+        logger.error(f"Error getting token: {e}")
+        return None
+
+
+def get_token_by_password(endpoint: str, username: str, password: str, timeout=200) -> dict | None:
+    """Get token from a specific authentication service provider by username and password.
+
+    :param endpoint: Get token endpoint for the authentication service provider
+    :param username: Username for the authentication service provider
+    :param password: Password for the authentication service provider
+    :param timeout: Timeout for the API calls, defaults to 200
+    :return: Access token or None if an error occurred
+    """
+    data = {"grant_type": "password", "username": username, "password": password}
+
+    return _get_token(endpoint, data, timeout)
+
+
+def _get_token(endpoint: str, data: dict[str, str], timeout: int = 200) -> dict | None:
+    """Get token from a specific authentication service provider.
+
+    :param endpoint: Get token endpoint for the authentication service provider
+    :param data: Data for the authentication service provider
+    :param timeout: Timeout for the API calls, defaults to 200
+    :return: Access token or None if an error occurred
+    """
+    try:
+        response = requests.post(endpoint, json=data, timeout=timeout)
+        logger.info(f"Request URL: {response.url}")
+        response.raise_for_status()
+        return response.json().get("access_token")
+    except requests.RequestException as e:
+        logger.error(f"Error getting token: {e}")
+        return None
+
+
 def create_client_by_url(
     base_url: str,
-    username: str = "",
-    password: str = "",
+    basic_auth_username: str = "",
+    basic_auth_password: str = "",
+    service_provider_auth_client_id: str = "",
+    service_provider_auth_client_secret: str = "",
+    service_provider_auth_token_url: str = "",
     http_proxy: str = "",
     https_proxy: str = "",
     time_out: int = 200,
@@ -620,34 +801,45 @@ def create_client_by_url(
     logger.info(f"Create AAS server http client from URL '{base_url}'.")
     config_dict: dict[str, str] = {}
     config_dict["base_url"] = base_url
-    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["trust_env"] = trust_env
-    return create_client_by_dict(config_dict, password)
+    config_dict["basic_auth"] = None
+    config_dict["service_provider_auth"] = None
+
+    if basic_auth_password and basic_auth_username:
+        config_dict["basic_auth"] = {"username": basic_auth_username}
+
+    if service_provider_auth_client_id and service_provider_auth_client_secret and service_provider_auth_token_url:
+        config_dict["service_provider_auth"] = {
+            "client_id": service_provider_auth_client_id,
+            "token_url": service_provider_auth_token_url,
+        }
 
+    return create_client_by_dict(config_dict, basic_auth_password, service_provider_auth_client_secret)
 
-def create_client_by_dict(configuration: dict, password: str = "") -> AasHttpClient | None:
+
+def create_client_by_dict(configuration: dict, basic_auth_password: str = "", service_provider_auth_client_secret: str = "") -> AasHttpClient | None:
     """Create a HTTP client for a AAS server connection from the given configuration.
 
     :param configuration: Dictionary containing the BaSyx server connection settings.
-    :param password: Password for the AAS server, defaults to ""_
+    :param basic_auth_password: Password for the AAS server basic auth, defaults to ""
     :return: An instance of Http client initialized with the provided parameters.
     """
     logger.info("Create AAS server http client from dictionary.")
     config_string = json.dumps(configuration, indent=4)
 
-    return _create_client(config_string, password)
+    return _create_client(config_string, basic_auth_password, service_provider_auth_client_secret)
 
 
-def create_client_by_config(config_file: Path, password: str = "") -> AasHttpClient | None:
+def create_client_by_config(config_file: Path, basic_auth_password: str = "", service_provider_auth_client_secret: str = "") -> AasHttpClient | None:
     """Create a HTTP client for a AAS server connection from a given configuration file.
 
     :param config_file: Path to the configuration file containing the AAS server connection settings.
-    :param password: password for the BaSyx server interface client, defaults to ""_
+    :param basic_auth_password: password for the BaSyx server basic auth, defaults to ""
     :return: An instance of Http client initialized with the provided parameters.
     """
     config_file = config_file.resolve()
@@ -659,24 +851,28 @@ def create_client_by_config(config_file: Path, password: str = "") -> AasHttpCli
         config_string = config_file.read_text(encoding="utf-8")
         logger.debug(f"Configuration  file '{config_file}' found.")
 
-    return _create_client(config_string, password)
+    return _create_client(config_string, basic_auth_password, service_provider_auth_client_secret)
 
 
-def _create_client(config_string: str, password: str) -> AasHttpClient | None:
+def _create_client(config_string: str, basic_auth_password: str, service_provider_auth_client_secret: str) -> AasHttpClient | None:
     try:
         client = AasHttpClient.model_validate_json(config_string)
     except ValidationError as ve:
         raise ValidationError(f"Invalid BaSyx server configuration file: {ve}") from ve
 
-    logger.info(
-        f"Using server configuration: '{client.base_url}' | "
-        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)
+    logger.info("Using server configuration:")
+    logger.info(f"base_url: '{client.base_url}'")
+    logger.info(f"timeout: '{client.time_out}'")
+
+    if client.basic_auth:
+        logger.info(f"basic_auth: '{client.basic_auth.username}'")
+    if client.service_provider_auth:
+        logger.info(f"service_provider_auth: '{client.service_provider_auth.token_url}': {client.service_provider_auth.client_id}'")
+
+    logger.info(f"https_proxy: '{client.https_proxy}'")
+    logger.info(f"http_proxy: '{client.http_proxy}'")
+    logger.info(f"connection_timeout: '{client.connection_time_out}'.")
+    client.initialize(basic_auth_password, service_provider_auth_client_secret)
 
     # test the connection to the REST API
     connected = _connect_to_api(client)

{aas_http_client-0.4.1 → aas_http_client-0.4.3}/aas_http_client/demo/demo_process.py

@@ -5,9 +5,9 @@ from pathlib import Path
 
 from basyx.aas import model
 
-from aas_http_client.client import AasHttpClient, create_client_by_config
+from aas_http_client import client as aas_client
 from aas_http_client.utilities import model_builder, sdk_tools
-from aas_http_client.wrapper.sdk_wrapper import SdkWrapper, create_wrapper_by_config
+from aas_http_client.wrapper import sdk_wrapper
 
 logger = logging.getLogger(__name__)
 
@@ -21,20 +21,33 @@ def start() -> None:
 
     # create a submodel
     sm_short_id: str = model_builder.create_unique_short_id("poc_sm")
-    submodel = model_builder.create_base_submodel(sm_short_id)
+    submodel = model_builder.create_base_submodel(sm_short_id, sm_short_id)
     # add submodel element to submodel
     # submodel.submodel_element.add(sme)
 
     # create an AAS
     aas_short_id: str = model_builder.create_unique_short_id("poc_aas")
-    aas = model_builder.create_base_ass(aas_short_id)
+    aas = model_builder.create_base_ass(aas_short_id, aas_short_id)
 
     # add submodel to AAS
     sdk_tools.add_submodel_to_aas(aas, submodel)
 
-    wrapper = _create_sdk_wrapper(Path("./aas_http_client/demo/python_server_config.yml"))
-    # dotnet_sdk_wrapper = _create_sdk_wrapper(Path("./aas_http_client/demo/dotnet_server_config.yml"))
+    client = aas_client.create_client_by_url(
+        "http://javaaasserver:8075/",
+        service_provider_auth_client_id="fluid40",
+        service_provider_auth_client_secret="LdFB4jRrMMkgcVWgFkOVdDVDXtQ5os8w",
+        service_provider_auth_token_url="https://aurora-fluid40.iqstruct-engineering.de/auth/realms/BaSyx/protocol/openid-connect/token",
+    )
+
+    client = aas_client.create_client_by_config(Path("./aas_http_client/demo/java_server_config.yml"))
 
+    # tmp = get_token_by_basic_auth(
+    #     "https://aurora-fluid40.iqstruct-engineering.de/auth/realms/BaSyx/protocol/openid-connect/token",
+    #     "fluid40",
+    #     "LdFB4jRrMMkgcVWgFkOVdDVDXtQ5os8w",
+    # )
+
+    wrapper = _create_sdk_wrapper(Path("./aas_http_client/demo/python_server_config.yml"))
     for existing_shell in wrapper.get_all_asset_administration_shells():
         logger.warning(f"Delete shell '{existing_shell.id}'")
         wrapper.delete_asset_administration_shell_by_id(existing_shell.id)
@@ -64,7 +77,7 @@ def start() -> None:
         wrapper.delete_submodel_by_id(existing_submodel.id)
 
 
-def _create_client(config: Path) -> AasHttpClient:
+def _create_client(config: Path) -> aas_client.AasHttpClient:
     """Create a HTTP client from a given configuration file.
 
     :param config: Given configuration file
@@ -72,7 +85,7 @@ def _create_client(config: Path) -> AasHttpClient:
     """
     try:
         file = config
-        client = create_client_by_config(file, password="")
+        client = aas_client.create_client_by_config(file, password="")
 
     except Exception as e:
         logger.error(f"Failed to create client for {file}: {e}")
@@ -80,7 +93,7 @@ def _create_client(config: Path) -> AasHttpClient:
     return client
 
 
-def _create_sdk_wrapper(config: Path) -> SdkWrapper:
+def _create_sdk_wrapper(config: Path) -> sdk_wrapper.SdkWrapper:
     """Create a SDK wrapper from a given configuration file.
 
     :param config: Given configuration file
@@ -88,7 +101,7 @@ def _create_sdk_wrapper(config: Path) -> SdkWrapper:
     """
     try:
         file = config
-        client = create_wrapper_by_config(file, password="")
+        client = sdk_wrapper.create_wrapper_by_config(file, password="")
 
     except Exception as e:
         logger.error(f"Failed to create client for {file}: {e}")

{aas_http_client-0.4.1 → aas_http_client-0.4.3}/aas_http_client/wrapper/sdk_wrapper.py

@@ -25,7 +25,7 @@ class SdkWrapper:
         :param config_string: Configuration string for the BaSyx server connection.
         :param password: Password for the BaSyx server interface client, defaults to "".
         """
-        client = _create_client(config_string, password)
+        client = _create_client(config_string, password, "")
 
         if not client:
             raise ValueError("Failed to create AAS HTTP client with the provided configuration.")
@@ -257,7 +257,7 @@ class SdkWrapper:
         return submodel_elements
 
     def post_submodel_element_submodel_repo(self, submodel_id: str, submodel_element: model.SubmodelElement) -> model.SubmodelElement | None:
-        """Creates a new submodel element. !!!Serialization to model.SubmodelElements currently not possible.
+        """Creates a new submodel element.
 
         :param submodel_id: Encoded ID of the submodel to create elements for
         :param submodel_element: Submodel element to create
@@ -267,6 +267,20 @@ class SdkWrapper:
         content: dict = self._client.post_submodel_element_submodel_repo(submodel_id, sme_data)
         return _to_object(content)
 
+    def post_submodel_element_by_path_submodel_repo(
+        self, submodel_id: str, submodel_element_path: str, submodel_element: model.SubmodelElement
+    ) -> model.SubmodelElement | None:
+        """Creates a new submodel element at a specified path within submodel elements hierarchy.
+
+        :param submodel_id: Encoded ID of the submodel to create elements for
+        :param submodel_element_path: Path within the Submodel elements hierarchy
+        :param submodel_element: The new Submodel element
+        :return: Submodel element object or None if an error occurred
+        """
+        sme_data = _to_dict(submodel_element)
+        content: dict = self._client.post_submodel_element_by_path_submodel_repo(submodel_id, submodel_element_path, sme_data)
+        return _to_object(content)
+
     def get_submodel_element_by_path_submodel_repo(self, submodel_id: str, submodel_element_path: str) -> model.SubmodelElement | None:
         """Returns a specific submodel element from the Submodel at a specified path.
 

{aas_http_client-0.4.1 → aas_http_client-0.4.3}/aas_http_client.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aas-http-client
-Version: 0.4.1
+Version: 0.4.3
 Summary: Generic python HTTP client for communication with various types of AAS servers
 Author-email: Daniel Klein <daniel.klein@em.ag>
 License: # :em engineering methods AG Software License

{aas_http_client-0.4.1 → aas_http_client-0.4.3}/aas_http_client.egg-info/SOURCES.txt

@@ -8,6 +8,7 @@ aas_http_client.egg-info/SOURCES.txt
 aas_http_client.egg-info/dependency_links.txt
 aas_http_client.egg-info/requires.txt
 aas_http_client.egg-info/top_level.txt
+aas_http_client/classes/auth_classes.py
 aas_http_client/core/encoder.py
 aas_http_client/core/version_check.py
 aas_http_client/demo/demo_process.py

{aas_http_client-0.4.1 → aas_http_client-0.4.3}/pyproject.toml

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

{aas_http_client-0.4.1 → aas_http_client-0.4.3}/tests/test_client.py

@@ -29,7 +29,7 @@ def client(request) -> AasHttpClient:
         if not file.exists():
             raise FileNotFoundError(f"Configuration file {file} does not exist.")
 
-        client = create_client_by_config(file, password="")
+        client = create_client_by_config(file)
     except Exception as e:
         raise RuntimeError("Unable to connect to server.")
 
@@ -555,6 +555,60 @@ def test_018d_patch_submodel_element_by_path_value_only_submodel_repo(client: Aa
         assert get_result.get("description", {})[0].get("text", "") == shared_sme_float.description.get("en", "")
         assert get_result.get("displayName", {})[0].get("text", "") == shared_sme_float.display_name.get("en", "")
 
+def test_019a_post_submodel_element_by_path_submodel_repo(client: AasHttpClient, shared_sm: model.Submodel):
+    submodel_element_list = model.SubmodelElementList(id_short="sme_list_1", type_value_list_element=model.Property, value_type_list_element=model.datatypes.String)
+    submodel_element_list_dict = sdk_tools.convert_to_dict(submodel_element_list)
+    first_result = client.post_submodel_element_submodel_repo(shared_sm.id, submodel_element_list_dict)
+
+    assert first_result is not None
+
+    property = model_builder.create_base_submodel_element_property("sme_property_in_list", model.datatypes.String, "Value in List")
+    property_dict = sdk_tools.convert_to_dict(property)
+    del property_dict["idShort"]
+
+    result = client.post_submodel_element_by_path_submodel_repo(shared_sm.id, submodel_element_list.id_short, property_dict)
+
+    assert result is not None
+    assert "idShort" not in result  # idShort was deleted
+
+    submodel = client.get_submodel_by_id(shared_sm.id)
+
+    assert submodel is not None
+    elements = submodel.get("submodelElements", [])
+    assert len(elements) == 5  # 4 previous properties + 1 list
+    assert elements[4].get("idShort", "") == submodel_element_list.id_short
+    list_elements = elements[4].get("value", [])
+    assert len(list_elements) == 1
+    assert list_elements[0].get("idShort", "") == ""
+    assert list_elements[0].get("value", "") == property.value
+
+
+def test_019b_post_submodel_element_by_path_submodel_repo(client: AasHttpClient, shared_sm: model.Submodel):
+    submodel_element_collection = model.SubmodelElementCollection(id_short="sme_collection_1")
+    submodel_element_collection_dict = sdk_tools.convert_to_dict(submodel_element_collection)
+    first_result = client.post_submodel_element_submodel_repo(shared_sm.id, submodel_element_collection_dict)
+
+    assert first_result is not None
+
+    property = model_builder.create_base_submodel_element_property("sme_property_in_collection", model.datatypes.String, "Value in List")
+    property_dict = sdk_tools.convert_to_dict(property)
+
+    result = client.post_submodel_element_by_path_submodel_repo(shared_sm.id, submodel_element_collection.id_short, property_dict)
+
+    assert result is not None
+    assert result["idShort"] == property.id_short
+
+    submodel = client.get_submodel_by_id(shared_sm.id)
+
+    assert submodel is not None
+    elements = submodel.get("submodelElements", [])
+    assert len(elements) == 6
+    assert elements[5].get("idShort", "") == submodel_element_collection.id_short
+    list_elements = elements[5].get("value", [])
+    assert len(list_elements) == 1
+    assert list_elements[0].get("idShort", "") == property.id_short
+    assert list_elements[0].get("value", "") == property.value
+
 def test_098_delete_asset_administration_shell_by_id(client: AasHttpClient, shared_aas: model.AssetAdministrationShell):
     result = client.delete_asset_administration_shell_by_id(shared_aas.id)