dashscope 1.8.0__py3-none-any.whl → 1.25.6__py3-none-any.whl

dashscope/customize/deployments.py

@@ -0,0 +1,146 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+
+from dashscope.client.base_api import (CreateMixin, DeleteMixin, GetMixin,
+                                       ListMixin, PutMixin, StreamEventMixin)
+from dashscope.customize.customize_types import (Deployment, DeploymentDelete,
+                                                 DeploymentList)
+
+
+class Deployments(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) -> Deployment:
+        """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:
+            Deployment: _description_
+        """
+        req = {'model_name': model, 'capacity': capacity}
+
+        if version is not None:
+            req['model_version'] = version
+        if suffix is not None:
+            req['suffix'] = suffix
+        response = super().call(req,
+                                api_key=api_key,
+                                workspace=workspace,
+                                **kwargs)
+        return Deployment(**response)
+
+    @classmethod
+    def list(cls,
+             page_no=1,
+             page_size=10,
+             api_key: str = None,
+             workspace: str = None,
+             **kwargs) -> DeploymentList:
+        """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:
+            Deployment: The deployment list.
+        """
+        response = super().list(page_no=page_no,
+                                page_size=page_size,
+                                api_key=api_key,
+                                workspace=workspace,
+                                **kwargs)
+        return DeploymentList(**response)
+
+    @classmethod
+    def get(cls,
+            deployed_model: str,
+            api_key: str = None,
+            workspace: str = None,
+            **kwargs) -> Deployment:
+        """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:
+            Deployment: The deployment information.
+        """
+        response = super().get(deployed_model,
+                               api_key=api_key,
+                               workspace=workspace,
+                               **kwargs)
+        return Deployment(**response)
+
+    @classmethod
+    def delete(cls,
+               deployed_model: str,
+               api_key: str = None,
+               workspace: str = None,
+               **kwargs) -> DeploymentDelete:
+        """Delete model deployment.
+
+        Args:
+            deployed_model (str): The deployment id.
+            api_key (str, optional): The api key. Defaults to None.
+            workspace (str): The dashscope workspace id.
+
+        Returns:
+            Deployment: The delete result.
+        """
+        response = super().delete(deployed_model,
+                                  api_key=api_key,
+                                  workspace=workspace,
+                                  **kwargs)
+        return DeploymentDelete(**response)
+
+    @classmethod
+    def scale(cls,
+              deployed_model: str,
+              capacity: int,
+              api_key: str = None,
+              workspace: str = None,
+              **kwargs) -> Deployment:
+        """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:
+            Deployment: The delete result.
+        """
+        req = {'deployed_model': deployed_model, 'capacity': capacity}
+        path = '%s/%s/scale' % (cls.SUB_PATH.lower(), deployed_model)
+        response = super().put(deployed_model,
+                               req,
+                               path=path,
+                               api_key=api_key,
+                               workspace=workspace,
+                               **kwargs)
+        return Deployment(**response)

dashscope/customize/finetunes.py

@@ -0,0 +1,234 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+
+import time
+from http import HTTPStatus
+from typing import Iterator, Union
+
+from dashscope.client.base_api import (CancelMixin, CreateMixin, DeleteMixin,
+                                       GetStatusMixin, ListMixin, LogMixin,
+                                       StreamEventMixin)
+from dashscope.common.constants import TaskStatus
+from dashscope.customize.customize_types import (FineTune, FineTuneCancel,
+                                                 FineTuneDelete, FineTuneEvent,
+                                                 FineTuneList)
+
+
+class FineTunes(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) -> FineTune:
+        """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:
+            FineTune: The request result.
+        """
+        if isinstance(training_file_ids, str):
+            training_file_ids = [training_file_ids]
+        if validation_file_ids and isinstance(validation_file_ids, str):
+            validation_file_ids = [validation_file_ids]
+        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']
+        resp = super().call(request,
+                            api_key=api_key,
+                            workspace=workspace,
+                            **kwargs)
+        return FineTune(**resp)
+
+    @classmethod
+    def cancel(cls,
+               job_id: str,
+               api_key: str = None,
+               workspace: str = None,
+               **kwargs) -> FineTuneCancel:
+        """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:
+            FineTune: The request result.
+        """
+        rsp = super().cancel(job_id,
+                             api_key=api_key,
+                             workspace=workspace,
+                             **kwargs)
+        return FineTuneCancel(**rsp)
+
+    @classmethod
+    def list(cls,
+             page_no=1,
+             page_size=10,
+             api_key: str = None,
+             workspace: str = None,
+             **kwargs) -> FineTuneList:
+        """List fine-tune job.
+
+        Args:
+            api_key (str, optional): The api key
+            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:
+            FineTune: The fine-tune jobs in the result.
+        """
+        response = super().list(page_no=page_no,
+                                page_size=page_size,
+                                api_key=api_key,
+                                workspace=workspace,
+                                **kwargs)
+        return FineTuneList(**response)
+
+    @classmethod
+    def get(cls,
+            job_id: str,
+            api_key: str = None,
+            workspace: str = None,
+            **kwargs) -> FineTune:
+        """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:
+            FineTune: The job info
+        """
+        response = super().get(job_id,
+                               api_key=api_key,
+                               workspace=workspace,
+                               **kwargs)
+        return FineTune(**response)
+
+    @classmethod
+    def delete(cls,
+               job_id: str,
+               api_key: str = None,
+               workspace: str = None,
+               **kwargs) -> FineTuneDelete:
+        """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:
+            FineTune: The delete result.
+        """
+        rsp = super().delete(job_id,
+                             api_key=api_key,
+                             workspace=workspace,
+                             **kwargs)
+        return FineTuneDelete(**rsp)
+
+    @classmethod
+    def stream_events(cls,
+                      job_id: str,
+                      api_key: str = None,
+                      workspace: str = None,
+                      **kwargs) -> Iterator[FineTuneEvent]:
+        """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:
+            FineTune: The job log events.
+        """
+        responses = super().stream_events(job_id,
+                                          api_key=api_key,
+                                          workspace=workspace,
+                                          **kwargs)
+        for rsp in responses:
+            yield FineTuneEvent(**rsp)
+
+    @classmethod
+    def logs(cls,
+             job_id: str,
+             *,
+             offset=1,
+             line=1000,
+             api_key: str = None,
+             workspace: str = None,
+             **kwargs) -> FineTune:
+        """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:
+            FineTune: The response
+        """
+        return super().logs(job_id,
+                            offset=offset,
+                            line=line,
+                            workspace=workspace,
+                            api_key=api_key)
+
+    @classmethod
+    def wait(cls,
+             job_id: str,
+             api_key: str = None,
+             workspace: str = None,
+             **kwargs):
+        try:
+            while True:
+                rsp = FineTunes.get(job_id,
+                                    api_key=api_key,
+                                    workspace=workspace,
+                                    **kwargs)
+                if rsp.status_code == HTTPStatus.OK:
+                    if rsp.output['status'] in [
+                            TaskStatus.FAILED, TaskStatus.CANCELED,
+                            TaskStatus.SUCCEEDED
+                    ]:
+                        return rsp
+                    else:
+                        time.sleep(30)
+                else:
+                    return rsp
+        except Exception:
+            raise Exception(
+                'You can stream output via: dashscope fine_tunes.stream -j %s'
+                % job_id)

dashscope/embeddings/__init__.py

@@ -1,3 +1,7 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+
+from .batch_text_embedding import BatchTextEmbedding
+from .batch_text_embedding_response import BatchTextEmbeddingResponse
 from .text_embedding import TextEmbedding
 
-__all__ = [TextEmbedding]
+__all__ = [TextEmbedding, BatchTextEmbedding, BatchTextEmbeddingResponse]

dashscope/embeddings/batch_text_embedding.py

@@ -0,0 +1,208 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+
+from typing import Union
+
+from dashscope.api_entities.dashscope_response import DashScopeAPIResponse
+from dashscope.client.base_api import BaseAsyncApi
+from dashscope.common.error import InputRequired
+from dashscope.common.utils import _get_task_group_and_task
+from dashscope.embeddings.batch_text_embedding_response import \
+    BatchTextEmbeddingResponse
+
+
+class BatchTextEmbedding(BaseAsyncApi):
+    task = 'text-embedding'
+    function = 'text-embedding'
+    """API for async text embedding.
+    """
+    class Models:
+        text_embedding_async_v1 = 'text-embedding-async-v1'
+        text_embedding_async_v2 = 'text-embedding-async-v2'
+
+    @classmethod
+    def call(cls,
+             model: str,
+             url: str,
+             api_key: str = None,
+             workspace: str = None,
+             **kwargs) -> BatchTextEmbeddingResponse:
+        """Call async text embedding service and get result.
+
+        Args:
+            model (str): The model, reference ``Models``.
+            url (Any): The async request file url, which contains text
+                to embedding line by line.
+            api_key (str, optional): The api api_key. Defaults to None.
+            workspace (str): The dashscope workspace id.
+            **kwargs:
+                text_type(str, `optional`): [query|document], After the
+                text is converted into a vector, it can be applied to
+                downstream tasks such as retrieval, clustering, and
+                classification. For asymmetric tasks such as retrieval,
+                in order to achieve better retrieval results, it is
+                recommended to distinguish between query text (query)
+                and bottom database text (document) types, clustering
+                Symmetric tasks such as , classification, etc. do not
+                need to be specially specified, and the system
+                default value "document" can be used
+        Raises:
+            InputRequired: The url cannot be empty.
+
+        Returns:
+            AsyncTextEmbeddingResponse: The async text embedding task result.
+        """
+        return super().call(model,
+                            url,
+                            api_key=api_key,
+                            workspace=workspace,
+                            **kwargs)
+
+    @classmethod
+    def async_call(cls,
+                   model: str,
+                   url: str,
+                   api_key: str = None,
+                   workspace: str = None,
+                   **kwargs) -> BatchTextEmbeddingResponse:
+        """Create a async text embedding task, and return task information.
+
+        Args:
+            model (str): The model, reference ``Models``.
+            url (Any): The async request file url, which contains text
+                to embedding line by line.
+            api_key (str, optional): The api api_key. Defaults to None.
+            workspace (str): The dashscope workspace id.
+            **kwargs:
+                text_type(str, `optional`): [query|document], After the
+                text is converted into a vector, it can be applied to
+                downstream tasks such as retrieval, clustering, and
+                classification. For asymmetric tasks such as retrieval,
+                in order to achieve better retrieval results, it is
+                recommended to distinguish between query text (query)
+                and bottom database text (document) types, clustering
+                Symmetric tasks such as , classification, etc. do not
+                need to be specially specified, and the system
+                default value "document" can be used
+
+        Raises:
+            InputRequired: The url cannot be empty.
+
+        Returns:
+            DashScopeAPIResponse: The image synthesis
+                task id in the response.
+        """
+        if url is None or not url:
+            raise InputRequired('url is required!')
+        input = {'url': url}
+        task_group, _ = _get_task_group_and_task(__name__)
+        response = super().async_call(model=model,
+                                      task_group=task_group,
+                                      task=BatchTextEmbedding.task,
+                                      function=BatchTextEmbedding.function,
+                                      api_key=api_key,
+                                      input=input,
+                                      workspace=workspace,
+                                      **kwargs)
+        return BatchTextEmbeddingResponse.from_api_response(response)
+
+    @classmethod
+    def fetch(cls,
+              task: Union[str, BatchTextEmbeddingResponse],
+              api_key: str = None,
+              workspace: str = None) -> BatchTextEmbeddingResponse:
+        """Fetch async text embedding task status or result.
+
+        Args:
+            task (Union[str, AsyncTextEmbeddingResponse]): The task_id or
+                AsyncTextEmbeddingResponse return by async_call().
+            api_key (str, optional): The api api_key. Defaults to None.
+            workspace (str): The dashscope workspace id.
+
+        Returns:
+            AsyncTextEmbeddingResponse: The task status or result.
+        """
+        response = super().fetch(task, api_key, workspace=workspace)
+        return BatchTextEmbeddingResponse.from_api_response(response)
+
+    @classmethod
+    def wait(cls,
+             task: Union[str, BatchTextEmbeddingResponse],
+             api_key: str = None,
+             workspace: str = None) -> BatchTextEmbeddingResponse:
+        """Wait for async text embedding task to complete, and return the result.
+
+        Args:
+            task (Union[str, AsyncTextEmbeddingResponse]): The task_id or
+                AsyncTextEmbeddingResponse return by async_call().
+            api_key (str, optional): The api api_key. Defaults to None.
+            workspace (str): The dashscope workspace id.
+
+        Returns:
+            AsyncTextEmbeddingResponse: The task result.
+        """
+        response = super().wait(task, api_key, workspace=workspace)
+        return BatchTextEmbeddingResponse.from_api_response(response)
+
+    @classmethod
+    def cancel(cls,
+               task: Union[str, BatchTextEmbeddingResponse],
+               api_key: str = None,
+               workspace: str = None) -> DashScopeAPIResponse:
+        """Cancel async text embedding task.
+        Only tasks whose status is PENDING can be canceled.
+
+        Args:
+            task (Union[str, AsyncTextEmbeddingResponse]): The task_id or
+                AsyncTextEmbeddingResponse return by async_call().
+            api_key (str, optional): The api api_key. Defaults to None.
+            workspace (str): The dashscope workspace id.
+
+        Returns:
+            DashScopeAPIResponse: The response data.
+        """
+        return super().cancel(task, api_key, workspace=workspace)
+
+    @classmethod
+    def list(cls,
+             start_time: str = None,
+             end_time: str = None,
+             model_name: str = None,
+             api_key_id: str = None,
+             region: str = None,
+             status: str = None,
+             page_no: int = 1,
+             page_size: int = 10,
+             api_key: str = None,
+             workspace: str = None,
+             **kwargs) -> DashScopeAPIResponse:
+        """List async tasks.
+
+        Args:
+            start_time (str, optional): The tasks start time,
+                for example: 20230420000000. Defaults to None.
+            end_time (str, optional): The tasks end time,
+                for example: 20230420000000. Defaults to None.
+            model_name (str, optional): The tasks model name. Defaults to None.
+            api_key_id (str, optional): The tasks api-key-id. Defaults to None.
+            region (str, optional): The service region,
+                for example: cn-beijing. Defaults to None.
+            status (str, optional): The status of tasks[PENDING,
+                RUNNING, SUCCEEDED, FAILED, CANCELED]. Defaults to None.
+            page_no (int, optional): The page number. Defaults to 1.
+            page_size (int, optional): The page size. Defaults to 10.
+            api_key (str, optional): The user api-key. Defaults to None.
+
+        Returns:
+            DashScopeAPIResponse: The response data.
+        """
+        return super().list(start_time=start_time,
+                            end_time=end_time,
+                            model_name=model_name,
+                            api_key_id=api_key_id,
+                            region=region,
+                            status=status,
+                            page_no=page_no,
+                            page_size=page_size,
+                            api_key=api_key,
+                            workspace=workspace,
+                            **kwargs)

dashscope/embeddings/batch_text_embedding_response.py

@@ -0,0 +1,65 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+
+from http import HTTPStatus
+
+from attr import dataclass
+
+from dashscope.api_entities.dashscope_response import (DashScopeAPIResponse,
+                                                       DictMixin)
+
+
+@dataclass(init=False)
+class BatchTextEmbeddingOutput(DictMixin):
+    task_id: str
+    task_status: str
+    url: str
+
+    def __init__(self,
+                 task_id: str,
+                 task_status: str,
+                 url: str = None,
+                 **kwargs):
+        super().__init__(self,
+                         task_id=task_id,
+                         task_status=task_status,
+                         url=url,
+                         **kwargs)
+
+
+@dataclass(init=False)
+class BatchTextEmbeddingUsage(DictMixin):
+    total_tokens: int
+
+    def __init__(self, total_tokens: int=None, **kwargs):
+        super().__init__(total_tokens=total_tokens, **kwargs)
+
+
+@dataclass(init=False)
+class BatchTextEmbeddingResponse(DashScopeAPIResponse):
+    output: BatchTextEmbeddingOutput
+    usage: BatchTextEmbeddingUsage
+
+    @staticmethod
+    def from_api_response(api_response: DashScopeAPIResponse):
+        if api_response.status_code == HTTPStatus.OK:
+            output = None
+            usage = None
+            if api_response.output is not None:
+                output = BatchTextEmbeddingOutput(**api_response.output)
+            if api_response.usage is not None:
+                usage = BatchTextEmbeddingUsage(**api_response.usage)
+
+            return BatchTextEmbeddingResponse(
+                status_code=api_response.status_code,
+                request_id=api_response.request_id,
+                code=api_response.code,
+                message=api_response.message,
+                output=output,
+                usage=usage)
+
+        else:
+            return BatchTextEmbeddingResponse(
+                status_code=api_response.status_code,
+                request_id=api_response.request_id,
+                code=api_response.code,
+                message=api_response.message)