dashscope 1.20.7__py3-none-any.whl → 1.20.8__py3-none-any.whl

dashscope/deployment.py

@@ -0,0 +1,163 @@
+from dashscope.api_entities.dashscope_response import DashScopeAPIResponse
+from dashscope.client.base_api import (CreateMixin, DeleteMixin, GetMixin,
+                                       ListMixin, PutMixin, StreamEventMixin)
+
+
+class Deployment(CreateMixin, DeleteMixin, ListMixin, GetMixin,
+                 StreamEventMixin, PutMixin):
+    SUB_PATH = 'deployments'
+    """Deploy a model.
+    """
+    @classmethod
+    def call(cls,
+             model: str,
+             capacity: int,
+             version: str = None,
+             suffix: str = None,
+             api_key: str = None,
+             workspace: str = None,
+             **kwargs) -> DashScopeAPIResponse:
+        """Call to deployment a model service.
+
+        Args:
+            model (str): The model name.
+            version (str, optional): The model version, unnecessary
+                for fine-tuned model. Defaults to None.
+            suffix (str, optional): The name suffix of the model deployment,
+                If specified, the final model name will be model_suffix.
+                Defaults to None.
+            capacity (int, optional): The model service capacity.
+            api_key (str, optional): The api-key. Defaults to None.
+            workspace (str): The dashscope workspace id.
+
+        Returns:
+            DashScopeAPIResponse: _description_
+        """
+        req = {'model_name': model, 'capacity': capacity}
+
+        if version is not None:
+            req['model_version'] = version
+        if suffix is not None:
+            req['suffix'] = suffix
+        return super().call(req,
+                            api_key=api_key,
+                            workspace=workspace,
+                            **kwargs)
+
+    @classmethod
+    def list(cls,
+             page_no=1,
+             page_size=10,
+             api_key: str = None,
+             workspace: str = None,
+             **kwargs) -> DashScopeAPIResponse:
+        """List deployments.
+
+        Args:
+            api_key (str, optional): The api api_key, if not present,
+                will get by default rule(TODO: api key doc). Defaults to None.
+            page_no (int, optional): Page number. Defaults to 1.
+            page_size (int, optional): Items per page. Defaults to 10.
+            workspace (str): The dashscope workspace id.
+
+        Returns:
+            DashScopeAPIResponse: The deployment list.
+        """
+        return super().list(page_no,
+                            page_size,
+                            api_key,
+                            workspace=workspace,
+                            **kwargs)
+
+    @classmethod
+    def get(cls,
+            deployed_model: str,
+            api_key: str = None,
+            workspace: str = None,
+            **kwargs) -> DashScopeAPIResponse:
+        """Get model deployment information.
+
+        Args:
+            deployed_model (str): The deployment_id.
+            api_key (str, optional): The api key. Defaults to None.
+            workspace (str): The dashscope workspace id.
+
+        Returns:
+            DashScopeAPIResponse: The deployment information.
+        """
+        return super().get(deployed_model,
+                           api_key,
+                           workspace=workspace,
+                           **kwargs)
+
+    @classmethod
+    def delete(cls,
+               deployment_id: str,
+               api_key: str = None,
+               workspace: str = None,
+               **kwargs) -> DashScopeAPIResponse:
+        """Delete model deployment.
+
+        Args:
+            deployment_id (str): The deployment id.
+            api_key (str, optional): The api key. Defaults to None.
+            workspace (str): The dashscope workspace id.
+
+        Returns:
+            DashScopeAPIResponse: The delete result.
+        """
+        return super().delete(deployment_id,
+                              api_key,
+                              workspace=workspace,
+                              **kwargs)
+
+    @classmethod
+    def update(cls,
+               deployment_id: str,
+               version: str,
+               api_key: str = None,
+               workspace: str = None,
+               **kwargs) -> DashScopeAPIResponse:
+        """Update model deployment.
+
+        Args:
+            deployment_id (str): The deployment id.
+            version (str): The target model version.
+            api_key (str, optional): The api key. Defaults to None.
+            workspace (str): The dashscope workspace id.
+
+        Returns:
+            DashScopeAPIResponse: The delete result.
+        """
+        req = {'deployment_model': deployment_id, 'model_version': version}
+        return super().put(deployment_id,
+                           req,
+                           api_key,
+                           workspace=workspace,
+                           **kwargs)
+
+    @classmethod
+    def scale(cls,
+              deployment_id: str,
+              capacity: int,
+              api_key: str = None,
+              workspace: str = None,
+              **kwargs) -> DashScopeAPIResponse:
+        """Scaling model deployment.
+
+        Args:
+            deployment_id (str): The deployment id.
+            capacity (int): The target service capacity.
+            api_key (str, optional): The api key. Defaults to None.
+
+        Returns:
+            DashScopeAPIResponse: The delete result.
+        """
+        req = {'deployed_model': deployment_id, 'capacity': capacity}
+        path = '%s/%s/scale' % (cls.SUB_PATH.lower(), deployment_id)
+        return super().put(deployment_id,
+                           req,
+                           path=path,
+                           api_key=api_key,
+                           workspace=workspace,
+                           **kwargs)

dashscope/file.py

@@ -0,0 +1,94 @@
+import os
+
+from dashscope.api_entities.dashscope_response import DashScopeAPIResponse
+from dashscope.client.base_api import (DeleteMixin, FileUploadMixin, GetMixin,
+                                       ListMixin)
+from dashscope.common.constants import FilePurpose
+from dashscope.common.error import InvalidFileFormat
+from dashscope.common.utils import is_validate_fine_tune_file
+
+
+class File(FileUploadMixin, ListMixin, DeleteMixin, GetMixin):
+    SUB_PATH = 'files'
+
+    @classmethod
+    def upload(cls,
+               file_path: str,
+               purpose: str = FilePurpose.fine_tune,
+               description: str = None,
+               api_key: str = None,
+               **kwargs) -> DashScopeAPIResponse:
+        """Upload file for model fine-tune or other tasks.
+
+        Args:
+            file_path (str): The local file name to upload.
+            purpose (str): The purpose of the file[fine-tune|inference]
+            description (str, optional): The file description message.
+            api_key (str, optional): The api key. Defaults to None.
+
+        Returns:
+            DashScopeAPIResponse: The upload information
+        """
+        if purpose == FilePurpose.fine_tune:
+            if not is_validate_fine_tune_file(file_path):
+                raise InvalidFileFormat(
+                    'The file %s is not in valid jsonl format' % file_path)
+        with open(file_path, 'rb') as f:
+            return super().upload(files=[('files', (os.path.basename(f.name),
+                                                    f, None))],
+                                  descriptions=[description]
+                                  if description is not None else None,
+                                  api_key=api_key,
+                                  **kwargs)
+
+    @classmethod
+    def list(cls,
+             page=1,
+             page_size=10,
+             api_key: str = None,
+             **kwargs) -> DashScopeAPIResponse:
+        """List uploaded files.
+
+        Args:
+            api_key (str, optional):
+            The api api_key, can be None,
+                if None, will get by default rule(TODO: api key doc).
+            page (int, optional): Page number. Defaults to 1.
+            page_size (int, optional): Items per page. Defaults to 10.
+
+        Returns:
+            DashScopeAPIResponse: The fine-tune jobs in the result.
+        """
+        return super().list(page, page_size, api_key, **kwargs)
+
+    @classmethod
+    def get(cls,
+            file_id: str,
+            api_key: str = None,
+            **kwargs) -> DashScopeAPIResponse:
+        """Get the file info.
+
+        Args:
+            file_id (str): The file id.
+            api_key (str, optional): The api key. Defaults to None.
+
+        Returns:
+            DashScopeAPIResponse: The job info
+        """
+        return super().get(file_id, api_key, **kwargs)
+
+    @classmethod
+    def delete(cls,
+               file_id: str,
+               api_key: str = None,
+               **kwargs) -> DashScopeAPIResponse:
+        """Delete uploaded file.
+
+        Args:
+            file_id (str): The file id want to delete.
+            api_key (str, optional): The api key. Defaults to None.
+
+        Returns:
+            DashScopeAPIResponse: Delete result.
+        """
+        return super().delete(file_id, api_key, **kwargs)

dashscope/finetune.py

@@ -0,0 +1,175 @@
+from typing import Union
+
+from dashscope.api_entities.dashscope_response import DashScopeAPIResponse
+from dashscope.client.base_api import (CancelMixin, CreateMixin, DeleteMixin,
+                                       GetStatusMixin, ListMixin, LogMixin,
+                                       StreamEventMixin)
+
+
+class FineTune(CreateMixin, CancelMixin, DeleteMixin, ListMixin,
+               GetStatusMixin, StreamEventMixin, LogMixin):
+    SUB_PATH = 'fine-tunes'
+
+    @classmethod
+    def call(cls,
+             model: str,
+             training_file_ids: Union[list, str],
+             validation_file_ids: Union[list, str] = None,
+             mode: str = None,
+             hyper_parameters: dict = {},
+             api_key: str = None,
+             workspace: str = None,
+             **kwargs) -> DashScopeAPIResponse:
+        """Create fine-tune job
+
+        Args:
+            model (str): The model to be fine-tuned
+            training_file_ids (list, str): Ids of the fine-tune training data,
+                which can be pre-uploaded using the File API.
+            validation_file_ids ([list,str], optional): Ids of the fine-tune
+                validating data, which can be pre-uploaded using the File API.
+            mode (str): The fine-tune mode, sft or efficient_sft.
+            hyper_parameters (dict, optional): The fine-tune hyper parameters.
+                Defaults to empty.
+            api_key (str, optional): The api key. Defaults to None.
+            workspace (str): The dashscope workspace id.
+
+        Returns:
+            DashScopeAPIResponse: The request result.
+        """
+        request = {
+            'model': model,
+            'training_file_ids': training_file_ids,
+            'validation_file_ids': validation_file_ids,
+            'hyper_parameters': hyper_parameters if hyper_parameters else {},
+        }
+        if mode is not None:
+            request['training_type'] = mode
+        if 'finetuned_output' in kwargs:
+            request['finetuned_output'] = kwargs['finetuned_output']
+        return super().call(request,
+                            api_key=api_key,
+                            workspace=workspace,
+                            **kwargs)
+
+    @classmethod
+    def cancel(cls,
+               job_id: str,
+               api_key: str = None,
+               workspace: str = None,
+               **kwargs) -> DashScopeAPIResponse:
+        """Cancel a running fine-tune job.
+
+        Args:
+            job_id (str): The fine-tune job id.
+            api_key (str, optional): The api api_key, can be None,
+                if None, will get by default rule(TODO: api key doc).
+            workspace (str): The dashscope workspace id.
+
+        Returns:
+            DashScopeAPIResponse: The request result.
+        """
+        return super().cancel(job_id, api_key, workspace=workspace, **kwargs)
+
+    @classmethod
+    def list(cls,
+             page=1,
+             page_size=10,
+             api_key: str = None,
+             workspace: str = None,
+             **kwargs) -> DashScopeAPIResponse:
+        """List fine-tune job.
+
+        Args:
+            api_key (str, optional): The api key
+            page (int, optional): Page number. Defaults to 1.
+            page_size (int, optional): Items per page. Defaults to 10.
+            workspace (str): The dashscope workspace id.
+
+        Returns:
+            DashScopeAPIResponse: The fine-tune jobs in the result.
+        """
+        return super().list(page,
+                            page_size,
+                            api_key,
+                            workspace=workspace,
+                            **kwargs)
+
+    @classmethod
+    def get(cls,
+            job_id: str,
+            api_key: str = None,
+            workspace: str = None,
+            **kwargs) -> DashScopeAPIResponse:
+        """Get fine-tune job information.
+
+        Args:
+            job_id (str): The fine-tune job id
+            api_key (str, optional): The api key. Defaults to None.
+            workspace (str): The dashscope workspace id.
+
+        Returns:
+            DashScopeAPIResponse: The job info
+        """
+        return super().get(job_id, api_key, workspace=workspace, **kwargs)
+
+    @classmethod
+    def delete(cls,
+               job_id: str,
+               api_key: str = None,
+               workspace: str = None,
+               **kwargs) -> DashScopeAPIResponse:
+        """Delete a fine-tune job.
+
+        Args:
+            job_id (str): The fine-tune job id.
+            api_key (str, optional): The api key. Defaults to None.
+            workspace (str): The dashscope workspace id.
+
+        Returns:
+            DashScopeAPIResponse: The delete result.
+        """
+        return super().delete(job_id, api_key, workspace=workspace, **kwargs)
+
+    @classmethod
+    def stream_events(cls,
+                      job_id: str,
+                      api_key: str = None,
+                      workspace: str = None,
+                      **kwargs) -> DashScopeAPIResponse:
+        """Get fine-tune job events.
+
+        Args:
+            job_id (str): The fine-tune job id
+            api_key (str, optional): the api key. Defaults to None.
+            workspace (str): The dashscope workspace id.
+
+        Returns:
+            DashScopeAPIResponse: The job log events.
+        """
+        return super().stream_events(job_id,
+                                     api_key,
+                                     workspace=workspace,
+                                     **kwargs)
+
+    @classmethod
+    def logs(cls,
+             job_id: str,
+             offset=1,
+             line=1000,
+             api_key: str = None,
+             workspace: str = None,
+             **kwargs) -> DashScopeAPIResponse:
+        """Get log of the job.
+
+        Args:
+            job_id (str): The job id(used for fine-tune)
+            offset (int, optional): start log line. Defaults to 1.
+            line (int, optional): total line return. Defaults to 1000.
+            api_key (str, optional): The api key. Defaults to None.
+            workspace (str): The dashscope workspace id.
+
+        Returns:
+            DashScopeAPIResponse: The response
+        """
+        return super().logs(job_id, offset, line, workspace=workspace)