mdtpy 25.2.3__py3-none-any.whl

mdtpy/__init__.py

@@ -0,0 +1,4 @@
+from .model import MDTException, InternalError, ResourceNotFoundError
+from mdtpy.client import connect, HttpMDTManagerClient
+
+__version__ = '25.02.03'

mdtpy/cli.py

@@ -0,0 +1,160 @@
+from __future__ import annotations
+
+import sys
+from typing import Optional
+import subprocess
+
+from mdt.types import *
+from mdt.types import Parameter, Input, Output, ElementReference
+
+
+MDT_OPERATION_SERVER_ENDPOINT = "http://localhost:12987"
+LOG_LEVEL:Optional[str] = None
+CLIENT_CONFIG_PATH:Optional[str] = None
+
+def list_instances(filter:Optional[str]=None) -> list[str]:
+    filter_opt = f" --filter {filter}" if filter else ""
+    loglevel_str = f" --loglevel {LOG_LEVEL}" if LOG_LEVEL else ""
+    client_conf_opt = f" --client_conf {CLIENT_CONFIG_PATH}" if CLIENT_CONFIG_PATH else ""
+    cmd:str = f"mdt list instances {filter_opt}{loglevel_str}{client_conf_opt}"
+    result = subprocess.run(cmd, shell=True, capture_output=True)
+    if result.returncode != 0:
+        raise MDTCliError(result.stderr)
+    return result.stdout.decode('utf-8').splitlines()
+
+
+def add_instance(id:str, model_path:str, conf_path:str,
+                 jar_path:Optional[str]=None,
+                 port:Optional[int]=None,
+                 logger:Optional[str]=None,
+                 endpoint:Optional[str]=None):
+    jar_path_str = f" --jar {jar_path}" if jar_path else ""
+    port_str = f" --port {port}" if port else ""
+    logger_str = f" --logger {logger}" if logger else ""
+    ep_str = f" --endpoint {endpoint}" if endpoint else ""
+    cmd:str = f"mdt add {id} -m {model_path} -c {conf_path}{jar_path_str}{port_str} " \
+              f"{logger_str}{ep_str}"
+    result = subprocess.run(cmd, shell=True, capture_output=True, check=True, encoding='utf-8')
+    if result.returncode != 0:
+        raise MDTCliError(result.stderr)
+
+
+def remove_instance(id:str, endpoint:Optional[str]=None):
+    ep_str = f" --endpoint {endpoint}" if endpoint else ""
+    cmd:str = f"mdt remove {id}{ep_str}"
+    result = subprocess.run(cmd, shell=True, capture_output=True, check=True, encoding='utf-8')
+    if result.returncode != 0:
+        raise MDTCliError(result.stderr)
+    
+    
+def start_instance(id:str, all:bool=False, recursive:bool=False, nowait:bool=False, thread_count:int=1,
+                   poll_interval:str="1s", timeout:Optional[str]=None):
+    all_opt = f" --all" if all else ""
+    recursive_opt = f" --recursive" if recursive else ""
+    thread_count_opt = f" --nthreads {thread_count}" if all else ""
+    nowait_opt = f" --nowait" if nowait else ""
+    poll_interval_pot = f" --poll {poll_interval}"
+    timeout_opt = f" --timeout {timeout}" if all else ""
+    loglevel_str = f" --loglevel {LOG_LEVEL}" if LOG_LEVEL else ""
+    client_conf_opt = f" --client_conf {CLIENT_CONFIG_PATH}" if CLIENT_CONFIG_PATH else ""
+    cmd:str = f"mdt start {id} {all_opt}{recursive_opt}{thread_count_opt}{nowait_opt}" \
+                f"{poll_interval_pot}{timeout_opt}{loglevel_str}{client_conf_opt}"
+    result = subprocess.run(cmd, shell=True, capture_output=True)
+    if result.returncode != 0:
+        raise MDTCliError(result.stderr)
+    
+    
+def stop_instance(id:str, all:bool=False, recursive:bool=False, nowait:bool=False):
+    all_opt = f" --all" if all else ""
+    recursive_opt = f" --recursive" if recursive else ""
+    nowait_opt = f" --nowait" if nowait else ""
+    loglevel_str = f" --loglevel {LOG_LEVEL}" if LOG_LEVEL else ""
+    client_conf_opt = f" --client_conf {CLIENT_CONFIG_PATH}" if CLIENT_CONFIG_PATH else ""
+    cmd:str = f"mdt stop {id} {all_opt}{recursive_opt}{nowait_opt}{loglevel_str}{client_conf_opt}"
+    result = subprocess.run(cmd, shell=True, capture_output=True)
+    if result.returncode != 0:
+        raise MDTCliError(result.stderr)
+    
+    
+def get_element(ref:Parameter|Input|Output|ElementReference, output:str='value'):
+    cmd:str = f"mdt get element {ref} -o {output}"
+    result = subprocess.run(cmd, shell=True, capture_output=True)
+    if result.returncode != 0:
+        raise MDTCliError(result.stderr)
+    return result.stdout.decode('utf-8')
+
+
+def set_element(ref:Parameter|Input|Output|ElementReference, value:str|File):
+    value_spec = None
+    if isinstance(value, str):
+        value_spec = f" --value {value}"
+    elif isinstance(value, File):
+        value_spec = f" --file {value.file_path}"
+        if value.path:
+            value_spec = f"{value_spec} --path {value.path}"
+    else:
+        raise ValueError(f'Unexpected value: f{value}')
+
+    loglevel_str = f" --loglevel {LOG_LEVEL}" if LOG_LEVEL else ""
+    client_conf_opt = f" --client_conf {CLIENT_CONFIG_PATH}" if CLIENT_CONFIG_PATH else ""
+    cmd:str = f"mdt set {ref}{value_spec} {loglevel_str}{client_conf_opt}"
+    result = subprocess.run(cmd, shell=True, capture_output=True)
+    if result.returncode != 0:
+        raise MDTCliError(result.stderr)
+
+
+def copy(src_ref:Parameter|Input|Output|ElementReference, tar_ref:Parameter|Input|Output|ElementReference):
+    loglevel_str = f" --loglevel {LOG_LEVEL}" if LOG_LEVEL else ""
+    client_conf_opt = f" --client_conf {CLIENT_CONFIG_PATH}" if CLIENT_CONFIG_PATH else ""
+    cmd:str = f"mdt copy {src_ref} {tar_ref}{loglevel_str}{client_conf_opt}"
+    result = subprocess.run(cmd, shell=True, capture_output=True)
+    if result.returncode != 0:
+        raise MDTCliError(result.stderr)
+
+
+def run_program(program_path:str):
+    loglevel_str = f" --loglevel {LOG_LEVEL}" if LOG_LEVEL else ""
+    client_conf_opt = f" --client_conf {CLIENT_CONFIG_PATH}" if CLIENT_CONFIG_PATH else ""
+    cmd:str = f"mdt run program {program_path} {loglevel_str}{client_conf_opt}"
+    result = subprocess.run(cmd, shell=True, capture_output=True)
+    if result.returncode != 0:
+        raise MDTCliError(result.stderr)
+    
+
+def replace_in_arg(arg_name:str):
+    return arg_name.replace('in_', 'in.')
+def replace_out_arg(arg_name:str):
+    return arg_name.replace('out_', 'out.')
+def run_http(op_id:str, server:str, poll_interval:Optional[str]=None, timeout:Optional[str]=None, **kwargs):
+    loglevel_str = f" --loglevel {LOG_LEVEL}" if LOG_LEVEL else ""
+    client_conf_opt = f" --client_conf {CLIENT_CONFIG_PATH}" if CLIENT_CONFIG_PATH else ""
+    poll_interval_opt = f" --poll {poll_interval}" if poll_interval else ""
+    timeout_opt = f" --timeout {timeout}" if timeout else ""
+    extra_in_args = ' '.join([f'--{replace_in_arg(key)} {value}' for key, value in kwargs.items() if key.startswith('in_')])
+    extra_out_args = ' '.join([f'--{replace_out_arg(key)} {value}' for key, value in kwargs.items() if key.startswith('out_')])
+    cmd:str = f"mdt run http --server {server} --id {op_id} {poll_interval_opt}{timeout_opt}" \
+                f"{loglevel_str}{client_conf_opt} {extra_in_args} {extra_out_args}"
+    result = subprocess.run(cmd, shell=True, capture_output=True)
+    if result.returncode != 0:
+        raise MDTCliError(result.stderr)
+
+
+import os
+def main():
+    start_instance('heater')
+    # set_value('param:Test/0', '15')
+
+    # os.chdir('/home/kwlee/mdt/models/innercase')
+    # set_file('param:inspector/UpperIlluminanceImage', file='Innercase07-1.jpg')
+
+    # os.chdir('/home/kwlee/mdt/models/innercase')
+    # # run_program('program.json', logger='info')
+    # run_http(op_id='test', submodel='Test/Simulation', timeout='5m', logger='info')
+
+if __name__ == '__main__':
+    main()
+
+# mdt run http --server http://localhost:12987 --id inspector/UpdateDefectList \
+# --in.Defect arg:inspector/ThicknessInspection/out/Defect  --in.DefectList param:inspector/DefectList --out.DefectList param:inspector/DefectList
+
+# mdt run http --server http://localhost:12987 --id inspector/UpdateDefectList

mdtpy/client/__init__.py

@@ -0,0 +1,7 @@
+
+from .http_client import *
+from .http_service_client import *
+from .http_instance_client import *
+from .http_registry_client import *
+from .http_repository_client import *
+from .http_fa3st_client import *

mdtpy/client/http_client.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+from typing import Optional
+
+import base64
+import requests
+
+from mdtpy.model import MDTException, RemoteError
+from ..model.aas_model import Endpoint
+
+
+def to_base64_string(src:str) -> str:
+    return base64.urlsafe_b64encode(bytes(src, 'utf-8')).decode('ascii')
+
+def parse_none_response(resp:requests.Response) -> None:
+    if resp.status_code >= 200 and resp.status_code < 300:
+        return
+    else:
+        raise to_exception(resp)
+    
+def parse_response(result_cls, resp:requests.Response):
+    if resp.status_code >= 200 and resp.status_code < 300:
+        return result_cls.from_json(resp.text)
+    else:
+        raise to_exception(resp)
+    
+def parse_list_response(result_cls, resp:requests.Response):
+    if resp.status_code >= 200 and resp.status_code < 300:
+        return [result_cls.from_dict(descElm) for descElm in resp.json()]
+    else:
+        raise to_exception(resp)
+    
+def to_exception(resp:requests.Response) -> MDTException:
+    json_obj = resp.json()
+
+    if 'messages' in json_obj:
+        message = json_obj['messages'][0]
+        return RemoteError(message['text'])
+    elif 'code' in json_obj:
+        code = json_obj['code']
+        if code == 'java.lang.IllegalArgumentException':
+            raise RemoteError(json_obj['message'])
+        elif code == 'utils.InternalException':
+            raise RemoteError(json_obj['message'])
+        elif code == 'java.lang.NullPointerException':
+            raise RemoteError(f"code={json_obj['code']}, message={json_obj['message']}")
+        elif code == 'org.springframework.web.servlet.resource.NoResourceFoundException':
+            raise RemoteError(json_obj['text'])
+        elif code == 'org.springframework.web.HttpRequestMethodNotSupportedException':
+            raise RemoteError(json_obj['text'])
+        paths = code.split('.')
+        
+        from importlib import import_module
+        moduleName = '.'.join(paths[:-1])
+        module = import_module(moduleName)
+        exception_cls = getattr(module, paths[-1])
+        return exception_cls(json_obj['text'])
+
+def extract_href(endpoints:list[Endpoint]) -> Optional[str]:
+    if len(endpoints) == 0:
+        return None
+    href = endpoints[0].protocolInformation.href
+    if href == None or len(href) == 0:
+        return None
+    else:
+        return href

mdtpy/client/http_fa3st_client.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+from typing import Optional, Any
+from dataclasses import dataclass
+
+import base64
+import requests
+import json
+
+from ..model import MDTException, ResourceNotFoundError, InternalError
+from .http_client import to_exception, parse_none_response
+from ..impl import json_deserializer
+
+@dataclass(frozen=True, slots=True)
+class Message:
+    messageType: str
+    text: str
+    code: str
+    timestamp: str
+    
+
+class HttpFa3stClient:
+    """
+    A client class for FA3ST API that handles HTTP requests and responses.
+    -------
+    to_base64_string(id: str) -> str
+        Encodes the given string ID to a base64 string.
+    parse_none_response(resp: requests.Response) -> None
+        Parses a response that is expected to have no content.
+    parse_response(result_cls, resp: requests.Response)
+        Parses the HTTP response based on the status code and expected result class.
+    to_exception(resp: requests.Response) -> MDTException
+        Converts an HTTP response to an appropriate exception based on the response content.
+    """
+    def to_base64_string(self, id:str) -> str:
+        return base64.b64encode(id.encode('UTF-8')).decode('ascii')
+    
+    def parse_none_response(self, resp:requests.Response) -> None:
+        return parse_none_response(resp)
+        
+    def parse_response(self, result_cls, resp:requests.Response):
+        if resp.status_code == 204:
+            return None
+        elif resp.status_code >= 200 and resp.status_code < 300:
+            if result_cls == bytes:
+                content_type = resp.headers['content-type']
+                content = resp.content
+                return content_type, content
+            
+            resp_json = json.loads(resp.text)
+            if 'result' in resp_json:
+                resp_json = resp_json['result'][0]
+            return json_deserializer.read_resource(resp_json)
+        else:
+            raise to_exception(resp)
+
+    def to_exception(self, resp:requests.Response) -> MDTException:
+        json_obj = resp.json()
+        message = Message(**json_obj['messages'][0])
+        if message.text.startswith("Resource not found"):
+            details = message.text[41:-1]
+            return ResourceNotFoundError.create("ModelRef", details)
+        elif message.text.startswith('error parsing body'):
+            return InternalError('JSON parsing failed')
+        else:
+            return MDTException(message.text)

mdtpy/client/http_instance_client.py

@@ -0,0 +1,316 @@
+from __future__ import annotations
+
+from typing import Optional, Generator, cast
+from collections.abc import Iterator
+
+import requests
+
+from mdtpy.model import MDTInstanceManager, MDTInstance, MDTInstanceCollection, InstanceDescriptor, InstanceSubmodelDescriptor, \
+                        MDTInstanceStatus, SubmodelServiceCollection, OperationSubmodelServiceCollection, MDT_SEMANTIC_ID, \
+                        InvalidResourceStateError, ResourceNotFoundError
+                        
+from .utils import StatusPoller
+from .http_registry_client import HttpAssetAdministrationShellRegistryClient, HttpSubmodelRegistryClient
+from .http_service_client import HttpAssetAdministrationShellServiceClient, HttpSubmodelServiceClient
+from .http_repository_client import *
+from .http_client import to_base64_string, parse_none_response, parse_response, parse_list_response, extract_href
+    
+    
+def connect(host:str='localhost', port:int=12985, path:str='/instance-manager') -> HttpMDTManagerClient:
+    endpoint = f"http://{host}:{port}{path}"
+    return HttpMDTManagerClient(endpoint)
+
+
+class HttpMDTManagerClient(MDTInstanceManager):
+    def __init__(self, endpoint:str) -> None:
+        super().__init__()
+        
+        self.endpoint = endpoint
+        self._instances = HttpInstanceCollection(self, endpoint)
+        self.endpoint_base = '/'.join(endpoint.split('/')[:-1])
+
+    @property
+    def instances(self) -> HttpInstanceCollection:
+        return self._instances
+        
+    def getAssetAdministrationShellRegistry(self) -> HttpAssetAdministrationShellRegistryClient:
+        return HttpAssetAdministrationShellRegistryClient(self.endpoint_base + "/shell-registry/shell-descriptors")
+    
+    def getSubmodelRegistry(self) -> HttpSubmodelRegistryClient:
+        return HttpSubmodelRegistryClient(self.endpoint_base + "/shell-registry/submodel-descriptors")
+        
+    def getAssetAdministrationShellService(self, aasId:str) -> HttpAssetAdministrationShellServiceClient:
+        eps = self.getAssetAdministrationShellRegistry() \
+                    .getAssetAdministrationShellDescriptorById(aasId) \
+                    .endpoints
+        href = extract_href(eps)
+        if href:
+            return HttpAssetAdministrationShellServiceClient(href)
+        else:
+            raise InvalidResourceStateError.create("AssetAdministrationShell", f"id={aasId}")
+        
+    def getSubmodelService(self, submodelId:str, serviceClass=None) -> SubmodelService:
+        eps = self.getSubmodelRegistry() \
+                    .getSubmodelDescriptorById(submodelId) \
+                    .endpoints
+        href = extract_href(eps)
+        if href:
+            return serviceClass(href) if serviceClass else HttpSubmodelServiceClient(href)
+        else:
+            raise InvalidResourceStateError.create("Submodel", f"id={submodelId}")
+
+
+class HttpInstanceCollection(MDTInstanceCollection):
+    def __init__(self, inst_mgr:HttpMDTManagerClient, endpoint:str):
+        self.url_prefix = f"{endpoint}/instances"
+        self.instance_manager = inst_mgr
+    
+    def __bool__(self):
+        resp = requests.get(self.url_prefix)
+        return len(parse_list_response(InstanceDescriptor, resp)) > 0
+    
+    def __len__(self):
+        resp = requests.get(self.url_prefix)
+        return len(parse_list_response(InstanceDescriptor, resp))
+        
+    def __iter__(self) -> Iterator[HttpInstanceClient]:
+        resp = requests.get(self.url_prefix)
+        inst_desc_list = parse_list_response(InstanceDescriptor, resp)
+        return iter(HttpInstanceClient(self, self.instance_manager, inst_desc) for inst_desc in inst_desc_list)
+    
+    def __contains__(self, key:str) -> bool:
+        url = f'{self.url_prefix}/{key}'
+        resp = requests.get(url)
+        return resp.status_code == 200
+        
+    def __getitem__(self, key:str) -> HttpInstanceClient:
+        url = f'{self.url_prefix}/{key}'
+        resp = requests.get(url)
+        inst_desc = parse_response(InstanceDescriptor, resp)
+        return HttpInstanceClient(self.instance_manager, self.url_prefix, inst_desc)
+    
+    def __setitem__(self, key:str, value:HttpInstanceClient) -> None:
+        raise NotImplementedError('HttpInstanceCollection does not support set operation')
+    
+    def __delitem__(self, key:str) -> None:
+        url = f'{self.url_prefix}/{key}'
+        resp = requests.delete(url)
+        parse_none_response(resp)
+    
+    def find(self, condition:str) -> Generator[HttpInstanceClient, None, None]:
+        resp = requests.get(self.url_prefix, params={'filter': f"{condition}"})
+        inst_desc_list = parse_list_response(InstanceDescriptor, resp)
+        return (HttpInstanceClient(self, inst_desc) for inst_desc in inst_desc_list)
+    
+    def add(self, id:str, port:int, inst_dir:str) -> HttpInstanceClient:
+        import shutil
+        shutil.make_archive(inst_dir, 'zip', inst_dir)
+        zipped_file = f'{inst_dir}.zip'
+        
+        from requests_toolbelt.multipart.encoder import MultipartEncoder
+        m = MultipartEncoder(
+            fields = {
+                'id': id,
+                'port': str(port),
+                'bundle': ('filename', open(zipped_file, 'rb'), 'application/zip')
+            }
+        )
+        resp = requests.post(self.url_prefix, data=m, headers={'Content-Type': m.content_type}, verify=False)
+        inst_desc = parse_response(InstanceDescriptor, resp)
+        return HttpInstanceClient(self, inst_desc)
+    
+    def remove(self, id:str) -> None:
+        url = f'{self.url_prefix}/{id}'
+        resp = requests.delete(url)
+        return parse_none_response(resp)
+        
+    def remove_all(self) -> None:
+        url = f"{self.url_prefix}"
+        resp = requests.delete(url)
+        parse_none_response(resp)
+    
+    def __repr__(self):
+        return 'HttpMDTInstances(url={self.url_prefix})'
+    
+    
+class InstanceStartPoller(StatusPoller):
+    def __init__(self, status_url:str, init_desc:Optional[InstanceDescriptor]=None,
+                 poll_interval:float=1.0, timeout:Optional[float]=None) -> None:
+        super().__init__(poll_interval=poll_interval, timeout=timeout)
+        self.status_url = status_url
+        self.desc = init_desc
+        
+    def check_done(self) -> bool:
+        if self.desc.status == MDTInstanceStatus.STARTING.name:
+            resp = requests.get(self.status_url)
+            self.desc = parse_response(InstanceDescriptor, resp)
+            return self.desc.status != MDTInstanceStatus.STARTING.name
+        else:
+            return True
+    
+class InstanceStopPoller(StatusPoller):
+    def __init__(self, status_url:str, init_desc:Optional[InstanceDescriptor]=None,
+                 poll_interval:float=1.0, timeout:Optional[float]=None) -> None:
+        super().__init__(poll_interval=poll_interval, timeout=timeout)
+        self.status_url = status_url
+        self.desc = init_desc
+        
+    def check_done(self) -> bool:
+        if self.desc.status == MDTInstanceStatus.STOPPING.name:
+            resp = requests.get(self.status_url)
+            self.desc = parse_response(InstanceDescriptor, resp)
+            return self.desc.status != MDTInstanceStatus.STOPPING.name
+        else:
+            return True
+    
+
+class HttpInstanceClient(MDTInstance):
+    def __init__(self, instance_manager:HttpMDTManagerClient, base_url:str, descriptor:InstanceDescriptor) -> None:
+        super().__init__()
+        
+        self.instance_manager = instance_manager
+        self.descriptor = descriptor
+        self.base_url = base_url
+        self._submodels = HttpSubmodelServiceCollection(self)
+         
+    @property
+    def id(self) -> str:
+        return self.descriptor.id
+         
+    @property
+    def aasId(self) -> str:
+        return self.descriptor.aasId
+         
+    @property
+    def aasIdShort(self) -> Optional[str]:
+        return self.descriptor.aasIdShort
+    
+    @property
+    def status(self) -> MDTInstanceStatus:
+        return MDTInstanceStatus[self.descriptor.status]
+        
+    @property
+    def serviceEndpoint(self) -> Optional[str]:
+        return self.descriptor.baseEndpoint
+    
+    @property
+    def shell(self) -> HttpAssetAdministrationShellServiceClient:
+        return self.instance_manager.getAssetAdministrationShellService(self.aasId)
+
+    @property
+    def submodels(self) -> HttpSubmodelServiceCollection:
+        return self._submodels
+        
+    def start(self, nowait=False) -> None:
+        url = f"{self.base_url}/{self.id}/start"
+        resp = requests.put(url, data="")
+        self.descriptor = parse_response(InstanceDescriptor, resp)
+        if nowait:
+            if self.descriptor.status != MDTInstanceStatus.STARTING.name and MDTInstanceStatus.RUNNING.name:
+                raise InvalidResourceStateError.create(f"Failed to start MDTInstance: id={self.id}")
+        else:
+            poller = InstanceStartPoller(f"{self.base_url}/{self.id}", init_desc=self.descriptor)
+            poller.wait_for_done()
+            self.descriptor = poller.desc
+            if self.descriptor.status != MDTInstanceStatus.RUNNING.name:
+                raise InvalidResourceStateError.create(f"Failed to start MDTInstance: id={self.id}")
+    
+    def stop(self, nowait=False) -> None:
+        url = f"{self.base_url}/{self.id}/stop"
+        resp = requests.put(url, data="")
+        self.descriptor = parse_response(InstanceDescriptor, resp)
+        if nowait:
+            if self.descriptor.status != MDTInstanceStatus.STOPPING.name and MDTInstanceStatus.STOPPED.name:
+                raise InvalidResourceStateError.create(f"Failed to stop MDTInstance: id={self.id}")
+        else:
+            poller = InstanceStopPoller(f"{self.base_url}/{self.id}", init_desc=self.descriptor)
+            poller.wait_for_done()
+            self.descriptor = poller.desc
+            if self.descriptor.status != MDTInstanceStatus.STOPPED.name:
+                raise InvalidResourceStateError.create(f"Failed to stop MDTInstance: id={self.id}")
+    
+    @property
+    def parameters(self) -> ElementReferenceCollection:
+        for sm_svc in self.submodels:
+            if sm_svc.semanticId == 'https://etri.re.kr/mdt/Submodel/Data/1/1':
+                return cast(DataSubmodelServiceClient, sm_svc).parameters
+        raise ResourceNotFoundError.create("Data Submodel", 'semanticId=https://etri.re.kr/mdt/Submodel/Data/1/1')
+    
+    @property
+    def operations(self) -> OperationSubmodelServiceCollection:
+        return OperationSubmodelServiceCollection(self.submodels)
+        
+    def __eq__(self, value: object) -> bool:
+        if isinstance(value, MDTInstance):
+            return self.id == value.id
+        else:
+            return False
+    
+    def __repr__(self) -> str:
+        return f"MDTInstance[id={self.descriptor.id}, aas-id={self.descriptor.aasId}, " \
+                f"aas-id-short={self.descriptor.aasIdShort}, status={self.status}]"
+
+
+class HttpSubmodelServiceCollection(SubmodelServiceCollection):
+    def __init__(self, instance:HttpInstanceClient) -> None:
+        super().__init__()
+        self.instance = instance
+
+    def __iter__(self) -> Iterator[SubmodelService]:
+        return iter(self.createSubmodelService(sm_desc) for sm_desc in self.instance.descriptor.submodels)
+    
+    def __bool__(self) -> bool:
+        return bool(self.instance.descriptor.submodels)
+    
+    def __len__(self) -> int:
+        return len(self.instance.descriptor.submodels)
+          
+    def __getitem__(self, key:str) -> SubmodelService:
+        if isinstance(key, str):
+            for sm_desc in self.instance.descriptor.submodels:
+                if sm_desc.idShort == key:
+                    return self.createSubmodelService(sm_desc)
+            raise ResourceNotFoundError.create("Submodel", f'idShort={key}')
+        else:
+            raise ValueError(f'Invalid Submodel key: {key}')
+        
+    def __setitem__(self, key:str, value:SubmodelService) -> None:
+        raise NotImplementedError('SubmodelServiceCollection does not support set operation')
+    
+    def __delitem__(self, key:str) -> None:
+        raise NotImplementedError('SubmodelServiceCollection does not support delete operation')
+    
+    def find(self, **kwargs) -> Generator[SubmodelService, None, None]:
+        matches:list[InstanceSubmodelDescriptor] = self.instance.descriptor.submodels
+        for key, value in kwargs.items():
+            match key:
+                case 'idShort':
+                    matches = [sm_desc for sm_desc in matches if sm_desc.idShort == value]
+                case 'semanticId':
+                    matches = [sm_desc for sm_desc in matches if sm_desc.semanticId == value]
+        return (self.createSubmodelService(sm_desc) for sm_desc in matches)
+    
+    def __repr__(self):
+        return 'SubmodelServiceCollection(instance={self.instance.descriptor.id})'
+                
+    def createSubmodelService(self, sm_desc:InstanceSubmodelDescriptor) -> SubmodelService:
+        if not self.instance.descriptor.baseEndpoint:
+            raise ValueError(f'MDTInstance is not ready: id={self.instance.descriptor.id}, state={self.instance.descriptor.status}')
+        
+        submodel_url = f'{self.instance.descriptor.baseEndpoint}/submodels/{to_base64_string(sm_desc.id)}'
+        if sm_desc:
+            if sm_desc.semanticId == MDT_SEMANTIC_ID.DATA:
+                if self.instance.descriptor.assetType == 'Machine':
+                    return DataSubmodelServiceClient(self.instance.descriptor.id, sm_desc, submodel_url, 'Equipment')
+                elif self.instance.descriptor.assetType == 'Process':
+                    return DataSubmodelServiceClient(submodel_url, sm_desc, 'Operation')
+                else:
+                    return DataSubmodelServiceClient(self.instance.descriptor.id, sm_desc, submodel_url, 'Equipment')
+            elif sm_desc.semanticId == MDT_SEMANTIC_ID.AI:
+                return AIServiceClient(self.instance.descriptor.id, sm_desc, submodel_url)
+            elif sm_desc.semanticId == MDT_SEMANTIC_ID.SIMULATION:
+                return SimulationServiceClient(self.instance.descriptor.id, sm_desc, submodel_url)
+            elif sm_desc.semanticId == MDT_SEMANTIC_ID.INFORMATION_MODEL:
+                return InformationModelServiceClient(self.instance.descriptor.id, sm_desc, submodel_url)
+            else:
+                return HttpSubmodelServiceClient(self.instance.descriptor.id, sm_desc, submodel_url)