Qwen-Coder est un modèle de langage conçu pour les tâches liées au code. Vous pouvez utiliser l'API pour générer du code, compléter du code et appeler des outils afin d'interagir avec des systèmes externes.
RemarqueNous vous recommandons d'utiliser les modèles généralistes les plus récents plutôt que les modèles Qwen-Coder. Pour plus d'informations, consultez la rubrique Génération de texte afin de sélectionner le modèle adapté à votre scénario.
Premiers pas
Avant de commencer, obtenez une clé API et configurez-la en tant que variable d'environnement. Si vous utilisez un kit de développement logiciel (SDK), vous devez installer le SDK OpenAI ou DashScope.
L'exemple suivant montre comment appeler le modèle qwen-coder-plus-latest pour écrire une fonction Python qui recherche les nombres premiers.
API Chat Completions compatible OpenAI
Python
Exemple de requêteimport os
from openai import OpenAI
client = OpenAI(
# API keys vary by region. To get an API key, visit: https://www.alibabacloud.com/help/en/model-studio/get-api-key
# If the environment variable is not configured, replace the following line with your Alibaba Cloud Model Studio API key: api_key="sk-xxx",
api_key=os.getenv("DASHSCOPE_API_KEY"),
base_url="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1",
)
completion = client.chat.completions.create(
model="qwen-coder-plus-latest",
messages=[
{'role': 'system', 'content': 'You are a helpful assistant.'},
{'role': 'user', 'content': 'Write a Python function named find_prime_numbers that takes an integer n as a parameter and returns a list of all prime numbers less than n. Do not output non-code content or Markdown code blocks.'}],
)
print(completion.choices[0].message.content)
def find_prime_numbers(n):
if n <= 2:
return []
primes = []
for num in range(2, n):
is_prime = True
for i in range(2, int(num ** 0.5) + 1):
if num % i == 0:
is_prime = False
break
if is_prime:
primes.append(num)
return primes
Node.js
Exemple de requêteimport OpenAI from "openai";
const client = new OpenAI(
{
// API keys vary by region. To get an API key, visit: https://www.alibabacloud.com/help/en/model-studio/get-api-key
// If the environment variable is not configured, replace the following line with your Model Studio API key: apiKey: "sk-xxx",
apiKey: process.env.DASHSCOPE_API_KEY,
// The following URL is for the Singapore region. When making a call, replace {WorkspaceId} with your actual workspace ID. URLs vary by region.
baseURL: "https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1"
}
);
async function main() {
const completion = await client.chat.completions.create({
model: "qwen-coder-plus-latest",
messages: [
{ role: "system", content: "You are a helpful assistant." },
{ role: "user", content: "Write a Python function named find_prime_numbers that takes an integer n as a parameter and returns a list of all prime numbers less than n. Do not output non-code content or Markdown code blocks." }
],
});
console.log(completion.choices[0].message.content);
}
main();
def find_prime_numbers(n):
if n <= 2:
return []
primes = []
for num in range(2, n):
is_prime = True
for i in range(2, int(num ** 0.5) + 1):
if num % i == 0:
is_prime = False
break
if is_prime:
primes.append(num)
return primes
curl
Exemple de requêteLes URL varient selon la région.
curl -X POST https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1/chat/completions \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "qwen-coder-plus-latest",
"messages": [
{
"role": "system",
"content": "You are a helpful assistant."
},
{
"role": "user",
"content": "Write a Python function named find_prime_numbers that takes an integer n as a parameter and returns a list of all prime numbers less than n. Do not output non-code content or Markdown code blocks."
}
]
}'
{
"model": "qwen-coder-plus-latest",
"id": "chatcmpl-3123d5cb-01b8-9a90-98cc-5bffbb369xxx",
"choices": [
{
"message": {
"content": "def find_prime_numbers(n):\n if n <= 2:\n return []\n \n primes = []\n for num in range(2, n):\n is_prime = True\n for i in range(2, int(num ** 0.5) + 1):\n if num % i == 0:\n is_prime = False\n break\n if is_prime:\n primes.append(num)\n \n return primes",
"role": "assistant"
},
"index": 0,
"finish_reason": "stop"
}
],
"created": 1770108104,
"object": "chat.completion",
"usage": {
"total_tokens": 155,
"completion_tokens": 89,
"prompt_tokens": 66
}
}
DashScope
Python
Exemple de requêteimport dashscope
import os
dashscope.base_http_api_url = 'https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api/v1'
messages = [
{
"role": "system",
"content": "You are a helpful assistant."
},
{
"role": "user",
"content": "Write a Python function named find_prime_numbers that takes an integer n as a parameter and returns a list of all prime numbers less than n. Do not output non-code content or Markdown code blocks."
}
]
response = dashscope.Generation.call(
# API keys vary by region. To get an API key, visit: https://www.alibabacloud.com/help/en/model-studio/get-api-key
# If the environment variable is not configured, replace the following line with your Alibaba Cloud Model Studio API key: api_key = "sk-xxx",
api_key=os.getenv("DASHSCOPE_API_KEY"),
model="qwen-coder-plus-latest",
messages=messages,
result_format="message"
)
if response.status_code == 200:
print(response.output.choices[0].message.content)
else:
print(f"HTTP return code: {response.status_code}")
print(f"Error code: {response.code}")
print(f"Error message: {response.message}")
def find_prime_numbers(n):
if n <= 2:
return []
primes = []
for num in range(2, n):
is_prime = True
for i in range(2, int(num ** 0.5) + 1):
if num % i == 0:
is_prime = False
break
if is_prime:
primes.append(num)
return primes
Java
Exemple de requêteimport java.util.Arrays;
import com.alibaba.dashscope.aigc.generation.Generation;
import com.alibaba.dashscope.aigc.generation.GenerationResult;
import com.alibaba.dashscope.aigc.generation.GenerationParam;
import com.alibaba.dashscope.common.Message;
import com.alibaba.dashscope.common.Role;
import com.alibaba.dashscope.exception.ApiException;
import com.alibaba.dashscope.exception.InputRequiredException;
import com.alibaba.dashscope.exception.NoApiKeyException;
import com.alibaba.dashscope.protocol.Protocol;
public class Main {
public static GenerationResult callWithMessage()
throws NoApiKeyException, ApiException, InputRequiredException {
String apiKey = System.getenv("DASHSCOPE_API_KEY");
Generation gen = new Generation(Protocol.HTTP.getValue(), "https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api/v1");
Message sysMsg = Message.builder()
.role(Role.SYSTEM.getValue())
.content("You are a helpful assistant.").build();
Message userMsg = Message.builder()
.role(Role.USER.getValue())
.content("Write a Python function named find_prime_numbers that takes an integer n as a parameter and returns a list of all prime numbers less than n. Do not output non-code content or Markdown code blocks.").build();
GenerationParam param = GenerationParam.builder()
.apiKey(apiKey)
.model("qwen-coder-plus-latest")
.messages(Arrays.asList(sysMsg, userMsg))
.resultFormat(GenerationParam.ResultFormat.MESSAGE)
.build();
return gen.call(param);
}
public static void main(String[] args){
try {
GenerationResult result = callWithMessage();
System.out.println(result.getOutput().getChoices().get(0).getMessage().getContent());
} catch (ApiException | NoApiKeyException | InputRequiredException e) {
System.err.println("Request exception: " + e.getMessage());
e.printStackTrace();
}
}
}
def find_prime_numbers(n):
if n <= 2:
return []
primes = []
for num in range(2, n):
is_prime = True
for i in range(2, int(num ** 0.5) + 1):
if num % i == 0:
is_prime = False
break
if is_prime:
primes.append(num)
return primes
curl
Exemple de requêteLes URL varient selon la région.
curl -X POST "https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api/v1/services/aigc/text-generation/generation" \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "qwen-coder-plus-latest",
"input":{
"messages":[
{
"role": "system",
"content": "You are a helpful assistant."
},
{
"role": "user",
"content": "Write a Python function named find_prime_numbers that takes an integer n as a parameter and returns a list of all prime numbers less than n. Do not output non-code content or Markdown code blocks."
}
]
},
"parameters": {
"result_format": "message"
}
}'
{
"output": {
"choices": [
{
"message": {
"content": "def find_prime_numbers(n):\n if n <= 2:\n return []\n \n primes = []\n for num in range(2, n):\n is_prime = True\n for i in range(2, int(num ** 0.5) + 1):\n if num % i == 0:\n is_prime = False\n break\n if is_prime:\n primes.append(num)\n \n return primes",
"role": "assistant"
},
"finish_reason": "stop"
}
]
},
"usage": {
"total_tokens": 155,
"input_tokens": 66,
"output_tokens": 89
},
"request_id": "dd78b1cf-8029-46bb-9bea-b794ded7bxxx"
}
Fonctionnalités principales
Appel d'outils
Fournissez au modèle un ensemble d'outils pour interagir avec des environnements externes, tels que la lecture et l'écriture de fichiers, l'appel d'API ou l'exploitation de bases de données. Le modèle décide lui-même s'il doit appeler ces outils et comment le faire, en fonction de vos instructions. Pour plus d'informations, consultez la rubrique Function Calling.
Le flux complet d'appel d'outils comprend les étapes suivantes :
- Définir les outils et initier une requête : Définissez une liste d'outils dans la requête et demandez au modèle d'accomplir une tâche nécessitant ces outils.
- Exécuter les outils : Analysez les éléments
tool_callsretournés par le modèle et appelez les fonctions d'outils correspondantes implémentées localement pour effectuer la tâche. - Retourner les résultats d'exécution : Formatez les résultats d'exécution des outils selon un format spécifique et renvoyez-les au modèle. Ce dernier utilise ensuite ces résultats pour finaliser la tâche.
L'exemple suivant montre comment guider le modèle pour qu'il génère du code et utilise l'outil write_file afin de l'enregistrer dans un fichier local.
API Chat Completions compatible OpenAI
Python
import os
import json
from openai import OpenAI
client = OpenAI(
# API keys vary by region. To get an API key, visit: https://www.alibabacloud.com/help/en/model-studio/get-api-key
# If the environment variable is not configured, replace the following line with your Alibaba Cloud Model Studio API key: api_key="sk-xxx",
api_key=os.getenv("DASHSCOPE_API_KEY"),
base_url="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1",
)
tools = [
{
"type": "function",
"function": {
"name": "write_file",
"description": "Writes content to a specified file. Creates the file if it does not exist.",
"parameters": {
"type": "object",
"properties": {
"path": {
"type": "string",
"description": "The relative or absolute path of the object file."
},
"content": {
"type": "string",
"description": "The string content to write to the file."
}
},
"required": ["path", "content"]
}
}
}
]
# Implement the tool function
def write_file(path: str, content: str) -> str:
"""Writes content to a file."""
try:
# Ensure the directory exists
os.makedirs(os.path.dirname(path),
exist_ok=True) if os.path.dirname(path) else None
with open(path, 'w', encoding='utf-8') as f:
f.write(content)
return f"Success: The file '{path}' has been written."
except Exception as e:
return f"Error: An exception occurred while writing the file - {str(e)}"
messages = [{"role": "user", "content": "Write a Python quicksort algorithm and name the file quick_sort.py."}]
completion = client.chat.completions.create(
model="qwen-coder-plus-latest",
messages=messages,
tools=tools
)
assistant_output = completion.choices[0].message
if assistant_output.content is None:
assistant_output.content = ""
messages.append(assistant_output)
# If no tool call is needed, print the content directly
if assistant_output.tool_calls is None:
print(f"No tool call needed. Direct response: {assistant_output.content}")
else:
# Enter the tool calling loop
while assistant_output.tool_calls is not None:
for tool_call in assistant_output.tool_calls:
tool_call_id = tool_call.id
func_name = tool_call.function.name
arguments = json.loads(tool_call.function.arguments)
print(f"Calling tool [{func_name}] with arguments: {arguments}")
# Execute the tool
tool_result = write_file(**arguments)
# Construct the tool return message
tool_message = {
"role": "tool",
"tool_call_id": tool_call_id,
"content": tool_result,
}
print(f"Tool returned: {tool_message['content']}")
messages.append(tool_message)
# Call the model again to get a summarized natural language response
response = client.chat.completions.create(
model="qwen-coder-plus-latest",
messages=messages,
tools=tools
)
assistant_output = response.choices[0].message
if assistant_output.content is None:
assistant_output.content = ""
messages.append(assistant_output)
print(f"Final model response: {assistant_output.content}")
Calling tool [write_file] with arguments: {'content': 'def quick_sort(arr):\\n if len(arr) <= 1:\\n return arr\\n pivot = arr[len(arr) // 2]\\n left = [x for x in arr if x < pivot]\\n middle = [x for x in arr if x == pivot]\\n right = [x for x in arr if x > pivot]\\n return quick_sort(left) + middle + quick_sort(right)\\n\\nif __name__ == \\"__main__\\":\\n example_list = [3, 6, 8, 10, 1, 2, 1]\\n print(\\"Original list:\\", example_list)\\n sorted_list = quick_sort(example_list)\\n print(\\"Sorted list:\\", sorted_list)', 'path': 'quick_sort.py'}
Tool returned: Success: The file 'quick_sort.py' has been written.
Final model response: I have created a file named `quick_sort.py` for you, which contains the Python implementation of the quicksort algorithm. You can run this file to see the example output. Let me know if you need any further modifications or explanations!
Node.js
import OpenAI from "openai";
import fs from "fs/promises";
import path from "path";
const client = new OpenAI({
// API keys vary by region. To get an API key, visit: https://www.alibabacloud.com/help/en/model-studio/get-api-key
// If the environment variable is not configured, replace the following line with your Model Studio API key: apiKey: "sk-xxx",
apiKey: process.env.DASHSCOPE_API_KEY,
baseURL: "https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1"
});
const tools = [
{
"type": "function",
"function": {
"name": "write_file",
"description": "Writes content to a specified file. Creates the file if it does not exist.",
"parameters": {
"type": "object",
"properties": {
"path": {
"type": "string",
"description": "The relative or absolute path of the object file."
},
"content": {
"type": "string",
"description": "The string content to write to the file."
}
},
"required": ["path", "content"]
}
}
}
];
// Implement the tool function
async function write_file(filePath, content) {
try {
// For security reasons, the file writing feature is disabled by default. To use it, uncomment the following lines and ensure the path is secure.
// const dir = path.dirname(filePath);
// if (dir) {
// await fs.mkdir(dir, { recursive: true });
// }
// await fs.writeFile(filePath, content, "utf-8");
return `Success: The file '${filePath}' has been written.`;
} catch (error) {
return `Error: An exception occurred while writing the file - ${error.message}`;
}
}
const messages = [{"role": "user", "content": "Write a Python quicksort algorithm and name the file quick_sort.py."}];
async function main() {
const completion = await client.chat.completions.create({
model: "qwen-coder-plus-latest",
messages: messages,
tools: tools
});
let assistant_output = completion.choices[0].message;
// Ensure content is not null
if (!assistant_output.content) assistant_output.content = "";
messages.push(assistant_output);
// If no tool call is needed, print the content directly
if (!assistant_output.tool_calls) {
console.log(`No tool call needed. Direct response: ${assistant_output.content}`);
} else {
// Enter the tool calling loop
while (assistant_output.tool_calls) {
for (const tool_call of assistant_output.tool_calls) {
const tool_call_id = tool_call.id;
const func_name = tool_call.function.name;
const args = JSON.parse(tool_call.function.arguments);
console.log(`Calling tool [${func_name}] with arguments:`, args);
// Execute the tool
const tool_result = await write_file(args.path, args.content);
// Construct the tool return message
const tool_message = {
"role": "tool",
"tool_call_id": tool_call_id,
"content": tool_result
};
console.log(`Tool returned: ${tool_message.content}`);
messages.push(tool_message);
}
// Call the model again to get a summarized natural language response
const response = await client.chat.completions.create({
model: "qwen-coder-plus-latest",
messages: messages,
tools: tools
});
assistant_output = response.choices[0].message;
if (!assistant_output.content) assistant_output.content = "";
messages.push(assistant_output);
}
console.log(`Final model response: ${assistant_output.content}`);
}
}
main();
Calling tool [write_file] with arguments: {
content: 'def quick_sort(arr):\\n if len(arr) <= 1:\\n return arr\\n pivot = arr[len(arr) // 2]\\n left = [x for x in arr if x < pivot]\\n middle = [x for x in arr if x == pivot]\\n right = [x for x in arr if x > pivot]\\n return quick_sort(left) + middle + quick_sort(right)\\n\\nif __name__ == \\"__main__\\":\\n example_list = [3, 6, 8, 10, 1, 2, 1]\\n print(\\"Original list:\\", example_list)\\n sorted_list = quick_sort(example_list)\\n print(\\"Sorted list:\\", sorted_list)',
path: 'quick_sort.py'
}
Tool returned: Success: The file 'quick_sort.py' has been written.
Final model response: The `quick_sort.py` file has been successfully created with the Python implementation of the quicksort algorithm. You can run this file to see the sorting result for the example list. Let me know if you need any further modifications or explanations!
curl
Cet exemple présente la première étape du processus d'appel d'outils : l'initiation d'une requête et la récupération de l'intention du modèle d'appeler un outil.
Les URL varient selon la région.
curl -X POST https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1/chat/completions \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "qwen-coder-plus-latest",
"messages": [
{
"role": "user",
"content": "Write a Python quicksort algorithm and name the file quick_sort.py."
}
],
"tools": [
{
"type": "function",
"function": {
"name": "write_file",
"description": "Writes content to a specified file. Creates the file if it does not exist.",
"parameters": {
"type": "object",
"properties": {
"path": {
"type": "string",
"description": "The relative or absolute path of the object file."
},
"content": {
"type": "string",
"description": "The string content to write to the file."
}
},
"required": ["path", "content"]
}
}
}
]
}'
{
"choices": [
{
"message": {
"content": "",
"role": "assistant",
"tool_calls": [
{
"index": 0,
"id": "call_0ca7505bb6e44471a40511e5",
"type": "function",
"function": {
"name": "write_file",
"arguments": "{\"content\": \"def quick_sort(arr):\\\\n if len(arr) <= 1:\\\\n return arr\\\\n pivot = arr[len(arr) // 2]\\\\n left = [x for x in arr if x < pivot]\\\\n middle = [x for x in arr if x == pivot]\\\\n right = [x for x in arr if x > pivot]\\\\n return quick_sort(left) + middle + quick_sort(right)\\\\n\\\\nif __name__ == \\\\\\\"__main__\\\\\\\":\\\\n example_list = [3, 6, 8, 10, 1, 2, 1]\\\\n print(\\\\\\\"Original list:\\\\\\\", example_list)\\\\n sorted_list = quick_sort(example_list)\\\\n print(\\\\\\\"Sorted list:\\\\\\\", sorted_list)\", \"path\": \"quick_sort.py\"}"
}
}
]
},
"finish_reason": "tool_calls",
"index": 0,
"logprobs": null
}
],
"object": "chat.completion",
"usage": {
"prompt_tokens": 494,
"completion_tokens": 193,
"total_tokens": 687,
"prompt_tokens_details": {
"cached_tokens": 0
}
},
"created": 1761620025,
"system_fingerprint": null,
"model": "qwen-coder-plus-latest",
"id": "chatcmpl-20e96159-beea-451f-b3a4-d13b218112b5"
}
DashScope
Python
import os
import json
import dashscope
dashscope.base_http_api_url = 'https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api/v1'
tools = [
{
"type": "function",
"function": {
"name": "write_file",
"description": "Writes content to a specified file. Creates the file if it does not exist.",
"parameters": {
"type": "object",
"properties": {
"path": {
"type": "string",
"description": "The relative or absolute path of the object file."
},
"content": {
"type": "string",
"description": "The string content to write to the file."
}
},
"required": ["path", "content"]
}
}
}
]
# Implement the tool function
def write_file(path: str, content: str) -> str:
"""Writes content to a file."""
try:
# For security reasons, the file writing feature is disabled by default. To use it, uncomment the following lines and ensure the path is secure.
# os.makedirs(os.path.dirname(path),exist_ok=True) if os.path.dirname(path) else None
# with open(path, 'w', encoding='utf-8') as f:
# f.write(content)
return f"Success: The file '{path}' has been written."
except Exception as e:
return f"Error: An exception occurred while writing the file - {str(e)}"
messages = [{"role": "user", "content": "Write a Python quicksort algorithm and name the file quick_sort.py."}]
response = dashscope.Generation.call(
# If the environment variable is not configured, replace the following line with your Model Studio API key: api_key="sk-xxx",
api_key=os.getenv('DASHSCOPE_API_KEY'),
model='qwen-coder-plus-latest',
messages=messages,
tools=tools,
result_format='message'
)
if response.status_code == 200:
assistant_output = response.output.choices[0].message
messages.append(assistant_output)
# If no tool call is needed, print the content directly
if "tool_calls" not in assistant_output or not assistant_output["tool_calls"]:
print(f"No tool call needed. Direct response: {assistant_output['content']}")
else:
# Enter the tool calling loop
while "tool_calls" in assistant_output and assistant_output["tool_calls"]:
for tool_call in assistant_output["tool_calls"]:
func_name = tool_call["function"]["name"]
arguments = json.loads(tool_call["function"]["arguments"])
tool_call_id = tool_call.get("id")
print(f"Calling tool [{func_name}] with arguments: {arguments}")
# Execute the tool
tool_result = write_file(**arguments)
# Construct the tool return message
tool_message = {
"role": "tool",
"content": tool_result,
"tool_call_id": tool_call_id
}
print(f"Tool returned: {tool_message['content']}")
messages.append(tool_message)
# Call the model again to get a summarized natural language response
response = dashscope.Generation.call(
api_key=os.getenv('DASHSCOPE_API_KEY'),
model='qwen-coder-plus-latest',
messages=messages,
tools=tools,
result_format='message'
)
if response.status_code == 200:
print(f"Final model response: {response.output.choices[0].message.content}")
assistant_output = response.output.choices[0].message
messages.append(assistant_output)
else:
print(f"Error during summary response generation: {response}")
break
else:
print(f"Execution error: {response}")
Calling tool [write_file] with arguments: {'content': 'def quick_sort(arr):\\n if len(arr) <= 1:\\n return arr\\n pivot = arr[len(arr) // 2]\\n left = [x for x in arr if x < pivot]\\n middle = [x for x in arr if x == pivot]\\n right = [x for x in arr if x > pivot]\\n return quick_sort(left) + middle + quick_sort(right)\\n\\nif __name__ == \\"__main__\\":\\n example_list = [3, 6, 8, 10, 1, 2, 1]\\n print(\\"Original list:\\", example_list)\\n sorted_list = quick_sort(example_list)\\n print(\\"Sorted list:\\", sorted_list)', 'path': 'quick_sort.py'}
Tool returned: Success: The file 'quick_sort.py' has been written.
Final model response: The `quick_sort.py` file has been successfully created with the Python implementation of the quicksort algorithm. You can run this file to see the sorting result for the example list. Let me know if you need any further modifications or explanations!
Java
import com.alibaba.dashscope.aigc.generation.Generation;
import com.alibaba.dashscope.aigc.generation.GenerationParam;
import com.alibaba.dashscope.aigc.generation.GenerationResult;
import com.alibaba.dashscope.common.Message;
import com.alibaba.dashscope.common.Role;
import com.alibaba.dashscope.protocol.Protocol;
import com.alibaba.dashscope.exception.NoApiKeyException;
import com.alibaba.dashscope.exception.InputRequiredException;
import com.alibaba.dashscope.tools.FunctionDefinition;
import com.alibaba.dashscope.tools.ToolCallBase;
import com.alibaba.dashscope.tools.ToolCallFunction;
import com.alibaba.dashscope.tools.ToolFunction;
import com.alibaba.dashscope.utils.JsonUtils;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.File;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class Main {
/**
* Writes content to a file.
* @param arguments A JSON string passed in by the model, which contains the parameters required for the tool.
* @return The result string after the tool is executed.
*/
public static String writeFile(String arguments) {
try {
ObjectMapper objectMapper = new ObjectMapper();
JsonNode argsNode = objectMapper.readTree(arguments);
String path = argsNode.get("path").asText();
String content = argsNode.get("content").asText();
// For security reasons, the file writing feature is disabled by default. To use it, uncomment the following lines and ensure the path is secure.
// File file = new File(path);
// File parentDir = file.getParentFile();
// if (parentDir != null && !parentDir.exists()) {
// parentDir.mkdirs();
// }
// Files.write(Paths.get(path), content.getBytes(StandardCharsets.UTF_8));
return "Success: File '" + path + "' has been written";
} catch (Exception e) {
return "Error: An exception occurred while writing the file - " + e.getMessage();
}
}
public static void main(String[] args) {
try {
// Define the tool parameter schema.
String writePropertyParams =
"{\"type\":\"object\",\"properties\":{\"path\":{\"type\":\"string\",\"description\":\"The relative or absolute path of the target file\"},\"content\":{\"type\":\"string\",\"description\":\"The string content to write to the file\"}},\"required\":[\"path\",\"content\"]}";
FunctionDefinition writeFileFunction = FunctionDefinition.builder()
.name("write_file")
.description("Writes content to a specified file. Creates the file if it does not exist.")
.parameters(JsonUtils.parseString(writePropertyParams).getAsJsonObject())
.build();
Generation gen = new Generation(Protocol.HTTP.getValue(), "https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api/v1");
String userInput = "Write a Python script for quick sort and name it quick_sort.py";
List<Message> messages = new ArrayList<>();
messages.add(Message.builder().role(Role.USER.getValue()).content(userInput).build());
// First call to the model.
GenerationParam param = GenerationParam.builder()
.model("qwen-coder-plus-latest")
.apiKey(System.getenv("DASHSCOPE_API_KEY"))
.messages(messages)
.tools(Arrays.asList(ToolFunction.builder().function(writeFileFunction).build()))
.resultFormat(GenerationParam.ResultFormat.MESSAGE)
.build();
GenerationResult result = gen.call(param);
Message assistantOutput = result.getOutput().getChoices().get(0).getMessage();
messages.add(assistantOutput);
// If no tool call is required, directly output the content.
if (assistantOutput.getToolCalls() == null || assistantOutput.getToolCalls().isEmpty()) {
System.out.println("No tool call is required. Direct reply: " + assistantOutput.getContent());
} else {
// Enter the tool calling loop.
while (assistantOutput.getToolCalls() != null && !assistantOutput.getToolCalls().isEmpty()) {
for (ToolCallBase toolCall : assistantOutput.getToolCalls()) {
ToolCallFunction functionCall = (ToolCallFunction) toolCall;
String funcName = functionCall.getFunction().getName();
String arguments = functionCall.getFunction().getArguments();
System.out.println("Calling tool [" + funcName + "], arguments: " + arguments);
// Execute the tool.
String toolResult = writeFile(arguments);
// Construct the tool return message.
Message toolMessage = Message.builder()
.role("tool")
.toolCallId(toolCall.getId())
.content(toolResult)
.build();
System.out.println("Tool returns: " + toolMessage.getContent());
messages.add(toolMessage);
}
// Call the model again to get a summarized natural language response.
param.setMessages(messages);
result = gen.call(param);
assistantOutput = result.getOutput().getChoices().get(0).getMessage();
messages.add(assistantOutput);
}
System.out.println("Final model reply: " + assistantOutput.getContent());
}
} catch (NoApiKeyException | InputRequiredException e) {
System.err.println("Error: " + e.getMessage());
} catch (Exception e) {
e.printStackTrace();
}
}
}
Calling tool [write_file] with arguments: {"content": "def quick_sort(arr):\\n if len(arr) <= 1:\\n return arr\\n pivot = arr[len(arr) // 2]\\n left = [x for x in arr if x < pivot]\\n middle = [x for x in arr if x == pivot]\\n right = [x for x in arr if x > pivot]\\n return quick_sort(left) + middle + quick_sort(right)\\n\\nif __name__ == \\\"__main__\\\":\\n example_array = [3, 6, 8, 10, 1, 2, 1]\\n print(\\\"Original array:\\\", example_array)\\n sorted_array = quick_sort(example_array)\\n print(\\\"Sorted array:\\\", sorted_array)", "path": "quick_sort.py"}
Tool returned: Success: The file 'quick_sort.py' has been written.
Final model response: I have successfully created the Python code file `quick_sort.py` for you. This file contains a `quick_sort` function and an example of its usage. You can run it in your terminal or editor to test the quicksort functionality.
curl
Cet exemple présente la première étape du processus d'appel d'outils : l'initiation d'une requête et la récupération de l'intention du modèle d'appeler un outil.
Les URL varient selon la région.
curl --location "https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api/v1/services/aigc/text-generation/generation" \
--header "Authorization: Bearer $DASHSCOPE_API_KEY" \
--header "Content-Type: application/json" \
--data '{
"model": "qwen-coder-plus-latest",
"input": {
"messages": [{
"role": "user",
"content": "Write a Python quicksort algorithm and name the file quick_sort.py."
}]
},
"parameters": {
"result_format": "message",
"tools": [
{
"type": "function",
"function": {
"name": "write_file",
"description": "Writes content to a specified file. Creates the file if it does not exist.",
"parameters": {
"type": "object",
"properties": {
"path": {
"type": "string",
"description": "The relative or absolute path of the object file."
},
"content": {
"type": "string",
"description": "The string content to write to the file."
}
},
"required": ["path", "content"]
}
}
}
]
}
}'
{
"output": {
"choices": [
{
"finish_reason": "tool_calls",
"message": {
"role": "assistant",
"tool_calls": [
{
"function": {
"name": "write_file",
"arguments": "{\"content\": \"def quick_sort(arr):\\\\n if len(arr) <= 1:\\\\n return arr\\\\n pivot = arr[len(arr) // 2]\\\\n left = [x for x in arr if x < pivot]\\\\n middle = [x for x in arr if x == pivot]\\\\n right = [x for x in arr if x > pivot]\\\\n return quick_sort(left) + middle + quick_sort(right)\\\\n\\\\nif __name__ == \\\\\\\"__main__\\\\\\\":\\\\n example_list = [3, 6, 8, 10, 1, 2, 1]\\\\n print(\\\\\\\"Original list:\\\\\\\", example_list)\\\\n sorted_list = quick_sort(example_list)\\\\n print(\\\\\\\"Sorted list:\\\\\\\", sorted_list), \"path\": \"quick_sort.py\"}"
},
"index": 0,
"id": "call_645b149bbd274e8bb3789aae",
"type": "function"
}
],
"content": ""
}
}
]
},
"usage": {
"total_tokens": 684,
"output_tokens": 193,
"input_tokens": 491,
"prompt_tokens_details": {
"cached_tokens": 0
}
},
"request_id": "d2386acd-fce3-9d0f-8015-c5f3a8bf9f5c"
}
Complétion de code
Qwen-Coder prend en charge deux méthodes de complétion de code. Choisissez celle qui correspond le mieux à vos besoins :
- Mode partiel : Cette méthode fonctionne avec tous les modèles Qwen-Coder et dans toutes les régions. Elle permet la complétion par préfixe et s'avère simple à mettre en œuvre. Nous vous la recommandons.
- API Completions : Cette méthode est uniquement prise en charge pour les modèles de la série
qwen2.5-coderdans la région Chine (Pékin). Elle permet à la fois la complétion par préfixe et la complétion intermédiaire (fill-in-the-middle).
Mode partiel
Cette fonctionnalité permet au modèle de compléter automatiquement le reste de votre code à partir d'un préfixe fourni.
Pour utiliser cette fonctionnalité, ajoutez un message avec role défini sur assistant et partial: true à la liste messages. Le champ content du message assistant correspond au préfixe de code que vous fournissez. Pour plus d'informations, consultez la rubrique Mode partiel.
Compatible OpenAI
Python
Requêteimport os
from openai import OpenAI
client = OpenAI(
# If the environment variable is not configured, replace the following line with your Alibaba Cloud Model Studio API key: api_key="sk-xxx",
api_key=os.getenv("DASHSCOPE_API_KEY"),
base_url="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1",
)
completion = client.chat.completions.create(
model="qwen-coder-plus-latest",
messages=[{
"role": "user",
"content": "Help me write a Python script to generate prime numbers up to 100. Do not output non-code content or Markdown code blocks."
},
{
"role": "assistant",
"content": "def generate_prime_number",
"partial": True
}]
)
print(completion.choices[0].message.content)
(n):
primes = []
for i in range(2, n+1):
is_prime = True
for j in range(2, int(i**0.5)+1):
if i % j == 0:
is_prime = False
break
if is_prime:
primes.append(i)
return primes
prime_numbers = generate_prime_number(100)
print(prime_numbers)
Node.js
Exemple de requêteimport OpenAI from "openai";
const client = new OpenAI(
{
// If the environment variable is not configured, replace the following line with your Model Studio API key: apiKey: "sk-xxx",
apiKey: process.env.DASHSCOPE_API_KEY,
baseURL: "https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1"
}
);
async function main() {
const completion = await client.chat.completions.create({
model: "qwen-coder-plus-latest",
messages: [
{ role: "user", content: "Help me write a Python script to generate prime numbers up to 100. Do not output non-code content or Markdown code blocks." },
{ role: "assistant", content: "def generate_prime_number", partial: true}
],
});
console.log(completion.choices[0].message.content);
}
main();
(n):
primes = []
for i in range(2, n+1):
is_prime = True
for j in range(2, int(i**0.5)+1):
if i % j == 0:
is_prime = False
break
if is_prime:
primes.append(i)
return primes
prime_numbers = generate_prime_number(100)
print(prime_numbers)
curl
Exemple de requêteLes URL varient selon la région.
curl -X POST https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1/chat/completions \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "qwen-coder-plus-latest",
"messages": [{
"role": "user",
"content": "Help me write a Python script to generate prime numbers up to 100. Do not output non-code content or Markdown code blocks."
},
{
"role": "assistant",
"content": "def generate_prime_number",
"partial": true
}]
}'
{
"choices": [
{
"message": {
"content": "(n):\n primes = []\n for num in range(2, n + 1):\n is_prime = True\n for i in range(2, int(num ** 0.5) + 1):\n if num % i == 0:\n is_prime = False\n break\n if is_prime:\n primes.append(num)\n return primes\n\nprime_numbers = generate_prime_number(100)\nprint(prime_numbers)",
"role": "assistant"
},
"finish_reason": "stop",
"index": 0,
"logprobs": null
}
],
"object": "chat.completion",
"usage": {
"prompt_tokens": 38,
"completion_tokens": 93,
"total_tokens": 131,
"prompt_tokens_details": {
"cached_tokens": 0
}
},
"created": 1761634556,
"system_fingerprint": null,
"model": "qwen-coder-plus-latest",
"id": "chatcmpl-c108050a-bb6d-4423-9d36-f64aa6a32976"
}
DashScope
Python
Exemple de requêtefrom http import HTTPStatus
import dashscope
import os
dashscope.base_http_api_url = 'https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api/v1'
messages = [{
"role": "user",
"content": "Help me write a Python script to generate prime numbers up to 100. Do not output non-code content or Markdown code blocks."
},
{
"role": "assistant",
"content": "def generate_prime_number",
"partial": True
}]
response = dashscope.Generation.call(
# If the environment variable is not configured, replace the following line with your Model Studio API key: api_key="sk-xxx",
api_key=os.getenv('DASHSCOPE_API_KEY'),
model='qwen-coder-plus-latest',
messages=messages,
result_format='message',
)
if response.status_code == HTTPStatus.OK:
print(response.output.choices[0].message.content)
else:
print(f"HTTP return code: {response.status_code}")
print(f"Error code: {response.code}")
print(f"Error message: {response.message}")
(n):
primes = []
for i in range(2, n+1):
is_prime = True
for j in range(2, int(i**0.5)+1):
if i % j == 0:
is_prime = False
break
if is_prime:
primes.append(i)
return primes
prime_numbers = generate_prime_number(100)
print(prime_numbers)
curl
Exemple de requêteLes URL varient selon la région.
curl -X POST "https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api/v1/services/aigc/text-generation/generation" \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "qwen-coder-plus-latest",
"input":{
"messages":[{
"role": "user",
"content": "Help me write a Python script to generate prime numbers up to 100. Do not output non-code content or Markdown code blocks."
},
{
"role": "assistant",
"content": "def generate_prime_number",
"partial": true
}]
},
"parameters": {
"result_format": "message"
}
}'
{
"output": {
"choices": [
{
"message": {
"content": "(n):\n prime_list = []\n for i in range(2, n+1):\n is_prime = True\n for j in range(2, int(i**0.5)+1):\n if i % j == 0:\n is_prime = False\n break\n if is_prime:\n prime_list.append(i)\n return prime_list\n\nprime_numbers = generate_prime_number(100)\nprint(prime_numbers)",
"role": "assistant"
},
"finish_reason": "stop"
}
]
},
"usage": {
"total_tokens": 131,
"output_tokens": 92,
"input_tokens": 39,
"prompt_tokens_details": {
"cached_tokens": 0
}
},
"request_id": "9917f629-e819-4519-af44-b0e677e94b2c"
}
API Completions
ImportantL'API Completions est disponible uniquement pour les modèles situés dans la région Chine (Pékin) et nécessite une clé API provenant de la région Chine (Pékin).
qwen-coder-turbo-latest
L'API Completions utilise des balises spéciales fim (Fill-in-the-Middle) dans le prompt pour guider la complétion par le modèle.
Complétion basée sur le préfixe
Modèle de prompt :<|fim_prefix|>{prefix_content}<|fim_suffix|>
<|fim_prefix|>et<|fim_middle|>sont des tokens spéciaux qui guident le modèle pour compléter le texte. Ne les modifiez pas.- Remplacez
{prefix_content}par vos informations de préfixe, telles que le nom de la fonction, les paramètres d'entrée et les instructions d'utilisation.
import os
from openai import OpenAI
client = OpenAI(
base_url="https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1",
api_key=os.getenv("DASHSCOPE_API_KEY")
)
completion = client.completions.create(
model="qwen-coder-turbo-latest",
prompt="<|fim_prefix|>def quick_sort(arr):<|fim_suffix|>",
)
print(completion.choices[0].text)
import OpenAI from "openai";
const client = new OpenAI(
{
// If the environment variable is not configured, replace the following line with your Alibaba Cloud Model Studio API key: apiKey: "sk-xxx",
apiKey: process.env.DASHSCOPE_API_KEY,
baseURL: "https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1"
}
);
async function main() {
const completion = await client.completions.create({
model: "qwen-coder-turbo-latest",
prompt: "<|fim_prefix|>def quick_sort(arr):<|fim_suffix|>",
});
console.log(completion.choices[0].text)
}
main();
curl -X POST https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1/completions \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "qwen-coder-turbo-latest",
"prompt": "<|fim_prefix|>def quick_sort(arr):<|fim_suffix|>"
}'
Complétion basée sur le préfixe et le suffixe
Modèle de prompt :<|fim_prefix|>{prefix_content}<|fim_suffix|>{suffix_content}<|fim_middle|>
<|fim_prefix|>,<|fim_middle|>et<|fim_middle|>sont des tokens spéciaux qui guident le modèle pour compléter le texte. Ne les modifiez pas.- Remplacez
{prefix_content}par vos informations de préfixe, telles que le nom de la fonction, les paramètres d'entrée et les instructions d'utilisation. - Remplacez
{suffix_content}par vos informations de suffixe, telles que les paramètres de retour de la fonction.
import os
from openai import OpenAI
client = OpenAI(
base_url="https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1",
api_key=os.getenv("DASHSCOPE_API_KEY")
)
prefix_content = """def reverse_words_with_special_chars(s):
'''
Reverse each word in a string while preserving the position of non-alphabetic characters and word order.
Example:
reverse_words_with_special_chars("Hello, world!") -> "olleH, dlrow!"
Parameters:
s (str): The input string, which may contain punctuation.
Returns:
str: The processed string with words reversed but non-alphabetic characters in their original positions.
'''
"""
suffix_content = "return result"
completion = client.completions.create(
model="qwen-coder-turbo-latest",
prompt=f"<|fim_prefix|>{prefix_content}<|fim_suffix|>{suffix_content}<|fim_middle|>",
)
print(completion.choices[0].text)
import OpenAI from 'openai';
const client = new OpenAI({
baseURL: "https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1",
apiKey: process.env.DASHSCOPE_API_KEY
});
const prefixContent = `def reverse_words_with_special_chars(s):
'''
Reverse each word in a string while preserving the position of non-alphabetic characters and word order.
Example:
reverse_words_with_special_chars("Hello, world!") -> "olleH, dlrow!"
Parameters:
s (str): The input string, which may contain punctuation.
Returns:
str: The processed string with words reversed but non-alphabetic characters in their original positions.
'''
`;
const suffixContent = "return result";
async function main() {
const completion = await client.completions.create({
model: "qwen-coder-turbo-latest",
prompt: `<|fim_prefix|>${prefixContent}<|fim_suffix|>${suffixContent}<|fim_middle|>`
});
console.log(completion.choices[0].text);
}
main();
curl -X POST https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1/completions \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "qwen-coder-turbo-latest",
"prompt": "<|fim_prefix|>def reverse_words_with_special_chars(s):\n\"\"\"\nReverse each word in a string while preserving the position of non-alphabetic characters and word order.\n Example:\n reverse_words_with_special_chars(\"Hello, world!\") -> \"olleH, dlrow!\"\n Parameters:\n s (str): The input string, which may contain punctuation.\n Returns:\n str: The processed string with words reversed but non-alphabetic characters in their original positions.\n\"\"\"\n<|fim_suffix|>return result<|fim_middle|>"
}'
Mise en production
Pour optimiser l'efficacité et réduire les coûts liés à l'utilisation des modèles Qwen-Coder, tenez compte des recommandations suivantes :
- Activez lasortie en streaming : Définissez
stream=Truepour recevoir les résultats intermédiaires en temps réel. Cela réduit le risque de délais d'attente expirés et améliore l'expérience utilisateur. - Réduisez la température : Les tâches de génération de code exigent généralement des résultats déterministes et précis. Diminuer le paramètre
temperaturepermet de limiter l'aléatoire des sorties générées. - Utilisez un modèle prenant en charge le cache de contexte : Dans les scénarios comportant de nombreux préfixes répétitifs, comme la complétion ou la révision de code, recourir à un modèle compatible avec le cache de contexte permet de réduire efficacement les coûts.
- Limitez le nombre d'outils : Pour garantir des appels de modèles efficaces et économiques, ne transmettez pas plus de 20 outils dans le paramètre
toolspar appel. Fournir trop de descriptions d'outils consomme excessivement de tokens d'entrée, ce qui augmente les coûts, ralentit la réponse et complique la sélection de l'outil approprié par le modèle. Pour plus d'informations, consultez la rubrique Function Calling.
Facturation et limitation de débit
-
Facturation de base : La facturation repose sur le nombre de
tokensd'entrée et detokensde sortie pour chaque requête. Le prix unitaire varie selon le modèle. Pour connaître les tarifs spécifiques, consultez la Liste des modèles. -
Éléments de facturation spécifiques :
- Facturation par paliers : Les modèles de la série
qwen3-coderappliquent une facturation par paliers. Lorsque le nombre de tokens d'entrée d'une seule requête atteint un palier donné, l'ensemble des tokens d'entrée et de sortie de cette requête est facturé au tarif correspondant à ce palier. - Cache de contexte : Pour les modèles prenant en charge le cache de contexte, ce mécanisme peut réduire considérablement les coûts des requêtes comportant de grandes quantités d'entrées répétitives, notamment lors de révisions de code. Le texte d'entrée correspondant au cache implicite est facturé à 20 % du tarif standard. Celui correspondant au cache explicite est facturé à 10 % du tarif standard. Pour plus d'informations, consultez la rubrique Cache de contexte.
- Appel d'outils (Function Calling) : Lorsque vous utilisez la fonctionnalité d'appel d'outils, les descriptions d'outils définies dans le paramètre
toolssont incluses dans le décompte total destokenset font l'objet d'une facturation.
- Facturation par paliers : Les modèles de la série
-
Limitation de débit : Les appels API sont soumis à une double limite : le nombre de requêtes par minute (RPM) et le nombre de tokens par minute (TPM). Pour plus d'informations, consultez la rubrique Limitation de débit.
-
Quota gratuit(région Singapour uniquement) : Après avoir activé Model Studio ou obtenu l'approbation de votre demande de modèle, chaque modèle Qwen-Coder inclut un quota gratuit d'un million de tokens pour les nouveaux utilisateurs, valable pendant 90 jours.
Référence API
Pour plus d'informations sur les paramètres d'entrée et de sortie des modèles Qwen-Coder, consultez la rubrique Génération de texte.
FAQ
Pourquoi les outils de développement comme Qwen Code et Claude Code consomment-ils autant de tokens ?
Lorsque vous utilisez un outil de développement externe pour appeler un modèle Qwen-Coder, cet outil peut effectuer plusieurs appels API, ce qui consomme un grand nombre de tokens. Pour découvrir les méthodes spécifiques permettant de surveiller et de réduire la consommation de tokens, consultez les documents Qwen Code et Claude Code. Vous pouvez activer la fonctionnalité stop-when-quota-exhausted afin d'éviter des frais supplémentaires une fois votre quota gratuit épuisé.
Vous avez également la possibilité de souscrire un plan de codage IA. Ce plan propose un forfait mensuel fixe donnant droit à un quota de requêtes mensuelles utilisables dans les outils IA. Pour plus d'informations, consultez le document Présentation du Coding Plan.
Comment consulter l'utilisation du modèle ?
Une heure après avoir appelé un modèle, accédez à la page Monitoring (Singapour ou Pékin). Définissez les critères de recherche, tels que la plage horaire et l'espace de travail. Ensuite, dans la zone Models, localisez le modèle cible et cliquez sur Monitor dans la colonne Actions pour afficher les statistiques d'appel du modèle. Pour plus d'informations, consultez le document Monitoring.
Les données sont mises à jour toutes les heures. En période de forte activité, un délai d'environ une heure peut survenir.
Comment faire en sorte que le modèle ne produise que du code, sans texte explicatif ?
Vous pouvez employer les méthodes suivantes :
- Contraintes dans le prompt : Fournissez des instructions claires dans le prompt, par exemple : « Retourne uniquement le code. N'inclus aucune explication, commentaire ou balise Markdown. »
- Définir une séquence stop : Utilisez des expressions telles que
stop=["\n# Explanation:", "Note:"]pour interrompre la génération avant que le modèle ne commence à produire du texte explicatif. Pour plus d'informations, consultez la référence API Qwen.