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

dashscope/api_entities/dashscope_response.py

@@ -1,3 +1,5 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+
 import json
 from dataclasses import dataclass
 from http import HTTPStatus
@@ -110,13 +112,14 @@ class Role:
     SYSTEM = 'system'
     BOT = 'bot'
     ASSISTANT = 'assistant'
+    ATTACHMENT = 'attachment'
 
 
 class Message(DictMixin):
     role: str
     content: Union[str, List]
 
-    def __init__(self, role: str, content: str, **kwargs):
+    def __init__(self, role: str, content: str = None, **kwargs):
         super().__init__(role=role, content=content, **kwargs)
 
     @classmethod
@@ -136,12 +139,37 @@ class Message(DictMixin):
 class Choice(DictMixin):
     finish_reason: str
     message: Message
-    def __init__(self, finish_reason: str = None, message: Message = None, **kwargs):
+
+    def __init__(self,
+                 finish_reason: str = None,
+                 message: Message = None,
+                 **kwargs):
         msgObject = None
-        if message is not None:
+        if message is not None and message:
             msgObject = Message(**message)
-        super().__init__(finish_reason=finish_reason, 
-                         message=msgObject, **kwargs)
+        super().__init__(finish_reason=finish_reason,
+                         message=msgObject,
+                         **kwargs)
+
+
+@dataclass(init=False)
+class Audio(DictMixin):
+    data: str
+    url: str
+    id: str
+    expires_at: int
+
+    def __init__(self,
+                 data: str = None,
+                 url: str = None,
+                 id: str = None,
+                 expires_at: int = None,
+                 **kwargs):
+        super().__init__(data=data,
+                         url=url,
+                         id=id,
+                         expires_at=expires_at,
+                         **kwargs)
 
 
 @dataclass(init=False)
@@ -159,7 +187,7 @@ class GenerationOutput(DictMixin):
         if choices is not None:
             chs = []
             for choice in choices:
-                chs.append(Choice(**choice))             
+                chs.append(Choice(**choice))
         super().__init__(text=text,
                          finish_reason=finish_reason,
                          choices=chs,
@@ -205,23 +233,29 @@ class GenerationResponse(DashScopeAPIResponse):
                                       code=api_response.code,
                                       message=api_response.message)
 
+
 @dataclass(init=False)
 class MultiModalConversationOutput(DictMixin):
     choices: List[Choice]
+    audio: Audio
 
     def __init__(self,
                  text: str = None,
                  finish_reason: str = None,
                  choices: List[Choice] = None,
+                 audio: Audio = None,
                  **kwargs):
         chs = None
         if choices is not None:
             chs = []
             for choice in choices:
-                chs.append(Choice(**choice)) 
+                chs.append(Choice(**choice))
+        if audio is not None:
+            audio = Audio(**audio)
         super().__init__(text=text,
                          finish_reason=finish_reason,
                          choices=chs,
+                         audio=audio,
                          **kwargs)
 
 
@@ -229,14 +263,18 @@ class MultiModalConversationOutput(DictMixin):
 class MultiModalConversationUsage(DictMixin):
     input_tokens: int
     output_tokens: int
+    characters: int
+
     # TODO add image usage info.
 
     def __init__(self,
                  input_tokens: int = 0,
                  output_tokens: int = 0,
+                 characters: int = 0,
                  **kwargs):
         super().__init__(input_tokens=input_tokens,
                          output_tokens=output_tokens,
+                         characters=characters,
                          **kwargs)
 
 
@@ -260,10 +298,12 @@ class MultiModalConversationResponse(DashScopeAPIResponse):
                 output=MultiModalConversationOutput(**api_response.output),
                 usage=MultiModalConversationUsage(**usage))
         else:
-            return MultiModalConversationResponse(status_code=api_response.status_code,
-                                      request_id=api_response.request_id,
-                                      code=api_response.code,
-                                      message=api_response.message)
+            return MultiModalConversationResponse(
+                status_code=api_response.status_code,
+                request_id=api_response.request_id,
+                code=api_response.code,
+                message=api_response.message)
+
 
 @dataclass(init=False)
 class ConversationResponse(GenerationResponse):
@@ -366,7 +406,7 @@ class RecognitionResponse(DashScopeAPIResponse):
         """
         result = False
         if sentence is not None and 'end_time' in sentence and sentence[
-                'end_time'] is not None:
+            'end_time'] is not None:
             result = True
         return result
 
@@ -433,8 +473,8 @@ class ImageSynthesisOutput(DictMixin):
     results: List[ImageSynthesisResult]
 
     def __init__(self,
-                 task_id: str,
-                 task_status: str,
+                 task_id: str = None,
+                 task_status: str = None,
                  results: List[ImageSynthesisResult] = [],
                  **kwargs):
         res = []
@@ -448,14 +488,49 @@ class ImageSynthesisOutput(DictMixin):
                          **kwargs)
 
 
+@dataclass(init=False)
+class VideoSynthesisOutput(DictMixin):
+    task_id: str
+    task_status: str
+    video_url: str
+
+    def __init__(self,
+                 task_id: str,
+                 task_status: str,
+                 video_url: str = '',
+                 **kwargs):
+        super().__init__(self,
+                         task_id=task_id,
+                         task_status=task_status,
+                         video_url=video_url,
+                         **kwargs)
+
+
 @dataclass(init=False)
 class ImageSynthesisUsage(DictMixin):
     image_count: int
 
-    def __init__(self, image_count: int, **kwargs):
+    def __init__(self, image_count: int = None, **kwargs):
         super().__init__(image_count=image_count, **kwargs)
 
 
+@dataclass(init=False)
+class VideoSynthesisUsage(DictMixin):
+    video_count: int
+    video_duration: int
+    video_ratio: str
+
+    def __init__(self,
+                 video_count: int = 1,
+                 video_duration: int = 0,
+                 video_ratio: str = '',
+                 **kwargs):
+        super().__init__(video_count=video_count,
+                         video_duration=video_duration,
+                         video_ratio=video_ratio,
+                         **kwargs)
+
+
 @dataclass(init=False)
 class ImageSynthesisResponse(DashScopeAPIResponse):
     output: ImageSynthesisOutput
@@ -483,3 +558,156 @@ class ImageSynthesisResponse(DashScopeAPIResponse):
                                           request_id=api_response.request_id,
                                           code=api_response.code,
                                           message=api_response.message)
+
+
+@dataclass(init=False)
+class VideoSynthesisResponse(DashScopeAPIResponse):
+    output: VideoSynthesisOutput
+    usage: VideoSynthesisUsage
+
+    @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 = VideoSynthesisOutput(**api_response.output)
+            if api_response.usage is not None:
+                usage = VideoSynthesisUsage(**api_response.usage)
+
+            return VideoSynthesisResponse(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 VideoSynthesisResponse(status_code=api_response.status_code,
+                                          request_id=api_response.request_id,
+                                          code=api_response.code,
+                                          message=api_response.message)
+
+
+@dataclass(init=False)
+class ReRankResult(DictMixin):
+    index: int
+    relevance_score: float
+    document: Dict = None
+
+    def __init__(self,
+                 index: int,
+                 relevance_score: float,
+                 document: Dict = None,
+                 **kwargs):
+        super().__init__(index=index,
+                         relevance_score=relevance_score,
+                         document=document,
+                         **kwargs)
+
+
+@dataclass(init=False)
+class ReRankOutput(DictMixin):
+    results: List[ReRankResult]
+
+    def __init__(self, results: List[ReRankResult] = None, **kwargs):
+        ress = None
+        if results is not None:
+            ress = []
+            for res in results:
+                ress.append(ReRankResult(**res))
+        super().__init__(results=ress, **kwargs)
+
+
+@dataclass(init=False)
+class ReRankUsage(DictMixin):
+    total_tokens: int
+
+    def __init__(self, total_tokens=None, **kwargs):
+        super().__init__(total_tokens=total_tokens, **kwargs)
+
+
+@dataclass(init=False)
+class ReRankResponse(DashScopeAPIResponse):
+    output: ReRankOutput
+    usage: GenerationUsage
+
+    @staticmethod
+    def from_api_response(api_response: DashScopeAPIResponse):
+        if api_response.status_code == HTTPStatus.OK:
+            usage = {}
+            if api_response.usage:
+                usage = api_response.usage
+
+            return ReRankResponse(status_code=api_response.status_code,
+                                  request_id=api_response.request_id,
+                                  code=api_response.code,
+                                  message=api_response.message,
+                                  output=ReRankOutput(**api_response.output),
+                                  usage=ReRankUsage(**usage))
+        else:
+            return ReRankResponse(status_code=api_response.status_code,
+                                  request_id=api_response.request_id,
+                                  code=api_response.code,
+                                  message=api_response.message)
+
+
+@dataclass(init=False)
+class TextToSpeechAudio(DictMixin):
+    expires_at: int
+    id: str
+    data: str
+    url: str
+
+    def __init__(self,
+                 expires_at: int,
+                 id: str,
+                 data: str = None,
+                 url: str = None,
+                 **kwargs):
+        super().__init__(expires_at=expires_at,
+                         id=id,
+                         data=data,
+                         url=url,
+                         **kwargs)
+
+
+@dataclass(init=False)
+class TextToSpeechOutput(DictMixin):
+    finish_reason: str
+    audio: TextToSpeechAudio
+
+    def __init__(self,
+                 finish_reason: str = None,
+                 audio: TextToSpeechAudio = None,
+                 **kwargs):
+        super().__init__(finish_reason=finish_reason,
+                         audio=audio,
+                         **kwargs)
+
+
+@dataclass(init=False)
+class TextToSpeechResponse(DashScopeAPIResponse):
+    output: TextToSpeechOutput
+    usage: MultiModalConversationUsage
+
+    @staticmethod
+    def from_api_response(api_response: DashScopeAPIResponse):
+        if api_response.status_code == HTTPStatus.OK:
+            usage = {}
+            if api_response.usage:
+                usage = api_response.usage
+
+            return MultiModalConversationResponse(
+                status_code=api_response.status_code,
+                request_id=api_response.request_id,
+                code=api_response.code,
+                message=api_response.message,
+                output=TextToSpeechOutput(**api_response.output),
+                usage=MultiModalConversationUsage(**usage))
+        else:
+            return TextToSpeechResponse(
+                status_code=api_response.status_code,
+                request_id=api_response.request_id,
+                code=api_response.code,
+                message=api_response.message)

dashscope/api_entities/encryption.py

@@ -0,0 +1,179 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+import base64
+import json
+from dataclasses import dataclass
+import os
+from typing import Optional
+
+import requests
+from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
+from cryptography.hazmat.primitives import serialization, hashes
+from cryptography.hazmat.primitives.asymmetric import padding
+from cryptography.hazmat.backends import default_backend
+
+import dashscope
+from dashscope.common.constants import ENCRYPTION_AES_SECRET_KEY_BYTES, ENCRYPTION_AES_IV_LENGTH
+from dashscope.common.logging import logger
+
+
+class Encryption:
+    def __init__(self):
+        self.pub_key_id: str = ''
+        self.pub_key_str: str = ''
+        self.aes_key_bytes: bytes = b''
+        self.encrypted_aes_key_str: str = ''
+        self.iv_bytes: bytes = b''
+        self.base64_iv_str: str = ''
+        self.valid: bool = False
+
+    def initialize(self):
+        public_keys = self._get_public_keys()
+        if not public_keys:
+            return
+
+        public_key_str = public_keys.get('public_key')
+        public_key_id = public_keys.get('public_key_id')
+        if not public_key_str or not public_key_id:
+            logger.error("public keys data not valid")
+            return
+
+        aes_key_bytes = self._generate_aes_secret_key()
+        iv_bytes = self._generate_iv()
+
+        encrypted_aes_key_str = self._encrypt_aes_key_with_rsa(aes_key_bytes, public_key_str)
+        base64_iv_str = base64.b64encode(iv_bytes).decode('utf-8')
+
+        self.pub_key_id = public_key_id
+        self.pub_key_str = public_key_str
+        self.aes_key_bytes = aes_key_bytes
+        self.encrypted_aes_key_str = encrypted_aes_key_str
+        self.iv_bytes = iv_bytes
+        self.base64_iv_str = base64_iv_str
+
+        self.valid = True
+
+    def encrypt(self, dict_plaintext):
+        return self._encrypt_text_with_aes(json.dumps(dict_plaintext, ensure_ascii=False),
+                                           self.aes_key_bytes, self.iv_bytes)
+
+    def decrypt(self, base64_ciphertext):
+        return self._decrypt_text_with_aes(base64_ciphertext, self.aes_key_bytes, self.iv_bytes)
+
+    def is_valid(self):
+        return self.valid
+
+    def get_pub_key_id(self):
+        return self.pub_key_id
+
+    def get_encrypted_aes_key_str(self):
+        return self.encrypted_aes_key_str
+
+    def get_base64_iv_str(self):
+        return self.base64_iv_str
+
+    @staticmethod
+    def _get_public_keys():
+        url = dashscope.base_http_api_url + '/public-keys/latest'
+        headers = {
+            "Authorization": f"Bearer {dashscope.api_key}"
+        }
+
+        response = requests.get(url, headers=headers)
+        if response.status_code != 200:
+            logger.error("exceptional public key response: %s" % response)
+            return None
+
+        json_resp = response.json()
+        response_data = json_resp.get('data')
+
+        if not response_data:
+            logger.error("no valid data in public key response")
+            return None
+
+        return response_data
+
+    @staticmethod
+    def _generate_aes_secret_key():
+        return os.urandom(ENCRYPTION_AES_SECRET_KEY_BYTES)
+
+    @staticmethod
+    def _generate_iv():
+        return os.urandom(ENCRYPTION_AES_IV_LENGTH)
+
+    @staticmethod
+    def _encrypt_text_with_aes(plaintext, key, iv):
+        """使用AES-GCM加密数据"""
+
+        # 创建AES-GCM加密器
+        aes_gcm = Cipher(
+            algorithms.AES(key),
+            modes.GCM(iv, tag=None),
+            backend=default_backend()
+        ).encryptor()
+
+        # 关联数据设为空（根据需求可调整）
+        aes_gcm.authenticate_additional_data(b'')
+
+        # 加密数据
+        ciphertext = aes_gcm.update(plaintext.encode('utf-8')) + aes_gcm.finalize()
+
+        # 获取认证标签
+        tag = aes_gcm.tag
+
+        # 组合密文和标签
+        encrypted_data = ciphertext + tag
+
+        # 返回Base64编码结果
+        return base64.b64encode(encrypted_data).decode('utf-8')
+
+    @staticmethod
+    def _decrypt_text_with_aes(base64_ciphertext, aes_key, iv):
+        """使用AES-GCM解密响应"""
+
+        # 解码Base64数据
+        encrypted_data = base64.b64decode(base64_ciphertext)
+
+        # 分离密文和标签（标签长度16字节）
+        ciphertext = encrypted_data[:-16]
+        tag = encrypted_data[-16:]
+
+        # 创建AES-GCM解密器
+        aes_gcm = Cipher(
+            algorithms.AES(aes_key),
+            modes.GCM(iv, tag),
+            backend=default_backend()
+        ).decryptor()
+
+        # 验证关联数据（与加密时一致）
+        aes_gcm.authenticate_additional_data(b'')
+
+        # 解密数据
+        decrypted_bytes = aes_gcm.update(ciphertext) + aes_gcm.finalize()
+
+        # 明文
+        plaintext = decrypted_bytes.decode('utf-8')
+
+        return json.loads(plaintext)
+
+    @staticmethod
+    def _encrypt_aes_key_with_rsa(aes_key, public_key_str):
+        """使用RSA公钥加密AES密钥"""
+
+        # 解码Base64格式的公钥
+        public_key_bytes = base64.b64decode(public_key_str)
+
+        # 加载公钥
+        public_key = serialization.load_der_public_key(
+            public_key_bytes,
+            backend=default_backend()
+        )
+
+        base64_aes_key = base64.b64encode(aes_key).decode('utf-8')
+
+        # 使用RSA加密
+        encrypted_bytes = public_key.encrypt(
+            base64_aes_key.encode('utf-8'),
+            padding.PKCS1v15()
+        )
+
+        return base64.b64encode(encrypted_bytes).decode('utf-8')