dashscope 1.22.1__py3-none-any.whl → 1.22.2__py3-none-any.whl

dashscope/api_entities/chat_completion_types.py

@@ -1,349 +0,0 @@
-# adapter from openai sdk
-from dataclasses import dataclass
-from typing import Dict, List, Literal, Optional
-
-from dashscope.common.base_type import BaseObjectMixin
-"""
-{
-    "choices": [
-        {
-            "message": {
-                "role": "assistant",
-                "content": "很抱歉，由于您提供的信息不完整，我无法直接比较两篇文章的内容。但是，一般而言，大型语言模型的训练通常确实涉及两个主要阶段：\n\n1. **预训练阶段 (Pre-Training Phase)**：在这个阶段，模型在大规模无标注文本数据集（如互联网上的网页、书籍、新闻等）上进行训练。目的是让模型学习语言的通用模式和结构。常见的预训练技术包括自回归（Autoregressive）模型如GPT系列，以及transformer架构下的编码器-解码器模型如BERT系列。\n\n2. **微调阶段 (Fine-Tuning Phase)**：预训练模型在特定任务的数据集上进行进一步训练，以适应下游任务，如问答、文本分类、机器翻译等。这个阶段允许模型根据具体任务的需求调整权重，从而提高性能。\n\n如果您能提供更详细的信息或两篇文章的具体内容，我可以给出更准确的比较分析。"
-            },
-            "finish_reason": "stop",
-            "index": 0,
-            "logprobs": null
-        }
-    ],
-    "object": "chat.completion",
-    "usage": {
-        "prompt_tokens": 66,
-        "completion_tokens": 195,
-        "total_tokens": 261
-    },
-    "created": 1716539630,
-    "system_fingerprint": null,
-    "model": "qwen-long",
-    "id": "chatcmpl-a737071790e091c6be016ea27a891392",
-    "status_code": 200
-}
-"""
-
-@dataclass(init=False)
-class CompletionUsage(BaseObjectMixin):
-    completion_tokens: int
-    """Number of tokens in the generated completion."""
-
-    prompt_tokens: int
-    """Number of tokens in the prompt."""
-
-    total_tokens: int
-    """Total number of tokens used in the request (prompt + completion)."""
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-
-@dataclass(init=False)
-class TopLogprob(BaseObjectMixin):
-    token: str
-    """The token."""
-
-    bytes: Optional[List[int]] = None
-    """A list of integers representing the UTF-8 bytes representation of the token.
-
-    Useful in instances where characters are represented by multiple tokens and
-    their byte representations must be combined to generate the correct text
-    representation. Can be `null` if there is no bytes representation for the token.
-    """
-
-    logprob: float
-    """The log probability of this token, if it is within the top 20 most likely
-    tokens.
-
-    Otherwise, the value `-9999.0` is used to signify that the token is very
-    unlikely.
-    """
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-
-@dataclass(init=False)
-class ChatCompletionTokenLogprob(BaseObjectMixin):
-    token: str
-    """The token."""
-
-    bytes: Optional[List[int]] = None
-    """A list of integers representing the UTF-8 bytes representation of the token.
-
-    Useful in instances where characters are represented by multiple tokens and
-    their byte representations must be combined to generate the correct text
-    representation. Can be `null` if there is no bytes representation for the token.
-    """
-
-    logprob: float
-    """The log probability of this token, if it is within the top 20 most likely
-    tokens.
-
-    Otherwise, the value `-9999.0` is used to signify that the token is very
-    unlikely.
-    """
-
-    top_logprobs: List[TopLogprob]
-    """List of the most likely tokens and their log probability, at this token
-    position.
-
-    In rare cases, there may be fewer than the number of requested `top_logprobs`
-    returned.
-    """
-    def __init__(self, **kwargs):
-        if 'top_logprobs' in kwargs and kwargs['top_logprobs'] is not None and kwargs['top_logprobs']:
-            top_logprobs = []
-            for logprob in kwargs['top_logprobs']:
-                top_logprobs.append(ChatCompletionTokenLogprob(**logprob))
-            self.top_logprobs = top_logprobs
-        else:
-            self.top_logprobs = None
-                
-        super().__init__(**kwargs)
-        
-   
-@dataclass(init=False)
-class ChoiceLogprobs(BaseObjectMixin):
-    content: Optional[List[ChatCompletionTokenLogprob]] = None
-    """A list of message content tokens with log probability information."""
-    def __init__(self, **kwargs):
-        if 'content' in kwargs and kwargs['content'] is not None and kwargs['content']:
-            logprobs = []
-            for logprob in kwargs['content']:
-                logprobs.append(ChatCompletionTokenLogprob(**logprob))
-            self.content = logprobs
-        else:
-            self.content = None
-                
-        super().__init__(**kwargs)
-
-@dataclass(init=False)
-class FunctionCall(BaseObjectMixin):
-    arguments: str
-    """
-    The arguments to call the function with, as generated by the model in JSON
-    format. Note that the model does not always generate valid JSON, and may
-    hallucinate parameters not defined by your function schema. Validate the
-    arguments in your code before calling your function.
-    """
-
-    name: str
-    """The name of the function to call."""
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-
-@dataclass(init=False)
-class Function(BaseObjectMixin):
-    arguments: str
-    """
-    The arguments to call the function with, as generated by the model in JSON
-    format. Note that the model does not always generate valid JSON, and may
-    hallucinate parameters not defined by your function schema. Validate the
-    arguments in your code before calling your function.
-    """
-
-    name: str
-    """The name of the function to call."""
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-
-@dataclass(init=False)
-class ChatCompletionMessageToolCall(BaseObjectMixin):
-    id: str
-    """The ID of the tool call."""
-
-    function: Function
-    """The function that the model called."""
-
-    type: Literal["function"]
-    """The type of the tool. Currently, only `function` is supported."""
-    def __init__(self, **kwargs):
-        if 'function' in kwargs and kwargs['function'] is not None and kwargs['function']:
-            self.function = Function(**kwargs.pop('function', {}))
-        else:
-            function = None
-                
-        super().__init__(**kwargs)
-    
-@dataclass(init=False)
-class ChatCompletionMessage(BaseObjectMixin):
-    content: Optional[str] = None
-    """The contents of the message."""
-
-    role: Literal["assistant"]
-    """The role of the author of this message."""
-
-    function_call: Optional[FunctionCall] = None
-    """Deprecated and replaced by `tool_calls`.
-
-    The name and arguments of a function that should be called, as generated by the
-    model.
-    """
-
-    tool_calls: Optional[List[ChatCompletionMessageToolCall]] = None
-    
-    """The tool calls generated by the model, such as function calls."""
-    def __init__(self, **kwargs):
-        if 'function_call' in kwargs and kwargs['function_call'] is not None and kwargs['function_call']:
-            self.function_call = FunctionCall(**kwargs.pop('function_call', {}))
-        
-        if 'tool_calls' in kwargs and kwargs['tool_calls'] is not None and kwargs['tool_calls']:
-            tool_calls = []
-            for tool_call in kwargs['tool_calls']:
-                tool_calls.append(ChatCompletionMessageToolCall(**tool_call))
-            self.tool_calls = tool_calls
-                
-        super().__init__(**kwargs)
-    
-@dataclass(init=False)
-class Choice(BaseObjectMixin):
-    finish_reason: Literal["stop", "length", "tool_calls", "content_filter", "function_call"]
-    """The reason the model stopped generating tokens.
-
-    This will be `stop` if the model hit a natural stop point or a provided stop
-    sequence, `length` if the maximum number of tokens specified in the request was
-    reached, `content_filter` if content was omitted due to a flag from our content
-    filters, `tool_calls` if the model called a tool, or `function_call`
-    (deprecated) if the model called a function.
-    """
-
-    index: int
-    """The index of the choice in the list of choices."""
-
-    logprobs: Optional[ChoiceLogprobs] = None
-    """Log probability information for the choice."""
-
-    message: ChatCompletionMessage
-    """A chat completion message generated by the model."""
-    
-    def __init__(self, **kwargs):
-        if 'message' in kwargs and kwargs['message'] is not None and kwargs['message']:
-            self.message = ChatCompletionMessage(**kwargs.pop('message', {}))
-        else:
-            self.message = None
-        
-        if 'logprobs' in kwargs and kwargs['logprobs'] is not None and kwargs['logprobs']:
-            self.logprobs = ChoiceLogprobs(**kwargs.pop('logprobs', {}))
-
-        super().__init__(**kwargs)
-    
-@dataclass(init=False)
-class ChatCompletion(BaseObjectMixin):
-    status_code: int
-    """The call response status_code, 200 indicate create success.
-    """
-    code: str
-    """The request failed, this is the error code.
-    """
-    message: str
-    """The request failed, this is the error message.
-    """
-    id: str
-    """A unique identifier for the chat completion.
-    """
-    choices: List[Choice]
-    """A list of chat completion choices.
-
-    Can be more than one if `n` is greater than 1.
-    """
-
-    created: int
-    """The Unix timestamp (in seconds) of when the chat completion was created."""
-
-    model: str
-    """The model used for the chat completion."""
-
-    object: Literal["chat.completion"]
-    """The object type, which is always `chat.completion`."""
-
-    system_fingerprint: Optional[str] = None
-    """This fingerprint represents the backend configuration that the model runs with.
-
-    Can be used in conjunction with the `seed` request parameter to understand when
-    backend changes have been made that might impact determinism.
-    """
-
-    usage: Optional[CompletionUsage] = None
-    """Usage statistics for the completion request."""
-    
-    def __init__(self, **kwargs):
-        if 'usage' in kwargs and kwargs['usage'] is not None and kwargs['usage']:
-            self.usage = CompletionUsage(**kwargs.pop('usage', {}))
-        else:
-            self.usage = None
-        
-        if 'choices' in kwargs and kwargs['choices'] is not None and kwargs['choices']:
-            choices = []
-            for choice in kwargs.pop('choices', []):
-                choices.append(Choice(**choice))
-            self.choices = choices
-        else:
-            self.choices = None
-        super().__init__(**kwargs)
-        
-@dataclass(init=False)
-class ChatCompletionChunk(BaseObjectMixin):
-    status_code: int
-    """The call response status_code, 200 indicate create success.
-    """
-    code: str
-    """The request failed, this is the error code.
-    """
-    message: str
-    """The request failed, this is the error message.
-    """
-    id: str
-    """A unique identifier for the chat completion. Each chunk has the same ID."""
-
-    choices: List[Choice]
-    """A list of chat completion choices.
-
-    Can contain more than one elements if `n` is greater than 1. Can also be empty
-    for the last chunk if you set `stream_options: {"include_usage": true}`.
-    """
-
-    created: int
-    """The Unix timestamp (in seconds) of when the chat completion was created.
-
-    Each chunk has the same timestamp.
-    """
-
-    model: str
-    """The model to generate the completion."""
-
-    object: Literal["chat.completion.chunk"]
-    """The object type, which is always `chat.completion.chunk`."""
-
-    system_fingerprint: Optional[str] = None
-    """
-    This fingerprint represents the backend configuration that the model runs with.
-    Can be used in conjunction with the `seed` request parameter to understand when
-    backend changes have been made that might impact determinism.
-    """
-
-    usage: Optional[CompletionUsage] = None
-    """
-    An optional field that will only be present when you set
-    `stream_options: {"include_usage": true}` in your request. When present, it
-    contains a null value except for the last chunk which contains the token usage
-    statistics for the entire request.
-    """
-    def __init__(self, **kwargs):
-        if 'usage' in kwargs and kwargs['usage'] is not None and kwargs['usage']:
-            self.usage = CompletionUsage(**kwargs.pop('usage', {}))
-        else:
-            self.usage = None
-        
-        if 'choices' in kwargs and kwargs['choices'] is not None and kwargs['choices']:
-            choices = []
-            for choice in kwargs.pop('choices', []):
-                choices.append(Choice(**choice))
-            self.choices = choices
-        else:
-            self.choices = None
-        super().__init__(**kwargs)
-    

dashscope/utils/temporary_storage.py

@@ -1,160 +0,0 @@
-from dataclasses import dataclass
-import mimetypes
-import os
-from datetime import datetime
-from http import HTTPStatus
-from time import mktime
-from typing import List
-from urllib.parse import unquote_plus, urlparse
-from wsgiref.handlers import format_date_time
-import time
-import threading
-
-import requests
-
-from dashscope.api_entities.dashscope_response import DashScopeAPIResponse
-from dashscope.client.base_api import GetMixin
-from dashscope.common.constants import (FILE_PATH_SCHEMA,
-                                        REQUEST_CONTENT_AUDIO,
-                                        REQUEST_CONTENT_IMAGE,
-                                        REQUEST_CONTENT_TEXT)
-from dashscope.common.error import InvalidInput, UploadFileException
-from dashscope.common.logging import logger
-from dashscope.common.utils import get_user_agent
-
-@dataclass
-class UploadToken:
-    token: str = None
-    expire_time: int = None
-
-class UploadTokenMeta(type):
-    def __init__(cls):
-        cls._tokens = {} # key model, value: token and expire_time
-        cls._lock = threading.Lock() # lock set
-        
-    @property
-    def token(cls, model):
-        current_time = time.perf_counter()
-        upload_token: UploadToken = cls._tokens[model] if model in cls._tokens else None
-        if upload_token is not None and current_time < upload_token.expire_time:
-            return upload_token.token
-        else:
-            return None
-    
-    @token.setter
-    def token(cls, model: str, upload_token: UploadToken):
-        cls._lock.acquire()
-        cls._tokens[model] = upload_token
-        cls._lock.release()
-    
-
-class OssUtils(GetMixin, metaclass=UploadTokenMeta):
-    SUB_PATH = 'uploads'
-
-    @classmethod
-    def _decode_response_error(cls, response: requests.Response):
-        if 'application/json' in response.headers.get('content-type', ''):
-            message = response.json()
-        else:
-            message = response.content.decode('utf-8')
-        return message
-
-    @classmethod
-    def upload(cls,
-               model: str,
-               file_path: str,
-               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
-        """
-        upload_token = cls.token(model)
-        if upload_token is None:
-            upload_info = cls.get_upload_certificate(model=model, api_key=api_key)            
-            if upload_info.status_code != HTTPStatus.OK:
-                raise UploadFileException(
-                    'Get upload certificate failed, code: %s, message: %s' %
-                    (upload_info.code, upload_info.message))
-            upload_info = upload_info.output
-            cls.token = xx
-        
-        upload_info = upload_info.output
-        headers = {}
-        headers = {'user-agent': get_user_agent()}
-        headers['Accept'] = 'application/json'
-        headers['Date'] = format_date_time(mktime(datetime.now().timetuple()))
-        form_data = {}
-        form_data['OSSAccessKeyId'] = upload_info['oss_access_key_id']
-        form_data['Signature'] = upload_info['signature']
-        form_data['policy'] = upload_info['policy']
-        form_data['key'] = upload_info['upload_dir'] + \
-            '/' + os.path.basename(file_path)
-        form_data['x-oss-object-acl'] = upload_info['x_oss_object_acl']
-        form_data['x-oss-forbid-overwrite'] = upload_info[
-            'x_oss_forbid_overwrite']
-        form_data['success_action_status'] = '200'
-        form_data['x-oss-content-type'] = mimetypes.guess_type(file_path)[0]
-        url = upload_info['upload_host']
-        files = {'file': open(file_path, 'rb')}
-        with requests.Session() as session:
-            response = session.post(url,
-                                    files=files,
-                                    data=form_data,
-                                    headers=headers,
-                                    timeout=3600)
-            if response.status_code == HTTPStatus.OK:
-                return 'oss://' + form_data['key']
-            else:
-                msg = (
-                    'Uploading file: %s to oss failed, error: %s' %
-                    (file_path, cls._decode_response_error(response=response)))
-                logger.error(msg)
-                raise UploadFileException(msg)
-
-    @classmethod
-    def get_upload_certificate(cls,
-                               model: str,
-                               api_key: str = None,
-                               **kwargs) -> DashScopeAPIResponse:
-        """Get a oss upload certificate.
-
-        Args:
-            api_key (str, optional): The api key. Defaults to None.
-
-        Returns:
-            DashScopeAPIResponse: The job info
-        """
-        params = {'action': 'getPolicy'}
-        params['model'] = model
-        return super().get(None, api_key, params=params, **kwargs)
-
-
-def upload_file(model: str, upload_path: str, api_key: str):
-    if upload_path.startswith(FILE_PATH_SCHEMA):
-        parse_result = urlparse(upload_path)
-        if parse_result.netloc:
-            file_path = parse_result.netloc + unquote_plus(parse_result.path)
-        else:
-            file_path = unquote_plus(parse_result.path)
-        if os.path.exists(file_path):
-            file_url = OssUtils.upload(model=model,
-                                       file_path=file_path,
-                                       api_key=api_key)
-            if file_url is None:
-                raise UploadFileException('Uploading file: %s failed' %
-                                          upload_path)
-            return file_url
-        else:
-            raise InvalidInput('The file: %s is not exists!' % file_path)
-    return None
-
-
-