dxpipe-sdk 0.1.0__tar.gz

dxpipe_sdk-0.1.0/PKG-INFO

@@ -0,0 +1,136 @@
+Metadata-Version: 2.4
+Name: dxpipe-sdk
+Version: 0.1.0
+Summary: Python SDK for DxPipe model editing and simulation workflows
+Author: DxPipe Team
+License-Expression: LicenseRef-Proprietary
+Keywords: dxpipe,pipeline-simulation,oil-gas,sdk,digital-twin
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.31.0
+Requires-Dist: websocket-client>=1.8.0
+Provides-Extra: dev
+Requires-Dist: build>=1.2.2; extra == "dev"
+Requires-Dist: twine>=5.1.1; extra == "dev"
+
+# dxpipe-sdk
+
+dxpipe-sdk is a Python SDK for DxPipe model editing, simulation execution, streaming result retrieval, and runtime command control.
+
+## Features
+
+- Token-based authentication against the DxPipe backend
+- Create models for supported workspace types and open existing models
+- Add, remove, connect, and configure components in the model graph
+- Save model snapshots and start simulation jobs
+- Poll or stream logs, plots, tables, inspect data, and container messages
+- Send runtime commands to components during online or transient execution
+
+## Requirements
+
+- Python 3.10 or later
+- A reachable DxPipe service endpoint
+- A DxPipe account that can obtain access tokens
+
+## Install
+
+Install from a built wheel or from PyPI after publication:
+
+```bash
+pip install dxpipe-sdk
+```
+
+For local development in this repository:
+
+```bash
+pip install -e .
+```
+
+## Quick Start
+
+```python
+from dxpipe_sdk import DxPipeClient
+
+client = DxPipeClient(
+    base_url="http://localhost:8000",
+    username="admin",
+    password="your-password",
+)
+
+model = client.create_model(
+    name="sdk-demo-model",
+    workspace_type="lps_online",
+    description="Created by dxpipe-sdk",
+)
+
+source = model.add_component("Source", position=(0, 0))
+pipe = model.add_component("Pipe", position=(240, 0))
+load = model.add_component("Load", position=(480, 0))
+
+model.connect(source, "0", pipe, "0")
+model.connect(pipe, "1", load, "0")
+
+model.save()
+job = model.run(timeout=120, image="dxpipe")
+
+for message in job.stream_results(timeout=2):
+    print(message.get("type"), message.get("key"))
+```
+
+## Public API
+
+The package currently exports these main entry points:
+
+- `DxPipeClient`
+- `Model`
+- `Component`
+- `Connection`
+- `Job`
+- `MetaService`
+- `ResultStream`
+- `LogMessage`
+- `PlotMessage`
+- `TableMessage`
+- `InspectMessage`
+- `ContainerMessage`
+- `DxPipeError`
+- `AuthError`
+- `APIError`
+- `NotFoundError`
+- `ValidationError`
+
+## Examples
+
+- `examples/quickstart.py`: create, save, run, and fetch results
+- `examples/transient_streaming.py`: stream transient online results and send commands during execution
+- `examples/run_existing_model.py`: open an existing model by ID and run it
+
+## Release Validation
+
+Build and metadata check:
+
+```bash
+python -m build
+python -m twine check dist/*
+```
+
+Minimal install smoke test with the built wheel:
+
+```bash
+python -m venv .smoke-venv
+.smoke-venv\Scripts\python -m pip install dist\dxpipe_sdk-0.1.0-py3-none-any.whl
+.smoke-venv\Scripts\python -c "from dxpipe_sdk import DxPipeClient, Model, Job, ResultStream; print('smoke ok')"
+```
+
+## License
+
+This package is currently distributed as proprietary software.

dxpipe_sdk-0.1.0/README.md

@@ -0,0 +1,112 @@
+# dxpipe-sdk
+
+dxpipe-sdk is a Python SDK for DxPipe model editing, simulation execution, streaming result retrieval, and runtime command control.
+
+## Features
+
+- Token-based authentication against the DxPipe backend
+- Create models for supported workspace types and open existing models
+- Add, remove, connect, and configure components in the model graph
+- Save model snapshots and start simulation jobs
+- Poll or stream logs, plots, tables, inspect data, and container messages
+- Send runtime commands to components during online or transient execution
+
+## Requirements
+
+- Python 3.10 or later
+- A reachable DxPipe service endpoint
+- A DxPipe account that can obtain access tokens
+
+## Install
+
+Install from a built wheel or from PyPI after publication:
+
+```bash
+pip install dxpipe-sdk
+```
+
+For local development in this repository:
+
+```bash
+pip install -e .
+```
+
+## Quick Start
+
+```python
+from dxpipe_sdk import DxPipeClient
+
+client = DxPipeClient(
+    base_url="http://localhost:8000",
+    username="admin",
+    password="your-password",
+)
+
+model = client.create_model(
+    name="sdk-demo-model",
+    workspace_type="lps_online",
+    description="Created by dxpipe-sdk",
+)
+
+source = model.add_component("Source", position=(0, 0))
+pipe = model.add_component("Pipe", position=(240, 0))
+load = model.add_component("Load", position=(480, 0))
+
+model.connect(source, "0", pipe, "0")
+model.connect(pipe, "1", load, "0")
+
+model.save()
+job = model.run(timeout=120, image="dxpipe")
+
+for message in job.stream_results(timeout=2):
+    print(message.get("type"), message.get("key"))
+```
+
+## Public API
+
+The package currently exports these main entry points:
+
+- `DxPipeClient`
+- `Model`
+- `Component`
+- `Connection`
+- `Job`
+- `MetaService`
+- `ResultStream`
+- `LogMessage`
+- `PlotMessage`
+- `TableMessage`
+- `InspectMessage`
+- `ContainerMessage`
+- `DxPipeError`
+- `AuthError`
+- `APIError`
+- `NotFoundError`
+- `ValidationError`
+
+## Examples
+
+- `examples/quickstart.py`: create, save, run, and fetch results
+- `examples/transient_streaming.py`: stream transient online results and send commands during execution
+- `examples/run_existing_model.py`: open an existing model by ID and run it
+
+## Release Validation
+
+Build and metadata check:
+
+```bash
+python -m build
+python -m twine check dist/*
+```
+
+Minimal install smoke test with the built wheel:
+
+```bash
+python -m venv .smoke-venv
+.smoke-venv\Scripts\python -m pip install dist\dxpipe_sdk-0.1.0-py3-none-any.whl
+.smoke-venv\Scripts\python -c "from dxpipe_sdk import DxPipeClient, Model, Job, ResultStream; print('smoke ok')"
+```
+
+## License
+
+This package is currently distributed as proprietary software.

dxpipe_sdk-0.1.0/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "dxpipe-sdk"
+version = "0.1.0"
+description = "Python SDK for DxPipe model editing and simulation workflows"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "LicenseRef-Proprietary"
+authors = [
+    {name = "DxPipe Team"},
+]
+keywords = ["dxpipe", "pipeline-simulation", "oil-gas", "sdk", "digital-twin"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = [
+    "requests>=2.31.0",
+    "websocket-client>=1.8.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "build>=1.2.2",
+    "twine>=5.1.1",
+]
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]

dxpipe_sdk-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

dxpipe_sdk-0.1.0/src/dxpipe_sdk/__init__.py

@@ -0,0 +1,36 @@
+from .client import DxPipeClient
+from .component import Component, PortRef
+from .connection import Connection
+from .exceptions import APIError, AuthError, DxPipeError, NotFoundError, ValidationError
+from .job import Job
+from .meta import MetaService
+from .model import Model
+from .result import (
+    ContainerMessage,
+    InspectMessage,
+    LogMessage,
+    PlotMessage,
+    ResultStream,
+    TableMessage,
+)
+
+__all__ = [
+    "APIError",
+    "AuthError",
+    "Component",
+    "Connection",
+    "ContainerMessage",
+    "DxPipeClient",
+    "DxPipeError",
+    "InspectMessage",
+    "Job",
+    "LogMessage",
+    "MetaService",
+    "Model",
+    "NotFoundError",
+    "PlotMessage",
+    "PortRef",
+    "ResultStream",
+    "TableMessage",
+    "ValidationError",
+]

dxpipe_sdk-0.1.0/src/dxpipe_sdk/_expression.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+import re
+from types import SimpleNamespace
+from typing import Any, Mapping
+
+
+_NOT_PATTERN = re.compile(r"(?<![=!<>])!(?!=)")
+
+
+def _to_namespace(value: Any) -> Any:
+    if isinstance(value, Mapping):
+        return SimpleNamespace(**{key: _to_namespace(item) for key, item in value.items()})
+    if isinstance(value, list):
+        return [_to_namespace(item) for item in value]
+    return value
+
+
+def _equal_text(left: Any, right: Any) -> bool:
+    return str(left) == str(right)
+
+
+def _transform(expr: str) -> str:
+    transformed = expr.strip()
+    transformed = transformed.replace("&&", " and ")
+    transformed = transformed.replace("||", " or ")
+    transformed = re.sub(r"\btrue\b", "True", transformed, flags=re.IGNORECASE)
+    transformed = re.sub(r"\bfalse\b", "False", transformed, flags=re.IGNORECASE)
+    transformed = re.sub(r"\bnull\b", "None", transformed, flags=re.IGNORECASE)
+    transformed = _NOT_PATTERN.sub(" not ", transformed)
+    return transformed
+
+
+def evaluate_condition(expr: str | None, scope: Mapping[str, Any] | None = None) -> bool:
+    if expr is None:
+        return False
+    text = expr.strip()
+    if not text:
+        return False
+    transformed = _transform(text)
+    locals_scope = {key: _to_namespace(value) for key, value in (scope or {}).items()}
+    try:
+        result = eval(
+            transformed,
+            {"__builtins__": {}, "equalText": _equal_text, "min": min, "max": max, "abs": abs, "len": len},
+            locals_scope,
+        )
+    except Exception:
+        return False
+    return bool(result)

dxpipe_sdk-0.1.0/src/dxpipe_sdk/auth.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+import requests
+
+from .exceptions import AuthError
+
+
+@dataclass(slots=True)
+class TokenPair:
+    access_token: str
+    refresh_token: str | None = None
+
+
+class TokenAuth:
+    def __init__(
+        self,
+        *,
+        base_url: str,
+        session: requests.Session,
+        access_token: str | None = None,
+        refresh_token: str | None = None,
+        username: str | None = None,
+        password: str | None = None,
+        timeout: float = 30.0,
+    ) -> None:
+        self._base_url = base_url.rstrip("/")
+        self._session = session
+        self._timeout = timeout
+        self._username = username
+        self._password = password
+        self._tokens = TokenPair(access_token or "", refresh_token)
+
+    @property
+    def access_token(self) -> str | None:
+        return self._tokens.access_token or None
+
+    @property
+    def refresh_token(self) -> str | None:
+        return self._tokens.refresh_token
+
+    @property
+    def authorization_header(self) -> dict[str, str]:
+        if not self.access_token:
+            return {}
+        return {"Authorization": f"Bearer {self.access_token}"}
+
+    @property
+    def can_refresh(self) -> bool:
+        return bool(self.refresh_token or (self._username and self._password))
+
+    def ensure_login(self) -> None:
+        if self.access_token:
+            return
+        if not (self._username and self._password):
+            raise AuthError("No access token or username/password was provided.")
+        self.login(self._username, self._password)
+
+    def login(self, username: str, password: str) -> TokenPair:
+        response = self._session.post(
+            f"{self._base_url}/api/token/",
+            json={"username": username, "password": password},
+            timeout=self._timeout,
+        )
+        payload = _parse_json(response)
+        if response.status_code >= 400:
+            raise AuthError(_extract_error_message(payload, response.text))
+
+        access = payload.get("access") or payload.get("access_token")
+        refresh = payload.get("refresh") or payload.get("refresh_token")
+        if not access:
+            raise AuthError("Token endpoint did not return an access token.")
+        self._username = username
+        self._password = password
+        self._tokens = TokenPair(access, refresh)
+        return self._tokens
+
+    def refresh(self) -> TokenPair:
+        if self.refresh_token:
+            response = self._session.post(
+                f"{self._base_url}/api/token/refresh/",
+                json={"refresh": self.refresh_token},
+                timeout=self._timeout,
+            )
+            payload = _parse_json(response)
+            if response.status_code < 400:
+                access = payload.get("access") or payload.get("access_token")
+                refresh = payload.get("refresh") or payload.get("refresh_token") or self.refresh_token
+                if access:
+                    self._tokens = TokenPair(access, refresh)
+                    return self._tokens
+
+        if self._username and self._password:
+            return self.login(self._username, self._password)
+        raise AuthError("Unable to refresh access token.")
+
+
+def _parse_json(response: requests.Response) -> dict[str, Any]:
+    try:
+        payload = response.json()
+    except ValueError:
+        return {}
+    return payload if isinstance(payload, dict) else {}
+
+
+def _extract_error_message(payload: dict[str, Any], fallback: str) -> str:
+    for key in ("detail", "message", "error", "msg"):
+        value = payload.get(key)
+        if isinstance(value, str) and value.strip():
+            return value
+    return fallback or "Authentication failed."

dxpipe_sdk-0.1.0/src/dxpipe_sdk/client.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+from typing import Any
+
+import requests
+
+from .auth import TokenAuth
+from .http import HttpClient
+from .job import Job
+from .meta import MetaService
+from .model import Model
+
+
+class DxPipeClient:
+    def __init__(
+        self,
+        *,
+        base_url: str,
+        token: str | None = None,
+        refresh_token: str | None = None,
+        username: str | None = None,
+        password: str | None = None,
+        timeout: float = 30.0,
+        session: requests.Session | None = None,
+    ) -> None:
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        self.session = session or requests.Session()
+        self.auth = TokenAuth(
+            base_url=self.base_url,
+            session=self.session,
+            access_token=token,
+            refresh_token=refresh_token,
+            username=username,
+            password=password,
+            timeout=timeout,
+        )
+        self.http = HttpClient(base_url=self.base_url, auth=self.auth, timeout=timeout, session=self.session)
+        self.meta = MetaService(self.http)
+
+    def __enter__(self) -> "DxPipeClient":
+        return self
+
+    def __exit__(self, exc_type: Any, exc: Any, tb: Any) -> None:
+        self.close()
+
+    def close(self) -> None:
+        self.session.close()
+
+    def login(self, username: str, password: str) -> None:
+        self.auth.login(username, password)
+
+    def list_models(self, **params: Any) -> list[Model]:
+        return Model.list(self, **params)
+
+    def get_model(self, model_id: str) -> Model:
+        return Model.get(self, model_id)
+
+    def create_model(
+        self,
+        *,
+        name: str,
+        workspace_type: str,
+        description: str = "",
+        publicity: str = "private",
+        global_params: dict[str, Any] | None = None,
+    ) -> Model:
+        return Model.create(
+            self,
+            name=name,
+            workspace_type=workspace_type,
+            description=description,
+            publicity=publicity,
+            global_params=global_params,
+        )
+
+    def list_jobs(self, **params: Any) -> list[Job]:
+        return Job.list(self, **params)
+
+    def get_job(self, job_id: str) -> Job:
+        return Job.get(self, job_id)