qianfan package

Library aimed to helping developer to interactive with LLM.

qianfan.AK(ak: str) → None

Set the API Key (AK) for LLM API authentication.

This function allows you to set the API Key that will be used for authentication throughout the entire SDK. The API Key can be acquired from the qianfan console: https://console.bce.baidu.com/qianfan/ais/console/applicationConsole/application

Parameters:

ak (str):

The API Key to be set for LLM API authentication.

qianfan.AccessKey(access_key: str) → None

Set the Access Key for console api authentication.

This function allows you to set the Access Key that will be used for authentication throughout the entire SDK. The Access Key can be acquired from the baidu bce console: https://console.bce.baidu.com/iam/#/iam/accesslist

Parameters:

access_key (str):

The Access Key to be set for console API authentication.

qianfan.AccessToken(access_token: str) → None

Set the access token for LLM api authentication.

This function allows you to set the access token that will be used for authentication throughout the entire SDK. The access token can be generated from API key and secret key according to the instructions at https://cloud.baidu.com/doc/WENXINWORKSHOP/s/Ilkkrb0i5.

This function is only needed when you only have access token. If you have both API key and secret key, sdk will automatically refresh the access token for you.

Parameters:

access_token (str):

The access token to be set for LLM API authentication.

class qianfan.ChatCompletion(model: Optional[str] = None, endpoint: Optional[str] = None, **kwargs: Any)

Bases: BaseResource

QianFan ChatCompletion is an agent for calling QianFan ChatCompletion API.

async abatch_do(messages_list: List[Union[List[Dict], QfMessages]], worker_num: int = 1, **kwargs: Any) → List[Union[QfResponse, AsyncIterator[QfResponse]]]

Async batch perform chat-based language generation using user-supplied messages.

Parameters:

messages_list: List[Union[List[Dict], QfMessages]]:

List of the messages list in the conversation. Please refer to ChatCompletion.do for more information of each messages.

worker_num (int):

The number of prompts to process at the same time.

kwargs (Any):

Please refer to ChatCompletion.do for other parameters such as model, endpoint, retry_count, etc.

``` response_list = await ChatCompletion().abatch_do([…], worker_num = 10) for response in response_list:

# response is QfResponse if succeed, or response will be exception print(response)

```

async ado(messages: Union[List[Dict], QfMessages], model: Optional[str] = None, endpoint: Optional[str] = None, stream: bool = False, retry_count: int = 1, request_timeout: float = 60, request_id: Optional[str] = None, backoff_factor: float = 0, auto_concat_truncate: bool = False, truncated_continue_prompt: str = '继续', **kwargs: Any) → Union[QfResponse, AsyncIterator[QfResponse]]

Async perform chat-based language generation using user-supplied messages.

Parameters:

messages (Union[List[Dict], QfMessages]):

A list of messages in the conversation including the one from system. Each message should be a dictionary containing ‘role’ and ‘content’ keys, representing the role (either ‘user’, or ‘assistant’) and content of the message, respectively. Alternatively, you can provide a QfMessages object for convenience.

model (Optional[str]):

The name or identifier of the language model to use. If not specified, the default model is used(ERNIE-Bot-turbo).

endpoint (Optional[str]):

The endpoint for making API requests. If not provided, the default endpoint is used.

stream (bool):

If set to True, the responses are streamed back as an iterator. If False, a single response is returned.

retry_count (int):

The number of times to retry the request in case of failure.

request_timeout (float):

The maximum time (in seconds) to wait for a response from the model.

backoff_factor (float):

A factor to increase the waiting time between retry attempts.

auto_concat_truncate (bool):

[Experimental] If set to True, continuously requesting will be run until is_truncated is False. As a result, the entire reply will be returned. Cause this feature highly relies on the understanding ability of LLM, Use it carefully.

truncated_continue_prompt (str):

[Experimental] The prompt to use when requesting more content for auto truncated reply.

kwargs (Any):

Additional keyword arguments that can be passed to customize the request.

Additional parameters like temperature will vary depending on the model, please refer to the API documentation. The additional parameters can be passed as follows:

` ChatCompletion().ado(messages = ..., temperature = 0.2, top_p = 0.5) `

batch_do(messages_list: List[Union[List[Dict], QfMessages]], worker_num: int = 1, **kwargs: Any) → BatchRequestFuture

Batch perform chat-based language generation using user-supplied messages.

Parameters:

messages_list: List[Union[List[Dict], QfMessages]]:

List of the messages list in the conversation. Please refer to ChatCompletion.do for more information of each messages.

worker_num (int):

The number of prompts to process at the same time.

kwargs (Any):

Please refer to ChatCompletion.do for other parameters such as model, endpoint, retry_count, etc.

``` response_list = ChatCompletion().batch_do([…], worker_num = 10) for response in response_list:

# return QfResponse if succeed, or exception will be raised print(response.result())

# or while response_list.finished_count() != response_list.task_count():

time.sleep(1)

print(response_list.results()) ```

do(messages: Union[List[Dict], QfMessages], model: Optional[str] = None, endpoint: Optional[str] = None, stream: bool = False, retry_count: int = 1, request_timeout: float = 60, request_id: Optional[str] = None, backoff_factor: float = 0, auto_concat_truncate: bool = False, truncated_continue_prompt: str = '继续', **kwargs: Any) → Union[QfResponse, Iterator[QfResponse]]

Perform chat-based language generation using user-supplied messages.

Parameters:

messages (Union[List[Dict], QfMessages]):

A list of messages in the conversation including the one from system. Each message should be a dictionary containing ‘role’ and ‘content’ keys, representing the role (either ‘user’, or ‘assistant’) and content of the message, respectively. Alternatively, you can provide a QfMessages object for convenience.

model (Optional[str]):

The name or identifier of the language model to use. If not specified, the default model is used(ERNIE-Bot-turbo).

endpoint (Optional[str]):

The endpoint for making API requests. If not provided, the default endpoint is used.

stream (bool):

If set to True, the responses are streamed back as an iterator. If False, a single response is returned.

retry_count (int):

The number of times to retry the request in case of failure.

request_timeout (float):

The maximum time (in seconds) to wait for a response from the model.

backoff_factor (float):

A factor to increase the waiting time between retry attempts.

auto_concat_truncate (bool):

[Experimental] If set to True, continuously requesting will be run until is_truncated is False. As a result, the entire reply will be returned. Cause this feature highly relies on the understanding ability of LLM, Use it carefully.

truncated_continue_prompt (str):

[Experimental] The prompt to use when requesting more content for auto truncated reply.

kwargs (Any):

Additional keyword arguments that can be passed to customize the request.

Additional parameters like temperature will vary depending on the model, please refer to the API documentation. The additional parameters can be passed as follows:

` ChatCompletion().do(messages = ..., temperature = 0.2, top_p = 0.5) `

class qianfan.Completion(model: Optional[str] = None, endpoint: Optional[str] = None, **kwargs: Any)

Bases: BaseResource

QianFan Completion is an agent for calling QianFan completion API.

async abatch_do(prompt_list: List[str], worker_num: int = 1, **kwargs: Any) → List[Union[QfResponse, AsyncIterator[QfResponse]]]

Async batch generate a completion based on the user-provided prompt.

Parameters:

prompt_list (List[str]):

The input prompt list to generate the continuation from.

worker_num (int):

The number of prompts to process at the same time.

kwargs (Any):

Please refer to Completion.ado for other parameters such as model, endpoint, retry_count, etc.

``` response_list = await Completion().abatch_do([…], worker_num = 10) for response in response_list:

# response is QfResponse if succeed, or response will be exception print(response)

```

async ado(prompt: str, model: Optional[str] = None, endpoint: Optional[str] = None, stream: bool = False, retry_count: int = 1, request_timeout: float = 60, request_id: Optional[str] = None, backoff_factor: float = 0, **kwargs: Any) → Union[QfResponse, AsyncIterator[QfResponse]]

Async generate a completion based on the user-provided prompt.

Parameters:

prompt (str):

The input prompt to generate the continuation from.

model (Optional[str]):

The name or identifier of the language model to use. If not specified, the default model is used(ERNIE-Bot-turbo).

endpoint (Optional[str]):

The endpoint for making API requests. If not provided, the default endpoint is used.

stream (bool):

If set to True, the responses are streamed back as an iterator. If False, a single response is returned.

retry_count (int):

The number of times to retry the request in case of failure.

request_timeout (float):

The maximum time (in seconds) to wait for a response from the model.

backoff_factor (float):

A factor to increase the waiting time between retry attempts.

kwargs (Any):

Additional keyword arguments that can be passed to customize the request.

Additional parameters like temperature will vary depending on the model, please refer to the API documentation. The additional parameters can be passed as follows:

` Completion().do(prompt = ..., temperature = 0.2, top_p = 0.5) `

batch_do(prompt_list: List[str], worker_num: int = 1, **kwargs: Any) → BatchRequestFuture

Batch generate a completion based on the user-provided prompt.

Parameters:

prompt_list (List[str]):

The input prompt list to generate the continuation from.

worker_num (int):

The number of prompts to process at the same time.

kwargs (Any):

Please refer to Completion.do for other parameters such as model, endpoint, retry_count, etc.

``` response_list = Completion().batch_do([”…”, “…”], worker_num = 10) for response in response_list:

# return QfResponse if succeed, or exception will be raised print(response.result())

# or while response_list.finished_count() != response_list.task_count():

time.sleep(1)

print(response_list.results()) ```

do(prompt: str, model: Optional[str] = None, endpoint: Optional[str] = None, stream: bool = False, retry_count: int = 1, request_timeout: float = 60, request_id: Optional[str] = None, backoff_factor: float = 0, **kwargs: Any) → Union[QfResponse, Iterator[QfResponse]]

Generate a completion based on the user-provided prompt.

Parameters:

prompt (str):

The input prompt to generate the continuation from.

model (Optional[str]):

The name or identifier of the language model to use. If not specified, the default model is used(ERNIE-Bot-turbo).

endpoint (Optional[str]):

The endpoint for making API requests. If not provided, the default endpoint is used.

stream (bool):

If set to True, the responses are streamed back as an iterator. If False, a single response is returned.

retry_count (int):

The number of times to retry the request in case of failure.

request_timeout (float):

The maximum time (in seconds) to wait for a response from the model.

backoff_factor (float):

A factor to increase the waiting time between retry attempts.

kwargs (Any):

Additional keyword arguments that can be passed to customize the request.

Additional parameters like temperature will vary depending on the model, please refer to the API documentation. The additional parameters can be passed as follows:

` Completion().do(prompt = ..., temperature = 0.2, top_p = 0.5) `

class qianfan.Embedding(model: Optional[str] = None, endpoint: Optional[str] = None, **kwargs: Any)

Bases: BaseResource

QianFan Embedding is an agent for calling QianFan embedding API.

async abatch_do(texts_list: List[List[str]], worker_num: int = 1, **kwargs: Any) → List[Union[QfResponse, AsyncIterator[QfResponse]]]

Async batch generate embeddings for a list of input texts using a specified model.

Parameters:

texts_list (List[List[str]]):

List of the input text list to generate the embeddings.

worker_num (int):

The number of prompts to process at the same time.

kwargs (Any):

Please refer to Embedding.ado for other parameters such as model, endpoint, retry_count, etc.

``` response_list = await Embedding().abatch_do([…], worker_num = 10) for response in response_list:

# response is QfResponse if succeed, or response will be exception print(response)

```

async ado(texts: List[str], model: Optional[str] = None, endpoint: Optional[str] = None, stream: bool = False, retry_count: int = 1, request_timeout: float = 60, request_id: Optional[str] = None, backoff_factor: float = 0, **kwargs: Any) → Union[QfResponse, AsyncIterator[QfResponse]]

Async generate embeddings for a list of input texts using a specified model.

Parameters:

texts (List[str]):

A list of input texts for which embeddings need to be generated.

model (Optional[str]):

The name or identifier of the language model to use. If not specified, the default model is used(ERNIE-Bot-turbo).

endpoint (Optional[str]):

The endpoint for making API requests. If not provided, the default endpoint is used.

stream (bool):

If set to True, the responses are streamed back as an iterator. If False, a single response is returned.

retry_count (int):

The number of times to retry the request in case of failure.

request_timeout (float):

The maximum time (in seconds) to wait for a response from the model.

backoff_factor (float):

A factor to increase the waiting time between retry attempts.

kwargs (Any):

Additional keyword arguments that can be passed to customize the request.

Additional parameters like temperature will vary depending on the model, please refer to the API documentation. The additional parameters can be passed as follows:

` Embedding().do(texts = ..., temperature = 0.2, top_p = 0.5) `

batch_do(texts_list: List[List[str]], worker_num: int = 1, **kwargs: Any) → BatchRequestFuture

Batch generate embeddings for a list of input texts using a specified model.

Parameters:

texts_list (List[List[str]]):

List of the input text list to generate the embeddings.

worker_num (int):

The number of prompts to process at the same time.

kwargs (Any):

Please refer to Completion.do for other parameters such as model, endpoint, retry_count, etc.

``` response_list = Completion().batch_do([”…”, “…”], worker_num = 10) for response in response_list:

# return QfResponse if succeed, or exception will be raised print(response.result())

# or while response_list.finished_count() != response_list.task_count():

time.sleep(1)

print(response_list.results()) ```

do(texts: List[str], model: Optional[str] = None, endpoint: Optional[str] = None, stream: bool = False, retry_count: int = 1, request_timeout: float = 60, request_id: Optional[str] = None, backoff_factor: float = 0, **kwargs: Any) → Union[QfResponse, Iterator[QfResponse]]

Generate embeddings for a list of input texts using a specified model.

Parameters:

texts (List[str]):

A list of input texts for which embeddings need to be generated.

model (Optional[str]):

The name or identifier of the language model to use. If not specified, the default model is used(ERNIE-Bot-turbo).

endpoint (Optional[str]):

The endpoint for making API requests. If not provided, the default endpoint is used.

stream (bool):

If set to True, the responses are streamed back as an iterator. If False, a single response is returned.

retry_count (int):

The number of times to retry the request in case of failure.

request_timeout (float):

The maximum time (in seconds) to wait for a response from the model.

backoff_factor (float):

A factor to increase the waiting time between retry attempts.

kwargs (Any):

Additional keyword arguments that can be passed to customize the request.

Additional parameters like temperature will vary depending on the model, please refer to the API documentation. The additional parameters can be passed as follows:

` Embedding().do(texts = ..., temperature = 0.2, top_p = 0.5) `

qianfan.Messages

alias of QfMessages

class qianfan.Plugin(model: Optional[str] = None, endpoint: Optional[str] = None, **kwargs: Any)

Bases: BaseResource

QianFan Plugin API Resource

async abatch_do(prompt_list: List[str], worker_num: int = 1, **kwargs: Any) → List[Union[QfResponse, AsyncIterator[QfResponse]]]

Async batch execute a plugin action on the provided input prompt and generate responses.

Parameters:

prompt_list (List[str]):

The list user input or prompt for which a response is generated.

worker_num (int):

The number of prompts to process at the same time.

kwargs (Any):

Please refer to Plugin.ado for other parameters such as model, endpoint, retry_count, etc.

``` response_list = await Plugin().abatch_do([…], worker_num = 10) for response in response_list:

# response is QfResponse if succeed, or response will be exception print(response)

```

async ado(prompt: str, model: Optional[str] = None, endpoint: Optional[str] = None, stream: bool = False, retry_count: int = 1, request_timeout: float = 60, request_id: Optional[str] = None, backoff_factor: float = 0, **kwargs: Any) → Union[QfResponse, AsyncIterator[QfResponse]]

Async execute a plugin action on the provided input prompt and generate responses.

Parameters:

prompt (str):

The user input or prompt for which a response is generated.

model (Optional[str]):

The name or identifier of the language model to use. If not specified, the default model is used(ERNIE-Bot-turbo).

endpoint (Optional[str]):

The endpoint for making API requests. If not provided, the default endpoint is used.

stream (bool):

If set to True, the responses are streamed back as an iterator. If False, a single response is returned.

retry_count (int):

The number of times to retry the request in case of failure.

request_timeout (float):

The maximum time (in seconds) to wait for a response from the model.

backoff_factor (float):

A factor to increase the waiting time between retry attempts.

kwargs (Any):

Additional keyword arguments that can be passed to customize the request.

Additional parameters like temperature will vary depending on the model, please refer to the API documentation. The additional parameters can be passed as follows:

` Plugin().do(prompt = ..., temperature = 0.2, top_p = 0.5) `

batch_do(prompt_list: List[str], worker_num: int = 1, **kwargs: Any) → BatchRequestFuture

Batch generate execute a plugin action on the provided input prompt and generate responses.

Parameters:

prompt_list (List[str]):

The list user input or prompt for which a response is generated.

worker_num (int):

The number of prompts to process at the same time.

kwargs (Any):

Please refer to Plugin.do for other parameters such as model, endpoint, retry_count, etc.

``` response_list = Plugin().batch_do([”…”, “…”], worker_num = 10) for response in response_list:

# return QfResponse if succeed, or exception will be raised print(response.result())

# or while response_list.finished_count() != response_list.task_count():

time.sleep(1)

print(response_list.results()) ```

do(prompt: str, model: Optional[str] = None, endpoint: Optional[str] = None, stream: bool = False, retry_count: int = 1, request_timeout: float = 60, request_id: Optional[str] = None, backoff_factor: float = 0, **kwargs: Any) → Union[QfResponse, Iterator[QfResponse]]

Execute a plugin action on the provided input prompt and generate responses.

Parameters:

prompt (str):

The user input or prompt for which a response is generated.

model (Optional[str]):

The name or identifier of the language model to use. If not specified, the default model is used(ERNIE-Bot-turbo).

endpoint (Optional[str]):

The endpoint for making API requests. If not provided, the default endpoint is used.

stream (bool):

If set to True, the responses are streamed back as an iterator. If False, a single response is returned.

retry_count (int):

The number of times to retry the request in case of failure.

request_timeout (float):

The maximum time (in seconds) to wait for a response from the model.

backoff_factor (float):

A factor to increase the waiting time between retry attempts.

kwargs (Any):

Additional keyword arguments that can be passed to customize the request.

Additional parameters like temperature will vary depending on the model, please refer to the API documentation. The additional parameters can be passed as follows:

` Plugin().do(prompt = ..., temperature = 0.2, top_p = 0.5) `

class qianfan.QfMessages

Bases: object

An auxiliary class for representing a list of messages in a chat model.

Example usage:

messages = QfMessages()
# append a message by str
messages.append("Hello!")
# send the messages directly
resp = qianfan.ChatCompletion().do(messages = messages)
# append the response to the messages and continue the conversation
messages.append(resp)
messages.append("next message", role = QfRole.User) # role is optional

append(message: Union[str, QfResponse], role: Optional[Union[str, QfRole]] = None) → None

Appends a message to the QfMessages object.

Parameters:

message (Union[str, QfResponse]):

The message to be appended. It can be a string or a QfResponse object. When the object is a QfResponse object, the role of the message sender will be QfRole.Assistant by default, unless you specify the role using the ‘role’

role (Optional[Union[str, QfRole]]):

An optional parameter to specify the role of the message sender. If not provided, the function will determine the role based on the existed message.

Example usage can be found in the introduction of this class.

class qianfan.QfResponse(code: int, headers: ~typing.Dict[str, str] = <factory>, body: ~typing.Dict[str, ~typing.Any] = <factory>)

Bases: Mapping

Response from Qianfan API

body: Dict[str, Any]

The JSON-formatted body of the response.

code: int

The HTTP status code of the response.

headers: Dict[str, str]

A dictionary of HTTP headers included in the response.

class qianfan.QfRole(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: Enum

Role type supported in Qianfan

Assistant = 'assistant'

Function = 'function'

User = 'user'

qianfan.Response

alias of QfResponse

qianfan.Role

alias of QfRole

qianfan.SK(sk: str) → None

Set the Secret Key (SK) for LLM api authentication. The secret key is paired with the API key.

This function allows you to set the Secret Key that will be used for authentication throughout the entire SDK. The Secret Key can be acquired from the qianfan console: https://console.bce.baidu.com/qianfan/ais/console/applicationConsole/application

Parameters:

sk (str):

The Secret Key to be set for LLM API authentication.

qianfan.SecretKey(secret_key: str) → None

Set the Secret Key for console api authentication. The secret key is paired with the access key.

This function allows you to set the Secret Key that will be used for authentication throughout the entire SDK. The secret Key can be acquired from the baidu bce console: https://console.bce.baidu.com/iam/#/iam/accesslist

Parameters:

secret_key (str):

The Secret Key to be set for console API authentication.

class qianfan.Text2Image(model: Optional[str] = None, endpoint: Optional[str] = None, **kwargs: Any)

Bases: BaseResource

QianFan Text2Image API Resource

async abatch_do(prompt_list: List[str], worker_num: int = 1, **kwargs: Any) → List[Union[QfResponse, AsyncIterator[QfResponse]]]

Async batch execute a plugin action on the provided input prompt and generate responses.

Parameters:

prompt_list (List[str]):

The list user input or prompt for which a response is generated.

worker_num (int):

The number of prompts to process at the same time.

kwargs (Any):

Please refer to Plugin.ado for other parameters such as model, endpoint, retry_count, etc.

``` response_list = await Text2Image().abatch_do([…], worker_num = 10) for response in response_list:

# response is QfResponse if succeed, or response will be exception print(response)

```

async ado(prompt: str, model: Optional[str] = None, endpoint: Optional[str] = None, with_decode: Optional[str] = None, retry_count: int = 1, request_timeout: float = 60, request_id: Optional[str] = None, backoff_factor: float = 0, **kwargs: Any) → Union[QfResponse, AsyncIterator[QfResponse]]

Async execute a text2image action on the provided input prompt and generate responses.

Parameters:

prompt (str):

The user input or prompt for which a response is generated.

model (Optional[str]):

The name or identifier of the language model to use. If not specified, the default model is used(ERNIE-Bot-turbo).

endpoint (Optional[str]):

The endpoint for making API requests. If not provided, the default endpoint is used.

with_decode(Optional[str]):

The way to decode data. If not provided, the decode is not used. use “base64” to auto decode from data.

retry_count (int):

The number of times to retry the request in case of failure.

request_timeout (float):

The maximum time (in seconds) to wait for a response from the model.

backoff_factor (float):

A factor to increase the waiting time between retry attempts.

kwargs (Any):

Additional keyword arguments that can be passed to customize the request.

Additional parameters like temperature will vary depending on the model, please refer to the API documentation. The additional parameters can be passed as follows:

` Text2Image().do(prompt = ..., steps=20) `

batch_do(prompt_list: List[str], worker_num: int = 1, **kwargs: Any) → BatchRequestFuture

Batch generate execute a plugin action on the provided input prompt and generate responses.

Parameters:

prompt_list (List[str]):

The list user input or prompt for which a response is generated.

worker_num (int):

The number of prompts to process at the same time.

kwargs (Any):

Please refer to Plugin.do for other parameters such as model, endpoint, retry_count, etc.

``` response_list = Text2Image().batch_do([”…”, “…”], worker_num = 10) for response in response_list:

# return QfResponse if succeed, or exception will be raised print(response.result())

# or while response_list.finished_count() != response_list.task_count():

time.sleep(1)

print(response_list.results()) ```

do(prompt: str, model: Optional[str] = None, endpoint: Optional[str] = None, with_decode: Optional[str] = None, retry_count: int = 1, request_timeout: float = 60, request_id: Optional[str] = None, backoff_factor: float = 0, **kwargs: Any) → Union[QfResponse, Iterator[QfResponse]]

Execute a text2image action on the provided input prompt and generate responses.

Parameters:

prompt (str):

The user input or prompt for which a response is generated.

model (Optional[str]):

The name or identifier of the language model to use. If not specified, the default model is used(ERNIE-Bot-turbo).

endpoint (Optional[str]):

The endpoint for making API requests. If not provided, the default endpoint is used.

with_decode(Optional[str]):

The way to decode data. If not provided, the decode is not used. use “base64” to auto decode from data.

retry_count (int):

The number of times to retry the request in case of failure.

request_timeout (float):

The maximum time (in seconds) to wait for a response from the model.

backoff_factor (float):

A factor to increase the waiting time between retry attempts.

kwargs (Any):

Additional keyword arguments that can be passed to customize the request.

Additional parameters like temperature will vary depending on the model, please refer to the API documentation. The additional parameters can be passed as follows:

` Text2Image().do(prompt = ..., steps=20) `

class qianfan.Tokenizer

Bases: object

Class for Tokenizer API

classmethod count_tokens(text: str, mode: Literal['local', 'remote'] = 'local', model: str = 'ERNIE-Bot', **kwargs: Any) → int

Count the number of tokens in a given text.

Parameters:

text (str):

The input text for which tokens need to be counted.

mode (str, optional):

local (default):

local SIMULATION (Chinese characters count + English word count * 1.3)

remote:

use qianfan api to calculate the token count. API will return accurate token count, but only ERNIE-Bot series models are supported.

model (str, optional):

The name of the model to be used for token counting, which may influence the counting strategy. Default is ‘ERNIE-Bot’.

kwargs (Any):

Additional keyword arguments that can be passed to customize the request.

qianfan.disable_log() → None

Disables logging.

This function turns off the logging feature, preventing the recording of log messages.

Parameters:

None

qianfan.enable_log(log_level: int = 20) → None

Set the logging level for the qianfan sdk.

This function allows you to configure the logging level for the sdk’s logging system. The logging level determines the verbosity of log messages that will be recorded. By default, it is set to ‘WARN’, which logs only important information.

Parameters:

log_level (int, optional):

The logging level to set for the application. It controls the granularity of log messages. You can specify one of the following integer values or str like “INFO”:

• logging.CRITICAL (50): Logs only critical messages.

• logging.ERROR (40): Logs error and critical messages.

• logging.WARNING (30): Logs warnings, errors, and critical messages.

• logging.INFO (20): Logs general information, warnings, errors, and critical messages.

• logging.DEBUG (10): Logs detailed debugging information, in addition to all the above log levels.

Example Usage: To enable detailed debugging, you can call the function like this: enable_log(logging.DEBUG)

To set the logging level to only log errors and critical messages, use: enable_log(“ERROR”)

qianfan.get_config() → GlobalConfig

Subpackages

• qianfan.components package
  • Prompt
    • Prompt.base_prompt()
    • Prompt.creator_name
    • Prompt.crispe_prompt()
    • Prompt.delete()
    • Prompt.fewshot_prompt()
    • Prompt.framework_type
    • Prompt.from_file()
    • Prompt.id
    • Prompt.identifier
    • Prompt.labels
    • Prompt.name
    • Prompt.negative_template
    • Prompt.negative_variables
    • Prompt.render()
    • Prompt.save_to_file()
    • Prompt.scene_type
    • Prompt.set_negative_template()
    • Prompt.set_template()
    • Prompt.template
    • Prompt.type
    • Prompt.variables
  • PromptLabel
    • PromptLabel.color
    • PromptLabel.id
    • PromptLabel.name
  • Subpackages
    • qianfan.components.hub package
      • Submodules
      • qianfan.components.hub.hub module
      • qianfan.components.hub.interface module
    • qianfan.components.prompt package
      • Submodules
      • qianfan.components.prompt.prompt module
• qianfan.dataset package
  • DataExportDestinationType
    • DataExportDestinationType.PlatformBos
    • DataExportDestinationType.PrivateBos
  • DataProjectType
    • DataProjectType.Conversation
    • DataProjectType.GenericText
    • DataProjectType.QuerySet
    • DataProjectType.Text2Image
  • DataSetType
    • DataSetType.MultiModel
    • DataSetType.TextOnly
  • DataSource
    • DataSource.afetch()
    • DataSource.asave()
    • DataSource.fetch()
    • DataSource.format_type()
    • DataSource.save()
    • DataSource.set_format_type()
  • DataSourceType
    • DataSourceType.PrivateBos
    • DataSourceType.SharedZipUrl
  • DataStorageType
    • DataStorageType.PrivateBos
    • DataStorageType.PublicBos
  • DataTemplateType
    • DataTemplateType.GenericText
    • DataTemplateType.NonSortedConversation
    • DataTemplateType.QuerySet
    • DataTemplateType.SortedConversation
    • DataTemplateType.Text2Image
  • Dataset
    • Dataset.add_default_group_column()
    • Dataset.append()
    • Dataset.col_append()
    • Dataset.col_delete()
    • Dataset.col_filter()
    • Dataset.col_insert()
    • Dataset.col_list()
    • Dataset.col_map()
    • Dataset.col_names()
    • Dataset.col_renames()
    • Dataset.create_from_pyarrow_table()
    • Dataset.create_from_pyobj()
    • Dataset.delete()
    • Dataset.delete_group_column()
    • Dataset.filter()
    • Dataset.insert()
    • Dataset.is_dataset_located_in_qianfan()
    • Dataset.list()
    • Dataset.load()
    • Dataset.map()
    • Dataset.online_data_process()
    • Dataset.save()
  • FileDataSource
    • FileDataSource.afetch()
    • FileDataSource.asave()
    • FileDataSource.fetch()
    • FileDataSource.file_format
    • FileDataSource.format_type()
    • FileDataSource.model_config
    • FileDataSource.model_fields
    • FileDataSource.path
    • FileDataSource.save()
    • FileDataSource.set_format_type()
  • QianfanDataSource
    • QianfanDataSource.afetch()
    • QianfanDataSource.ak
    • QianfanDataSource.asave()
    • QianfanDataSource.create_bare_dataset()
    • QianfanDataSource.create_from_bos_file()
    • QianfanDataSource.data_format_type
    • QianfanDataSource.download_when_init
    • QianfanDataSource.fetch()
    • QianfanDataSource.format_type()
    • QianfanDataSource.get_existed_dataset()
    • QianfanDataSource.group_id
    • QianfanDataSource.id
    • QianfanDataSource.info
    • QianfanDataSource.model_config
    • QianfanDataSource.model_fields
    • QianfanDataSource.name
    • QianfanDataSource.project_type
    • QianfanDataSource.release_dataset()
    • QianfanDataSource.save()
    • QianfanDataSource.set_format_type()
    • QianfanDataSource.set_type
    • QianfanDataSource.sk
    • QianfanDataSource.storage_id
    • QianfanDataSource.storage_name
    • QianfanDataSource.storage_path
    • QianfanDataSource.storage_raw_path
    • QianfanDataSource.storage_region
    • QianfanDataSource.storage_type
    • QianfanDataSource.template_type
    • QianfanDataSource.version
  • Table
    • Table.append()
    • Table.col_append()
    • Table.col_delete()
    • Table.col_filter()
    • Table.col_insert()
    • Table.col_list()
    • Table.col_map()
    • Table.col_names()
    • Table.col_renames()
    • Table.column_number()
    • Table.delete()
    • Table.filter()
    • Table.insert()
    • Table.is_dataset_grouped()
    • Table.is_dataset_packed()
    • Table.list()
    • Table.map()
    • Table.pack()
    • Table.row_number()
    • Table.to_pydict()
    • Table.to_pylist()
    • Table.unpack()
  • Submodules
  • qianfan.dataset.consts module
  • qianfan.dataset.data_operator module
    • DeduplicationSimhash
      • DeduplicationSimhash.distance
      • DeduplicationSimhash.model_config
      • DeduplicationSimhash.model_fields
      • DeduplicationSimhash.operator_name
    • Deduplicator
      • Deduplicator.model_config
      • Deduplicator.model_fields
      • Deduplicator.operator_type
    • DesensitizationProcessor
      • DesensitizationProcessor.model_config
      • DesensitizationProcessor.model_fields
      • DesensitizationProcessor.operator_type
    • ExceptionRegulator
      • ExceptionRegulator.model_config
      • ExceptionRegulator.model_fields
      • ExceptionRegulator.operator_type
    • Filter
      • Filter.model_config
      • Filter.model_fields
      • Filter.operator_type
    • FilterCheckCharacterRepetitionRemoval
      • FilterCheckCharacterRepetitionRemoval.character_repetition_max_cutoff
      • FilterCheckCharacterRepetitionRemoval.model_config
      • FilterCheckCharacterRepetitionRemoval.model_fields
      • FilterCheckCharacterRepetitionRemoval.operator_name
    • FilterCheckFlaggedWords
      • FilterCheckFlaggedWords.flagged_words_max_cutoff
      • FilterCheckFlaggedWords.model_config
      • FilterCheckFlaggedWords.model_fields
      • FilterCheckFlaggedWords.operator_name
    • FilterCheckLangId
      • FilterCheckLangId.lang_id_min_cutoff
      • FilterCheckLangId.model_config
      • FilterCheckLangId.model_fields
      • FilterCheckLangId.operator_name
    • FilterCheckNumberWords
      • FilterCheckNumberWords.model_config
      • FilterCheckNumberWords.model_fields
      • FilterCheckNumberWords.number_words_max_cutoff
      • FilterCheckNumberWords.number_words_min_cutoff
      • FilterCheckNumberWords.operator_name
    • FilterCheckPerplexity
      • FilterCheckPerplexity.model_config
      • FilterCheckPerplexity.model_fields
      • FilterCheckPerplexity.operator_name
      • FilterCheckPerplexity.perplexity_max_cutoff
    • FilterCheckSpecialCharacters
      • FilterCheckSpecialCharacters.model_config
      • FilterCheckSpecialCharacters.model_fields
      • FilterCheckSpecialCharacters.operator_name
      • FilterCheckSpecialCharacters.special_characters_max_cutoff
    • FilterCheckWordRepetitionRemoval
      • FilterCheckWordRepetitionRemoval.model_config
      • FilterCheckWordRepetitionRemoval.model_fields
      • FilterCheckWordRepetitionRemoval.operator_name
      • FilterCheckWordRepetitionRemoval.word_repetition_max_cutoff
    • QianfanOperator
      • QianfanOperator.model_config
      • QianfanOperator.model_fields
      • QianfanOperator.operator_name
      • QianfanOperator.operator_type
    • RemoveEmoji
      • RemoveEmoji.model_config
      • RemoveEmoji.model_fields
      • RemoveEmoji.operator_name
    • RemoveInvisibleCharacter
      • RemoveInvisibleCharacter.model_config
      • RemoveInvisibleCharacter.model_fields
      • RemoveInvisibleCharacter.operator_name
    • RemoveNonMeaningCharacters
      • RemoveNonMeaningCharacters.model_config
      • RemoveNonMeaningCharacters.model_fields
      • RemoveNonMeaningCharacters.operator_name
    • RemoveWebIdentifiers
      • RemoveWebIdentifiers.model_config
      • RemoveWebIdentifiers.model_fields
      • RemoveWebIdentifiers.operator_name
    • ReplaceEmails
      • ReplaceEmails.model_config
      • ReplaceEmails.model_fields
      • ReplaceEmails.operator_name
    • ReplaceIdentifier
      • ReplaceIdentifier.model_config
      • ReplaceIdentifier.model_fields
      • ReplaceIdentifier.operator_name
    • ReplaceIp
      • ReplaceIp.model_config
      • ReplaceIp.model_fields
      • ReplaceIp.operator_name
    • ReplaceTraditionalChineseToSimplified
      • ReplaceTraditionalChineseToSimplified.model_config
      • ReplaceTraditionalChineseToSimplified.model_fields
      • ReplaceTraditionalChineseToSimplified.operator_name
    • ReplaceUniformWhitespace
      • ReplaceUniformWhitespace.model_config
      • ReplaceUniformWhitespace.model_fields
      • ReplaceUniformWhitespace.operator_name
  • qianfan.dataset.data_source module
    • DataSource
      • DataSource.afetch()
      • DataSource.asave()
      • DataSource.fetch()
      • DataSource.format_type()
      • DataSource.save()
      • DataSource.set_format_type()
    • FileDataSource
      • FileDataSource.afetch()
      • FileDataSource.asave()
      • FileDataSource.fetch()
      • FileDataSource.file_format
      • FileDataSource.format_type()
      • FileDataSource.model_config
      • FileDataSource.model_fields
      • FileDataSource.path
      • FileDataSource.save()
      • FileDataSource.set_format_type()
    • FormatType
      • FormatType.Csv
      • FormatType.Json
      • FormatType.Jsonl
      • FormatType.Text
    • QianfanDataSource
      • QianfanDataSource.afetch()
      • QianfanDataSource.ak
      • QianfanDataSource.asave()
      • QianfanDataSource.create_bare_dataset()
      • QianfanDataSource.create_from_bos_file()
      • QianfanDataSource.data_format_type
      • QianfanDataSource.download_when_init
      • QianfanDataSource.fetch()
      • QianfanDataSource.format_type()
      • QianfanDataSource.get_existed_dataset()
      • QianfanDataSource.group_id
      • QianfanDataSource.id
      • QianfanDataSource.info
      • QianfanDataSource.model_config
      • QianfanDataSource.model_fields
      • QianfanDataSource.name
      • QianfanDataSource.project_type
      • QianfanDataSource.release_dataset()
      • QianfanDataSource.save()
      • QianfanDataSource.set_format_type()
      • QianfanDataSource.set_type
      • QianfanDataSource.sk
      • QianfanDataSource.storage_id
      • QianfanDataSource.storage_name
      • QianfanDataSource.storage_path
      • QianfanDataSource.storage_raw_path
      • QianfanDataSource.storage_region
      • QianfanDataSource.storage_type
      • QianfanDataSource.template_type
      • QianfanDataSource.version
  • qianfan.dataset.dataset module
    • Dataset
      • Dataset.add_default_group_column()
      • Dataset.append()
      • Dataset.col_append()
      • Dataset.col_delete()
      • Dataset.col_filter()
      • Dataset.col_insert()
      • Dataset.col_list()
      • Dataset.col_map()
      • Dataset.col_names()
      • Dataset.col_renames()
      • Dataset.create_from_pyarrow_table()
      • Dataset.create_from_pyobj()
      • Dataset.delete()
      • Dataset.delete_group_column()
      • Dataset.filter()
      • Dataset.insert()
      • Dataset.is_dataset_located_in_qianfan()
      • Dataset.list()
      • Dataset.load()
      • Dataset.map()
      • Dataset.online_data_process()
      • Dataset.save()
  • qianfan.dataset.process_interface module
    • Addable
      • Addable.append()
      • Addable.insert()
    • Listable
      • Listable.list()
    • Processable
      • Processable.delete()
      • Processable.filter()
      • Processable.map()
  • qianfan.dataset.schema module
    • QianfanGenericText
      • QianfanGenericText.validate()
    • QianfanNonSortedConversation
      • QianfanNonSortedConversation.validate()
    • QianfanQuerySet
      • QianfanQuerySet.validate()
    • QianfanSchema
      • QianfanSchema.validate()
    • QianfanSortedConversation
      • QianfanSortedConversation.validate()
    • QianfanText2Image
      • QianfanText2Image.validate()
    • Schema
      • Schema.validate()
  • qianfan.dataset.table module
    • Table
      • Table.append()
      • Table.col_append()
      • Table.col_delete()
      • Table.col_filter()
      • Table.col_insert()
      • Table.col_list()
      • Table.col_map()
      • Table.col_names()
      • Table.col_renames()
      • Table.column_number()
      • Table.delete()
      • Table.filter()
      • Table.insert()
      • Table.is_dataset_grouped()
      • Table.is_dataset_packed()
      • Table.list()
      • Table.map()
      • Table.pack()
      • Table.row_number()
      • Table.to_pydict()
      • Table.to_pylist()
      • Table.unpack()
  • qianfan.dataset.utils module
• qianfan.extensions package
  • Subpackages
    • qianfan.extensions.langchain package
      • Subpackages
• qianfan.resources package
  • ChatCompletion
    • ChatCompletion.abatch_do()
    • ChatCompletion.ado()
    • ChatCompletion.batch_do()
    • ChatCompletion.do()
  • Completion
    • Completion.abatch_do()
    • Completion.ado()
    • Completion.batch_do()
    • Completion.do()
  • Data
    • Data.annotate_an_entity()
    • Data.create_bare_dataset()
    • Data.create_data_import_task()
    • Data.create_dataset_augmenting_task()
    • Data.create_dataset_etl_task()
    • Data.create_dataset_export_task()
    • Data.delete_an_entity()
    • Data.delete_dataset()
    • Data.delete_dataset_augmenting_task()
    • Data.delete_dataset_etl_task()
    • Data.get_dataset_aug_task_list()
    • Data.get_dataset_augmenting_task_info()
    • Data.get_dataset_etl_task_info()
    • Data.get_dataset_etl_task_list()
    • Data.get_dataset_export_records()
    • Data.get_dataset_import_error_detail()
    • Data.get_dataset_info()
    • Data.get_dataset_status_in_batch()
    • Data.list_all_entity_in_dataset()
    • Data.release_dataset()
  • Embedding
    • Embedding.abatch_do()
    • Embedding.ado()
    • Embedding.batch_do()
    • Embedding.do()
  • FineTune
    • FineTune.create_job()
    • FineTune.create_task()
    • FineTune.get_job()
    • FineTune.stop_job()
  • Model
    • Model.create_evaluation_task()
    • Model.detail()
    • Model.get_evaluation_info()
    • Model.get_evaluation_result()
    • Model.list()
    • Model.publish()
    • Model.stop_evaluation_task()
  • Plugin
    • Plugin.abatch_do()
    • Plugin.ado()
    • Plugin.batch_do()
    • Plugin.do()
  • Prompt
    • Prompt.create()
    • Prompt.delete()
    • Prompt.info()
    • Prompt.list()
    • Prompt.list_labels()
    • Prompt.update()
  • QfMessages
    • QfMessages.append()
  • QfResponse
    • QfResponse.body
    • QfResponse.code
    • QfResponse.headers
  • QfRole
    • QfRole.Assistant
    • QfRole.Function
    • QfRole.User
  • Service
    • Service.create()
    • Service.get()
  • Text2Image
    • Text2Image.abatch_do()
    • Text2Image.ado()
    • Text2Image.batch_do()
    • Text2Image.do()
  • Tokenizer
    • Tokenizer.count_tokens()
  • Subpackages
    • qianfan.resources.auth package
      • Submodules
      • qianfan.resources.auth.iam module
      • qianfan.resources.auth.oauth module
    • qianfan.resources.console package
      • Submodules
      • qianfan.resources.console.app module
      • qianfan.resources.console.consts module
      • qianfan.resources.console.data module
      • qianfan.resources.console.finetune module
      • qianfan.resources.console.model module
      • qianfan.resources.console.prompt module
      • qianfan.resources.console.service module
      • qianfan.resources.console.utils module
    • qianfan.resources.images package
      • Submodules
      • qianfan.resources.images.text2image module
    • qianfan.resources.llm package
      • Submodules
      • qianfan.resources.llm.base module
      • qianfan.resources.llm.chat_completion module
      • qianfan.resources.llm.completion module
      • qianfan.resources.llm.eb_plugin module
      • qianfan.resources.llm.embedding module
      • qianfan.resources.llm.plugin module
    • qianfan.resources.requestor package
      • Submodules
      • qianfan.resources.requestor.base module
      • qianfan.resources.requestor.console_requestor module
      • qianfan.resources.requestor.openapi_requestor module
    • qianfan.resources.tools package
      • Submodules
      • qianfan.resources.tools.tokenizer module
      • qianfan.resources.tools.utils module
  • Submodules
  • qianfan.resources.http_client module
    • HTTPClient
      • HTTPClient.arequest()
      • HTTPClient.arequest_stream()
      • HTTPClient.request()
      • HTTPClient.request_stream()
  • qianfan.resources.rate_limiter module
    • RateLimiter
  • qianfan.resources.typing module
    • QfLLMInfo
      • QfLLMInfo.endpoint
      • QfLLMInfo.optional_keys
      • QfLLMInfo.required_keys
    • QfMessages
      • QfMessages.append()
    • QfRequest
      • QfRequest.headers
      • QfRequest.json_body
      • QfRequest.method
      • QfRequest.query
      • QfRequest.requests_args()
      • QfRequest.retry_config
      • QfRequest.url
    • QfResponse
      • QfResponse.body
      • QfResponse.code
      • QfResponse.headers
    • QfRole
      • QfRole.Assistant
      • QfRole.Function
      • QfRole.User
    • RetryConfig
      • RetryConfig.backoff_factor
      • RetryConfig.retry_count
      • RetryConfig.timeout
    • default_field()
• qianfan.trainer package
  • DeployAction
    • DeployAction.deploy_config
    • DeployAction.exec()
    • DeployAction.model_id
    • DeployAction.model_version_id
    • DeployAction.result
    • DeployAction.resume()
  • Event
    • Event.action_id
    • Event.action_state
    • Event.data
    • Event.description
  • EventHandler
    • EventHandler.dispatch()
  • LLMFinetune
    • LLMFinetune.output
    • LLMFinetune.resume()
    • LLMFinetune.run()
    • LLMFinetune.status
    • LLMFinetune.stop()
  • LoadDataSetAction
    • LoadDataSetAction.dataset
    • LoadDataSetAction.exec()
    • LoadDataSetAction.resume()
  • Model
    • Model.batch_run_on_qianfan()
    • Model.deploy()
    • Model.dumps()
    • Model.exec()
    • Model.id
    • Model.job_id
    • Model.loads()
    • Model.name
    • Model.publish()
    • Model.service
    • Model.task_id
    • Model.version_id
  • ModelPublishAction
    • ModelPublishAction.exec()
    • ModelPublishAction.job_id
    • ModelPublishAction.model
    • ModelPublishAction.result
    • ModelPublishAction.resume()
    • ModelPublishAction.task_id
  • Service
    • Service.deploy()
    • Service.deploy_config
    • Service.dumps()
    • Service.endpoint
    • Service.exec()
    • Service.get_res()
    • Service.id
    • Service.loads()
    • Service.model
    • Service.service_type
    • Service.status
  • TrainAction
    • TrainAction.base_model
    • TrainAction.exec()
    • TrainAction.get_default_train_config()
    • TrainAction.is_incr
    • TrainAction.job_description
    • TrainAction.job_id
    • TrainAction.result
    • TrainAction.resume()
    • TrainAction.stop()
    • TrainAction.task_description
    • TrainAction.task_id
    • TrainAction.task_name
    • TrainAction.train_config
    • TrainAction.train_mode
    • TrainAction.train_type
  • Submodules
  • qianfan.trainer.actions module
    • DeployAction
      • DeployAction.deploy_config
      • DeployAction.exec()
      • DeployAction.model_id
      • DeployAction.model_version_id
      • DeployAction.result
      • DeployAction.resume()
    • LoadDataSetAction
      • LoadDataSetAction.dataset
      • LoadDataSetAction.exec()
      • LoadDataSetAction.resume()
    • ModelPublishAction
      • ModelPublishAction.exec()
      • ModelPublishAction.job_id
      • ModelPublishAction.model
      • ModelPublishAction.result
      • ModelPublishAction.resume()
      • ModelPublishAction.task_id
    • TrainAction
      • TrainAction.base_model
      • TrainAction.exec()
      • TrainAction.get_default_train_config()
      • TrainAction.is_incr
      • TrainAction.job_description
      • TrainAction.job_id
      • TrainAction.result
      • TrainAction.resume()
      • TrainAction.stop()
      • TrainAction.task_description
      • TrainAction.task_id
      • TrainAction.task_name
      • TrainAction.train_config
      • TrainAction.train_mode
      • TrainAction.train_type
  • qianfan.trainer.base module
    • BaseAction
      • BaseAction.action_error_event()
      • BaseAction.action_event()
      • BaseAction.action_type()
      • BaseAction.dumps()
      • BaseAction.exec()
      • BaseAction.loads()
      • BaseAction.resume()
      • BaseAction.stop()
    • Executable
      • Executable.exec()
    • ExecuteSerializable
    • Pipeline
      • Pipeline.exec()
      • Pipeline.exec_from()
      • Pipeline.register_event_handler()
      • Pipeline.resume()
      • Pipeline.stop()
    • Serializable
      • Serializable.dumps()
      • Serializable.loads()
    • Trainer
      • Trainer.actions
      • Trainer.get_evaluate_result()
      • Trainer.get_log()
      • Trainer.output
      • Trainer.ppls
      • Trainer.register_event_handler()
      • Trainer.result
      • Trainer.resume()
      • Trainer.run()
      • Trainer.status
      • Trainer.stop()
    • with_event()
  • qianfan.trainer.configs module
    • DeployConfig
      • DeployConfig.description
      • DeployConfig.endpoint_prefix
      • DeployConfig.extras
      • DeployConfig.model_config
      • DeployConfig.model_fields
      • DeployConfig.name
      • DeployConfig.pool_type
      • DeployConfig.replicas
      • DeployConfig.service_type
    • TrainConfig
      • TrainConfig.batch_size
      • TrainConfig.epoch
      • TrainConfig.extras
      • TrainConfig.learning_rate
      • TrainConfig.max_seq_len
      • TrainConfig.model_config
      • TrainConfig.model_fields
      • TrainConfig.peft_type
      • TrainConfig.trainset_rate
  • qianfan.trainer.consts module
    • ActionState
      • ActionState.Done
      • ActionState.Error
      • ActionState.Preceding
      • ActionState.Running
      • ActionState.Stopped
    • FinetuneStatus
      • FinetuneStatus.DatasetLoadFailed
      • FinetuneStatus.DatasetLoadStopped
      • FinetuneStatus.DatasetLoaded
      • FinetuneStatus.DatasetLoading
      • FinetuneStatus.ModelPublishFailed
      • FinetuneStatus.ModelPublished
      • FinetuneStatus.ModelPublishing
      • FinetuneStatus.TrainCreated
      • FinetuneStatus.TrainFailed
      • FinetuneStatus.TrainFinished
      • FinetuneStatus.TrainStopped
      • FinetuneStatus.Training
      • FinetuneStatus.Unknown
    • ServiceStatus
      • ServiceStatus.Created
      • ServiceStatus.DeployFailed
      • ServiceStatus.DeployStopped
      • ServiceStatus.Deployed
      • ServiceStatus.Deploying
      • ServiceStatus.Unknown
    • ServiceType
      • ServiceType.Chat
      • ServiceType.Completion
      • ServiceType.Embedding
      • ServiceType.Text2Image
  • qianfan.trainer.event module
    • Event
      • Event.action_id
      • Event.action_state
      • Event.data
      • Event.description
    • EventHandler
      • EventHandler.dispatch()
    • dispatch_event()
  • qianfan.trainer.finetune module
    • LLMFinetune
      • LLMFinetune.output
      • LLMFinetune.resume()
      • LLMFinetune.run()
      • LLMFinetune.status
      • LLMFinetune.stop()
  • qianfan.trainer.model module
    • Model
      • Model.batch_run_on_qianfan()
      • Model.deploy()
      • Model.dumps()
      • Model.exec()
      • Model.id
      • Model.job_id
      • Model.loads()
      • Model.name
      • Model.publish()
      • Model.service
      • Model.task_id
      • Model.version_id
    • Service
      • Service.deploy()
      • Service.deploy_config
      • Service.dumps()
      • Service.endpoint
      • Service.exec()
      • Service.get_res()
      • Service.id
      • Service.loads()
      • Service.model
      • Service.service_type
      • Service.status
    • model_deploy()
• qianfan.utils package
  • AsyncLock
  • disable_log()
  • enable_log()
  • log_debug()
  • log_error()
  • log_info()
  • log_warn()
  • Submodules
  • qianfan.utils.bos_uploader module
    • generate_bos_file_path()
    • upload_content_to_bos()
  • qianfan.utils.helper module
    • Singleton
  • qianfan.utils.logging module
    • Logger
      • Logger.debug()
      • Logger.error()
      • Logger.info()
      • Logger.warn()
    • disable_log()
    • enable_log()
    • log_debug()
    • log_error()
    • log_info()
    • log_warn()
  • qianfan.utils.utils module
    • AsyncLock
    • generate_letter_num_random_id()
    • uuid()

Submodules

qianfan.config module

qianfan.config.AK(ak: str) → None

Set the API Key (AK) for LLM API authentication.

This function allows you to set the API Key that will be used for authentication throughout the entire SDK. The API Key can be acquired from the qianfan console: https://console.bce.baidu.com/qianfan/ais/console/applicationConsole/application

Parameters:

ak (str):

The API Key to be set for LLM API authentication.

qianfan.config.AccessKey(access_key: str) → None

Set the Access Key for console api authentication.

This function allows you to set the Access Key that will be used for authentication throughout the entire SDK. The Access Key can be acquired from the baidu bce console: https://console.bce.baidu.com/iam/#/iam/accesslist

Parameters:

access_key (str):

The Access Key to be set for console API authentication.

qianfan.config.AccessToken(access_token: str) → None

Set the access token for LLM api authentication.

This function allows you to set the access token that will be used for authentication throughout the entire SDK. The access token can be generated from API key and secret key according to the instructions at https://cloud.baidu.com/doc/WENXINWORKSHOP/s/Ilkkrb0i5.

This function is only needed when you only have access token. If you have both API key and secret key, sdk will automatically refresh the access token for you.

Parameters:

access_token (str):

The access token to be set for LLM API authentication.

class qianfan.config.GlobalConfig(_case_sensitive: bool | None = None, _env_prefix: str | None = None, _env_file: DotenvType | None = PosixPath('.'), _env_file_encoding: str | None = None, _env_nested_delimiter: str | None = None, _secrets_dir: str | Path | None = None, *, AK: Optional[str] = None, SK: Optional[str] = None, ACCESS_KEY: Optional[str] = None, SECRET_KEY: Optional[str] = None, ACCESS_TOKEN: Optional[str] = None, BASE_URL: str = 'https://aip.baidubce.com', AUTH_TIMEOUT: float = 5, DISABLE_EB_SDK: bool = True, EB_SDK_INSTALLED: bool = False, IAM_SIGN_EXPIRATION_SEC: int = 300, CONSOLE_API_BASE_URL: str = 'https://qianfan.baidubce.com', ACCESS_TOKEN_REFRESH_MIN_INTERVAL: float = 3600, QPS_LIMIT: float = 0, APPID: Optional[int] = None, ENABLE_PRIVATE: bool = False, ENABLE_AUTH: Optional[bool] = None, ACCESS_CODE: Optional[str] = None, IMPORT_STATUS_POLLING_INTERVAL: float = 2, EXPORT_STATUS_POLLING_INTERVAL: float = 2, RELEASE_STATUS_POLLING_INTERVAL: float = 2, EXPORT_FILE_SIZE_LIMIT: int = 2147483648, ETL_STATUS_POLLING_INTERVAL: float = 2, GET_ENTITY_CONTENT_FAILED_RETRY_TIMES: int = 3, TRAIN_STATUS_POLLING_INTERVAL: float = 30, TRAINER_STATUS_POLLING_BACKOFF_FACTOR: float = 3, TRAINER_STATUS_POLLING_RETRY_TIMES: float = 3, MODEL_PUBLISH_STATUS_POLLING_INTERVAL: float = 30, DEPLOY_STATUS_POLLING_INTERVAL: float = 30, DEFAULT_FINE_TUNE_TRAIN_TYPE: str = 'ERNIE-Bot-turbo-0725')

Bases: BaseSettings

The global config of whole qianfan sdk

ACCESS_CODE: Optional[str]

ACCESS_KEY: Optional[str]

ACCESS_TOKEN: Optional[str]

ACCESS_TOKEN_REFRESH_MIN_INTERVAL: float

AK: Optional[str]

APPID: Optional[int]

AUTH_TIMEOUT: float

BASE_URL: str

CONSOLE_API_BASE_URL: str

DEFAULT_FINE_TUNE_TRAIN_TYPE: str

DEPLOY_STATUS_POLLING_INTERVAL: float

DISABLE_EB_SDK: bool

EB_SDK_INSTALLED: bool

ENABLE_AUTH: Optional[bool]

ENABLE_PRIVATE: bool

ETL_STATUS_POLLING_INTERVAL: float

EXPORT_FILE_SIZE_LIMIT: int

EXPORT_STATUS_POLLING_INTERVAL: float

GET_ENTITY_CONTENT_FAILED_RETRY_TIMES: int

IAM_SIGN_EXPIRATION_SEC: int

IMPORT_STATUS_POLLING_INTERVAL: float

MODEL_PUBLISH_STATUS_POLLING_INTERVAL: float

QPS_LIMIT: float

RELEASE_STATUS_POLLING_INTERVAL: float

SECRET_KEY: Optional[str]

SK: Optional[str]

TRAINER_STATUS_POLLING_BACKOFF_FACTOR: float

TRAINER_STATUS_POLLING_RETRY_TIMES: float

TRAIN_STATUS_POLLING_INTERVAL: float

model_config: ClassVar[SettingsConfigDict] = {'arbitrary_types_allowed': True, 'case_sensitive': True, 'env_file': None, 'env_file_encoding': None, 'env_nested_delimiter': None, 'env_prefix': 'QIANFAN_', 'extra': 'forbid', 'protected_namespaces': ('model_', 'settings_'), 'secrets_dir': None, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'ACCESS_CODE': FieldInfo(annotation=Union[str, NoneType], required=False), 'ACCESS_KEY': FieldInfo(annotation=Union[str, NoneType], required=False), 'ACCESS_TOKEN': FieldInfo(annotation=Union[str, NoneType], required=False), 'ACCESS_TOKEN_REFRESH_MIN_INTERVAL': FieldInfo(annotation=float, required=False, default=3600), 'AK': FieldInfo(annotation=Union[str, NoneType], required=False), 'APPID': FieldInfo(annotation=Union[int, NoneType], required=False), 'AUTH_TIMEOUT': FieldInfo(annotation=float, required=False, default=5), 'BASE_URL': FieldInfo(annotation=str, required=False, default='https://aip.baidubce.com'), 'CONSOLE_API_BASE_URL': FieldInfo(annotation=str, required=False, default='https://qianfan.baidubce.com'), 'DEFAULT_FINE_TUNE_TRAIN_TYPE': FieldInfo(annotation=str, required=False, default='ERNIE-Bot-turbo-0725'), 'DEPLOY_STATUS_POLLING_INTERVAL': FieldInfo(annotation=float, required=False, default=30), 'DISABLE_EB_SDK': FieldInfo(annotation=bool, required=False, default=True), 'EB_SDK_INSTALLED': FieldInfo(annotation=bool, required=False, default=False), 'ENABLE_AUTH': FieldInfo(annotation=Union[bool, NoneType], required=False), 'ENABLE_PRIVATE': FieldInfo(annotation=bool, required=False, default=False), 'ETL_STATUS_POLLING_INTERVAL': FieldInfo(annotation=float, required=False, default=2), 'EXPORT_FILE_SIZE_LIMIT': FieldInfo(annotation=int, required=False, default=2147483648), 'EXPORT_STATUS_POLLING_INTERVAL': FieldInfo(annotation=float, required=False, default=2), 'GET_ENTITY_CONTENT_FAILED_RETRY_TIMES': FieldInfo(annotation=int, required=False, default=3), 'IAM_SIGN_EXPIRATION_SEC': FieldInfo(annotation=int, required=False, default=300), 'IMPORT_STATUS_POLLING_INTERVAL': FieldInfo(annotation=float, required=False, default=2), 'MODEL_PUBLISH_STATUS_POLLING_INTERVAL': FieldInfo(annotation=float, required=False, default=30), 'QPS_LIMIT': FieldInfo(annotation=float, required=False, default=0), 'RELEASE_STATUS_POLLING_INTERVAL': FieldInfo(annotation=float, required=False, default=2), 'SECRET_KEY': FieldInfo(annotation=Union[str, NoneType], required=False), 'SK': FieldInfo(annotation=Union[str, NoneType], required=False), 'TRAINER_STATUS_POLLING_BACKOFF_FACTOR': FieldInfo(annotation=float, required=False, default=3), 'TRAINER_STATUS_POLLING_RETRY_TIMES': FieldInfo(annotation=float, required=False, default=3), 'TRAIN_STATUS_POLLING_INTERVAL': FieldInfo(annotation=float, required=False, default=30)}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

qianfan.config.SK(sk: str) → None

Set the Secret Key (SK) for LLM api authentication. The secret key is paired with the API key.

This function allows you to set the Secret Key that will be used for authentication throughout the entire SDK. The Secret Key can be acquired from the qianfan console: https://console.bce.baidu.com/qianfan/ais/console/applicationConsole/application

Parameters:

sk (str):

The Secret Key to be set for LLM API authentication.

qianfan.config.SecretKey(secret_key: str) → None

Set the Secret Key for console api authentication. The secret key is paired with the access key.

This function allows you to set the Secret Key that will be used for authentication throughout the entire SDK. The secret Key can be acquired from the baidu bce console: https://console.bce.baidu.com/iam/#/iam/accesslist

Parameters:

secret_key (str):

The Secret Key to be set for console API authentication.

qianfan.config.get_config() → GlobalConfig

qianfan.consts module

Consts used in qianfan sdk

class qianfan.consts.APIErrorCode(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: Enum

Error code from API return value

APINameNotExist = 336005

APITokenExpired = 111

APITokenInvalid = 110

AppNotExist = 15

DailyLimitReached = 17

GetServiceTokenFailed = 13

InternalError = 336000

InvalidArgument = 336001

InvalidArgumentSystem = 336104

InvalidArgumentUserSetting = 336105

InvalidHTTPMethod = 336101

InvalidJSON = 336002

InvalidParam = 336003

InvalidRequest = 100

NoError = 0

NoPermissionToAccessData = 6

PermissionError = 336004

QPSLimitReached = 18

RequestLimitReached = 4

ServerHighLoad = 336100

ServiceUnavailable = 2

TotalRequestLimitReached = 19

UnknownError = 1

UnsupportedMethod = 3

class qianfan.consts.Consts

Bases: object

Constant used by qianfan sdk

AppListAPI: str = '/wenxinworkshop/service/appList'

AuthAPI: str = '/oauth/2.0/token'

DatasetAnnotateAPI: str = '/wenxinworkshop/entity/annotate'

DatasetAugListTaskAPI: str = '/wenxinworkshop/enhance/list'

DatasetAugTaskDeleteAPI: str = '/wenxinworkshop/enhance/delete'

DatasetAugTaskInfoAPI: str = '/wenxinworkshop/enhance/detail'

DatasetCreateAPI: str = '/wenxinworkshop/dataset/create'

DatasetCreateAugTaskAPI: str = '/wenxinworkshop/enhance/create'

DatasetCreateETLTaskAPI: str = '/wenxinworkshop/etl/create'

DatasetDeleteAPI: str = '/wenxinworkshop/dataset/delete'

DatasetETLListTaskAPI: str = '/wenxinworkshop/etl/list'

DatasetETLTaskDeleteAPI: str = '/wenxinworkshop/etl/delete'

DatasetETLTaskInfoAPI: str = '/wenxinworkshop/etl/detail'

DatasetEntityDeleteAPI: str = '/wenxinworkshop/entity/delete'

DatasetEntityListAPI: str = '/wenxinworkshop/entity/list'

DatasetExportAPI: str = '/wenxinworkshop/dataset/export'

DatasetExportRecordAPI: str = '/wenxinworkshop/dataset/exportRecord'

DatasetImportAPI: str = '/wenxinworkshop/dataset/import'

DatasetImportErrorDetail: str = '/wenxinworkshop/dataset/importErrorDetail'

DatasetInfoAPI: str = '/wenxinworkshop/dataset/info'

DatasetReleaseAPI: str = '/wenxinworkshop/dataset/release'

DatasetStatusFetchInBatchAPI: str = '/wenxinworkshop/dataset/statusList'

EBTokenizerAPI: str = '/rpc/2.0/ai_custom/v1/wenxinworkshop/tokenizer/erniebot'

FineTuneCreateJobAPI: str = '/wenxinworkshop/finetune/createJob'

FineTuneCreateTaskAPI: str = '/wenxinworkshop/finetune/createTask'

FineTuneGetJobAPI: str = '/wenxinworkshop/finetune/jobDetail'

FineTuneStopJobAPI: str = '/wenxinworkshop/finetune/stopJob'

ModelAPIPrefix: str = '/rpc/2.0/ai_custom/v1/wenxinworkshop'

ModelDetailAPI: str = '/wenxinworkshop/modelrepo/modelDetail'

ModelEvalCreateAPI: str = '/wenxinworkshop/modelrepo/eval/create'

ModelEvalInfoAPI: str = '/wenxinworkshop/modelrepo/eval/detail'

ModelEvalResultAPI: str = '/wenxinworkshop/modelrepo/eval/report'

ModelEvalStopAPI: str = '/wenxinworkshop/modelrepo/eval/cancel'

ModelPublishAPI: str = '/wenxinworkshop/modelrepo/publishTrainModel'

ModelVersionDetailAPI: str = '/wenxinworkshop/modelrepo/modelVersionDetail'

PromptCreateAPI: str = '/wenxinworkshop/prompt/template/create'

PromptDeleteAPI: str = '/wenxinworkshop/prompt/template/delete'

PromptInfoAPI: str = '/wenxinworkshop/prompt/template/info'

PromptLabelListAPI: str = '/wenxinworkshop/prompt/label/list'

PromptListAPI: str = '/wenxinworkshop/prompt/template/list'

PromptRenderAPI: str = '/rest/2.0/wenxinworkshop/api/v1/template/info'

PromptUpdateAPI: str = '/wenxinworkshop/prompt/template/update'

QianfanRequestIdDefaultPrefix: str = 'sdk-py-0.2.2'

STREAM_RESPONSE_PREFIX: str = 'data: '

ServiceCreateAPI: str = '/wenxinworkshop/service/apply'

ServiceDetailAPI: str = '/wenxinworkshop/service/detail'

XRequestID: str = 'Request_id'

XResponseID: str = 'X-Baidu-Request-Id'

class qianfan.consts.DefaultLLMModel

Bases: object

Defualt LLM model in qianfan sdk

ChatCompletion = 'ERNIE-Bot-turbo'

Completion = 'ERNIE-Bot-turbo'

Embedding = 'Embedding-V1'

Text2Image = 'Stable-Diffusion-XL'

class qianfan.consts.DefaultValue

Bases: object

Default value used by qianfan sdk

AK: str = ''

AccessCode: str = ''

AccessToken: str = ''

AccessTokenRefreshMinInterval: float = 3600

AuthTimeout: float = 5

BaseURL: str = 'https://aip.baidubce.com'

ConsoleAK: str = ''

ConsoleAPIBaseURL: str = 'https://qianfan.baidubce.com'

ConsoleSK: str = ''

DefaultFinetuneTrainType: str = 'ERNIE-Bot-turbo-0725'

DeployStatusPollingInterval: float = 30

DisableErnieBotSDK: bool = True

DotEnvConfigFile: str = '.env'

ETLStatusPollingInterval: float = 2

EnablePrivate: bool = False

ExportFileSizeLimit: int = 2147483648

ExportStatusPollingInterval: float = 2

GetEntityContentFailedRetryTimes: int = 3

IAMSignExpirationSeconds: int = 300

ImportStatusPollingInterval: float = 2

ModelPublishStatusPollingInterval: float = 30

QpsLimit: float = 0

ReleaseStatusPollingInterval: float = 2

RetryBackoffFactor: float = 0

RetryCount: int = 1

RetryTimeout: float = 60

SK: str = ''

TrainStatusPollingInterval: float = 30

TrainerStatusPollingBackoffFactor: float = 3

TrainerStatusPollingRetryTimes: float = 3

TruncatedContinuePrompt = '继续'

class qianfan.consts.Env

Bases: object

Environment variable name used by qianfan sdk

AK: str = 'QIANFAN_AK'

AccessCode: str = 'QIANFAN_PRIVATE_ACCESS_CODE'

AccessKey: str = 'QIANFAN_ACCESS_KEY'

AccessToken: str = 'QIANFAN_ACCESS_TOKEN'

AccessTokenRefreshMinInterval: str = 'QIANFAN_ACCESS_TOKEN_REFRESH_MIN_INTERVAL'

AuthTimeout: str = 'QIANFAN_AUTH_TIMEOUT'

BaseURL: str = 'QIANFAN_BASE_URL'

ConsoleAPIBaseURL: str = 'QIANFAN_CONSOLE_API_BASE_URL'

DisableErnieBotSDK: str = 'QIANFAN_DISABLE_EB_SDK'

DotEnvConfigFile: str = 'QIANFAN_DOT_ENV_CONFIG_FILE'

ETLStatusPollingInterval: str = 'QIANFAN_ETL_STATUS_POLLING_INTERVAL'

EnablePrivate: str = 'QIANFAN_ENABLE_PRIVATE'

ExportFileSizeLimit: str = 'QIANFAN_EXPORT_FILE_SIZE_LIMIT'

ExportStatusPollingInterval: str = 'QIANFAN_EXPORT_STATUS_POLLING_INTERVAL'

GetEntityContentFailedRetryTimes: str = 'QIANFAN_GET_ENTITY_CONTENT_FAILED_RETRY_TIMES'

IAMSignExpirationSeconds: str = 'QIANFAN_IAM_SIGN_EXPIRATION_SEC'

ImportStatusPollingInterval: str = 'QIANFAN_IMPORT_STATUS_POLLING_INTERVAL'

QpsLimit: str = 'QIANFAN_QPS_LIMIT'

ReleaseStatusPollingInterval: str = 'QIANFAN_RELEASE_STATUS_POLLING_INTERVAL'

SK: str = 'QIANFAN_SK'

SecretKey: str = 'QIANFAN_SECRET_KEY'

class qianfan.consts.PromptFrameworkType(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: int, Enum

Basic: int = 1

基础框架

CRISPE: int = 2

CRISPE框架

Fewshot: int = 3

fewshot框架

NotUse: int = 0

不使用框架

class qianfan.consts.PromptSceneType(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: int, Enum

Text2Image: int = 2

文生图

Text2Text: int = 1

文生文

class qianfan.consts.PromptType(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: int, Enum

Preset = 1

预置模版

User = 2

用户创建模版

qianfan.errors module

the collection of errors for this library

exception qianfan.errors.APIError(error_code: int, error_msg: str, req_id: Any)

Bases: QianfanError

Base exception clas for the qianfan api error

exception qianfan.errors.AccessTokenExpiredError

Bases: QianfanError

Exception when access token is expired

exception qianfan.errors.ArgumentNotFoundError

Bases: QianfanError

Exception when the argument is not found

exception qianfan.errors.FileSizeOverflow

Bases: Exception

Exception when zip file is too big

exception qianfan.errors.InternalError

Bases: QianfanError

Exception when internal error occurs

exception qianfan.errors.InvalidArgumentError

Bases: QianfanError

Exception when the argument is invalid

exception qianfan.errors.NotImplmentError

Bases: QianfanError

Exception that’s raised when code not implemented.

exception qianfan.errors.QianfanError

Bases: Exception

Base exception class for the qianfan sdk.

exception qianfan.errors.QianfanRequestError

Bases: Exception

Exception when request on qianfan failed

exception qianfan.errors.RequestError

Bases: QianfanError

Exception when api request is failed

exception qianfan.errors.RequestTimeoutError

Bases: QianfanError

Exception when api request is timeout

exception qianfan.errors.ValidationError

Bases: Exception

Exception when validating failed

qianfan.version module

version specification