mdtpy 0.1.0__tar.gz

mdtpy-0.1.0/PKG-INFO

@@ -0,0 +1,23 @@
+Metadata-Version: 2.4
+Name: mdtpy
+Version: 0.1.0
+Summary: Python binding for MDT Platform
+Author: Kang-Woo Lee
+Author-email: kwlee@etri.re.kr
+Requires-Python: >=3.11
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: basyx-python-sdk (>=2.0.0,<3.0.0)
+Requires-Dist: dataclass-wizard (==0.22)
+Requires-Dist: isodate (>=0.7.2,<0.8.0)
+Requires-Dist: pandas (>=2.3.3,<3.0.0)
+Requires-Dist: requests (>=2.32.5,<3.0.0)
+Requires-Dist: requests-toolbelt (>=1.0.0,<2.0.0)
+Requires-Dist: tika (>=3.1.0,<4.0.0)
+Requires-Dist: urllib3 (>=2.6.2,<3.0.0)
+Description-Content-Type: text/markdown
+
+

mdtpy-0.1.0/pyproject.toml

@@ -0,0 +1,37 @@
+[project]
+name = "mdtpy"
+version = "0.1.0"
+description = "Python binding for MDT Platform"
+authors = [
+    {name = "Kang-Woo Lee",email = "kwlee@etri.re.kr"}
+]
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+    "basyx-python-sdk (>=2.0.0,<3.0.0)",
+    "urllib3 (>=2.6.2,<3.0.0)",
+    "requests (>=2.32.5,<3.0.0)",
+    "requests-toolbelt (>=1.0.0,<2.0.0)",
+    "dataclass-wizard (==0.22)",
+    "isodate (>=0.7.2,<0.8.0)",
+    "pandas (>=2.3.3,<3.0.0)",
+    "tika (>=3.1.0,<4.0.0)"
+]
+
+[tool.poetry]
+packages = [{include = "mdtpy", from = "src"}]
+
+[[tool.poetry.source]]
+name = "foo"
+url = "https://pypi.example.org/simple/"
+priority = "supplemental"
+
+
+[[tool.poetry.source]]
+name = "test"
+url = "https://pypi.example.org/simple/"
+priority = "supplemental"
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"

mdtpy-0.1.0/src/mdtpy/__init__.py

@@ -0,0 +1,12 @@
+
+# SSL 인증서 검증 경고 억제
+import urllib3
+urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+
+from .instance import *
+from .value import *
+from .descriptor import *
+from .exceptions import *
+from .timeseries import *
+from . import aas_misc as aas
+from . import basyx

mdtpy-0.1.0/src/mdtpy/aas_misc.py

@@ -0,0 +1,104 @@
+from __future__ import annotations
+
+from typing import Any, cast, Optional, Iterable
+from enum import Enum, auto
+
+import json
+import datetime
+from dataclasses import dataclass, field
+from dataclass_wizard import JSONWizard
+
+from basyx.aas import model
+from .basyx import serde as basyx_serde
+from . import utils
+
+    
+class SecurityTypeEnum(Enum):
+    NONE = auto()
+    RFC_TLSA = auto()
+    W3C_DID = auto()
+
+@dataclass(slots=True)
+class SecurityAttributeObject(JSONWizard):
+    type: SecurityTypeEnum
+    key: str
+    value: str
+
+@dataclass(slots=True)
+class ProtocolInformation:
+  href: str|None
+  endpointProtocol: str|None = field(default=None)
+  endpointProtocolVersion: str|None = field(default=None)
+  subprotocol: str|None = field(default=None)
+  subprotocolBody: str|None = field(default=None)
+  subprotocolBody_encoding: str|None = field(default=None)
+  securityAttributes: list[SecurityAttributeObject] = field(default_factory=list)
+
+@dataclass(slots=True)
+class Endpoint:
+  interface: str
+  protocolInformation: ProtocolInformation
+
+
+@dataclass(slots=True)
+class OperationVariable:
+  value: model.SubmodelElement
+
+  @classmethod
+  def from_dict(cls, data: dict) -> OperationVariable:
+    return cls(value=basyx_serde.from_dict(data['value']))
+
+  def to_dict(self) -> dict[str, Any]:
+    return { 'value': json.loads(basyx_serde.to_json(self.value)) }
+
+@dataclass(slots=True)
+class OperationResult:
+  messages: Optional[list[str]]
+  execution_state: str
+  success: bool
+  output_arguments: Optional[list[OperationVariable]]
+  inoutput_arguments: Optional[list[OperationVariable]]
+
+  @classmethod
+  def from_dict(cls, data: dict) -> OperationResult:
+    output_arguments = data.get('outputArguments')
+    if output_arguments:
+      output_arguments = [OperationVariable.from_dict(arg) for arg in output_arguments]
+    inoutput_arguments = data.get('inoutputArguments')
+    if inoutput_arguments:
+      inoutput_arguments = [OperationVariable.from_dict(arg) for arg in inoutput_arguments]
+
+    return cls(messages = data.get('messages'),
+              execution_state = data['executionState'],
+              success = data['success'],
+              output_arguments=output_arguments, 
+              inoutput_arguments=inoutput_arguments)
+  
+  @classmethod
+  def from_json(cls, json_str: str) -> OperationResult:
+    return cls.from_dict(json.loads(json_str))
+
+@dataclass(slots=True)
+class OperationHandle(JSONWizard):
+  handle_id: str
+    
+@dataclass(slots=True)
+class OperationRequest:
+  input_arguments: Iterable[OperationVariable]
+  inoutput_arguments: Iterable[OperationVariable]
+  client_timeout_duration: datetime.timedelta
+
+  def to_json(self) -> str:
+    in_opv_list = [ op_var.to_dict() for op_var in self.input_arguments ]
+    inout_opv_list = [ op_var.to_dict() for op_var in self.inoutput_arguments ]
+    return json.dumps({
+      'inputArguments': in_opv_list,
+      # 'inoutputArguments': inout_opv_list,
+      'clientTimeoutDuration': utils.timedelta_to_iso8601(self.client_timeout_duration)
+    })
+
+from .value import MultiLanguagePropertyValue, get_value
+def get_first_text(mlpv:MultiLanguagePropertyValue|model.MultiLanguageProperty) -> str|None:
+  if isinstance(mlpv, model.MultiLanguageProperty):
+    mlpv = cast(MultiLanguagePropertyValue, get_value(mlpv))
+  return next(iter(mlpv.values())) if mlpv else None

mdtpy-0.1.0/src/mdtpy/basyx/__init__.py

@@ -0,0 +1,2 @@
+from . import serde
+from . import utils

mdtpy-0.1.0/src/mdtpy/basyx/serde.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from typing import Any
+import json
+
+from basyx.aas.adapter.json.json_deserialization import AASFromJsonDecoder
+from basyx.aas.adapter.json.json_serialization import AASToJsonEncoder
+
+
+def from_json(json_str:str) -> Any:
+  return json.loads(json_str, cls=AASFromJsonDecoder)
+  
+def from_dict(data:dict) -> Any:
+  json_str = json.dumps(data)
+  return json.loads(json_str, cls=AASFromJsonDecoder)
+
+def to_json(obj:Any) -> str:
+  return json.dumps(obj, cls=AASToJsonEncoder)

mdtpy-0.1.0/src/mdtpy/basyx/utils.py

@@ -0,0 +1,169 @@
+from __future__ import annotations
+
+from typing import Optional
+import re
+
+from dateutil.relativedelta import relativedelta
+
+
+_ISO8601_DURATION_RE = re.compile(
+    r"""
+    ^\s*
+    (?P<sign>[+-])?
+    P
+    (?:
+        (?:(?P<years>\d+(?:[.,]\d+)?)Y)?
+        (?:(?P<months>\d+(?:[.,]\d+)?)M)?
+        (?:(?P<weeks>\d+(?:[.,]\d+)?)W)?
+        (?:(?P<days>\d+(?:[.,]\d+)?)D)?
+    )?
+    (?:T
+        (?:(?P<hours>\d+(?:[.,]\d+)?)H)?
+        (?:(?P<minutes>\d+(?:[.,]\d+)?)M)?
+        (?:(?P<seconds>\d+(?:[.,]\d+)?)S)?
+    )?
+    \s*$
+    """,
+    re.VERBOSE | re.IGNORECASE,
+)
+
+
+def _to_number(s: Optional[str]) -> float:
+    if not s:
+        return 0.0
+    return float(s.replace(",", "."))
+
+
+def parse_iso8601_to_relativedelta(duration: str) -> relativedelta:
+    """
+    Parse an ISO 8601 duration string and return a dateutil.relativedelta.relativedelta.
+
+    Examples:
+      - "P1Y2M3DT4H5M6S"
+      - "PT15M"
+      - "P2W"
+      - "-P3DT12H"
+      - "PT0.5S"
+    """
+    m = _ISO8601_DURATION_RE.match(duration)
+    if not m:
+        raise ValueError(f"Invalid ISO 8601 duration: {duration!r}")
+
+    sign = -1 if (m.group("sign") == "-") else 1
+
+    years = _to_number(m.group("years"))
+    months = _to_number(m.group("months"))
+    weeks = _to_number(m.group("weeks"))
+    days = _to_number(m.group("days"))
+    hours = _to_number(m.group("hours"))
+    minutes = _to_number(m.group("minutes"))
+    seconds = _to_number(m.group("seconds"))
+
+    # ISO 8601 allows fractional values; relativedelta expects integers for Y/M
+    # (fractional months/years are ambiguous). We reject fractional Y/M explicitly.
+    if years and not years.is_integer():
+        raise ValueError(f"Fractional years not supported for relativedelta: {duration!r}")
+    if months and not months.is_integer():
+        raise ValueError(f"Fractional months not supported for relativedelta: {duration!r}")
+
+    # For weeks/days/hours/minutes/seconds, we can carry fractions down to smaller units.
+    # Convert weeks to days.
+    total_days = days + (weeks * 7.0)
+
+    # Split fractional days into seconds
+    day_int = int(total_days)
+    day_frac = total_days - day_int
+
+    total_seconds = seconds + (minutes * 60.0) + (hours * 3600.0) + (day_frac * 86400.0)
+
+    sec_int = int(total_seconds)
+    sec_frac = total_seconds - sec_int
+    microseconds = int(round(sec_frac * 1_000_000))
+
+    # Handle rounding overflow (e.g., 0.9999996 rounds to 1_000_000)
+    if microseconds == 1_000_000:
+        sec_int += 1
+        microseconds = 0
+
+    rd = relativedelta(
+        years=sign * int(years),
+        months=sign * int(months),
+        days=sign * day_int,
+        seconds=sign * sec_int,
+        microseconds=sign * microseconds,
+    )
+    return rd
+
+
+def relativedelta_to_iso8601(rd: relativedelta) -> str:
+    """
+    Convert dateutil.relativedelta.relativedelta to an ISO 8601 duration string.
+
+    Examples:
+      relativedelta(years=1, months=2, days=3,
+                    hours=4, minutes=5, seconds=6)
+      -> "P1Y2M3DT4H5M6S"
+    """
+
+    # Determine sign (ISO-8601 uses a single leading sign)
+    def _sign(x: int) -> int:
+        return -1 if x < 0 else 1
+
+    signs = [
+        _sign(rd.years),
+        _sign(rd.months),
+        _sign(rd.days),
+        _sign(rd.hours),
+        _sign(rd.minutes),
+        _sign(rd.seconds),
+        _sign(rd.microseconds),
+    ]
+    sign = "-" if any(s < 0 for s in signs) else ""
+
+    # Use absolute values (ISO-8601 sign is global)
+    years = abs(rd.years)
+    months = abs(rd.months)
+    days = abs(rd.days)
+
+    hours = abs(rd.hours)
+    minutes = abs(rd.minutes)
+
+    seconds = abs(rd.seconds)
+    microseconds = abs(rd.microseconds)
+
+    # Combine seconds + microseconds
+    if microseconds:
+        seconds = seconds + microseconds / 1_000_000
+
+    date_parts = []
+    time_parts = []
+
+    if years:
+        date_parts.append(f"{years}Y")
+    if months:
+        date_parts.append(f"{months}M")
+    if days:
+        date_parts.append(f"{days}D")
+
+    if hours:
+        time_parts.append(f"{hours}H")
+    if minutes:
+        time_parts.append(f"{minutes}M")
+    if seconds:
+        # Strip trailing .0 for integers
+        if float(seconds).is_integer():
+            time_parts.append(f"{int(seconds)}S")
+        else:
+            time_parts.append(f"{seconds:.6f}".rstrip("0").rstrip(".") + "S")
+
+    # ISO-8601 requires at least one component
+    if not date_parts and not time_parts:
+        return "PT0S"
+
+    result = sign + "P"
+    result += "".join(date_parts)
+
+    if time_parts:
+        result += "T" + "".join(time_parts)
+
+    return result

mdtpy-0.1.0/src/mdtpy/descriptor.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+from typing import Optional
+from dataclasses import dataclass, field
+from enum import Enum
+
+from dataclass_wizard import JSONWizard
+
+
+class MDTInstanceStatus(Enum):
+  STOPPED = "STOPPED"
+  STARTING = "STARTING"
+  RUNNING = "RUNNING"
+  STOPPING = "STOPPING"
+  FAILED = "FAILED"
+
+class MDTAssetType(Enum):
+  Machine = "Machine"
+  Process = "Process"
+  Line = "Line"
+  Factory = "Factory"
+
+class AssetKind(Enum):
+  INSTANCE = "INSTANCE"
+  NOT_APPLICABLE = "NOT_APPLICABLE"
+  TYPE = "TYPE"
+
+
+@dataclass(frozen=True, slots=True)
+class InstanceDescriptor(JSONWizard):
+  """
+  MDTInstance Descriptor
+
+  Attributes:
+  ----------
+    id: str
+      The unique identifier of the MDTInstance.
+    status: MDTInstanceStatus
+      The Status of the MDTInstance.
+    base_endpoint: Optional[str]
+      The Base Endpoint of the MDTInstance.
+    aas_id: str
+      The AAS ID of the MDTInstance.
+    aas_idshort: Optional[str]
+      The AAS ID Short of the MDTInstance.
+    global_asset_id: Optional[str]
+      The Global Asset ID of the MDTInstance.
+    asset_type: Optional[MDTAssetType]
+      The Asset Type of the MDTInstance.
+    asset_kind: Optional[AssetKind]
+      The Asset Kind of the MDTInstance.
+  """
+  id: str
+  status: MDTInstanceStatus
+  aas_id: str
+  base_endpoint: Optional[str] = field(default=None, hash=False, compare=False)
+  aas_id_short: Optional[str] = field(default=None, hash=False, compare=False)
+  global_asset_id: Optional[str] = field(default=None, hash=False, compare=False)
+  asset_type: MDTAssetType|None = field(default=None, hash=False, compare=False)
+  asset_kind: AssetKind|None = field(default=None, hash=False, compare=False)
+
+@dataclass(frozen=True, slots=True)
+class MDTParameterDescriptor(JSONWizard):
+  id: str
+  value_type: str
+  reference: str
+  name: Optional[str] = None
+  endpoint: Optional[str] = None
+
+
+SEMANTIC_ID_INFOR_MODEL_SUBMODEL = "https://etri.re.kr/mdt/Submodel/InformationModel/1/1"
+SEMANTIC_ID_AI_SUBMODEL = "https://etri.re.kr/mdt/Submodel/AI/1/1"
+SEMANTIC_ID_SIMULATION_SUBMODEL = "https://etri.re.kr/mdt/Submodel/Simulation/1/1"
+SEMANTIC_ID_DATA_SUBMODEL = "https://etri.re.kr/mdt/Submodel/Data/1/1"
+SEMANTIC_ID_TIME_SERIES_SUBMODEL = 'https://admin-shell.io/idta/TimeSeries/1/1'
+
+@dataclass(frozen=True, slots=True)
+class MDTSubmodelDescriptor(JSONWizard):
+  id: str
+  id_short: str
+  semantic_id: str
+  endpoint: Optional[str]
+
+  def is_information_model(self) -> bool:
+    return self.semantic_id == SEMANTIC_ID_INFOR_MODEL_SUBMODEL
+
+  def is_data(self) -> bool:
+    return self.semantic_id == SEMANTIC_ID_DATA_SUBMODEL
+
+  def is_simulation(self) -> bool:
+    return self.semantic_id == SEMANTIC_ID_SIMULATION_SUBMODEL
+
+  def is_ai(self) -> bool:
+    return self.semantic_id == SEMANTIC_ID_AI_SUBMODEL
+
+  def is_time_series(self) -> bool:
+    return self.semantic_id == SEMANTIC_ID_TIME_SERIES_SUBMODEL
+
+
+@dataclass(frozen=True, slots=True)
+class ArgumentDescriptor(JSONWizard):
+  id: str
+  id_short_path: str
+  value_type: str
+  reference: str
+
+
+@dataclass(frozen=True, slots=True)
+class MDTOperationDescriptor(JSONWizard):
+  id: str
+  operation_type: str
+  input_arguments: list[ArgumentDescriptor]
+  output_arguments: list[ArgumentDescriptor]

mdtpy-0.1.0/src/mdtpy/exceptions.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+    
+class MDTException(Exception):
+  def __init__(self, details:str) -> None:
+    self.details = details
+    super().__init__(details)
+    
+  def __str__(self) -> str:
+    return repr(self)
+
+
+class InternalError(MDTException):
+  def __init__(self, details:str) -> None:
+    super().__init__(details)
+
+
+class TimeoutError(MDTException):
+  def __init__(self, details:str) -> None:
+    super().__init__(details)
+
+
+class CancellationError(MDTException):
+  def __init__(self, details:str) -> None:
+    super().__init__(details)
+
+
+class OperationError(MDTException):
+  def __init__(self, details:str) -> None:
+    super().__init__(details)
+
+
+class RemoteError(MDTException):
+  def __init__(self, details:str) -> None:
+    super().__init__(details)
+
+import requests
+class MDTInstanceConnectionError(MDTException):
+  def __init__(self, details:str, cause:requests.exceptions.ConnectionError) -> None:
+    super().__init__(details)
+    self.cause = cause
+
+  def __repr__(self) -> str:
+    return f"{self.__class__.__name__}(details={self.details}, cause={self.cause})"
+
+   
+class ResourceAlreadyExistsError(MDTException):
+  def __init__(self, details:str) -> None:
+    super().__init__(details)
+      
+  @classmethod
+  def create(cls, resource_type:str, id_spec:str):
+    return ResourceAlreadyExistsError(f"Resource(type={resource_type}, {id_spec})")
+    
+    
+class ResourceNotFoundError(MDTException):
+  def __init__(self, details:str) -> None:
+    super().__init__(details)
+      
+  @classmethod
+  def create(cls, resource_type:str, id_spec:str):
+    return ResourceNotFoundError(f"Resource(type={resource_type}, {id_spec})")
+        
+    
+class InvalidResourceStateError(MDTException):
+  def __init__(self, details:str) -> None:
+    super().__init__(details)
+      
+  @classmethod
+  def create(cls, resource_type:str, id_spec:str, status):
+    return InvalidResourceStateError(f"Resource(type={resource_type}, {id_spec}), status={status}")