mlflow-tcdeploy-plugin 1.0.0__tar.gz

mlflow_tcdeploy_plugin-1.0.0/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [2025] [tencent]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mlflow_tcdeploy_plugin-1.0.0/PKG-INFO

@@ -0,0 +1,96 @@
+Metadata-Version: 2.4
+Name: mlflow-tcdeploy-plugin
+Version: 1.0.0
+Summary: Tencent Cloud deployment plugin for MLflow
+Home-page: https://git.woa.com/WeDataOS/wedata3-monorepo
+Author: Tencent WeData Team
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: mlflow<3.11.0,>=3.10.0
+Requires-Dist: tencentcloud-sdk-python>=3.0.1478
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: python-dotenv; extra == "dev"
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# mlflow-tcdeploy-plugin
+
+MLflow deployment plugin，将腾讯云模型服务对接为 MLflow Deployment 后端。
+
+与 `mlflow-tclake-plugin`（Model Registry）配套使用：
+- `tclake`：负责模型存储 → TCLake
+- `tcdeploy`：负责模型部署 → 腾讯云在线推理服务
+
+## 安装
+
+```bash
+pip install mlflow-tcdeploy-plugin
+```
+
+## 环境变量（来自 wedata-pre-execute）
+
+| 变量 | 说明 | 必填 |
+|------|------|------|
+| `KERNEL_WEDATA_CLOUD_SDK_SECRET_ID` | 腾讯云 SecretId | 是 |
+| `KERNEL_WEDATA_CLOUD_SDK_SECRET_KEY` | 腾讯云 SecretKey | 是 |
+| `KERNEL_WEDATA_REGION` | 地域，如 `ap-guangzhou` | 否（默认 ap-guangzhou） |
+| `WEDATA_WORKSPACE_ID` | WeData 工作空间 ID | 是 |
+| `TENCENTCLOUD_ENDPOINT` | WeData API endpoint | 否（默认 wedata.internal.tencentcloudapi.com） |
+| `KERNEL_WEDATA_CLOUD_SDK_SECRET_TOKEN` | 临时凭证 Token | 否 |
+
+## 使用
+
+```python
+from mlflow.deployments import get_deploy_client
+
+client = get_deploy_client("tcdeploy")
+
+# 查询可用规格
+specs = client.list_instance_types(spec_type="CPU")
+available = [s for s in specs if s["available"]]
+print(available[0]["spec_name"])  # e.g. "TI.SA5.2XLARGE32.POST"
+
+# 创建部署
+client.create_deployment(
+    name="my-service",
+    model_uri="models:/MyModel/1",
+    config={"instance_type": "TI.SA5.2XLARGE32.POST"},
+)
+
+# 获取详情
+info = client.get_deployment(name="svc-id-xxxx")
+
+# 更新
+client.update_deployment(name="svc-id-xxxx", config={"replicas": 2})
+
+# 删除（幂等）
+client.delete_deployment(name="svc-id-xxxx")
+
+# 列举服务组
+groups = client.list_deployments()
+# 按服务组过滤
+groups = client.list_deployments(endpoint="grp-001")
+```
+
+## 测试
+
+```bash
+pytest tests/           # 单元测试
+pytest tests/integration/  # 集成测试（需要真实环境变量）
+```

mlflow_tcdeploy_plugin-1.0.0/README.md

@@ -0,0 +1,65 @@
+# mlflow-tcdeploy-plugin
+
+MLflow deployment plugin，将腾讯云模型服务对接为 MLflow Deployment 后端。
+
+与 `mlflow-tclake-plugin`（Model Registry）配套使用：
+- `tclake`：负责模型存储 → TCLake
+- `tcdeploy`：负责模型部署 → 腾讯云在线推理服务
+
+## 安装
+
+```bash
+pip install mlflow-tcdeploy-plugin
+```
+
+## 环境变量（来自 wedata-pre-execute）
+
+| 变量 | 说明 | 必填 |
+|------|------|------|
+| `KERNEL_WEDATA_CLOUD_SDK_SECRET_ID` | 腾讯云 SecretId | 是 |
+| `KERNEL_WEDATA_CLOUD_SDK_SECRET_KEY` | 腾讯云 SecretKey | 是 |
+| `KERNEL_WEDATA_REGION` | 地域，如 `ap-guangzhou` | 否（默认 ap-guangzhou） |
+| `WEDATA_WORKSPACE_ID` | WeData 工作空间 ID | 是 |
+| `TENCENTCLOUD_ENDPOINT` | WeData API endpoint | 否（默认 wedata.internal.tencentcloudapi.com） |
+| `KERNEL_WEDATA_CLOUD_SDK_SECRET_TOKEN` | 临时凭证 Token | 否 |
+
+## 使用
+
+```python
+from mlflow.deployments import get_deploy_client
+
+client = get_deploy_client("tcdeploy")
+
+# 查询可用规格
+specs = client.list_instance_types(spec_type="CPU")
+available = [s for s in specs if s["available"]]
+print(available[0]["spec_name"])  # e.g. "TI.SA5.2XLARGE32.POST"
+
+# 创建部署
+client.create_deployment(
+    name="my-service",
+    model_uri="models:/MyModel/1",
+    config={"instance_type": "TI.SA5.2XLARGE32.POST"},
+)
+
+# 获取详情
+info = client.get_deployment(name="svc-id-xxxx")
+
+# 更新
+client.update_deployment(name="svc-id-xxxx", config={"replicas": 2})
+
+# 删除（幂等）
+client.delete_deployment(name="svc-id-xxxx")
+
+# 列举服务组
+groups = client.list_deployments()
+# 按服务组过滤
+groups = client.list_deployments(endpoint="grp-001")
+```
+
+## 测试
+
+```bash
+pytest tests/           # 单元测试
+pytest tests/integration/  # 集成测试（需要真实环境变量）
+```

mlflow_tcdeploy_plugin-1.0.0/mlflow_tcdeploy_plugin/__init__.py

@@ -0,0 +1,3 @@
+# -*-coding:utf-8-*-
+
+__version__ = "1.0.0"

mlflow_tcdeploy_plugin-1.0.0/mlflow_tcdeploy_plugin/api_client.py

@@ -0,0 +1,129 @@
+from typing import Optional
+
+from tencentcloud.common import credential
+from tencentcloud.common.abstract_client import AbstractClient
+from tencentcloud.common.profile.client_profile import ClientProfile
+from tencentcloud.common.exception.tencent_cloud_sdk_exception import TencentCloudSDKException
+from mlflow.exceptions import MlflowException
+
+from mlflow_tcdeploy_plugin.config import TcDeployConfig
+
+
+class WedataDeployClient(AbstractClient):
+    """WeData deployment API client, inherits AbstractClient for TC3 signing."""
+    _apiVersion = '2025-10-10'
+    _endpoint = 'wedata.internal.tencentcloudapi.com'
+    _service = 'wedata'
+
+
+class ModelServiceApiClient:
+    """Wraps WeData model service cloud API calls."""
+
+    def __init__(self, config: TcDeployConfig):
+        self._config = config
+        cred = credential.Credential(
+            config.secret_id,
+            config.secret_key,
+            config.secret_token,
+        )
+        client_profile = ClientProfile()
+        client_profile.httpProfile.endpoint = config.endpoint
+
+        self._wedata_client = WedataDeployClient(cred, config.region, client_profile)
+
+    def _call(self, action: str, body: dict) -> dict:
+        try:
+            return self._wedata_client.call_json(action, body)
+        except TencentCloudSDKException as e:
+            raise MlflowException(f"{e.code}: {e.message}") from e
+
+    def _base_body(self) -> dict:
+        """Common fields required in all requests."""
+        return {"WorkspaceId": self._config.workspace_id}
+
+    def create_deployment(self, body: dict) -> dict:
+        req = {**self._base_body(), **body}
+        return self._call("CreateMLModelServices", req)
+
+    def update_deployment(self, service_id: str, body: dict) -> None:
+        req = {**self._base_body(), "ServiceId": service_id, **body}
+        self._call("UpdateMLModelService", req)
+
+    def delete_deployment(self, service_id: str) -> None:
+        req = {**self._base_body(), "ServiceId": service_id}
+        try:
+            self._call("DeleteMLModelService", req)
+        except MlflowException as e:
+            if "ResourceNotFound" in str(e):
+                return  # idempotent
+            raise
+
+    def get_deployment(self, service_id: str) -> dict:
+        req = {**self._base_body(), "ServiceId": service_id}
+        return self._call("GetMLModelService", req)
+
+    def list_deployments(self, endpoint: Optional[str] = None) -> list:
+        req = {**self._base_body()}
+        if endpoint:
+            req["ServiceGroupId"] = endpoint
+        resp = self._call("ListMLModelServiceGroups", req)
+        return resp.get("Groups", [])
+
+    def predict(
+        self,
+        service_group_id: str,
+        curl_data: str,
+        relative_url=None,
+        auth_token_value=None,
+    ) -> dict:
+        req = {
+            **self._base_body(),
+            "ServiceGroupId": service_group_id,
+            "CurlData": curl_data,
+        }
+        if relative_url is not None:
+            req["RelativeUrl"] = relative_url
+        if auth_token_value is not None:
+            req["AuthTokenValue"] = auth_token_value
+        return self._call("ModelServiceInterfaceCallTest", req)
+
+    def debug_pod_shell(self, service_id: str, pod_name: str) -> dict:
+        req = {
+            **self._base_body(),
+            "ServiceId": service_id,
+            "PodName": pod_name,
+        }
+        return self._call("CreateModelServicePodUrl", req)
+
+    def restart_pod(self, service_id: str, pod_name: str) -> dict:
+        req = {
+            **self._base_body(),
+            "ServiceId": service_id,
+            "PodName": pod_name,
+        }
+        return self._call("RebuildModelServicePod", req)
+
+    def get_pod_logs(
+        self,
+        service_id: str,
+        pod_name=None,
+        limit=None,
+        start_time=None,
+        end_time=None,
+        context=None,
+    ) -> dict:
+        req = {
+            **self._base_body(),
+            "ServiceId": service_id,
+        }
+        if pod_name is not None:
+            req["PodName"] = pod_name
+        if limit is not None:
+            req["Limit"] = limit
+        if start_time is not None:
+            req["StartTime"] = start_time
+        if end_time is not None:
+            req["EndTime"] = end_time
+        if context is not None:
+            req["Context"] = context
+        return self._call("ListMLServiceLogs", req)

mlflow_tcdeploy_plugin-1.0.0/mlflow_tcdeploy_plugin/client.py

@@ -0,0 +1,181 @@
+import json
+from typing import List, Optional
+
+from mlflow.deployments import BaseDeploymentClient
+from tencentcloud.common import credential
+from tencentcloud.tione.v20211111 import tione_client
+
+from mlflow_tcdeploy_plugin.api_client import ModelServiceApiClient
+from mlflow_tcdeploy_plugin.config import TcDeployConfig
+from mlflow_tcdeploy_plugin.models import build_create_request, snake_to_camel_dict, to_snake_case_dict
+
+
+class TcDeploymentClient(BaseDeploymentClient):
+    """
+    MLflow deployment client, connecting Tencent Cloud model service as MLflow deployment backend.
+
+    Usage:
+        from mlflow.deployments import get_deploy_client
+        client = get_deploy_client("tcdeploy")
+
+    Required environment variables (from wedata-pre-execute):
+        KERNEL_WEDATA_CLOUD_SDK_SECRET_ID, KERNEL_WEDATA_CLOUD_SDK_SECRET_KEY,
+        KERNEL_WEDATA_REGION, WEDATA_WORKSPACE_ID
+    """
+
+    def __init__(self, target_uri: str):
+        super().__init__(target_uri)
+        self._config = TcDeployConfig()
+        self._api = ModelServiceApiClient(self._config)
+
+    def create_deployment(
+        self,
+        name: str,
+        model_uri: str,
+        flavor=None,
+        config: Optional[dict] = None,
+        endpoint: Optional[str] = None,
+    ) -> dict:
+        """
+        Create a model service.
+
+        Args:
+            name: service name
+            model_uri: MLflow model URI, e.g. "models:/MyModel/1"
+            config: deployment config, must include instance_type.
+                    Use list_instance_types() to see available options.
+            endpoint: service group ID (serviceGroupId), optional
+        """
+        body = build_create_request(
+            name=name,
+            model_uri=model_uri,
+            config=config or {},
+            endpoint=endpoint,
+        )
+        raw = self._api.create_deployment(body)
+        return to_snake_case_dict(raw)
+
+    def update_deployment(
+        self,
+        name: str,
+        model_uri: Optional[str] = None,
+        flavor=None,
+        config: Optional[dict] = None,
+        endpoint: Optional[str] = None,
+    ) -> None:
+        """
+        Update a model service. name is serviceId. Only pass fields to change.
+        """
+        self._api.update_deployment(name, snake_to_camel_dict(config or {}))
+
+    def delete_deployment(
+        self,
+        name: str,
+        config: Optional[dict] = None,
+        endpoint: Optional[str] = None,
+    ) -> None:
+        """
+        Delete a model service. name is serviceId. Idempotent.
+        """
+        self._api.delete_deployment(name)
+
+    def get_deployment(self, name: str, endpoint: Optional[str] = None) -> dict:
+        """
+        Get model service details. name is serviceId. Returns snake_case dict.
+        """
+        raw = self._api.get_deployment(name)
+        return to_snake_case_dict(raw)
+
+    def list_deployments(self, endpoint: Optional[str] = None) -> List[dict]:
+        """
+        List service groups. endpoint is serviceGroupId filter, optional.
+        Each item includes "name" field (serviceGroupId) as required by MLflow spec.
+        """
+        raw_list = self._api.list_deployments(endpoint=endpoint)
+        result = []
+        for item in raw_list:
+            converted = to_snake_case_dict(item)
+            # MLflow spec requires each item to have "name" field
+            converted["name"] = item.get("ServiceGroupId", "")
+            result.append(converted)
+        return result
+
+    def list_instance_types(self, spec_type: Optional[str] = None) -> List[dict]:
+        """
+        Query available TIone spec list. Calls TIone SDK directly, bypassing Java layer.
+
+        Args:
+            spec_type: "CPU" or "GPU", returns all if not specified
+
+        Returns:
+            list of dict with spec_name, spec_alias, spec_type, available, available_region, gpu_type
+        """
+        cred = credential.Credential(
+            self._config.secret_id,
+            self._config.secret_key,
+            self._config.secret_token,
+        )
+        client = tione_client.TioneClient(cred, self._config.region)
+
+        # Access via module attribute so that unit-test patches on tione_client are effective
+        req = tione_client.models.DescribeInferenceSpecsRequest()
+        resp = client.DescribeInferenceSpecs(req)
+
+        specs = []
+        for s in resp.SpecInfos or []:
+            if spec_type and s.SpecType != spec_type:
+                continue
+            specs.append({
+                "spec_name": s.SpecName,
+                "spec_alias": s.SpecAlias,
+                "spec_type": s.SpecType,
+                "available": s.Available,
+                "available_region": list(s.AvailableRegion or []),
+                "gpu_type": s.GpuType or "",
+            })
+        return specs
+
+    def predict(
+        self,
+        deployment_name=None,
+        inputs=None,
+        endpoint=None,
+        config=None,
+    ):
+        try:
+            curl_data = json.dumps(inputs)
+        except (TypeError, ValueError) as e:
+            raise ValueError(f"inputs must be JSON-serializable, got {type(inputs).__name__}: {e}") from e
+
+        raw = self._api.predict(
+            service_group_id=deployment_name,
+            curl_data=curl_data,
+            relative_url=endpoint or "/predict",
+            auth_token_value=(config or {}).get("auth_token"),
+        )
+
+        raw_str = raw.get("CurlResponseRaw", "")
+        try:
+            return json.loads(raw_str)
+        except (json.JSONDecodeError, TypeError):
+            return {"raw": raw_str}
+
+    def debug_pod_shell(self, service_id, pod_name):
+        raw = self._api.debug_pod_shell(service_id=service_id, pod_name=pod_name)
+        return to_snake_case_dict(raw)
+
+    def restart_pod(self, service_id, pod_name):
+        raw = self._api.restart_pod(service_id=service_id, pod_name=pod_name)
+        return {"request_id": raw.get("TiOneRebuildServiceRequestId")}
+
+    def get_pod_logs(self, service_id, pod_name=None, limit=None, start_time=None, end_time=None, context=None):
+        raw = self._api.get_pod_logs(
+            service_id=service_id,
+            pod_name=pod_name,
+            limit=limit,
+            start_time=start_time,
+            end_time=end_time,
+            context=context,
+        )
+        logs = [to_snake_case_dict(entry) for entry in (raw.get("Content") or [])]
+        return {"logs": logs, "context": raw.get("Context")}

mlflow_tcdeploy_plugin-1.0.0/mlflow_tcdeploy_plugin/config.py

@@ -0,0 +1,45 @@
+import os
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+def _require_env(key: str, override: Optional[str]) -> str:
+    value = override or os.getenv(key)
+    if not value:
+        raise ValueError(
+            f"Missing required configuration: '{key}'. "
+            f"Set the environment variable or pass it as a parameter."
+        )
+    return value
+
+
+@dataclass
+class TcDeployConfig:
+    secret_id: str = field(init=False)
+    secret_key: str = field(init=False)
+    secret_token: Optional[str] = field(init=False)
+    region: str = field(init=False)
+    workspace_id: str = field(init=False)
+    endpoint: str = field(init=False)
+    sub_account_uin: str = field(init=False)
+    owner_uin: str = field(init=False)
+
+    def __init__(
+        self,
+        secret_id: Optional[str] = None,
+        secret_key: Optional[str] = None,
+        secret_token: Optional[str] = None,
+        region: Optional[str] = None,
+        workspace_id: Optional[str] = None,
+        endpoint: Optional[str] = None,
+    ):
+        self.secret_id = _require_env("KERNEL_WEDATA_CLOUD_SDK_SECRET_ID", secret_id)
+        self.secret_key = _require_env("KERNEL_WEDATA_CLOUD_SDK_SECRET_KEY", secret_key)
+        self.secret_token = secret_token or os.getenv("KERNEL_WEDATA_CLOUD_SDK_SECRET_TOKEN")
+        self.region = region or os.getenv("KERNEL_WEDATA_REGION", "ap-guangzhou")
+        self.workspace_id = _require_env("WEDATA_WORKSPACE_ID", workspace_id)
+        self.endpoint = endpoint or os.getenv(
+            "TENCENTCLOUD_ENDPOINT", "wedata.internal.tencentcloudapi.com"
+        )
+        self.sub_account_uin = os.getenv("KERNEL_LOGIN_UIN", "")
+        self.owner_uin = os.getenv("QCLOUD_UIN", "")

mlflow_tcdeploy_plugin-1.0.0/mlflow_tcdeploy_plugin/models.py

@@ -0,0 +1,89 @@
+import re
+from typing import Optional
+
+DEFAULT_CONFIG = {
+    "scaleMode": "MANUAL",
+    "replicas": 1,
+    "chargeType": "POSTPAID_BY_HOUR",
+    "authorizationEnable": False,
+    "logEnable": False,
+}
+
+# snake_case key → camelCase key mapping (config uses snake_case, request uses camelCase)
+_SNAKE_TO_CAMEL = {
+    "instance_type": "instanceType",
+    "scale_mode": "scaleMode",
+    "replicas": "replicas",
+    "charge_type": "chargeType",
+    "authorization_enable": "authorizationEnable",
+    "log_enable": "logEnable",
+    "service_group_id": "serviceGroupId",
+}
+
+
+def _camel_to_snake(name: str) -> str:
+    s1 = re.sub(r"(.)([A-Z][a-z]+)", r"\1_\2", name)
+    return re.sub(r"([a-z0-9])([A-Z])", r"\1_\2", s1).lower()
+
+
+def to_snake_case_dict(data: dict) -> dict:
+    """Recursively convert dict keys from camelCase to snake_case."""
+    result = {}
+    for k, v in data.items():
+        snake_key = _camel_to_snake(k)
+        if isinstance(v, dict):
+            result[snake_key] = to_snake_case_dict(v)
+        else:
+            result[snake_key] = v
+    return result
+
+
+def parse_model_uri(model_uri: str) -> dict:
+    """
+    Parse MLflow model URI into mlModelInfo fields.
+    Supports:
+      - models:/ModelName/Version  → name + version
+      - runs:/run_id/path          → modelPath
+    """
+    if model_uri.startswith("models:/"):
+        parts = model_uri[len("models:/"):].split("/")
+        if len(parts) < 2:
+            raise ValueError(f"Invalid models URI: {model_uri}")
+        return {"name": parts[0], "version": parts[1], "modelPath": None}
+    elif model_uri.startswith("runs:/"):
+        return {"name": None, "version": None, "modelPath": model_uri}
+    else:
+        raise ValueError(f"Unsupported model_uri scheme: {model_uri}")
+
+
+def snake_to_camel_dict(config: dict) -> dict:
+    """Convert config dict keys from snake_case to camelCase using _SNAKE_TO_CAMEL mapping."""
+    return {_SNAKE_TO_CAMEL.get(k, k): v for k, v in config.items()}
+
+
+def build_create_request(
+    name: str,
+    model_uri: str,
+    config: dict,
+    endpoint: Optional[str] = None,
+) -> dict:
+    """Assemble create_deployment parameters into a cloud API request body.
+
+    Note: WorkspaceId is injected by ModelServiceApiClient._base_body(), not here.
+    """
+    if not config.get("instance_type"):
+        raise ValueError(
+            "config must include 'instance_type'. "
+            "Use list_instance_types() to see available options."
+        )
+
+    camel_config = snake_to_camel_dict(config)
+
+    req = {**DEFAULT_CONFIG, **camel_config}
+    req["serviceName"] = name
+    req["mlModelInfo"] = parse_model_uri(model_uri)
+
+    if endpoint:
+        req["serviceGroupId"] = endpoint
+
+    return req