tencentcloud-sdk-python-ai3d 3.0.1490__tar.gz → 3.1.12__tar.gz

{tencentcloud_sdk_python_ai3d-3.0.1490 → tencentcloud_sdk_python_ai3d-3.1.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tencentcloud-sdk-python-ai3d
-Version: 3.0.1490
+Version: 3.1.12
 Summary: Tencent Cloud Ai3d SDK for Python
 Home-page: https://github.com/TencentCloud/tencentcloud-sdk-python
 Author: Tencent Cloud
@@ -15,7 +15,7 @@ Classifier: Programming Language :: Python :: 2.7
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.6
 Classifier: Programming Language :: Python :: 3.7
-Requires-Dist: tencentcloud-sdk-python-common<4.0.0,>=3.0.1490
+Requires-Dist: tencentcloud-sdk-python-common<4.0.0,>=3.1.12
 
 ============================
 Tencent Cloud SDK for Python

{tencentcloud_sdk_python_ai3d-3.0.1490 → tencentcloud_sdk_python_ai3d-3.1.12}/setup.py

@@ -8,7 +8,8 @@ ROOT = os.path.dirname(__file__)
 
 setup(
     name='tencentcloud-sdk-python-ai3d',
-    install_requires=["tencentcloud-sdk-python-common>=3.0.1490,<4.0.0"],
+    install_requires=["tencentcloud-sdk-python-common>=3.1.12,<4.0.0"],
+    
     version=tencentcloud.__version__,
     description='Tencent Cloud Ai3d SDK for Python',
     long_description=open('README.rst').read(),

{tencentcloud_sdk_python_ai3d-3.0.1490 → tencentcloud_sdk_python_ai3d-3.1.12}/tencentcloud/__init__.py

@@ -14,4 +14,4 @@
 # limitations under the License.
 
 
-__version__ = '3.0.1490'
+__version__ = '3.1.12'

tencentcloud_sdk_python_ai3d-3.1.12/tencentcloud/ai3d/v20250513/ai3d_client.py

@@ -0,0 +1,333 @@
+# -*- coding: utf8 -*-
+# Copyright (c) 2017-2025 Tencent. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import json
+
+from tencentcloud.common.exception.tencent_cloud_sdk_exception import TencentCloudSDKException
+from tencentcloud.common.abstract_client import AbstractClient
+from tencentcloud.ai3d.v20250513 import models
+
+
+class Ai3dClient(AbstractClient):
+    _apiVersion = '2025-05-13'
+    _endpoint = 'ai3d.tencentcloudapi.com'
+    _service = 'ai3d'
+
+
+    def Convert3DFormat(self, request):
+        r"""输入3D模型文件后，可进行3D模型文件格式转换。
+
+        :param request: Request instance for Convert3DFormat.
+        :type request: :class:`tencentcloud.ai3d.v20250513.models.Convert3DFormatRequest`
+        :rtype: :class:`tencentcloud.ai3d.v20250513.models.Convert3DFormatResponse`
+
+        """
+        try:
+            params = request._serialize()
+            headers = request.headers
+            body = self.call("Convert3DFormat", params, headers=headers)
+            response = json.loads(body)
+            model = models.Convert3DFormatResponse()
+            model._deserialize(response["Response"])
+            return model
+        except Exception as e:
+            if isinstance(e, TencentCloudSDKException):
+                raise
+            else:
+                raise TencentCloudSDKException(type(e).__name__, str(e))
+
+
+    def DescribeHunyuanTo3DUVJob(self, request):
+        r"""查询组件拆分任务。
+
+        :param request: Request instance for DescribeHunyuanTo3DUVJob.
+        :type request: :class:`tencentcloud.ai3d.v20250513.models.DescribeHunyuanTo3DUVJobRequest`
+        :rtype: :class:`tencentcloud.ai3d.v20250513.models.DescribeHunyuanTo3DUVJobResponse`
+
+        """
+        try:
+            params = request._serialize()
+            headers = request.headers
+            body = self.call("DescribeHunyuanTo3DUVJob", params, headers=headers)
+            response = json.loads(body)
+            model = models.DescribeHunyuanTo3DUVJobResponse()
+            model._deserialize(response["Response"])
+            return model
+        except Exception as e:
+            if isinstance(e, TencentCloudSDKException):
+                raise
+            else:
+                raise TencentCloudSDKException(type(e).__name__, str(e))
+
+
+    def DescribeReduceFaceJob(self, request):
+        r"""混元生3D接口，基于混元大模型，根据输入的文本描述/图片智能生成3D。
+        默认提供1个并发，代表最多能同时处理1个已提交的任务，上一个任务处理完毕后，才能开始处理下一个任务。
+
+        :param request: Request instance for DescribeReduceFaceJob.
+        :type request: :class:`tencentcloud.ai3d.v20250513.models.DescribeReduceFaceJobRequest`
+        :rtype: :class:`tencentcloud.ai3d.v20250513.models.DescribeReduceFaceJobResponse`
+
+        """
+        try:
+            params = request._serialize()
+            headers = request.headers
+            body = self.call("DescribeReduceFaceJob", params, headers=headers)
+            response = json.loads(body)
+            model = models.DescribeReduceFaceJobResponse()
+            model._deserialize(response["Response"])
+            return model
+        except Exception as e:
+            if isinstance(e, TencentCloudSDKException):
+                raise
+            else:
+                raise TencentCloudSDKException(type(e).__name__, str(e))
+
+
+    def DescribeTextureTo3DJob(self, request):
+        r"""混元生3D接口，基于混元大模型，根据输入的文本描述/图片智能生成3D。
+        默认提供1个并发，代表最多能同时处理1个已提交的任务，上一个任务处理完毕后，才能开始处理下一个任务。
+
+        :param request: Request instance for DescribeTextureTo3DJob.
+        :type request: :class:`tencentcloud.ai3d.v20250513.models.DescribeTextureTo3DJobRequest`
+        :rtype: :class:`tencentcloud.ai3d.v20250513.models.DescribeTextureTo3DJobResponse`
+
+        """
+        try:
+            params = request._serialize()
+            headers = request.headers
+            body = self.call("DescribeTextureTo3DJob", params, headers=headers)
+            response = json.loads(body)
+            model = models.DescribeTextureTo3DJobResponse()
+            model._deserialize(response["Response"])
+            return model
+        except Exception as e:
+            if isinstance(e, TencentCloudSDKException):
+                raise
+            else:
+                raise TencentCloudSDKException(type(e).__name__, str(e))
+
+
+    def QueryHunyuan3DPartJob(self, request):
+        r"""查询组件生成任务。
+
+        :param request: Request instance for QueryHunyuan3DPartJob.
+        :type request: :class:`tencentcloud.ai3d.v20250513.models.QueryHunyuan3DPartJobRequest`
+        :rtype: :class:`tencentcloud.ai3d.v20250513.models.QueryHunyuan3DPartJobResponse`
+
+        """
+        try:
+            params = request._serialize()
+            headers = request.headers
+            body = self.call("QueryHunyuan3DPartJob", params, headers=headers)
+            response = json.loads(body)
+            model = models.QueryHunyuan3DPartJobResponse()
+            model._deserialize(response["Response"])
+            return model
+        except Exception as e:
+            if isinstance(e, TencentCloudSDKException):
+                raise
+            else:
+                raise TencentCloudSDKException(type(e).__name__, str(e))
+
+
+    def QueryHunyuanTo3DProJob(self, request):
+        r"""混元生3D接口，基于混元大模型，根据输入的文本描述/图片智能生成3D。
+        默认提供3个并发，代表最多能同时处理3个已提交的任务，上一个任务处理完毕后，才能开始处理下一个任务。
+
+        :param request: Request instance for QueryHunyuanTo3DProJob.
+        :type request: :class:`tencentcloud.ai3d.v20250513.models.QueryHunyuanTo3DProJobRequest`
+        :rtype: :class:`tencentcloud.ai3d.v20250513.models.QueryHunyuanTo3DProJobResponse`
+
+        """
+        try:
+            params = request._serialize()
+            headers = request.headers
+            body = self.call("QueryHunyuanTo3DProJob", params, headers=headers)
+            response = json.loads(body)
+            model = models.QueryHunyuanTo3DProJobResponse()
+            model._deserialize(response["Response"])
+            return model
+        except Exception as e:
+            if isinstance(e, TencentCloudSDKException):
+                raise
+            else:
+                raise TencentCloudSDKException(type(e).__name__, str(e))
+
+
+    def QueryHunyuanTo3DRapidJob(self, request):
+        r"""混元生3D接口，基于混元大模型，根据输入的文本描述/图片智能生成3D。
+        默认提供1个并发，代表最多能同时处理1个已提交的任务，上一个任务处理完毕后，才能开始处理下一个任务。
+
+        :param request: Request instance for QueryHunyuanTo3DRapidJob.
+        :type request: :class:`tencentcloud.ai3d.v20250513.models.QueryHunyuanTo3DRapidJobRequest`
+        :rtype: :class:`tencentcloud.ai3d.v20250513.models.QueryHunyuanTo3DRapidJobResponse`
+
+        """
+        try:
+            params = request._serialize()
+            headers = request.headers
+            body = self.call("QueryHunyuanTo3DRapidJob", params, headers=headers)
+            response = json.loads(body)
+            model = models.QueryHunyuanTo3DRapidJobResponse()
+            model._deserialize(response["Response"])
+            return model
+        except Exception as e:
+            if isinstance(e, TencentCloudSDKException):
+                raise
+            else:
+                raise TencentCloudSDKException(type(e).__name__, str(e))
+
+
+    def SubmitHunyuan3DPartJob(self, request):
+        r"""输入3D模型文件后，根据模型结构自动进行组件识别生成。
+
+        :param request: Request instance for SubmitHunyuan3DPartJob.
+        :type request: :class:`tencentcloud.ai3d.v20250513.models.SubmitHunyuan3DPartJobRequest`
+        :rtype: :class:`tencentcloud.ai3d.v20250513.models.SubmitHunyuan3DPartJobResponse`
+
+        """
+        try:
+            params = request._serialize()
+            headers = request.headers
+            body = self.call("SubmitHunyuan3DPartJob", params, headers=headers)
+            response = json.loads(body)
+            model = models.SubmitHunyuan3DPartJobResponse()
+            model._deserialize(response["Response"])
+            return model
+        except Exception as e:
+            if isinstance(e, TencentCloudSDKException):
+                raise
+            else:
+                raise TencentCloudSDKException(type(e).__name__, str(e))
+
+
+    def SubmitHunyuanTo3DProJob(self, request):
+        r"""混元生3D接口，基于混元大模型，根据输入的文本描述/图片智能生成3D。
+        默认提供3个并发，代表最多能同时处理3个已提交的任务，上一个任务处理完毕后，才能开始处理下一个任务。
+
+        :param request: Request instance for SubmitHunyuanTo3DProJob.
+        :type request: :class:`tencentcloud.ai3d.v20250513.models.SubmitHunyuanTo3DProJobRequest`
+        :rtype: :class:`tencentcloud.ai3d.v20250513.models.SubmitHunyuanTo3DProJobResponse`
+
+        """
+        try:
+            params = request._serialize()
+            headers = request.headers
+            body = self.call("SubmitHunyuanTo3DProJob", params, headers=headers)
+            response = json.loads(body)
+            model = models.SubmitHunyuanTo3DProJobResponse()
+            model._deserialize(response["Response"])
+            return model
+        except Exception as e:
+            if isinstance(e, TencentCloudSDKException):
+                raise
+            else:
+                raise TencentCloudSDKException(type(e).__name__, str(e))
+
+
+    def SubmitHunyuanTo3DRapidJob(self, request):
+        r"""混元生3D接口，基于混元大模型，根据输入的文本描述/图片智能生成3D。
+        默认提供1个并发，代表最多能同时处理1个已提交的任务，上一个任务处理完毕后，才能开始处理下一个任务。
+
+        :param request: Request instance for SubmitHunyuanTo3DRapidJob.
+        :type request: :class:`tencentcloud.ai3d.v20250513.models.SubmitHunyuanTo3DRapidJobRequest`
+        :rtype: :class:`tencentcloud.ai3d.v20250513.models.SubmitHunyuanTo3DRapidJobResponse`
+
+        """
+        try:
+            params = request._serialize()
+            headers = request.headers
+            body = self.call("SubmitHunyuanTo3DRapidJob", params, headers=headers)
+            response = json.loads(body)
+            model = models.SubmitHunyuanTo3DRapidJobResponse()
+            model._deserialize(response["Response"])
+            return model
+        except Exception as e:
+            if isinstance(e, TencentCloudSDKException):
+                raise
+            else:
+                raise TencentCloudSDKException(type(e).__name__, str(e))
+
+
+    def SubmitHunyuanTo3DUVJob(self, request):
+        r"""输入模型后，可根据模型纹理进行UV展开，输出对应UV贴图。
+
+        :param request: Request instance for SubmitHunyuanTo3DUVJob.
+        :type request: :class:`tencentcloud.ai3d.v20250513.models.SubmitHunyuanTo3DUVJobRequest`
+        :rtype: :class:`tencentcloud.ai3d.v20250513.models.SubmitHunyuanTo3DUVJobResponse`
+
+        """
+        try:
+            params = request._serialize()
+            headers = request.headers
+            body = self.call("SubmitHunyuanTo3DUVJob", params, headers=headers)
+            response = json.loads(body)
+            model = models.SubmitHunyuanTo3DUVJobResponse()
+            model._deserialize(response["Response"])
+            return model
+        except Exception as e:
+            if isinstance(e, TencentCloudSDKException):
+                raise
+            else:
+                raise TencentCloudSDKException(type(e).__name__, str(e))
+
+
+    def SubmitReduceFaceJob(self, request):
+        r"""混元生3D接口，基于混元大模型，根据输入的文本描述/图片智能生成3D。
+        默认提供1个并发，代表最多能同时处理1个已提交的任务，上一个任务处理完毕后，才能开始处理下一个任务。
+
+        :param request: Request instance for SubmitReduceFaceJob.
+        :type request: :class:`tencentcloud.ai3d.v20250513.models.SubmitReduceFaceJobRequest`
+        :rtype: :class:`tencentcloud.ai3d.v20250513.models.SubmitReduceFaceJobResponse`
+
+        """
+        try:
+            params = request._serialize()
+            headers = request.headers
+            body = self.call("SubmitReduceFaceJob", params, headers=headers)
+            response = json.loads(body)
+            model = models.SubmitReduceFaceJobResponse()
+            model._deserialize(response["Response"])
+            return model
+        except Exception as e:
+            if isinstance(e, TencentCloudSDKException):
+                raise
+            else:
+                raise TencentCloudSDKException(type(e).__name__, str(e))
+
+
+    def SubmitTextureTo3DJob(self, request):
+        r"""混元生3D接口，基于混元大模型，根据输入的文本描述/图片智能生成3D。
+        默认提供1个并发，代表最多能同时处理1个已提交的任务，上一个任务处理完毕后，才能开始处理下一个任务。
+
+        :param request: Request instance for SubmitTextureTo3DJob.
+        :type request: :class:`tencentcloud.ai3d.v20250513.models.SubmitTextureTo3DJobRequest`
+        :rtype: :class:`tencentcloud.ai3d.v20250513.models.SubmitTextureTo3DJobResponse`
+
+        """
+        try:
+            params = request._serialize()
+            headers = request.headers
+            body = self.call("SubmitTextureTo3DJob", params, headers=headers)
+            response = json.loads(body)
+            model = models.SubmitTextureTo3DJobResponse()
+            model._deserialize(response["Response"])
+            return model
+        except Exception as e:
+            if isinstance(e, TencentCloudSDKException):
+                raise
+            else:
+                raise TencentCloudSDKException(type(e).__name__, str(e))

tencentcloud_sdk_python_ai3d-3.1.12/tencentcloud/ai3d/v20250513/ai3d_client_async.py

@@ -0,0 +1,268 @@
+# -*- coding: utf8 -*-
+# Copyright (c) 2017-2025 Tencent. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+
+from tencentcloud.common.abstract_client_async import AbstractClient
+from tencentcloud.ai3d.v20250513 import models
+from typing import Dict
+
+
+class Ai3dClient(AbstractClient):
+    _apiVersion = '2025-05-13'
+    _endpoint = 'ai3d.tencentcloudapi.com'
+    _service = 'ai3d'
+
+    async def Convert3DFormat(
+            self,
+            request: models.Convert3DFormatRequest,
+            opts: Dict = None,
+    ) -> models.Convert3DFormatResponse:
+        """
+        输入3D模型文件后，可进行3D模型文件格式转换。
+        """
+        
+        kwargs = {}
+        kwargs["action"] = "Convert3DFormat"
+        kwargs["params"] = request._serialize()
+        kwargs["resp_cls"] = models.Convert3DFormatResponse
+        kwargs["headers"] = request.headers
+        kwargs["opts"] = opts or {}
+        
+        return await self.call_and_deserialize(**kwargs)
+        
+    async def DescribeHunyuanTo3DUVJob(
+            self,
+            request: models.DescribeHunyuanTo3DUVJobRequest,
+            opts: Dict = None,
+    ) -> models.DescribeHunyuanTo3DUVJobResponse:
+        """
+        查询组件拆分任务。
+        """
+        
+        kwargs = {}
+        kwargs["action"] = "DescribeHunyuanTo3DUVJob"
+        kwargs["params"] = request._serialize()
+        kwargs["resp_cls"] = models.DescribeHunyuanTo3DUVJobResponse
+        kwargs["headers"] = request.headers
+        kwargs["opts"] = opts or {}
+        
+        return await self.call_and_deserialize(**kwargs)
+        
+    async def DescribeReduceFaceJob(
+            self,
+            request: models.DescribeReduceFaceJobRequest,
+            opts: Dict = None,
+    ) -> models.DescribeReduceFaceJobResponse:
+        """
+        混元生3D接口，基于混元大模型，根据输入的文本描述/图片智能生成3D。
+        默认提供1个并发，代表最多能同时处理1个已提交的任务，上一个任务处理完毕后，才能开始处理下一个任务。
+        """
+        
+        kwargs = {}
+        kwargs["action"] = "DescribeReduceFaceJob"
+        kwargs["params"] = request._serialize()
+        kwargs["resp_cls"] = models.DescribeReduceFaceJobResponse
+        kwargs["headers"] = request.headers
+        kwargs["opts"] = opts or {}
+        
+        return await self.call_and_deserialize(**kwargs)
+        
+    async def DescribeTextureTo3DJob(
+            self,
+            request: models.DescribeTextureTo3DJobRequest,
+            opts: Dict = None,
+    ) -> models.DescribeTextureTo3DJobResponse:
+        """
+        混元生3D接口，基于混元大模型，根据输入的文本描述/图片智能生成3D。
+        默认提供1个并发，代表最多能同时处理1个已提交的任务，上一个任务处理完毕后，才能开始处理下一个任务。
+        """
+        
+        kwargs = {}
+        kwargs["action"] = "DescribeTextureTo3DJob"
+        kwargs["params"] = request._serialize()
+        kwargs["resp_cls"] = models.DescribeTextureTo3DJobResponse
+        kwargs["headers"] = request.headers
+        kwargs["opts"] = opts or {}
+        
+        return await self.call_and_deserialize(**kwargs)
+        
+    async def QueryHunyuan3DPartJob(
+            self,
+            request: models.QueryHunyuan3DPartJobRequest,
+            opts: Dict = None,
+    ) -> models.QueryHunyuan3DPartJobResponse:
+        """
+        查询组件生成任务。
+        """
+        
+        kwargs = {}
+        kwargs["action"] = "QueryHunyuan3DPartJob"
+        kwargs["params"] = request._serialize()
+        kwargs["resp_cls"] = models.QueryHunyuan3DPartJobResponse
+        kwargs["headers"] = request.headers
+        kwargs["opts"] = opts or {}
+        
+        return await self.call_and_deserialize(**kwargs)
+        
+    async def QueryHunyuanTo3DProJob(
+            self,
+            request: models.QueryHunyuanTo3DProJobRequest,
+            opts: Dict = None,
+    ) -> models.QueryHunyuanTo3DProJobResponse:
+        """
+        混元生3D接口，基于混元大模型，根据输入的文本描述/图片智能生成3D。
+        默认提供3个并发，代表最多能同时处理3个已提交的任务，上一个任务处理完毕后，才能开始处理下一个任务。
+        """
+        
+        kwargs = {}
+        kwargs["action"] = "QueryHunyuanTo3DProJob"
+        kwargs["params"] = request._serialize()
+        kwargs["resp_cls"] = models.QueryHunyuanTo3DProJobResponse
+        kwargs["headers"] = request.headers
+        kwargs["opts"] = opts or {}
+        
+        return await self.call_and_deserialize(**kwargs)
+        
+    async def QueryHunyuanTo3DRapidJob(
+            self,
+            request: models.QueryHunyuanTo3DRapidJobRequest,
+            opts: Dict = None,
+    ) -> models.QueryHunyuanTo3DRapidJobResponse:
+        """
+        混元生3D接口，基于混元大模型，根据输入的文本描述/图片智能生成3D。
+        默认提供1个并发，代表最多能同时处理1个已提交的任务，上一个任务处理完毕后，才能开始处理下一个任务。
+        """
+        
+        kwargs = {}
+        kwargs["action"] = "QueryHunyuanTo3DRapidJob"
+        kwargs["params"] = request._serialize()
+        kwargs["resp_cls"] = models.QueryHunyuanTo3DRapidJobResponse
+        kwargs["headers"] = request.headers
+        kwargs["opts"] = opts or {}
+        
+        return await self.call_and_deserialize(**kwargs)
+        
+    async def SubmitHunyuan3DPartJob(
+            self,
+            request: models.SubmitHunyuan3DPartJobRequest,
+            opts: Dict = None,
+    ) -> models.SubmitHunyuan3DPartJobResponse:
+        """
+        输入3D模型文件后，根据模型结构自动进行组件识别生成。
+        """
+        
+        kwargs = {}
+        kwargs["action"] = "SubmitHunyuan3DPartJob"
+        kwargs["params"] = request._serialize()
+        kwargs["resp_cls"] = models.SubmitHunyuan3DPartJobResponse
+        kwargs["headers"] = request.headers
+        kwargs["opts"] = opts or {}
+        
+        return await self.call_and_deserialize(**kwargs)
+        
+    async def SubmitHunyuanTo3DProJob(
+            self,
+            request: models.SubmitHunyuanTo3DProJobRequest,
+            opts: Dict = None,
+    ) -> models.SubmitHunyuanTo3DProJobResponse:
+        """
+        混元生3D接口，基于混元大模型，根据输入的文本描述/图片智能生成3D。
+        默认提供3个并发，代表最多能同时处理3个已提交的任务，上一个任务处理完毕后，才能开始处理下一个任务。
+        """
+        
+        kwargs = {}
+        kwargs["action"] = "SubmitHunyuanTo3DProJob"
+        kwargs["params"] = request._serialize()
+        kwargs["resp_cls"] = models.SubmitHunyuanTo3DProJobResponse
+        kwargs["headers"] = request.headers
+        kwargs["opts"] = opts or {}
+        
+        return await self.call_and_deserialize(**kwargs)
+        
+    async def SubmitHunyuanTo3DRapidJob(
+            self,
+            request: models.SubmitHunyuanTo3DRapidJobRequest,
+            opts: Dict = None,
+    ) -> models.SubmitHunyuanTo3DRapidJobResponse:
+        """
+        混元生3D接口，基于混元大模型，根据输入的文本描述/图片智能生成3D。
+        默认提供1个并发，代表最多能同时处理1个已提交的任务，上一个任务处理完毕后，才能开始处理下一个任务。
+        """
+        
+        kwargs = {}
+        kwargs["action"] = "SubmitHunyuanTo3DRapidJob"
+        kwargs["params"] = request._serialize()
+        kwargs["resp_cls"] = models.SubmitHunyuanTo3DRapidJobResponse
+        kwargs["headers"] = request.headers
+        kwargs["opts"] = opts or {}
+        
+        return await self.call_and_deserialize(**kwargs)
+        
+    async def SubmitHunyuanTo3DUVJob(
+            self,
+            request: models.SubmitHunyuanTo3DUVJobRequest,
+            opts: Dict = None,
+    ) -> models.SubmitHunyuanTo3DUVJobResponse:
+        """
+        输入模型后，可根据模型纹理进行UV展开，输出对应UV贴图。
+        """
+        
+        kwargs = {}
+        kwargs["action"] = "SubmitHunyuanTo3DUVJob"
+        kwargs["params"] = request._serialize()
+        kwargs["resp_cls"] = models.SubmitHunyuanTo3DUVJobResponse
+        kwargs["headers"] = request.headers
+        kwargs["opts"] = opts or {}
+        
+        return await self.call_and_deserialize(**kwargs)
+        
+    async def SubmitReduceFaceJob(
+            self,
+            request: models.SubmitReduceFaceJobRequest,
+            opts: Dict = None,
+    ) -> models.SubmitReduceFaceJobResponse:
+        """
+        混元生3D接口，基于混元大模型，根据输入的文本描述/图片智能生成3D。
+        默认提供1个并发，代表最多能同时处理1个已提交的任务，上一个任务处理完毕后，才能开始处理下一个任务。
+        """
+        
+        kwargs = {}
+        kwargs["action"] = "SubmitReduceFaceJob"
+        kwargs["params"] = request._serialize()
+        kwargs["resp_cls"] = models.SubmitReduceFaceJobResponse
+        kwargs["headers"] = request.headers
+        kwargs["opts"] = opts or {}
+        
+        return await self.call_and_deserialize(**kwargs)
+        
+    async def SubmitTextureTo3DJob(
+            self,
+            request: models.SubmitTextureTo3DJobRequest,
+            opts: Dict = None,
+    ) -> models.SubmitTextureTo3DJobResponse:
+        """
+        混元生3D接口，基于混元大模型，根据输入的文本描述/图片智能生成3D。
+        默认提供1个并发，代表最多能同时处理1个已提交的任务，上一个任务处理完毕后，才能开始处理下一个任务。
+        """
+        
+        kwargs = {}
+        kwargs["action"] = "SubmitTextureTo3DJob"
+        kwargs["params"] = request._serialize()
+        kwargs["resp_cls"] = models.SubmitTextureTo3DJobResponse
+        kwargs["headers"] = request.headers
+        kwargs["opts"] = opts or {}
+        
+        return await self.call_and_deserialize(**kwargs)