diff --git a/.agent-store-config.yaml.example b/.agent-store-config.yaml.example new file mode 100644 index 000000000..037a44ed4 --- /dev/null +++ b/.agent-store-config.yaml.example @@ -0,0 +1,9 @@ +role: + name: Teacher # Referenced the `Teacher` in `metagpt/roles/teacher.py`. + module: metagpt.roles.teacher # Referenced `metagpt/roles/teacher.py`. + skills: # Refer to the skill `name` of the published skill in `.well-known/skills.yaml`. + - name: text_to_speech + description: Text-to-speech + - name: text_to_image + description: Create a drawing based on the text. + diff --git a/.gitignore b/.gitignore index c12506b0e..93e24ba48 100644 --- a/.gitignore +++ b/.gitignore @@ -159,3 +159,9 @@ workspace/* tmp metagpt/roles/idea_agent.py .aider* +*.bak + +# output folder +output +tmp.png + diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 338f832ac..09a3b19ab 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -1,8 +1,9 @@ default_stages: [ commit ] # Install -# 1. pip install pre-commit +# 1. pip install metagpt[dev] # 2. pre-commit install +# 3. pre-commit run --all-files # make sure all files are clean repos: - repo: https://github.com/pycqa/isort rev: 5.11.5 @@ -19,9 +20,10 @@ repos: rev: v0.0.284 hooks: - id: ruff + args: [ --fix ] - repo: https://github.com/psf/black rev: 23.3.0 hooks: - id: black - args: ['--line-length', '120'] \ No newline at end of file + args: ['--line-length', '120'] diff --git a/.well-known/ai-plugin.json b/.well-known/ai-plugin.json new file mode 100644 index 000000000..ac0178fd0 --- /dev/null +++ b/.well-known/ai-plugin.json @@ -0,0 +1,18 @@ +{ + "schema_version": "v1", + "name_for_model": "text processing tools", + "name_for_human": "MetaGPT Text Plugin", + "description_for_model": "Plugins for text processing, including text-to-speech, text-to-image, text-to-embedding, text summarization, text-to-code, vector similarity calculation, web content crawling, and more.", + "description_for_human": "Plugins for text processing, including text-to-speech, text-to-image, text-to-embedding, text summarization, text-to-code, vector similarity calculation, web content crawling, and more.", + "auth": { + "type": "none" + }, + "api": { + "type": "openapi", + "url": "https://github.com/iorisa/MetaGPT/blob/feature/assistant_role/.well-known/metagpt_oas3_api.yaml", + "has_user_authentication": false + }, + "logo_url": "https://github.com/geekan/MetaGPT/blob/main/docs/resources/MetaGPT-logo.png", + "contact_email": "mashenquan@fuzhi.cn", + "legal_info_url": "https://github.com/geekan/MetaGPT/blob/main/docs/README_CN.md" +} \ No newline at end of file diff --git a/.well-known/metagpt_oas3_api.yaml b/.well-known/metagpt_oas3_api.yaml new file mode 100644 index 000000000..0a702e8b6 --- /dev/null +++ b/.well-known/metagpt_oas3_api.yaml @@ -0,0 +1,338 @@ +openapi: "3.0.0" + +info: + title: "MetaGPT Export OpenAPIs" + version: "1.0" +servers: + - url: "/oas3" + variables: + port: + default: '8080' + description: HTTP service port + +paths: + /tts/azsure: + x-prerequisite: + configurations: + AZURE_TTS_SUBSCRIPTION_KEY: + type: string + description: "For more details, check out: [Azure Text-to_Speech](https://learn.microsoft.com/en-us/azure/ai-services/speech-service/language-support?tabs=tts)" + AZURE_TTS_REGION: + type: string + description: "For more details, check out: [Azure Text-to_Speech](https://learn.microsoft.com/en-us/azure/ai-services/speech-service/language-support?tabs=tts)" + required: + allOf: + - AZURE_TTS_SUBSCRIPTION_KEY + - AZURE_TTS_REGION + post: + summary: "Convert Text to Base64-encoded .wav File Stream" + description: "For more details, check out: [Azure Text-to_Speech](https://learn.microsoft.com/en-us/azure/ai-services/speech-service/language-support?tabs=tts)" + operationId: azure_tts.oas3_azsure_tts + requestBody: + required: true + content: + application/json: + schema: + type: object + required: + - text + properties: + text: + type: string + description: Text to convert + lang: + type: string + description: The language code or locale, e.g., en-US (English - United States) + default: "zh-CN" + voice: + type: string + description: "Voice style, see: [Azure Text-to_Speech](https://learn.microsoft.com/en-us/azure/ai-services/speech-service/language-support?tabs=tts), [Voice Gallery](https://speech.microsoft.com/portal/voicegallery)" + default: "zh-CN-XiaomoNeural" + style: + type: string + description: "Speaking style to express different emotions. For more details, checkout: [Azure Text-to_Speech](https://learn.microsoft.com/en-us/azure/ai-services/speech-service/language-support?tabs=tts)" + default: "affectionate" + role: + type: string + description: "Role to specify age and gender. For more details, checkout: [Azure Text-to_Speech](https://learn.microsoft.com/en-us/azure/ai-services/speech-service/language-support?tabs=tts)" + default: "Girl" + subscription_key: + type: string + description: "Key used to access Azure AI service API, see: [Azure Portal](https://portal.azure.com/) > `Resource Management` > `Keys and Endpoint`" + default: "" + region: + type: string + description: "Location (or region) of your resource, see: [Azure Portal](https://portal.azure.com/) > `Resource Management` > `Keys and Endpoint`" + default: "" + responses: + '200': + description: "Base64-encoded .wav file data if successful, otherwise an empty string." + content: + application/json: + schema: + type: object + properties: + wav_data: + type: string + format: base64 + '400': + description: "Bad Request" + '500': + description: "Internal Server Error" + + /tts/iflytek: + x-prerequisite: + configurations: + IFLYTEK_APP_ID: + type: string + description: "Application ID is used to access your iFlyTek service API, see: `https://console.xfyun.cn/services/tts`" + IFLYTEK_API_KEY: + type: string + description: "WebAPI argument, see: `https://console.xfyun.cn/services/tts`" + IFLYTEK_API_SECRET: + type: string + description: "WebAPI argument, see: `https://console.xfyun.cn/services/tts`" + required: + allOf: + - IFLYTEK_APP_ID + - IFLYTEK_API_KEY + - IFLYTEK_API_SECRET + post: + summary: "Convert Text to Base64-encoded .mp3 File Stream" + description: "For more details, check out: [iFlyTek](https://console.xfyun.cn/services/tts)" + operationId: iflytek_tts.oas3_iflytek_tts + requestBody: + required: true + content: + application/json: + schema: + type: object + required: + - text + properties: + text: + type: string + description: Text to convert + voice: + type: string + description: "Voice style, see: [iFlyTek Text-to_Speech](https://www.xfyun.cn/doc/tts/online_tts/API.html#%E6%8E%A5%E5%8F%A3%E8%B0%83%E7%94%A8%E6%B5%81%E7%A8%8B)" + default: "xiaoyan" + app_id: + type: string + description: "Application ID is used to access your iFlyTek service API, see: `https://console.xfyun.cn/services/tts`" + default: "" + api_key: + type: string + description: "WebAPI argument, see: `https://console.xfyun.cn/services/tts`" + default: "" + api_secret: + type: string + description: "WebAPI argument, see: `https://console.xfyun.cn/services/tts`" + default: "" + responses: + '200': + description: "Base64-encoded .mp3 file data if successful, otherwise an empty string." + content: + application/json: + schema: + type: object + properties: + wav_data: + type: string + format: base64 + '400': + description: "Bad Request" + '500': + description: "Internal Server Error" + + + /txt2img/openai: + x-prerequisite: + configurations: + OPENAI_API_KEY: + type: string + description: "OpenAI API key, For more details, checkout: `https://platform.openai.com/account/api-keys`" + required: + allOf: + - OPENAI_API_KEY + post: + summary: "Convert Text to Base64-encoded Image Data Stream" + operationId: openai_text_to_image.oas3_openai_text_to_image + requestBody: + required: true + content: + application/json: + schema: + type: object + properties: + text: + type: string + description: "The text used for image conversion." + size_type: + type: string + enum: ["256x256", "512x512", "1024x1024"] + default: "1024x1024" + description: "Size of the generated image." + openai_api_key: + type: string + default: "" + description: "OpenAI API key, For more details, checkout: `https://platform.openai.com/account/api-keys`" + responses: + '200': + description: "Base64-encoded image data." + content: + application/json: + schema: + type: object + properties: + image_data: + type: string + format: base64 + '400': + description: "Bad Request" + '500': + description: "Internal Server Error" + /txt2embedding/openai: + x-prerequisite: + configurations: + OPENAI_API_KEY: + type: string + description: "OpenAI API key, For more details, checkout: `https://platform.openai.com/account/api-keys`" + required: + allOf: + - OPENAI_API_KEY + post: + summary: Text to embedding + operationId: openai_text_to_embedding.oas3_openai_text_to_embedding + description: Retrieve an embedding for the provided text using the OpenAI API. + requestBody: + content: + application/json: + schema: + type: object + properties: + input: + type: string + description: The text used for embedding. + model: + type: string + description: "ID of the model to use. For more details, checkout: [models](https://api.openai.com/v1/models)" + enum: + - text-embedding-ada-002 + responses: + "200": + description: Successful response + content: + application/json: + schema: + $ref: "#/components/schemas/ResultEmbedding" + "4XX": + description: Client error + content: + application/json: + schema: + $ref: "#/components/schemas/Error" + "5XX": + description: Server error + content: + application/json: + schema: + $ref: "#/components/schemas/Error" + + /txt2image/metagpt: + x-prerequisite: + configurations: + METAGPT_TEXT_TO_IMAGE_MODEL_URL: + type: string + description: "Model url." + required: + allOf: + - METAGPT_TEXT_TO_IMAGE_MODEL_URL + post: + summary: "Text to Image" + description: "Generate an image from the provided text using the MetaGPT Text-to-Image API." + operationId: metagpt_text_to_image.oas3_metagpt_text_to_image + requestBody: + required: true + content: + application/json: + schema: + type: object + required: + - text + properties: + text: + type: string + description: "The text used for image conversion." + size_type: + type: string + enum: ["512x512", "512x768"] + default: "512x512" + description: "Size of the generated image." + model_url: + type: string + description: "Model reset API URL for text-to-image." + default: "" + responses: + '200': + description: "Base64-encoded image data." + content: + application/json: + schema: + type: object + properties: + image_data: + type: string + format: base64 + '400': + description: "Bad Request" + '500': + description: "Internal Server Error" + +components: + schemas: + Embedding: + type: object + description: Represents an embedding vector returned by the embedding endpoint. + properties: + object: + type: string + example: embedding + embedding: + type: array + items: + type: number + example: [0.0023064255, -0.009327292, ...] + index: + type: integer + example: 0 + Usage: + type: object + properties: + prompt_tokens: + type: integer + example: 8 + total_tokens: + type: integer + example: 8 + ResultEmbedding: + type: object + properties: + object: + type: string + example: result_embedding + data: + type: array + items: + $ref: "#/components/schemas/Embedding" + model: + type: string + example: text-embedding-ada-002 + usage: + $ref: "#/components/schemas/Usage" + Error: + type: object + properties: + error: + type: string + example: An error occurred \ No newline at end of file diff --git a/.well-known/openapi.yaml b/.well-known/openapi.yaml new file mode 100644 index 000000000..bc291b7db --- /dev/null +++ b/.well-known/openapi.yaml @@ -0,0 +1,35 @@ +openapi: "3.0.0" + +info: + title: Hello World + version: "1.0" +servers: + - url: /openapi + +paths: + /greeting/{name}: + post: + summary: Generate greeting + description: Generates a greeting message. + operationId: hello.post_greeting + responses: + 200: + description: greeting response + content: + text/plain: + schema: + type: string + example: "hello dave!" + parameters: + - name: name + in: path + description: Name of the person to greet. + required: true + schema: + type: string + example: "dave" + requestBody: + content: + application/json: + schema: + type: object \ No newline at end of file diff --git a/.well-known/skills.yaml b/.well-known/skills.yaml new file mode 100644 index 000000000..c19a9501e --- /dev/null +++ b/.well-known/skills.yaml @@ -0,0 +1,161 @@ +skillapi: "0.1.0" + +info: + title: "Agent Skill Specification" + version: "1.0" + +entities: + Assistant: + summary: assistant + description: assistant + skills: + - name: text_to_speech + description: Generate a voice file from the input text, text-to-speech + id: text_to_speech.text_to_speech + x-prerequisite: + configurations: + AZURE_TTS_SUBSCRIPTION_KEY: + type: string + description: "For more details, check out: [Azure Text-to_Speech](https://learn.microsoft.com/en-us/azure/ai-services/speech-service/language-support?tabs=tts)" + AZURE_TTS_REGION: + type: string + description: "For more details, check out: [Azure Text-to_Speech](https://learn.microsoft.com/en-us/azure/ai-services/speech-service/language-support?tabs=tts)" + IFLYTEK_APP_ID: + type: string + description: "Application ID is used to access your iFlyTek service API, see: `https://console.xfyun.cn/services/tts`" + IFLYTEK_API_KEY: + type: string + description: "WebAPI argument, see: `https://console.xfyun.cn/services/tts`" + IFLYTEK_API_SECRET: + type: string + description: "WebAPI argument, see: `https://console.xfyun.cn/services/tts`" + required: + oneOf: + - allOf: + - AZURE_TTS_SUBSCRIPTION_KEY + - AZURE_TTS_REGION + - allOf: + - IFLYTEK_APP_ID + - IFLYTEK_API_KEY + - IFLYTEK_API_SECRET + parameters: + text: + description: 'The text used for voice conversion.' + required: true + type: string + lang: + description: 'The value can contain a language code such as en (English), or a locale such as en-US (English - United States).' + type: string + enum: + - English + - Chinese + default: Chinese + voice: + description: Name of voice styles + type: string + default: zh-CN-XiaomoNeural + style: + type: string + description: Speaking style to express different emotions like cheerfulness, empathy, and calm. + enum: + - affectionate + - angry + - calm + - cheerful + - depressed + - disgruntled + - embarrassed + - envious + - fearful + - gentle + - sad + - serious + default: affectionate + role: + type: string + description: With roles, the same voice can act as a different age and gender. + enum: + - Girl + - Boy + - OlderAdultFemale + - OlderAdultMale + - SeniorFemale + - SeniorMale + - YoungAdultFemale + - YoungAdultMale + default: Girl + examples: + - ask: 'A girl says "hello world"' + answer: 'text_to_speech(text="hello world", role="Girl")' + - ask: 'A boy affectionate says "hello world"' + answer: 'text_to_speech(text="hello world", role="Boy", style="affectionate")' + - ask: 'A boy says "你好"' + answer: 'text_to_speech(text="你好", role="Boy", lang="Chinese")' + returns: + type: string + format: base64 + + - name: text_to_image + description: Create a drawing based on the text. + id: text_to_image.text_to_image + x-prerequisite: + configurations: + OPENAI_API_KEY: + type: string + description: "OpenAI API key, For more details, checkout: `https://platform.openai.com/account/api-keys`" + METAGPT_TEXT_TO_IMAGE_MODEL_URL: + type: string + description: "Model url." + required: + oneOf: + - OPENAI_API_KEY + - METAGPT_TEXT_TO_IMAGE_MODEL_URL + parameters: + text: + description: 'The text used for image conversion.' + type: string + required: true + size_type: + description: size type + type: string + default: "512x512" + examples: + - ask: 'Draw a girl' + answer: 'text_to_image(text="Draw a girl", size_type="512x512")' + - ask: 'Draw an apple' + answer: 'text_to_image(text="Draw an apple", size_type="512x512")' + returns: + type: string + format: base64 + + - name: web_search + description: Perform Google searches to provide real-time information. + id: web_search.web_search + x-prerequisite: + configurations: + SEARCH_ENGINE: + type: string + description: "Supported values: serpapi/google/serper/ddg" + SERPER_API_KEY: + type: string + description: "SERPER API KEY, For more details, checkout: `https://serper.dev/api-key`" + required: + allOf: + - SEARCH_ENGINE + - SERPER_API_KEY + parameters: + query: + type: string + description: 'The search query.' + required: true + max_results: + type: number + default: 6 + description: 'The number of search results to retrieve.' + examples: + - ask: 'Search for information about artificial intelligence' + answer: 'web_search(query="Search for information about artificial intelligence", max_results=6)' + - ask: 'Find news articles about climate change' + answer: 'web_search(query="Find news articles about climate change", max_results=6)' + returns: + type: string diff --git a/config/config.yaml b/config/config.yaml index 6a1fd597f..5025a4977 100644 --- a/config/config.yaml +++ b/config/config.yaml @@ -14,6 +14,8 @@ OPENAI_BASE_URL: "https://api.openai.com/v1" OPENAI_API_MODEL: "gpt-4-1106-preview" MAX_TOKENS: 4096 RPM: 10 +LLM_TYPE: OpenAI # Except for these three major models – OpenAI, MetaGPT LLM, and Azure – other large models can be distinguished based on the validity of the key. +TIMEOUT: 60 # Timeout for llm invocation #### if Spark #SPARK_APPID : "YOUR_APPID" @@ -119,4 +121,24 @@ RPM: 10 # PROMPT_FORMAT: json #json or markdown +### Agent configurations +# RAISE_NOT_CONFIG_ERROR: true # "true" if the LLM key is not configured, throw a NotConfiguredException, else "false". +# WORKSPACE_PATH_WITH_UID: false # "true" if using `{workspace}/{uid}` as the workspace path; "false" use `{workspace}`. + +### Meta Models +#METAGPT_TEXT_TO_IMAGE_MODEL: MODEL_URL + +### S3 config +#S3_ACCESS_KEY: "YOUR_S3_ACCESS_KEY" +#S3_SECRET_KEY: "YOUR_S3_SECRET_KEY" +#S3_ENDPOINT_URL: "YOUR_S3_ENDPOINT_URL" +#S3_SECURE: true # true/false +#S3_BUCKET: "YOUR_S3_BUCKET" + +### Redis config +#REDIS_HOST: "YOUR_REDIS_HOST" +#REDIS_PORT: "YOUR_REDIS_PORT" +#REDIS_PASSWORD: "YOUR_REDIS_PASSWORD" +#REDIS_DB: "YOUR_REDIS_DB_INDEX, str, 0-based" + # DISABLE_LLM_PROVIDER_CHECK: false diff --git a/examples/example.faiss b/examples/example.faiss new file mode 100644 index 000000000..a5a539dc4 Binary files /dev/null and b/examples/example.faiss differ diff --git a/examples/example.json b/examples/example.json new file mode 100644 index 000000000..996cbec3b --- /dev/null +++ b/examples/example.json @@ -0,0 +1,10 @@ +[ + { + "source": "Which facial cleanser is good for oily skin?", + "output": "ABC cleanser is preferred by many with oily skin." + }, + { + "source": "Is L'Oreal good to use?", + "output": "L'Oreal is a popular brand with many positive reviews." + } +] \ No newline at end of file diff --git a/examples/example.pkl b/examples/example.pkl new file mode 100644 index 000000000..a0e839763 Binary files /dev/null and b/examples/example.pkl differ diff --git a/examples/faq.xlsx b/examples/faq.xlsx new file mode 100644 index 000000000..85fda644e Binary files /dev/null and b/examples/faq.xlsx differ diff --git a/examples/search_kb.py b/examples/search_kb.py index c70cad2fd..0e0e0ffd0 100644 --- a/examples/search_kb.py +++ b/examples/search_kb.py @@ -2,30 +2,18 @@ # -*- coding: utf-8 -*- """ @File : search_kb.py +@Modified By: mashenquan, 2023-12-22. Delete useless codes. """ import asyncio from langchain.embeddings import OpenAIEmbeddings from metagpt.config import CONFIG -from metagpt.const import DATA_PATH +from metagpt.const import DATA_PATH, EXAMPLE_PATH from metagpt.document_store import FaissStore from metagpt.logs import logger from metagpt.roles import Sales -""" example.json, e.g. -[ - { - "source": "Which facial cleanser is good for oily skin?", - "output": "ABC cleanser is preferred by many with oily skin." - }, - { - "source": "Is L'Oreal good to use?", - "output": "L'Oreal is a popular brand with many positive reviews." - } -] -""" - def get_store(): embedding = OpenAIEmbeddings(openai_api_key=CONFIG.openai_api_key, openai_api_base=CONFIG.openai_base_url) @@ -33,13 +21,11 @@ def get_store(): async def search(): - role = Sales(profile="Sales", store=get_store()) - queries = ["Which facial cleanser is good for oily skin?", "Is L'Oreal good to use?"] - - for query in queries: - logger.info(f"User: {query}") - result = await role.run(query) - logger.info(result) + store = FaissStore(EXAMPLE_PATH / "example.json") + role = Sales(profile="Sales", store=store) + query = "Which facial cleanser is good for oily skin?" + result = await role.run(query) + logger.info(result) if __name__ == "__main__": diff --git a/examples/search_with_specific_engine.py b/examples/search_with_specific_engine.py index 1a217fdf2..9406a2965 100644 --- a/examples/search_with_specific_engine.py +++ b/examples/search_with_specific_engine.py @@ -1,3 +1,7 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +""" import asyncio from metagpt.roles import Searcher diff --git a/metagpt/actions/action_node.py b/metagpt/actions/action_node.py index 3529942c3..63f46ad45 100644 --- a/metagpt/actions/action_node.py +++ b/metagpt/actions/action_node.py @@ -14,6 +14,7 @@ from typing import Any, Dict, List, Optional, Tuple, Type from pydantic import BaseModel, create_model, root_validator, validator from tenacity import retry, stop_after_attempt, wait_random_exponential +from metagpt.config import CONFIG from metagpt.llm import BaseGPTAPI from metagpt.logs import logger from metagpt.provider.postprecess.llm_output_postprecess import llm_output_postprecess @@ -260,9 +261,10 @@ class ActionNode: output_data_mapping: dict, system_msgs: Optional[list[str]] = None, schema="markdown", # compatible to original format + timeout=CONFIG.timeout, ) -> (str, BaseModel): """Use ActionOutput to wrap the output of aask""" - content = await self.llm.aask(prompt, system_msgs) + content = await self.llm.aask(prompt, system_msgs, timeout=timeout) logger.debug(f"llm raw output:\n{content}") output_class = self.create_model_class(output_class_name, output_data_mapping) @@ -289,13 +291,13 @@ class ActionNode: def set_context(self, context): self.set_recursive("context", context) - async def simple_fill(self, schema, mode): + async def simple_fill(self, schema, mode, timeout=CONFIG.timeout): prompt = self.compile(context=self.context, schema=schema, mode=mode) if schema != "raw": mapping = self.get_mapping(mode) class_name = f"{self.key}_AN" - content, scontent = await self._aask_v1(prompt, class_name, mapping, schema=schema) + content, scontent = await self._aask_v1(prompt, class_name, mapping, schema=schema, timeout=timeout) self.content = content self.instruct_content = scontent else: @@ -304,7 +306,7 @@ class ActionNode: return self - async def fill(self, context, llm, schema="json", mode="auto", strgy="simple"): + async def fill(self, context, llm, schema="json", mode="auto", strgy="simple", timeout=CONFIG.timeout): """Fill the node(s) with mode. :param context: Everything we should know when filling node. @@ -320,6 +322,7 @@ class ActionNode: :param strgy: simple/complex - simple: run only once - complex: run each node + :param timeout: Timeout for llm invocation. :return: self """ self.set_llm(llm) @@ -328,12 +331,12 @@ class ActionNode: schema = self.schema if strgy == "simple": - return await self.simple_fill(schema=schema, mode=mode) + return await self.simple_fill(schema=schema, mode=mode, timeout=timeout) elif strgy == "complex": # 这里隐式假设了拥有children tmp = {} for _, i in self.children.items(): - child = await i.simple_fill(schema=schema, mode=mode) + child = await i.simple_fill(schema=schema, mode=mode, timeout=timeout) tmp.update(child.instruct_content.dict()) cls = self.create_children_class() self.instruct_content = cls(**tmp) diff --git a/metagpt/actions/clone_function.py b/metagpt/actions/clone_function.py index 24d584515..429f04286 100644 --- a/metagpt/actions/clone_function.py +++ b/metagpt/actions/clone_function.py @@ -1,4 +1,3 @@ -import traceback from pathlib import Path from pydantic import Field @@ -8,6 +7,7 @@ from metagpt.llm import LLM from metagpt.logs import logger from metagpt.provider.base_gpt_api import BaseGPTAPI from metagpt.schema import Message +from metagpt.utils.exceptions import handle_exception from metagpt.utils.highlight import highlight CLONE_PROMPT = """ @@ -39,7 +39,7 @@ class CloneFunction(WriteCode): if isinstance(code_path, str): code_path = Path(code_path) code_path.parent.mkdir(parents=True, exist_ok=True) - code_path.write_text(code) + code_path.write_text(code, encoding="utf-8") logger.info(f"Saving Code to {code_path}") async def run(self, template_func: str, source_code: str) -> str: @@ -51,20 +51,17 @@ class CloneFunction(WriteCode): return code +@handle_exception def run_function_code(func_code: str, func_name: str, *args, **kwargs): """Run function code from string code.""" - try: - locals_ = {} - exec(func_code, locals_) - func = locals_[func_name] - return func(*args, **kwargs), "" - except Exception: - return "", traceback.format_exc() + locals_ = {} + exec(func_code, locals_) + func = locals_[func_name] + return func(*args, **kwargs), "" def run_function_script(code_script_path: str, func_name: str, *args, **kwargs): """Run function code from script.""" - if isinstance(code_script_path, str): - code_path = Path(code_script_path) + code_path = Path(code_script_path) code = code_path.read_text(encoding="utf-8") return run_function_code(code, func_name, *args, **kwargs) diff --git a/metagpt/actions/execute_task.py b/metagpt/actions/execute_task.py index 8d4e569b4..b11f361b0 100644 --- a/metagpt/actions/execute_task.py +++ b/metagpt/actions/execute_task.py @@ -19,5 +19,5 @@ class ExecuteTask(Action): context: list[Message] = [] llm: BaseGPTAPI = Field(default_factory=LLM) - def run(self, *args, **kwargs): + async def run(self, *args, **kwargs): pass diff --git a/metagpt/actions/fix_bug.py b/metagpt/actions/fix_bug.py index 56b488218..0c5df6dc6 100644 --- a/metagpt/actions/fix_bug.py +++ b/metagpt/actions/fix_bug.py @@ -11,6 +11,3 @@ class FixBug(Action): """Fix bug action without any implementation details""" name: str = "FixBug" - - async def run(self, *args, **kwargs): - raise NotImplementedError diff --git a/metagpt/actions/rebuild_class_view.py b/metagpt/actions/rebuild_class_view.py new file mode 100644 index 000000000..2a6a6a6d9 --- /dev/null +++ b/metagpt/actions/rebuild_class_view.py @@ -0,0 +1,68 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +@Time : 2023/12/19 +@Author : mashenquan +@File : rebuild_class_view.py +@Desc : Rebuild class view info +""" +import re +from pathlib import Path + +from metagpt.actions import Action +from metagpt.config import CONFIG +from metagpt.const import CLASS_VIEW_FILE_REPO, GRAPH_REPO_FILE_REPO +from metagpt.repo_parser import RepoParser +from metagpt.utils.di_graph_repository import DiGraphRepository +from metagpt.utils.graph_repository import GraphKeyword, GraphRepository + + +class RebuildClassView(Action): + def __init__(self, name="", context=None, llm=None): + super().__init__(name=name, context=context, llm=llm) + + async def run(self, with_messages=None, format=CONFIG.prompt_schema): + graph_repo_pathname = CONFIG.git_repo.workdir / GRAPH_REPO_FILE_REPO / CONFIG.git_repo.workdir.name + graph_db = await DiGraphRepository.load_from(str(graph_repo_pathname.with_suffix(".json"))) + repo_parser = RepoParser(base_directory=self.context) + class_views = await repo_parser.rebuild_class_views(path=Path(self.context)) # use pylint + await GraphRepository.update_graph_db_with_class_views(graph_db, class_views) + symbols = repo_parser.generate_symbols() # use ast + for file_info in symbols: + await GraphRepository.update_graph_db_with_file_info(graph_db, file_info) + await self._create_mermaid_class_view(graph_db=graph_db) + await self._save(graph_db=graph_db) + + async def _create_mermaid_class_view(self, graph_db): + pass + # dataset = await graph_db.select(subject=concat_namespace(filename, class_name), predicate=GraphKeyword.HAS_PAGE_INFO) + # if not dataset: + # logger.warning(f"No page info for {concat_namespace(filename, class_name)}") + # return + # code_block_info = CodeBlockInfo.parse_raw(dataset[0].object_) + # src_code = await read_file_block(filename=Path(self.context) / filename, lineno=code_block_info.lineno, end_lineno=code_block_info.end_lineno) + # code_type = "" + # dataset = await graph_db.select(subject=filename, predicate=GraphKeyword.IS) + # for spo in dataset: + # if spo.object_ in ["javascript", "python"]: + # code_type = spo.object_ + # break + + # try: + # node = await REBUILD_CLASS_VIEW_NODE.fill(context=f"```{code_type}\n{src_code}\n```", llm=self.llm, to=format) + # class_view = node.instruct_content.dict()["Class View"] + # except Exception as e: + # class_view = RepoParser.rebuild_class_view(src_code, code_type) + # await graph_db.insert(subject=concat_namespace(filename, class_name), predicate=GraphKeyword.HAS_CLASS_VIEW, object_=class_view) + # logger.info(f"{concat_namespace(filename, class_name)} {GraphKeyword.HAS_CLASS_VIEW} {class_view}") + + async def _save(self, graph_db): + class_view_file_repo = CONFIG.git_repo.new_file_repository(relative_path=CLASS_VIEW_FILE_REPO) + dataset = await graph_db.select(predicate=GraphKeyword.HAS_CLASS_VIEW) + all_class_view = [] + for spo in dataset: + title = f"---\ntitle: {spo.subject}\n---\n" + filename = re.sub(r"[/:]", "_", spo.subject) + ".mmd" + await class_view_file_repo.save(filename=filename, content=title + spo.object_) + all_class_view.append(spo.object_) + await class_view_file_repo.save(filename="all.mmd", content="\n".join(all_class_view)) diff --git a/metagpt/actions/rebuild_class_view_an.py b/metagpt/actions/rebuild_class_view_an.py new file mode 100644 index 000000000..da32a9b5e --- /dev/null +++ b/metagpt/actions/rebuild_class_view_an.py @@ -0,0 +1,33 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +@Time : 2023/12/19 +@Author : mashenquan +@File : rebuild_class_view_an.py +@Desc : Defines `ActionNode` objects used by rebuild_class_view.py +""" +from metagpt.actions.action_node import ActionNode + +CLASS_SOURCE_CODE_BLOCK = ActionNode( + key="Class View", + expected_type=str, + instruction='Generate the mermaid class diagram corresponding to source code in "context."', + example=""" + classDiagram + class A { + -int x + +int y + -int speed + -int direction + +__init__(x: int, y: int, speed: int, direction: int) + +change_direction(new_direction: int) None + +move() None + } + """, +) + +REBUILD_CLASS_VIEW_NODES = [ + CLASS_SOURCE_CODE_BLOCK, +] + +REBUILD_CLASS_VIEW_NODE = ActionNode.from_children("RebuildClassView", REBUILD_CLASS_VIEW_NODES) diff --git a/metagpt/actions/search_and_summarize.py b/metagpt/actions/search_and_summarize.py index 25af21795..9fd392a5c 100644 --- a/metagpt/actions/search_and_summarize.py +++ b/metagpt/actions/search_and_summarize.py @@ -105,6 +105,7 @@ You are a member of a professional butler team and will provide helpful suggesti """ +# TOTEST class SearchAndSummarize(Action): name: str = "" content: Optional[str] = None diff --git a/metagpt/actions/skill_action.py b/metagpt/actions/skill_action.py new file mode 100644 index 000000000..301cebaab --- /dev/null +++ b/metagpt/actions/skill_action.py @@ -0,0 +1,111 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +@Time : 2023/8/28 +@Author : mashenquan +@File : skill_action.py +@Desc : Call learned skill +""" +from __future__ import annotations + +import ast +import importlib +import traceback +from copy import deepcopy +from typing import Dict, Optional + +from metagpt.actions import Action +from metagpt.learn.skill_loader import Skill +from metagpt.logs import logger +from metagpt.schema import Message + + +# TOTEST +class ArgumentsParingAction(Action): + skill: Skill + ask: str + rsp: Optional[Message] = None + args: Optional[Dict] = None + + @property + def prompt(self): + prompt = "You are a function parser. You can convert spoken words into function parameters.\n" + prompt += "\n---\n" + prompt += f"{self.skill.name} function parameters description:\n" + for k, v in self.skill.arguments.items(): + prompt += f"parameter `{k}`: {v}\n" + prompt += "\n---\n" + prompt += "Examples:\n" + for e in self.skill.examples: + prompt += f"If want you to do `{e.ask}`, return `{e.answer}` brief and clear.\n" + prompt += "\n---\n" + prompt += ( + f"\nRefer to the `{self.skill.name}` function description, and fill in the function parameters according " + 'to the example "I want you to do xx" in the Examples section.' + f"\nNow I want you to do `{self.ask}`, return function parameters in Examples format above, brief and " + "clear." + ) + return prompt + + async def run(self, with_message=None, **kwargs) -> Message: + prompt = self.prompt + rsp = await self.llm.aask(msg=prompt, system_msgs=[]) + logger.debug(f"SKILL:{prompt}\n, RESULT:{rsp}") + self.args = ArgumentsParingAction.parse_arguments(skill_name=self.skill.name, txt=rsp) + self.rsp = Message(content=rsp, role="assistant", instruct_content=self.args, cause_by=self) + return self.rsp + + @staticmethod + def parse_arguments(skill_name, txt) -> dict: + prefix = skill_name + "(" + if prefix not in txt: + logger.error(f"{skill_name} not in {txt}") + return None + if ")" not in txt: + logger.error(f"')' not in {txt}") + return None + begin_ix = txt.find(prefix) + end_ix = txt.rfind(")") + args_txt = txt[begin_ix + len(prefix) : end_ix] + logger.info(args_txt) + fake_expression = f"dict({args_txt})" + parsed_expression = ast.parse(fake_expression, mode="eval") + args = {} + for keyword in parsed_expression.body.keywords: + key = keyword.arg + value = ast.literal_eval(keyword.value) + args[key] = value + return args + + +class SkillAction(Action): + skill: Skill + args: Dict + rsp: Optional[Message] = None + + async def run(self, with_message=None, **kwargs) -> Message: + """Run action""" + options = deepcopy(kwargs) + if self.args: + for k in self.args.keys(): + if k in options: + options.pop(k) + try: + rsp = await self.find_and_call_function(self.skill.name, args=self.args, **options) + self.rsp = Message(content=rsp, role="assistant", cause_by=self) + except Exception as e: + logger.exception(f"{e}, traceback:{traceback.format_exc()}") + self.rsp = Message(content=f"Error: {e}", role="assistant", cause_by=self) + return self.rsp + + @staticmethod + async def find_and_call_function(function_name, args, **kwargs) -> str: + try: + module = importlib.import_module("metagpt.learn") + function = getattr(module, function_name) + # Invoke function and return result + result = await function(**args, **kwargs) + return result + except (ModuleNotFoundError, AttributeError): + logger.error(f"{function_name} not found") + raise ValueError(f"{function_name} not found") diff --git a/metagpt/actions/summarize_code.py b/metagpt/actions/summarize_code.py index 0aec15937..2d1cd4d3d 100644 --- a/metagpt/actions/summarize_code.py +++ b/metagpt/actions/summarize_code.py @@ -91,6 +91,7 @@ flowchart TB """ +# TOTEST class SummarizeCode(Action): name: str = "SummarizeCode" context: CodeSummarizeContext = Field(default_factory=CodeSummarizeContext) diff --git a/metagpt/actions/talk_action.py b/metagpt/actions/talk_action.py new file mode 100644 index 000000000..dc127109c --- /dev/null +++ b/metagpt/actions/talk_action.py @@ -0,0 +1,163 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +@Time : 2023/8/28 +@Author : mashenquan +@File : talk_action.py +@Desc : Act as it’s a talk +""" +from typing import Optional + +from metagpt.actions import Action +from metagpt.config import CONFIG +from metagpt.const import DEFAULT_LANGUAGE +from metagpt.logs import logger +from metagpt.schema import Message + + +# TOTEST +class TalkAction(Action): + context: str + history_summary: str = "" + knowledge: str = "" + rsp: Optional[Message] = None + + @property + def prompt(self): + prompt = "" + if CONFIG.agent_description: + prompt = ( + f"You are {CONFIG.agent_description}. Your responses should align with the role-play agreement, " + f"maintaining the character's persona and habits. When faced with unrelated questions, playfully " + f"decline to answer without revealing your AI nature to preserve the character's image.\n\n" + ) + prompt += f"Knowledge:\n{self.knowledge}\n\n" if self.knowledge else "" + prompt += f"{self.history_summary}\n\n" + prompt += ( + "If the information is insufficient, you can search in the historical conversation or knowledge above.\n" + ) + language = CONFIG.language or DEFAULT_LANGUAGE + prompt += ( + f"Answer the following questions strictly in {language}, and the answers must follow the Markdown format.\n " + f"{self.context}" + ) + logger.debug(f"PROMPT: {prompt}") + return prompt + + @property + def prompt_gpt4(self): + kvs = { + "{role}": CONFIG.agent_description or "", + "{history}": self.history_summary or "", + "{knowledge}": self.knowledge or "", + "{language}": CONFIG.language or DEFAULT_LANGUAGE, + "{ask}": self.context, + } + prompt = TalkActionPrompt.FORMATION_LOOSE + for k, v in kvs.items(): + prompt = prompt.replace(k, v) + logger.info(f"PROMPT: {prompt}") + return prompt + + # async def run_old(self, *args, **kwargs) -> ActionOutput: + # prompt = self.prompt + # rsp = await self.llm.aask(msg=prompt, system_msgs=[]) + # logger.debug(f"PROMPT:{prompt}\nRESULT:{rsp}\n") + # self._rsp = ActionOutput(content=rsp) + # return self._rsp + + @property + def aask_args(self): + language = CONFIG.language or DEFAULT_LANGUAGE + system_msgs = [ + f"You are {CONFIG.agent_description}.", + "Your responses should align with the role-play agreement, " + "maintaining the character's persona and habits. When faced with unrelated questions, playfully " + "decline to answer without revealing your AI nature to preserve the character's image.", + "If the information is insufficient, you can search in the context or knowledge.", + f"Answer the following questions strictly in {language}, and the answers must follow the Markdown format.", + ] + format_msgs = [] + if self.knowledge: + format_msgs.append({"role": "assistant", "content": self.knowledge}) + if self.history_summary: + format_msgs.append({"role": "assistant", "content": self.history_summary}) + return self.context, format_msgs, system_msgs + + async def run(self, with_message=None, **kwargs) -> Message: + msg, format_msgs, system_msgs = self.aask_args + rsp = await self.llm.aask(msg=msg, format_msgs=format_msgs, system_msgs=system_msgs) + self.rsp = Message(content=rsp, role="assistant", cause_by=self) + return self.rsp + + +class TalkActionPrompt: + FORMATION = """Formation: "Capacity and role" defines the role you are currently playing; + "[HISTORY_BEGIN]" and "[HISTORY_END]" tags enclose the historical conversation; + "[KNOWLEDGE_BEGIN]" and "[KNOWLEDGE_END]" tags enclose the knowledge may help for your responses; + "Statement" defines the work detail you need to complete at this stage; + "[ASK_BEGIN]" and [ASK_END] tags enclose the questions; + "Constraint" defines the conditions that your responses must comply with. + "Personality" defines your language style。 + "Insight" provides a deeper understanding of the characters' inner traits. + "Initial" defines the initial setup of a character. + +Capacity and role: {role} +Statement: Your responses should align with the role-play agreement, maintaining the + character's persona and habits. When faced with unrelated questions, playfully decline to answer without revealing + your AI nature to preserve the character's image. + +[HISTORY_BEGIN] + +{history} + +[HISTORY_END] + +[KNOWLEDGE_BEGIN] + +{knowledge} + +[KNOWLEDGE_END] + +Statement: If the information is insufficient, you can search in the historical conversation or knowledge. +Statement: Unless you are a language professional, answer the following questions strictly in {language} +, and the answers must follow the Markdown format. Strictly excluding any tag likes "[HISTORY_BEGIN]" +, "[HISTORY_END]", "[KNOWLEDGE_BEGIN]", "[KNOWLEDGE_END]" in responses. + + +{ask} +""" + + FORMATION_LOOSE = """Formation: "Capacity and role" defines the role you are currently playing; + "[HISTORY_BEGIN]" and "[HISTORY_END]" tags enclose the historical conversation; + "[KNOWLEDGE_BEGIN]" and "[KNOWLEDGE_END]" tags enclose the knowledge may help for your responses; + "Statement" defines the work detail you need to complete at this stage; + "Constraint" defines the conditions that your responses must comply with. + "Personality" defines your language style。 + "Insight" provides a deeper understanding of the characters' inner traits. + "Initial" defines the initial setup of a character. + +Capacity and role: {role} +Statement: Your responses should maintaining the character's persona and habits. When faced with unrelated questions +, playfully decline to answer without revealing your AI nature to preserve the character's image. + +[HISTORY_BEGIN] + +{history} + +[HISTORY_END] + +[KNOWLEDGE_BEGIN] + +{knowledge} + +[KNOWLEDGE_END] + +Statement: If the information is insufficient, you can search in the historical conversation or knowledge. +Statement: Unless you are a language professional, answer the following questions strictly in {language} +, and the answers must follow the Markdown format. Strictly excluding any tag likes "[HISTORY_BEGIN]" +, "[HISTORY_END]", "[KNOWLEDGE_BEGIN]", "[KNOWLEDGE_END]" in responses. + + +{ask} +""" diff --git a/metagpt/actions/write_prd.py b/metagpt/actions/write_prd.py index 1223e5486..47e02b699 100644 --- a/metagpt/actions/write_prd.py +++ b/metagpt/actions/write_prd.py @@ -123,7 +123,7 @@ class WritePRD(Action): # logger.info(rsp) project_name = CONFIG.project_name if CONFIG.project_name else "" context = CONTEXT_TEMPLATE.format(requirements=requirements, project_name=project_name) - node = await WRITE_PRD_NODE.fill(context=context, llm=self.llm, schema=schema) + node = await WRITE_PRD_NODE.fill(context=context, llm=self.llm) # schema=schema await self._rename_workspace(node) return node diff --git a/metagpt/actions/write_teaching_plan.py b/metagpt/actions/write_teaching_plan.py new file mode 100644 index 000000000..d889fdbe3 --- /dev/null +++ b/metagpt/actions/write_teaching_plan.py @@ -0,0 +1,193 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +@Time : 2023/7/27 +@Author : mashenquan +@File : write_teaching_plan.py +""" +from typing import Optional + +from pydantic import Field + +from metagpt.actions import Action +from metagpt.config import CONFIG +from metagpt.llm import LLM +from metagpt.logs import logger +from metagpt.provider.base_gpt_api import BaseGPTAPI + + +class WriteTeachingPlanPart(Action): + """Write Teaching Plan Part""" + + context: Optional[str] = None + llm: BaseGPTAPI = Field(default_factory=LLM) + topic: str = "" + language: str = "Chinese" + rsp: Optional[str] = None + + async def run(self, with_message=None, **kwargs): + statement_patterns = TeachingPlanBlock.TOPIC_STATEMENTS.get(self.topic, []) + statements = [] + for p in statement_patterns: + s = self.format_value(p) + statements.append(s) + formatter = ( + TeachingPlanBlock.PROMPT_TITLE_TEMPLATE + if self.topic == TeachingPlanBlock.COURSE_TITLE + else TeachingPlanBlock.PROMPT_TEMPLATE + ) + prompt = formatter.format( + formation=TeachingPlanBlock.FORMATION, + role=self.prefix, + statements="\n".join(statements), + lesson=self.context, + topic=self.topic, + language=self.language, + ) + + logger.debug(prompt) + rsp = await self._aask(prompt=prompt) + logger.debug(rsp) + self._set_result(rsp) + return self.rsp + + def _set_result(self, rsp): + if TeachingPlanBlock.DATA_BEGIN_TAG in rsp: + ix = rsp.index(TeachingPlanBlock.DATA_BEGIN_TAG) + rsp = rsp[ix + len(TeachingPlanBlock.DATA_BEGIN_TAG) :] + if TeachingPlanBlock.DATA_END_TAG in rsp: + ix = rsp.index(TeachingPlanBlock.DATA_END_TAG) + rsp = rsp[0:ix] + self.rsp = rsp.strip() + if self.topic != TeachingPlanBlock.COURSE_TITLE: + return + if "#" not in self.rsp or self.rsp.index("#") != 0: + self.rsp = "# " + self.rsp + + def __str__(self): + """Return `topic` value when str()""" + return self.topic + + def __repr__(self): + """Show `topic` value when debug""" + return self.topic + + @staticmethod + def format_value(value): + """Fill parameters inside `value` with `options`.""" + if not isinstance(value, str): + return value + if "{" not in value: + return value + + merged_opts = CONFIG.options or {} + try: + return value.format(**merged_opts) + except KeyError as e: + logger.warning(f"Parameter is missing:{e}") + + for k, v in merged_opts.items(): + value = value.replace("{" + f"{k}" + "}", str(v)) + return value + + +class TeachingPlanBlock: + FORMATION = ( + '"Capacity and role" defines the role you are currently playing;\n' + '\t"[LESSON_BEGIN]" and "[LESSON_END]" tags enclose the content of textbook;\n' + '\t"Statement" defines the work detail you need to complete at this stage;\n' + '\t"Answer options" defines the format requirements for your responses;\n' + '\t"Constraint" defines the conditions that your responses must comply with.' + ) + + COURSE_TITLE = "Title" + TOPICS = [ + COURSE_TITLE, + "Teaching Hours", + "Teaching Objectives", + "Teaching Content", + "Teaching Methods and Strategies", + "Learning Activities", + "Teaching Time Allocation", + "Assessment and Feedback", + "Teaching Summary and Improvement", + "Vocabulary Cloze", + "Choice Questions", + "Grammar Questions", + "Translation Questions", + ] + + TOPIC_STATEMENTS = { + COURSE_TITLE: [ + "Statement: Find and return the title of the lesson only in markdown first-level header format, " + "without anything else." + ], + "Teaching Content": [ + 'Statement: "Teaching Content" must include vocabulary, analysis, and examples of various grammar ' + "structures that appear in the textbook, as well as the listening materials and key points.", + 'Statement: "Teaching Content" must include more examples.', + ], + "Teaching Time Allocation": [ + 'Statement: "Teaching Time Allocation" must include how much time is allocated to each ' + "part of the textbook content." + ], + "Teaching Methods and Strategies": [ + 'Statement: "Teaching Methods and Strategies" must include teaching focus, difficulties, materials, ' + "procedures, in detail." + ], + "Vocabulary Cloze": [ + 'Statement: Based on the content of the textbook enclosed by "[LESSON_BEGIN]" and "[LESSON_END]", ' + "create vocabulary cloze. The cloze should include 10 {language} questions with {teaching_language} " + "answers, and it should also include 10 {teaching_language} questions with {language} answers. " + "The key-related vocabulary and phrases in the textbook content must all be included in the exercises.", + ], + "Grammar Questions": [ + 'Statement: Based on the content of the textbook enclosed by "[LESSON_BEGIN]" and "[LESSON_END]", ' + "create grammar questions. 10 questions." + ], + "Choice Questions": [ + 'Statement: Based on the content of the textbook enclosed by "[LESSON_BEGIN]" and "[LESSON_END]", ' + "create choice questions. 10 questions." + ], + "Translation Questions": [ + 'Statement: Based on the content of the textbook enclosed by "[LESSON_BEGIN]" and "[LESSON_END]", ' + "create translation questions. The translation should include 10 {language} questions with " + "{teaching_language} answers, and it should also include 10 {teaching_language} questions with " + "{language} answers." + ], + } + + # Teaching plan title + PROMPT_TITLE_TEMPLATE = ( + "Do not refer to the context of the previous conversation records, " + "start the conversation anew.\n\n" + "Formation: {formation}\n\n" + "{statements}\n" + "Constraint: Writing in {language}.\n" + 'Answer options: Encloses the lesson title with "[TEACHING_PLAN_BEGIN]" ' + 'and "[TEACHING_PLAN_END]" tags.\n' + "[LESSON_BEGIN]\n" + "{lesson}\n" + "[LESSON_END]" + ) + + # Teaching plan parts: + PROMPT_TEMPLATE = ( + "Do not refer to the context of the previous conversation records, " + "start the conversation anew.\n\n" + "Formation: {formation}\n\n" + "Capacity and role: {role}\n" + 'Statement: Write the "{topic}" part of teaching plan, ' + 'WITHOUT ANY content unrelated to "{topic}"!!\n' + "{statements}\n" + 'Answer options: Enclose the teaching plan content with "[TEACHING_PLAN_BEGIN]" ' + 'and "[TEACHING_PLAN_END]" tags.\n' + "Answer options: Using proper markdown format from second-level header format.\n" + "Constraint: Writing in {language}.\n" + "[LESSON_BEGIN]\n" + "{lesson}\n" + "[LESSON_END]" + ) + + DATA_BEGIN_TAG = "[TEACHING_PLAN_BEGIN]" + DATA_END_TAG = "[TEACHING_PLAN_END]" diff --git a/metagpt/actions/write_test.py b/metagpt/actions/write_test.py index 9eb0bdbb6..850606ca8 100644 --- a/metagpt/actions/write_test.py +++ b/metagpt/actions/write_test.py @@ -44,7 +44,7 @@ you should correctly import the necessary classes based on these file locations! class WriteTest(Action): name: str = "WriteTest" - context: Optional[str] = None + context: Optional[TestingContext] = None llm: BaseGPTAPI = Field(default_factory=LLM) async def write_code(self, prompt): diff --git a/metagpt/config.py b/metagpt/config.py index 16df19a4c..1ce12216d 100644 --- a/metagpt/config.py +++ b/metagpt/config.py @@ -6,12 +6,15 @@ Provide configuration, singleton 1. According to Section 2.2.3.11 of RFC 135, add git repository support. 2. Add the parameter `src_workspace` for the old version project path. """ +import datetime +import json import os import warnings from copy import deepcopy from enum import Enum from pathlib import Path from typing import Any +from uuid import uuid4 import yaml @@ -19,6 +22,7 @@ from metagpt.const import DEFAULT_WORKSPACE_ROOT, METAGPT_ROOT, OPTIONS from metagpt.logs import logger from metagpt.tools import SearchEngineType, WebBrowserEngineType from metagpt.utils.common import require_python_version +from metagpt.utils.cost_manager import CostManager from metagpt.utils.singleton import Singleton @@ -42,6 +46,8 @@ class LLMProviderEnum(Enum): FIREWORKS = "fireworks" OPEN_LLM = "open_llm" GEMINI = "gemini" + METAGPT = "metagpt" + AZURE_OPENAI = "azure_openai" OLLAMA = "ollama" @@ -58,7 +64,7 @@ class Config(metaclass=Singleton): key_yaml_file = METAGPT_ROOT / "config/key.yaml" default_yaml_file = METAGPT_ROOT / "config/config.yaml" - def __init__(self, yaml_file=default_yaml_file): + def __init__(self, yaml_file=default_yaml_file, cost_data=""): global_options = OPTIONS.get() # cli paras self.project_path = "" @@ -68,32 +74,57 @@ class Config(metaclass=Singleton): self.max_auto_summarize_code = 0 self._init_with_config_files_and_env(yaml_file) + # The agent needs to be billed per user, so billing information cannot be destroyed when the session ends. + self.cost_manager = CostManager(**json.loads(cost_data)) if cost_data else CostManager() self._update() global_options.update(OPTIONS.get()) logger.debug("Config loading done.") def get_default_llm_provider_enum(self) -> LLMProviderEnum: - for k, v in [ - (self.openai_api_key, LLMProviderEnum.OPENAI), - (self.anthropic_api_key, LLMProviderEnum.ANTHROPIC), - (self.zhipuai_api_key, LLMProviderEnum.ZHIPUAI), - (self.fireworks_api_key, LLMProviderEnum.FIREWORKS), - (self.open_llm_api_base, LLMProviderEnum.OPEN_LLM), - (self.gemini_api_key, LLMProviderEnum.GEMINI), - (self.ollama_api_base, LLMProviderEnum.OLLAMA), # reuse logic. but not a key - ]: - if self._is_valid_llm_key(k): - # logger.debug(f"Use LLMProvider: {v.value}") - if v == LLMProviderEnum.GEMINI and not require_python_version(req_version=(3, 10)): - warnings.warn("Use Gemini requires Python >= 3.10") - if self.openai_api_key and self.openai_api_model: - logger.info(f"OpenAI API Model: {self.openai_api_model}") - return v + """Get first valid LLM provider enum""" + mappings = { + LLMProviderEnum.OPENAI: bool( + self._is_valid_llm_key(self.OPENAI_API_KEY) and not self.OPENAI_API_TYPE and self.OPENAI_API_MODEL + ), + LLMProviderEnum.ANTHROPIC: self._is_valid_llm_key(self.ANTHROPIC_API_KEY), + LLMProviderEnum.ZHIPUAI: self._is_valid_llm_key(self.ZHIPUAI_API_KEY), + LLMProviderEnum.FIREWORKS: self._is_valid_llm_key(self.FIREWORKS_API_KEY), + LLMProviderEnum.OPEN_LLM: self._is_valid_llm_key(self.OPEN_LLM_API_BASE), + LLMProviderEnum.GEMINI: self._is_valid_llm_key(self.GEMINI_API_KEY), + LLMProviderEnum.METAGPT: bool( + self._is_valid_llm_key(self.OPENAI_API_KEY) and self.OPENAI_API_TYPE == "metagpt" + ), + LLMProviderEnum.AZURE_OPENAI: bool( + self._is_valid_llm_key(self.OPENAI_API_KEY) + and self.OPENAI_API_TYPE == "azure" + and self.DEPLOYMENT_NAME + and self.OPENAI_API_VERSION + ), + LLMProviderEnum.OLLAMA: self._is_valid_llm_key(self.OLLAMA_API_BASE), + } + provider = None + for k, v in mappings.items(): + if v: + provider = k + break + + if provider is LLMProviderEnum.GEMINI and not require_python_version(req_version=(3, 10)): + warnings.warn("Use Gemini requires Python >= 3.10") + model_mappings = { + LLMProviderEnum.OPENAI: self.OPENAI_API_MODEL, + LLMProviderEnum.AZURE_OPENAI: self.DEPLOYMENT_NAME, + } + model_name = model_mappings.get(provider) + if model_name: + logger.info(f"{provider} Model: {model_name}") + if provider: + logger.info(f"API: {provider}") + return provider raise NotConfiguredException("You should config a LLM configuration first") @staticmethod def _is_valid_llm_key(k: str) -> bool: - return k and k != "YOUR_API_KEY" + return bool(k and k != "YOUR_API_KEY") def _update(self): self.global_proxy = self._get("GLOBAL_PROXY") @@ -111,7 +142,7 @@ class Config(metaclass=Singleton): if not self._get("DISABLE_LLM_PROVIDER_CHECK"): _ = self.get_default_llm_provider_enum() - self.openai_base_url = self._get("OPENAI_BASE_URL") + # self.openai_base_url = self._get("OPENAI_BASE_URL") self.openai_proxy = self._get("OPENAI_PROXY") or self.global_proxy self.openai_api_type = self._get("OPENAI_API_TYPE") self.openai_api_version = self._get("OPENAI_API_VERSION") @@ -142,8 +173,7 @@ class Config(metaclass=Singleton): self.long_term_memory = self._get("LONG_TERM_MEMORY", False) if self.long_term_memory: logger.warning("LONG_TERM_MEMORY is True") - self.max_budget = self._get("MAX_BUDGET", 10.0) - self.total_cost = 0.0 + self.cost_manager.max_budget = self._get("MAX_BUDGET", 10.0) self.code_review_k_times = 2 self.puppeteer_config = self._get("PUPPETEER_CONFIG", "") @@ -154,10 +184,18 @@ class Config(metaclass=Singleton): self.mermaid_engine = self._get("MERMAID_ENGINE", "nodejs") self.pyppeteer_executable_path = self._get("PYPPETEER_EXECUTABLE_PATH", "") + workspace_uid = ( + self._get("WORKSPACE_UID") or f"{datetime.datetime.now().strftime('%Y%m%d%H%M%S')}-{uuid4().hex[-8:]}" + ) self.repair_llm_output = self._get("REPAIR_LLM_OUTPUT", False) self.prompt_schema = self._get("PROMPT_FORMAT", "json") self.workspace_path = Path(self._get("WORKSPACE_PATH", DEFAULT_WORKSPACE_ROOT)) + val = self._get("WORKSPACE_PATH_WITH_UID") + if val and val.lower() == "true": # for agent + self.workspace_path = self.workspace_path / workspace_uid self._ensure_workspace_exists() + self.max_auto_summarize_code = self.max_auto_summarize_code or self._get("MAX_AUTO_SUMMARIZE_CODE", 1) + self.timeout = int(self._get("TIMEOUT", 3)) def update_via_cli(self, project_path, project_name, inc, reqa_file, max_auto_summarize_code): """update config via cli""" @@ -198,7 +236,8 @@ class Config(metaclass=Singleton): return i.get(*args, **kwargs) def get(self, key, *args, **kwargs): - """Search for a value in config/key.yaml, config/config.yaml, and env; raise an error if not found""" + """Retrieve values from config/key.yaml, config/config.yaml, and environment variables. + Throw an error if not found.""" value = self._get(key, *args, **kwargs) if value is None: raise ValueError(f"Key '{key}' not found in environment variables or in the YAML file") diff --git a/metagpt/const.py b/metagpt/const.py index 1819bbb49..5e149ed72 100644 --- a/metagpt/const.py +++ b/metagpt/const.py @@ -48,9 +48,10 @@ def get_metagpt_root(): # METAGPT PROJECT ROOT AND VARS -METAGPT_ROOT = get_metagpt_root() +METAGPT_ROOT = get_metagpt_root() # Dependent on METAGPT_PROJECT_ROOT DEFAULT_WORKSPACE_ROOT = METAGPT_ROOT / "workspace" +EXAMPLE_PATH = METAGPT_ROOT / "examples" DATA_PATH = METAGPT_ROOT / "data" RESEARCH_PATH = DATA_PATH / "research" TUTORIAL_PATH = DATA_PATH / "tutorial_docx" @@ -100,7 +101,27 @@ TEST_CODES_FILE_REPO = "tests" TEST_OUTPUTS_FILE_REPO = "test_outputs" CODE_SUMMARIES_FILE_REPO = "docs/code_summaries" CODE_SUMMARIES_PDF_FILE_REPO = "resources/code_summaries" +RESOURCES_FILE_REPO = "resources" +SD_OUTPUT_FILE_REPO = "resources/SD_Output" +GRAPH_REPO_FILE_REPO = "docs/graph_repo" +CLASS_VIEW_FILE_REPO = "docs/class_views" YAPI_URL = "http://yapi.deepwisdomai.com/" +DEFAULT_LANGUAGE = "English" +DEFAULT_MAX_TOKENS = 1500 +COMMAND_TOKENS = 500 +BRAIN_MEMORY = "BRAIN_MEMORY" +SKILL_PATH = "SKILL_PATH" +SERPER_API_KEY = "SERPER_API_KEY" +DEFAULT_TOKEN_SIZE = 500 + +# format +BASE64_FORMAT = "base64" + +# REDIS +REDIS_KEY = "REDIS_KEY" LLM_API_TIMEOUT = 300 + +# Message id +IGNORED_MESSAGE_ID = "0" diff --git a/metagpt/document_store/faiss_store.py b/metagpt/document_store/faiss_store.py index 320e7518f..bfba1d386 100644 --- a/metagpt/document_store/faiss_store.py +++ b/metagpt/document_store/faiss_store.py @@ -13,6 +13,7 @@ from langchain.embeddings import OpenAIEmbeddings from langchain.vectorstores import FAISS from langchain_core.embeddings import Embeddings +from metagpt.config import CONFIG from metagpt.const import DATA_PATH from metagpt.document import IndexableDocument from metagpt.document_store.base_store import LocalStore @@ -25,7 +26,9 @@ class FaissStore(LocalStore): ): self.meta_col = meta_col self.content_col = content_col - self.embedding = embedding or OpenAIEmbeddings() + self.embedding = embedding or OpenAIEmbeddings( + openai_api_key=CONFIG.openai_api_key, openai_api_base=CONFIG.openai_base_url + ) super().__init__(raw_data, cache_dir) def _load(self) -> Optional["FaissStore"]: diff --git a/metagpt/environment.py b/metagpt/environment.py index 4f2fc9c5e..0ee85f707 100644 --- a/metagpt/environment.py +++ b/metagpt/environment.py @@ -17,6 +17,7 @@ from typing import Iterable, Set from pydantic import BaseModel, Field +from metagpt.config import CONFIG from metagpt.logs import logger from metagpt.roles.role import Role, role_subclass_registry from metagpt.schema import Message @@ -108,7 +109,7 @@ class Environment(BaseModel): for role in roles: # setup system message with roles role.set_env(self) - def publish_message(self, message: Message) -> bool: + def publish_message(self, message: Message, peekable: bool = True) -> bool: """ Distribute the message to the recipients. In accordance with the Message routing structure design in Chapter 2.2.1 of RFC 116, as already planned @@ -173,3 +174,8 @@ class Environment(BaseModel): def set_subscription(self, obj, tags): """Set the labels for message to be consumed by the object""" self.members[obj] = tags + + @staticmethod + def archive(auto_archive=True): + if auto_archive and CONFIG.git_repo: + CONFIG.git_repo.archive() diff --git a/metagpt/learn/__init__.py b/metagpt/learn/__init__.py index 28b8739c3..bab9f3e37 100644 --- a/metagpt/learn/__init__.py +++ b/metagpt/learn/__init__.py @@ -5,3 +5,9 @@ @Author : alexanderwu @File : __init__.py """ + +from metagpt.learn.text_to_image import text_to_image +from metagpt.learn.text_to_speech import text_to_speech +from metagpt.learn.google_search import google_search + +__all__ = ["text_to_image", "text_to_speech", "google_search"] diff --git a/metagpt/learn/google_search.py b/metagpt/learn/google_search.py new file mode 100644 index 000000000..ef099fe94 --- /dev/null +++ b/metagpt/learn/google_search.py @@ -0,0 +1,12 @@ +from metagpt.tools.search_engine import SearchEngine + + +async def google_search(query: str, max_results: int = 6, **kwargs): + """Perform a web search and retrieve search results. + + :param query: The search query. + :param max_results: The number of search results to retrieve + :return: The web search results in markdown format. + """ + resluts = await SearchEngine().run(query, max_results=max_results, as_string=False) + return "\n".join(f"{i}. [{j['title']}]({j['link']}): {j['snippet']}" for i, j in enumerate(resluts, 1)) diff --git a/metagpt/learn/skill_loader.py b/metagpt/learn/skill_loader.py new file mode 100644 index 000000000..abe5ea2ea --- /dev/null +++ b/metagpt/learn/skill_loader.py @@ -0,0 +1,100 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +@Time : 2023/8/18 +@Author : mashenquan +@File : skill_loader.py +@Desc : Skill YAML Configuration Loader. +""" +from pathlib import Path +from typing import Dict, List, Optional + +import aiofiles +import yaml +from pydantic import BaseModel, Field + +from metagpt.config import CONFIG + + +class Example(BaseModel): + ask: str + answer: str + + +class Returns(BaseModel): + type: str + format: Optional[str] = None + + +class Parameter(BaseModel): + type: str + description: str = None + + +class Skill(BaseModel): + name: str + description: str = None + id: str = None + x_prerequisite: Dict = Field(default=None, alias="x-prerequisite") + parameters: Dict[str, Parameter] = None + examples: List[Example] + returns: Returns + + @property + def arguments(self) -> Dict: + if not self.parameters: + return {} + ret = {} + for k, v in self.parameters.items(): + ret[k] = v.description if v.description else "" + return ret + + +class Entity(BaseModel): + name: str = None + skills: List[Skill] + + +class Components(BaseModel): + pass + + +class SkillsDeclaration(BaseModel): + skillapi: str + entities: Dict[str, Entity] + components: Components = None + + @staticmethod + async def load(skill_yaml_file_name: Path = None) -> "SkillsDeclaration": + if not skill_yaml_file_name: + skill_yaml_file_name = Path(__file__).parent.parent.parent / ".well-known/skills.yaml" + async with aiofiles.open(str(skill_yaml_file_name), mode="r") as reader: + data = await reader.read(-1) + skill_data = yaml.safe_load(data) + return SkillsDeclaration(**skill_data) + + def get_skill_list(self, entity_name: str = "Assistant") -> Dict: + """Return the skill name based on the skill description.""" + entity = self.entities.get(entity_name) + if not entity: + return {} + + # List of skills that the agent chooses to activate. + agent_skills = CONFIG.agent_skills + if not agent_skills: + return {} + + class _AgentSkill(BaseModel): + name: str + + names = [_AgentSkill(**i).name for i in agent_skills] + return {s.description: s.name for s in entity.skills if s.name in names} + + def get_skill(self, name, entity_name: str = "Assistant") -> Skill: + """Return a skill by name.""" + entity = self.entities.get(entity_name) + if not entity: + return None + for sk in entity.skills: + if sk.name == name: + return sk diff --git a/metagpt/learn/text_to_embedding.py b/metagpt/learn/text_to_embedding.py new file mode 100644 index 000000000..26dab0419 --- /dev/null +++ b/metagpt/learn/text_to_embedding.py @@ -0,0 +1,24 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +@Time : 2023/8/18 +@Author : mashenquan +@File : text_to_embedding.py +@Desc : Text-to-Embedding skill, which provides text-to-embedding functionality. +""" + +from metagpt.config import CONFIG +from metagpt.tools.openai_text_to_embedding import oas3_openai_text_to_embedding + + +async def text_to_embedding(text, model="text-embedding-ada-002", openai_api_key="", **kwargs): + """Text to embedding + + :param text: The text used for embedding. + :param model: One of ['text-embedding-ada-002'], ID of the model to use. For more details, checkout: `https://api.openai.com/v1/models`. + :param openai_api_key: OpenAI API key, For more details, checkout: `https://platform.openai.com/account/api-keys` + :return: A json object of :class:`ResultEmbedding` class if successful, otherwise `{}`. + """ + if CONFIG.OPENAI_API_KEY or openai_api_key: + return await oas3_openai_text_to_embedding(text, model=model, openai_api_key=openai_api_key) + raise EnvironmentError diff --git a/metagpt/learn/text_to_image.py b/metagpt/learn/text_to_image.py new file mode 100644 index 000000000..eaf528b3e --- /dev/null +++ b/metagpt/learn/text_to_image.py @@ -0,0 +1,38 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +@Time : 2023/8/18 +@Author : mashenquan +@File : text_to_image.py +@Desc : Text-to-Image skill, which provides text-to-image functionality. +""" + +from metagpt.config import CONFIG +from metagpt.const import BASE64_FORMAT +from metagpt.tools.metagpt_text_to_image import oas3_metagpt_text_to_image +from metagpt.tools.openai_text_to_image import oas3_openai_text_to_image +from metagpt.utils.s3 import S3 + + +async def text_to_image(text, size_type: str = "512x512", openai_api_key="", model_url="", **kwargs): + """Text to image + + :param text: The text used for image conversion. + :param openai_api_key: OpenAI API key, For more details, checkout: `https://platform.openai.com/account/api-keys` + :param size_type: If using OPENAI, the available size options are ['256x256', '512x512', '1024x1024'], while for MetaGPT, the options are ['512x512', '512x768']. + :param model_url: MetaGPT model url + :return: The image data is returned in Base64 encoding. + """ + image_declaration = "data:image/png;base64," + if CONFIG.METAGPT_TEXT_TO_IMAGE_MODEL_URL or model_url: + base64_data = await oas3_metagpt_text_to_image(text, size_type, model_url) + elif CONFIG.OPENAI_API_KEY or openai_api_key: + base64_data = await oas3_openai_text_to_image(text, size_type) + else: + raise ValueError("Missing necessary parameters.") + + s3 = S3() + url = await s3.cache(data=base64_data, file_ext=".png", format=BASE64_FORMAT) if s3.is_valid else "" + if url: + return f"![{text}]({url})" + return image_declaration + base64_data if base64_data else "" diff --git a/metagpt/learn/text_to_speech.py b/metagpt/learn/text_to_speech.py new file mode 100644 index 000000000..72958b8c7 --- /dev/null +++ b/metagpt/learn/text_to_speech.py @@ -0,0 +1,72 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +@Time : 2023/8/17 +@Author : mashenquan +@File : text_to_speech.py +@Desc : Text-to-Speech skill, which provides text-to-speech functionality +""" +import openai + +from metagpt.config import CONFIG +from metagpt.const import BASE64_FORMAT +from metagpt.tools.azure_tts import oas3_azsure_tts +from metagpt.tools.iflytek_tts import oas3_iflytek_tts +from metagpt.utils.s3 import S3 + + +async def text_to_speech( + text, + lang="zh-CN", + voice="zh-CN-XiaomoNeural", + style="affectionate", + role="Girl", + subscription_key="", + region="", + iflytek_app_id="", + iflytek_api_key="", + iflytek_api_secret="", + **kwargs, +): + """Text to speech + For more details, check out:`https://learn.microsoft.com/en-us/azure/ai-services/speech-service/language-support?tabs=tts` + + :param lang: The value can contain a language code such as en (English), or a locale such as en-US (English - United States). For more details, checkout: `https://learn.microsoft.com/en-us/azure/ai-services/speech-service/language-support?tabs=tts` + :param voice: For more details, checkout: `https://learn.microsoft.com/en-us/azure/ai-services/speech-service/language-support?tabs=tts`, `https://speech.microsoft.com/portal/voicegallery` + :param style: Speaking style to express different emotions like cheerfulness, empathy, and calm. For more details, checkout: `https://learn.microsoft.com/en-us/azure/ai-services/speech-service/language-support?tabs=tts` + :param role: With roles, the same voice can act as a different age and gender. For more details, checkout: `https://learn.microsoft.com/en-us/azure/ai-services/speech-service/language-support?tabs=tts` + :param text: The text used for voice conversion. + :param subscription_key: key is used to access your Azure AI service API, see: `https://portal.azure.com/` > `Resource Management` > `Keys and Endpoint` + :param region: This is the location (or region) of your resource. You may need to use this field when making calls to this API. + :param iflytek_app_id: Application ID is used to access your iFlyTek service API, see: `https://console.xfyun.cn/services/tts` + :param iflytek_api_key: WebAPI argument, see: `https://console.xfyun.cn/services/tts` + :param iflytek_api_secret: WebAPI argument, see: `https://console.xfyun.cn/services/tts` + :return: Returns the Base64-encoded .wav/.mp3 file data if successful, otherwise an empty string. + + """ + + if (CONFIG.AZURE_TTS_SUBSCRIPTION_KEY and CONFIG.AZURE_TTS_REGION) or (subscription_key and region): + audio_declaration = "data:audio/wav;base64," + base64_data = await oas3_azsure_tts(text, lang, voice, style, role, subscription_key, region) + s3 = S3() + url = await s3.cache(data=base64_data, file_ext=".wav", format=BASE64_FORMAT) if s3.is_valid else "" + if url: + return f"[{text}]({url})" + return audio_declaration + base64_data if base64_data else base64_data + if (CONFIG.IFLYTEK_APP_ID and CONFIG.IFLYTEK_API_KEY and CONFIG.IFLYTEK_API_SECRET) or ( + iflytek_app_id and iflytek_api_key and iflytek_api_secret + ): + audio_declaration = "data:audio/mp3;base64," + base64_data = await oas3_iflytek_tts( + text=text, app_id=iflytek_app_id, api_key=iflytek_api_key, api_secret=iflytek_api_secret + ) + s3 = S3() + url = await s3.cache(data=base64_data, file_ext=".mp3", format=BASE64_FORMAT) if s3.is_valid else "" + if url: + return f"[{text}]({url})" + return audio_declaration + base64_data if base64_data else base64_data + + raise openai.InvalidRequestError( + message="AZURE_TTS_SUBSCRIPTION_KEY, AZURE_TTS_REGION, IFLYTEK_APP_ID, IFLYTEK_API_KEY, IFLYTEK_API_SECRET error", + param={}, + ) diff --git a/metagpt/management/skill_manager.py b/metagpt/management/skill_manager.py index b3181b64e..e4892e3d9 100644 --- a/metagpt/management/skill_manager.py +++ b/metagpt/management/skill_manager.py @@ -4,11 +4,11 @@ @Time : 2023/6/5 01:44 @Author : alexanderwu @File : skill_manager.py +@Modified By: mashenquan, 2023/8/20. Remove useless `_llm` """ from metagpt.actions import Action from metagpt.const import PROMPT_PATH from metagpt.document_store.chromadb_store import ChromaStore -from metagpt.llm import LLM from metagpt.logs import logger Skill = Action @@ -18,7 +18,6 @@ class SkillManager: """Used to manage all skills""" def __init__(self): - self._llm = LLM() self._store = ChromaStore("skill_manager") self._skills: dict[str:Skill] = {} diff --git a/metagpt/memory/brain_memory.py b/metagpt/memory/brain_memory.py new file mode 100644 index 000000000..8b47ba79a --- /dev/null +++ b/metagpt/memory/brain_memory.py @@ -0,0 +1,253 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +@Time : 2023/8/18 +@Author : mashenquan +@File : brain_memory.py +@Desc : Used by AgentStore. Used for long-term storage and automatic compression. +@Modified By: mashenquan, 2023/9/4. + redis memory cache. +@Modified By: mashenquan, 2023/12/25. Simplify Functionality. +""" +import json +import re +from typing import Dict, List + +from pydantic import BaseModel, Field + +from metagpt.config import CONFIG +from metagpt.const import DEFAULT_LANGUAGE +from metagpt.logs import logger +from metagpt.provider import MetaGPTAPI +from metagpt.schema import Message, SimpleMessage +from metagpt.utils.redis import Redis + + +class BrainMemory(BaseModel): + history: List[Message] = Field(default_factory=list) + knowledge: List[Message] = Field(default_factory=list) + historical_summary: str = "" + last_history_id: str = "" + is_dirty: bool = False + last_talk: str = None + cacheable: bool = True + + def add_talk(self, msg: Message): + """ + Add message from user. + """ + msg.role = "user" + self.add_history(msg) + self.is_dirty = True + + def add_answer(self, msg: Message): + """Add message from LLM""" + msg.role = "assistant" + self.add_history(msg) + self.is_dirty = True + + def get_knowledge(self) -> str: + texts = [m.content for m in self.knowledge] + return "\n".join(texts) + + @staticmethod + async def loads(redis_key: str, redis_conf: Dict = None) -> "BrainMemory": + redis = Redis(conf=redis_conf) + if not redis.is_valid() or not redis_key: + return BrainMemory() + v = await redis.get(key=redis_key) + logger.debug(f"REDIS GET {redis_key} {v}") + if v: + bm = BrainMemory.parse_raw(v) + bm.is_dirty = False + return bm + return BrainMemory() + + async def dumps(self, redis_key: str, timeout_sec: int = 30 * 60, redis_conf: Dict = None): + if not self.is_dirty: + return + redis = Redis(conf=redis_conf) + if not redis.is_valid() or not redis_key: + return False + v = self.json(ensure_ascii=False) + if self.cacheable: + await redis.set(key=redis_key, data=v, timeout_sec=timeout_sec) + logger.debug(f"REDIS SET {redis_key} {v}") + self.is_dirty = False + + @staticmethod + def to_redis_key(prefix: str, user_id: str, chat_id: str): + return f"{prefix}:{user_id}:{chat_id}" + + async def set_history_summary(self, history_summary, redis_key, redis_conf): + if self.historical_summary == history_summary: + if self.is_dirty: + await self.dumps(redis_key=redis_key, redis_conf=redis_conf) + self.is_dirty = False + return + + self.historical_summary = history_summary + self.history = [] + await self.dumps(redis_key=redis_key, redis_conf=redis_conf) + self.is_dirty = False + + def add_history(self, msg: Message): + if msg.id: + if self.to_int(msg.id, 0) <= self.to_int(self.last_history_id, -1): + return + self.history.append(msg.dict()) + self.last_history_id = str(msg.id) + self.is_dirty = True + + def exists(self, text) -> bool: + for m in reversed(self.history): + if m.get("content") == text: + return True + return False + + @staticmethod + def to_int(v, default_value): + try: + return int(v) + except: + return default_value + + def pop_last_talk(self): + v = self.last_talk + self.last_talk = None + return v + + async def summarize(self, llm, max_words=200, keep_language: bool = False, limit: int = -1, **kwargs): + if isinstance(llm, MetaGPTAPI): + return await self._metagpt_summarize(max_words=max_words) + + return await self._openai_summarize(llm=llm, max_words=max_words, keep_language=keep_language, limit=limit) + + async def _openai_summarize(self, llm, max_words=200, keep_language: bool = False, limit: int = -1): + texts = [self.historical_summary] + for m in self.history: + texts.append(m.content) + text = "\n".join(texts) + + text_length = len(text) + if limit > 0 and text_length < limit: + return text + summary = await llm.summarize(text=text, max_words=max_words, keep_language=keep_language, limit=limit) + if summary: + await self.set_history_summary(history_summary=summary, redis_key=CONFIG.REDIS_KEY, redis_conf=CONFIG.REDIS) + return summary + raise ValueError(f"text too long:{text_length}") + + async def _metagpt_summarize(self, max_words=200): + if not self.history: + return "" + + total_length = 0 + msgs = [] + for m in reversed(self.history): + delta = len(m.content) + if total_length + delta > max_words: + left = max_words - total_length + if left == 0: + break + m.content = m.content[0:left] + msgs.append(m.dict()) + break + msgs.append(m) + total_length += delta + msgs.reverse() + self.history = msgs + self.is_dirty = True + await self.dumps(redis_key=CONFIG.REDIS_KEY, redis_conf=CONFIG.REDIS_CONF) + self.is_dirty = False + + return BrainMemory.to_metagpt_history_format(self.history) + + @staticmethod + def to_metagpt_history_format(history) -> str: + mmsg = [SimpleMessage(role=m.role, content=m.content) for m in history] + return json.dumps(mmsg) + + async def get_title(self, llm, max_words=5, **kwargs) -> str: + """Generate text title""" + if isinstance(llm, MetaGPTAPI): + return self.history[0].content if self.history else "New" + + summary = await self.summarize(llm=llm, max_words=500) + + language = CONFIG.language or DEFAULT_LANGUAGE + command = f"Translate the above summary into a {language} title of less than {max_words} words." + summaries = [summary, command] + msg = "\n".join(summaries) + logger.debug(f"title ask:{msg}") + response = await llm.aask(msg=msg, system_msgs=[]) + logger.debug(f"title rsp: {response}") + return response + + async def is_related(self, text1, text2, llm): + if isinstance(llm, MetaGPTAPI): + return await self._metagpt_is_related(text1=text1, text2=text2, llm=llm) + return await self._openai_is_related(text1=text1, text2=text2, llm=llm) + + @staticmethod + async def _metagpt_is_related(**kwargs): + return False + + @staticmethod + async def _openai_is_related(text1, text2, llm, **kwargs): + command = ( + f"{text2}\n\nIs there any sentence above related to the following sentence: {text1}.\nIf is there " + "any relevance, return [TRUE] brief and clear. Otherwise, return [FALSE] brief and clear." + ) + rsp = await llm.aask(msg=command, system_msgs=[]) + result = True if "TRUE" in rsp else False + p2 = text2.replace("\n", "") + p1 = text1.replace("\n", "") + logger.info(f"IS_RELATED:\nParagraph 1: {p2}\nParagraph 2: {p1}\nRESULT: {result}\n") + return result + + async def rewrite(self, sentence: str, context: str, llm): + if isinstance(llm, MetaGPTAPI): + return await self._metagpt_rewrite(sentence=sentence, context=context, llm=llm) + return await self._openai_rewrite(sentence=sentence, context=context, llm=llm) + + @staticmethod + async def _metagpt_rewrite(sentence: str): + return sentence + + @staticmethod + async def _openai_rewrite(sentence: str, context: str, llm): + command = ( + f"{context}\n\nExtract relevant information from every preceding sentence and use it to succinctly " + f"supplement or rewrite the following text in brief and clear:\n{sentence}" + ) + rsp = await llm.aask(msg=command, system_msgs=[]) + logger.info(f"REWRITE:\nCommand: {command}\nRESULT: {rsp}\n") + return rsp + + @staticmethod + def extract_info(input_string, pattern=r"\[([A-Z]+)\]:\s*(.+)"): + match = re.match(pattern, input_string) + if match: + return match.group(1), match.group(2) + else: + return None, input_string + + @property + def is_history_available(self): + return bool(self.history or self.historical_summary) + + @property + def history_text(self): + if len(self.history) == 0 and not self.historical_summary: + return "" + texts = [self.historical_summary] if self.historical_summary else [] + for m in self.history[:-1]: + if isinstance(m, Dict): + t = Message(**m).content + elif isinstance(m, Message): + t = m.content + else: + continue + texts.append(t) + + return "\n".join(texts) diff --git a/metagpt/memory/longterm_memory.py b/metagpt/memory/longterm_memory.py index 710074f81..1497b8910 100644 --- a/metagpt/memory/longterm_memory.py +++ b/metagpt/memory/longterm_memory.py @@ -2,6 +2,7 @@ # -*- coding: utf-8 -*- """ @Desc : the implement of Long-term memory +@Modified By: mashenquan, 2023/8/20. Remove global configuration `CONFIG`, enable configuration support for business isolation. """ from typing import Optional diff --git a/metagpt/memory/memory.py b/metagpt/memory/memory.py index e9891ed00..bd03786ad 100644 --- a/metagpt/memory/memory.py +++ b/metagpt/memory/memory.py @@ -12,6 +12,7 @@ from typing import Iterable, Set from pydantic import BaseModel, Field +from metagpt.const import IGNORED_MESSAGE_ID from metagpt.schema import Message from metagpt.utils.common import ( any_to_str, @@ -26,6 +27,7 @@ class Memory(BaseModel): storage: list[Message] = [] index: dict[str, list[Message]] = Field(default_factory=defaultdict(list)) + ignore_id: bool = False def __init__(self, **kwargs): index = kwargs.get("index", {}) @@ -54,6 +56,8 @@ class Memory(BaseModel): def add(self, message: Message): """Add a new message to storage, while updating the index""" + if self.ignore_id: + message.id = IGNORED_MESSAGE_ID if message in self.storage: return self.storage.append(message) @@ -84,6 +88,8 @@ class Memory(BaseModel): def delete(self, message: Message): """Delete the specified message from storage, while updating the index""" + if self.ignore_id: + message.id = IGNORED_MESSAGE_ID self.storage.remove(message) if message.cause_by and message in self.index[message.cause_by]: self.index[message.cause_by].remove(message) diff --git a/metagpt/memory/memory_storage.py b/metagpt/memory/memory_storage.py index fafb33568..1850e0ea0 100644 --- a/metagpt/memory/memory_storage.py +++ b/metagpt/memory/memory_storage.py @@ -1,11 +1,16 @@ #!/usr/bin/env python # -*- coding: utf-8 -*- -# @Desc : the implement of memory storage +""" +@Desc : the implement of memory storage +@Modified By: mashenquan, 2023/8/20. Remove global configuration `CONFIG`, enable configuration support for business isolation. +""" from pathlib import Path -from typing import List +from typing import Optional +from langchain.embeddings import OpenAIEmbeddings from langchain.vectorstores.faiss import FAISS +from langchain_core.embeddings import Embeddings from metagpt.const import DATA_PATH, MEM_TTL from metagpt.document_store.faiss_store import FaissStore @@ -19,20 +24,30 @@ class MemoryStorage(FaissStore): The memory storage with Faiss as ANN search engine """ - def __init__(self, mem_ttl: int = MEM_TTL): + def __init__(self, mem_ttl: int = MEM_TTL, embedding: Embeddings = None): self.role_id: str = None self.role_mem_path: str = None self.mem_ttl: int = mem_ttl # later use self.threshold: float = 0.1 # experience value. TODO The threshold to filter similar memories self._initialized: bool = False + self.embedding = embedding or OpenAIEmbeddings() self.store: FAISS = None # Faiss engine @property def is_initialized(self) -> bool: return self._initialized - def recover_memory(self, role_id: str) -> List[Message]: + def _load(self) -> Optional["FaissStore"]: + index_file, store_file = self._get_index_and_store_fname(index_ext=".faiss") # langchain FAISS using .faiss + + if not (index_file.exists() and store_file.exists()): + logger.info("Missing at least one of index_file/store_file, load failed and return None") + return None + + return FAISS.load_local(self.role_mem_path, self.embedding, self.role_id) + + def recover_memory(self, role_id: str) -> list[Message]: self.role_id = role_id self.role_mem_path = Path(DATA_PATH / f"role_mem/{self.role_id}/") self.role_mem_path.mkdir(parents=True, exist_ok=True) @@ -49,16 +64,16 @@ class MemoryStorage(FaissStore): return messages - def _get_index_and_store_fname(self): + def _get_index_and_store_fname(self, index_ext=".index", pkl_ext=".pkl"): if not self.role_mem_path: logger.error(f"You should call {self.__class__.__name__}.recover_memory fist when using LongTermMemory") return None, None - index_fpath = Path(self.role_mem_path / f"{self.role_id}.index") - storage_fpath = Path(self.role_mem_path / f"{self.role_id}.pkl") + index_fpath = Path(self.role_mem_path / f"{self.role_id}{index_ext}") + storage_fpath = Path(self.role_mem_path / f"{self.role_id}{pkl_ext}") return index_fpath, storage_fpath def persist(self): - super().persist() + self.store.save_local(self.role_mem_path, self.role_id) logger.debug(f"Agent {self.role_id} persist memory into local") def add(self, message: Message) -> bool: @@ -74,7 +89,7 @@ class MemoryStorage(FaissStore): self.persist() logger.info(f"Agent {self.role_id}'s memory_storage add a message") - def search_dissimilar(self, message: Message, k=4) -> List[Message]: + def search_dissimilar(self, message: Message, k=4) -> list[Message]: """search for dissimilar messages""" if not self.store: return [] diff --git a/metagpt/provider/__init__.py b/metagpt/provider/__init__.py index 42626a551..769c8e7b8 100644 --- a/metagpt/provider/__init__.py +++ b/metagpt/provider/__init__.py @@ -12,5 +12,16 @@ from metagpt.provider.ollama_api import OllamaGPTAPI from metagpt.provider.open_llm_api import OpenLLMGPTAPI from metagpt.provider.openai_api import OpenAIGPTAPI from metagpt.provider.zhipuai_api import ZhiPuAIGPTAPI +from metagpt.provider.azure_openai_api import AzureOpenAIGPTAPI +from metagpt.provider.metagpt_api import MetaGPTAPI -__all__ = ["FireWorksGPTAPI", "GeminiGPTAPI", "OpenLLMGPTAPI", "OpenAIGPTAPI", "ZhiPuAIGPTAPI", "OllamaGPTAPI"] +__all__ = [ + "FireWorksGPTAPI", + "GeminiGPTAPI", + "OpenLLMGPTAPI", + "OpenAIGPTAPI", + "ZhiPuAIGPTAPI", + "AzureOpenAIGPTAPI", + "MetaGPTAPI", + "OllamaGPTAPI", +] diff --git a/metagpt/provider/anthropic_api.py b/metagpt/provider/anthropic_api.py index f5b06c855..b9d7d9e38 100644 --- a/metagpt/provider/anthropic_api.py +++ b/metagpt/provider/anthropic_api.py @@ -7,13 +7,13 @@ """ import anthropic -from anthropic import Anthropic +from anthropic import Anthropic, AsyncAnthropic from metagpt.config import CONFIG class Claude2: - def ask(self, prompt): + def ask(self, prompt: str) -> str: client = Anthropic(api_key=CONFIG.anthropic_api_key) res = client.completions.create( @@ -23,10 +23,10 @@ class Claude2: ) return res.completion - async def aask(self, prompt): - client = Anthropic(api_key=CONFIG.anthropic_api_key) + async def aask(self, prompt: str) -> str: + aclient = AsyncAnthropic(api_key=CONFIG.anthropic_api_key) - res = client.completions.create( + res = await aclient.completions.create( model="claude-2", prompt=f"{anthropic.HUMAN_PROMPT} {prompt} {anthropic.AI_PROMPT}", max_tokens_to_sample=1000, diff --git a/metagpt/provider/azure_openai_api.py b/metagpt/provider/azure_openai_api.py new file mode 100644 index 000000000..ca0696830 --- /dev/null +++ b/metagpt/provider/azure_openai_api.py @@ -0,0 +1,69 @@ +# -*- coding: utf-8 -*- +""" +@Time : 2023/5/5 23:08 +@Author : alexanderwu +@File : openai.py +@Modified By: mashenquan, 2023/8/20. Remove global configuration `CONFIG`, enable configuration support for business isolation; + Change cost control from global to company level. +@Modified By: mashenquan, 2023/11/21. Fix bug: ReadTimeout. +@Modified By: mashenquan, 2023/12/1. Fix bug: Unclosed connection caused by openai 0.x. +""" + + +from openai import AsyncAzureOpenAI, AzureOpenAI +from openai._base_client import AsyncHttpxClientWrapper, SyncHttpxClientWrapper + +from metagpt.config import CONFIG, Config, LLMProviderEnum +from metagpt.provider.llm_provider_registry import register_provider +from metagpt.provider.openai_api import OpenAIGPTAPI, RateLimiter + + +@register_provider(LLMProviderEnum.AZURE_OPENAI) +class AzureOpenAIGPTAPI(OpenAIGPTAPI): + """ + Check https://platform.openai.com/examples for examples + """ + + def __init__(self): + self.config: Config = CONFIG + self._init_openai() + self.auto_max_tokens = False + RateLimiter.__init__(self, rpm=self.rpm) + + def _make_client(self): + kwargs, async_kwargs = self._make_client_kwargs() + # https://learn.microsoft.com/zh-cn/azure/ai-services/openai/how-to/migration?tabs=python-new%2Cdalle-fix + self.client = AzureOpenAI(**kwargs) + self.async_client = AsyncAzureOpenAI(**async_kwargs) + self.model = self.config.DEPLOYMENT_NAME # Used in _calc_usage & _cons_kwargs + + def _make_client_kwargs(self) -> (dict, dict): + kwargs = dict( + api_key=self.config.OPENAI_API_KEY, + api_version=self.config.OPENAI_API_VERSION, + azure_endpoint=self.config.OPENAI_BASE_URL, + ) + async_kwargs = kwargs.copy() + + # to use proxy, openai v1 needs http_client + proxy_params = self._get_proxy_params() + if proxy_params: + kwargs["http_client"] = SyncHttpxClientWrapper(**proxy_params) + async_kwargs["http_client"] = AsyncHttpxClientWrapper(**proxy_params) + + return kwargs, async_kwargs + + def _cons_kwargs(self, messages: list[dict], timeout=3, **configs) -> dict: + kwargs = { + "messages": messages, + "max_tokens": self.get_max_tokens(messages), + "n": 1, + "stop": None, + "temperature": 0.3, + "model": self.model, + } + if configs: + kwargs.update(configs) + kwargs["timeout"] = max(CONFIG.timeout, timeout) + + return kwargs diff --git a/metagpt/provider/base_chatbot.py b/metagpt/provider/base_chatbot.py index a6950f144..535130de7 100644 --- a/metagpt/provider/base_chatbot.py +++ b/metagpt/provider/base_chatbot.py @@ -4,6 +4,7 @@ @Time : 2023/5/5 23:00 @Author : alexanderwu @File : base_chatbot.py +@Modified By: mashenquan, 2023/11/21. Add `timeout`. """ from abc import ABC, abstractmethod from dataclasses import dataclass @@ -17,13 +18,13 @@ class BaseChatbot(ABC): use_system_prompt: bool = True @abstractmethod - def ask(self, msg: str) -> str: + def ask(self, msg: str, timeout=3) -> str: """Ask GPT a question and get an answer""" @abstractmethod - def ask_batch(self, msgs: list) -> str: + def ask_batch(self, msgs: list, timeout=3) -> str: """Ask GPT multiple questions and get a series of answers""" @abstractmethod - def ask_code(self, msgs: list) -> str: + def ask_code(self, msgs: list, timeout=3) -> str: """Ask GPT multiple questions and get a piece of code""" diff --git a/metagpt/provider/base_gpt_api.py b/metagpt/provider/base_gpt_api.py index c38576806..c7417af90 100644 --- a/metagpt/provider/base_gpt_api.py +++ b/metagpt/provider/base_gpt_api.py @@ -4,12 +4,12 @@ @Time : 2023/5/5 23:04 @Author : alexanderwu @File : base_gpt_api.py +@Desc : mashenquan, 2023/8/22. + try catch """ import json from abc import abstractmethod from typing import Optional -from metagpt.logs import logger from metagpt.provider.base_chatbot import BaseChatbot @@ -33,62 +33,65 @@ class BaseGPTAPI(BaseChatbot): def _default_system_msg(self): return self._system_msg(self.system_prompt) - def ask(self, msg: str) -> str: + def ask(self, msg: str, timeout=3) -> str: message = [self._default_system_msg(), self._user_msg(msg)] if self.use_system_prompt else [self._user_msg(msg)] - rsp = self.completion(message) + rsp = self.completion(message, timeout=timeout) return self.get_choice_text(rsp) - async def aask(self, msg: str, system_msgs: Optional[list[str]] = None, stream=True) -> str: + async def aask( + self, + msg: str, + system_msgs: Optional[list[str]] = None, + format_msgs: Optional[list[dict[str, str]]] = None, + timeout=3, + stream=True, + ) -> str: if system_msgs: - message = ( - self._system_msgs(system_msgs) + [self._user_msg(msg)] - if self.use_system_prompt - else [self._user_msg(msg)] - ) + message = self._system_msgs(system_msgs) else: - message = ( - [self._default_system_msg(), self._user_msg(msg)] if self.use_system_prompt else [self._user_msg(msg)] - ) - logger.debug(message) - rsp = await self.acompletion_text(message, stream=stream) + message = [self._default_system_msg()] + if format_msgs: + message.extend(format_msgs) + message.append(self._user_msg(msg)) + rsp = await self.acompletion_text(message, stream=stream, timeout=timeout) # logger.debug(rsp) return rsp def _extract_assistant_rsp(self, context): return "\n".join([i["content"] for i in context if i["role"] == "assistant"]) - def ask_batch(self, msgs: list) -> str: + def ask_batch(self, msgs: list, timeout=3) -> str: context = [] for msg in msgs: umsg = self._user_msg(msg) context.append(umsg) - rsp = self.completion(context) + rsp = self.completion(context, timeout=timeout) rsp_text = self.get_choice_text(rsp) context.append(self._assistant_msg(rsp_text)) return self._extract_assistant_rsp(context) - async def aask_batch(self, msgs: list) -> str: + async def aask_batch(self, msgs: list, timeout=3) -> str: """Sequential questioning""" context = [] for msg in msgs: umsg = self._user_msg(msg) context.append(umsg) - rsp_text = await self.acompletion_text(context) + rsp_text = await self.acompletion_text(context, timeout=timeout) context.append(self._assistant_msg(rsp_text)) return self._extract_assistant_rsp(context) - def ask_code(self, msgs: list[str]) -> str: + def ask_code(self, msgs: list[str], timeout=3) -> str: """FIXME: No code segment filtering has been done here, and all results are actually displayed""" - rsp_text = self.ask_batch(msgs) + rsp_text = self.ask_batch(msgs, timeout=timeout) return rsp_text - async def aask_code(self, msgs: list[str]) -> str: + async def aask_code(self, msgs: list[str], timeout=3) -> str: """FIXME: No code segment filtering has been done here, and all results are actually displayed""" - rsp_text = await self.aask_batch(msgs) + rsp_text = await self.aask_batch(msgs, timeout=timeout) return rsp_text @abstractmethod - def completion(self, messages: list[dict]): + def completion(self, messages: list[dict], timeout=3): """All GPTAPIs are required to provide the standard OpenAI completion interface [ {"role": "system", "content": "You are a helpful assistant."}, @@ -98,7 +101,7 @@ class BaseGPTAPI(BaseChatbot): """ @abstractmethod - async def acompletion(self, messages: list[dict]): + async def acompletion(self, messages: list[dict], timeout=3): """Asynchronous version of completion All GPTAPIs are required to provide the standard OpenAI completion interface [ @@ -109,7 +112,7 @@ class BaseGPTAPI(BaseChatbot): """ @abstractmethod - async def acompletion_text(self, messages: list[dict], stream=False) -> str: + async def acompletion_text(self, messages: list[dict], stream=False, generator: bool = False, timeout=3) -> str: """Asynchronous version of completion. Return str. Support stream-print""" def get_choice_text(self, rsp: dict) -> str: @@ -145,7 +148,7 @@ class BaseGPTAPI(BaseChatbot): :return dict: return first function of choice, for exmaple, {'name': 'execute', 'arguments': '{\n "language": "python",\n "code": "print(\'Hello, World!\')"\n}'} """ - return rsp.get("choices")[0]["message"]["tool_calls"][0]["function"].to_dict() + return rsp.get("choices")[0]["message"]["tool_calls"][0]["function"] def get_choice_function_arguments(self, rsp: dict) -> dict: """Required to provide the first function arguments of choice. @@ -158,8 +161,13 @@ class BaseGPTAPI(BaseChatbot): def messages_to_prompt(self, messages: list[dict]): """[{"role": "user", "content": msg}] to user: etc.""" - return "\n".join([f"{i['role']}: {i['content']}" for i in messages]) + return "\n".join([f"{i.role}: {i.content}" for i in messages]) def messages_to_dict(self, messages): """objects to [{"role": "user", "content": msg}] etc.""" return [i.to_dict() for i in messages] + + @abstractmethod + async def close(self): + """Close connection""" + pass diff --git a/metagpt/provider/fireworks_api.py b/metagpt/provider/fireworks_api.py index a76151666..55b1b6c28 100644 --- a/metagpt/provider/fireworks_api.py +++ b/metagpt/provider/fireworks_api.py @@ -2,24 +2,142 @@ # -*- coding: utf-8 -*- # @Desc : fireworks.ai's api -import openai +import re -from metagpt.config import CONFIG, LLMProviderEnum +from openai import APIConnectionError, AsyncStream +from openai.types import CompletionUsage +from openai.types.chat import ChatCompletionChunk +from tenacity import ( + after_log, + retry, + retry_if_exception_type, + stop_after_attempt, + wait_random_exponential, +) + +from metagpt.config import CONFIG, Config, LLMProviderEnum +from metagpt.logs import logger from metagpt.provider.llm_provider_registry import register_provider -from metagpt.provider.openai_api import CostManager, OpenAIGPTAPI, RateLimiter +from metagpt.provider.openai_api import OpenAIGPTAPI, RateLimiter, log_and_reraise +from metagpt.utils.cost_manager import CostManager, Costs + +MODEL_GRADE_TOKEN_COSTS = { + "-1": {"prompt": 0.0, "completion": 0.0}, # abnormal condition + "16": {"prompt": 0.2, "completion": 0.8}, # 16 means model size <= 16B; 0.2 means $0.2/1M tokens + "80": {"prompt": 0.7, "completion": 2.8}, # 80 means 16B < model size <= 80B + "mixtral-8x7b": {"prompt": 0.4, "completion": 1.6}, +} + + +class FireworksCostManager(CostManager): + def model_grade_token_costs(self, model: str) -> dict[str, float]: + def _get_model_size(model: str) -> float: + size = re.findall(".*-([0-9.]+)b", model) + size = float(size[0]) if len(size) > 0 else -1 + return size + + if "mixtral-8x7b" in model: + token_costs = MODEL_GRADE_TOKEN_COSTS["mixtral-8x7b"] + else: + model_size = _get_model_size(model) + if 0 < model_size <= 16: + token_costs = MODEL_GRADE_TOKEN_COSTS["16"] + elif 16 < model_size <= 80: + token_costs = MODEL_GRADE_TOKEN_COSTS["80"] + else: + token_costs = MODEL_GRADE_TOKEN_COSTS["-1"] + return token_costs + + def update_cost(self, prompt_tokens: int, completion_tokens: int, model: str): + """ + Refs to `https://app.fireworks.ai/pricing` **Developer pricing** + Update the total cost, prompt tokens, and completion tokens. + + Args: + prompt_tokens (int): The number of tokens used in the prompt. + completion_tokens (int): The number of tokens used in the completion. + model (str): The model used for the API call. + """ + self.total_prompt_tokens += prompt_tokens + self.total_completion_tokens += completion_tokens + + token_costs = self.model_grade_token_costs(model) + cost = (prompt_tokens * token_costs["prompt"] + completion_tokens * token_costs["completion"]) / 1000000 + self.total_cost += cost + logger.info( + f"Total running cost: ${self.total_cost:.4f} | Max budget: ${CONFIG.max_budget:.3f} | " + f"Current cost: ${cost:.4f}, prompt_tokens: {prompt_tokens}, completion_tokens: {completion_tokens}" + ) + CONFIG.total_cost = self.total_cost @register_provider(LLMProviderEnum.FIREWORKS) class FireWorksGPTAPI(OpenAIGPTAPI): def __init__(self): - self.__init_fireworks(CONFIG) - self.llm = openai - self.model = CONFIG.fireworks_api_model + self.config: Config = CONFIG + self.__init_fireworks() self.auto_max_tokens = False - self._cost_manager = CostManager() + self._cost_manager = FireworksCostManager() RateLimiter.__init__(self, rpm=self.rpm) - def __init_fireworks(self, config: "Config"): - openai.api_key = config.fireworks_api_key - openai.api_base = config.fireworks_api_base - self.rpm = int(config.get("RPM", 10)) + def __init_fireworks(self): + self.is_azure = False + self.rpm = int(self.config.get("RPM", 10)) + self._make_client() + self.model = self.config.fireworks_api_model # `self.model` should after `_make_client` to rewrite it + + def _make_client_kwargs(self) -> (dict, dict): + kwargs = dict(api_key=self.config.fireworks_api_key, base_url=self.config.fireworks_api_base) + async_kwargs = kwargs.copy() + return kwargs, async_kwargs + + def _update_costs(self, usage: CompletionUsage): + if self.config.calc_usage and usage: + try: + # use FireworksCostManager not CONFIG.cost_manager + self._cost_manager.update_cost(usage.prompt_tokens, usage.completion_tokens, self.model) + except Exception as e: + logger.error(f"updating costs failed!, exp: {e}") + + def get_costs(self) -> Costs: + return self._cost_manager.get_costs() + + async def _achat_completion_stream(self, messages: list[dict]) -> str: + response: AsyncStream[ChatCompletionChunk] = await self.async_client.chat.completions.create( + **self._cons_kwargs(messages), stream=True + ) + + collected_content = [] + usage = CompletionUsage(prompt_tokens=0, completion_tokens=0, total_tokens=0) + # iterate through the stream of events + async for chunk in response: + if chunk.choices: + choice = chunk.choices[0] + choice_delta = choice.delta + finish_reason = choice.finish_reason if hasattr(choice, "finish_reason") else None + if choice_delta.content: + collected_content.append(choice_delta.content) + print(choice_delta.content, end="") + if finish_reason: + # fireworks api return usage when finish_reason is not None + usage = CompletionUsage(**chunk.usage) + + full_content = "".join(collected_content) + self._update_costs(usage) + return full_content + + @retry( + wait=wait_random_exponential(min=1, max=60), + stop=stop_after_attempt(6), + after=after_log(logger, logger.level("WARNING").name), + retry=retry_if_exception_type(APIConnectionError), + retry_error_callback=log_and_reraise, + ) + async def acompletion_text( + self, messages: list[dict], stream=False, generator: bool = False, timeout: int = 3 + ) -> str: + """when streaming, print each token in place.""" + if stream: + return await self._achat_completion_stream(messages) + rsp = await self._achat_completion(messages) + return self.get_choice_text(rsp) diff --git a/metagpt/provider/google_gemini_api.py b/metagpt/provider/google_gemini_api.py index 825b0bfe3..eace329aa 100644 --- a/metagpt/provider/google_gemini_api.py +++ b/metagpt/provider/google_gemini_api.py @@ -23,7 +23,7 @@ from metagpt.config import CONFIG, LLMProviderEnum from metagpt.logs import log_llm_stream, logger from metagpt.provider.base_gpt_api import BaseGPTAPI from metagpt.provider.llm_provider_registry import register_provider -from metagpt.provider.openai_api import CostManager, log_and_reraise +from metagpt.provider.openai_api import log_and_reraise class GeminiGenerativeModel(GenerativeModel): @@ -53,7 +53,6 @@ class GeminiGPTAPI(BaseGPTAPI): self.__init_gemini(CONFIG) self.model = "gemini-pro" # so far only one model self.llm = GeminiGenerativeModel(model_name=self.model) - self._cost_manager = CostManager() def __init_gemini(self, config: CONFIG): genai.configure(api_key=config.gemini_api_key) @@ -76,10 +75,13 @@ class GeminiGPTAPI(BaseGPTAPI): try: prompt_tokens = int(usage.get("prompt_tokens", 0)) completion_tokens = int(usage.get("completion_tokens", 0)) - self._cost_manager.update_cost(prompt_tokens, completion_tokens, self.model) + CONFIG.cost_manager.update_cost(prompt_tokens, completion_tokens, self.model) except Exception as e: logger.error(f"google gemini updats costs failed! exp: {e}") + def close(self): + pass + def get_choice_text(self, resp: GenerateContentResponse) -> str: return resp.text @@ -134,7 +136,9 @@ class GeminiGPTAPI(BaseGPTAPI): retry=retry_if_exception_type(ConnectionError), retry_error_callback=log_and_reraise, ) - async def acompletion_text(self, messages: list[dict], stream=False) -> str: + async def acompletion_text( + self, messages: list[dict], stream=False, generator: bool = False, timeout: int = 3 + ) -> str: """response in async with stream or non-stream mode""" if stream: return await self._achat_completion_stream(messages) diff --git a/metagpt/provider/human_provider.py b/metagpt/provider/human_provider.py index c70a7f1a6..5850dd8dc 100644 --- a/metagpt/provider/human_provider.py +++ b/metagpt/provider/human_provider.py @@ -14,24 +14,35 @@ class HumanProvider(BaseGPTAPI): This enables replacing LLM anywhere in the framework with a human, thus introducing human interaction """ - def ask(self, msg: str) -> str: + def ask(self, msg: str, timeout=3) -> str: logger.info("It's your turn, please type in your response. You may also refer to the context below") rsp = input(msg) if rsp in ["exit", "quit"]: exit() return rsp - async def aask(self, msg: str, system_msgs: Optional[list[str]] = None) -> str: - return self.ask(msg) + async def aask( + self, + msg: str, + system_msgs: Optional[list[str]] = None, + format_msgs: Optional[list[dict[str, str]]] = None, + generator: bool = False, + timeout=3, + ) -> str: + return self.ask(msg, timeout=timeout) - def completion(self, messages: list[dict]): + def completion(self, messages: list[dict], timeout=3): """dummy implementation of abstract method in base""" return [] - async def acompletion(self, messages: list[dict]): + async def acompletion(self, messages: list[dict], timeout=3): """dummy implementation of abstract method in base""" return [] - async def acompletion_text(self, messages: list[dict], stream=False) -> str: + async def acompletion_text(self, messages: list[dict], stream=False, timeout=3) -> str: """dummy implementation of abstract method in base""" - return [] + return "" + + async def close(self): + """Close connection""" + pass diff --git a/metagpt/provider/metagpt_api.py b/metagpt/provider/metagpt_api.py new file mode 100644 index 000000000..7bc48b7ad --- /dev/null +++ b/metagpt/provider/metagpt_api.py @@ -0,0 +1,16 @@ +# -*- coding: utf-8 -*- +""" +@Time : 2023/5/5 23:08 +@Author : alexanderwu +@File : metagpt_api.py +@Desc : MetaGPT LLM provider. +""" +from metagpt.config import LLMProviderEnum +from metagpt.provider import OpenAIGPTAPI +from metagpt.provider.llm_provider_registry import register_provider + + +@register_provider(LLMProviderEnum.METAGPT) +class MetaGPTAPI(OpenAIGPTAPI): + def __init__(self): + super().__init__() diff --git a/metagpt/provider/ollama_api.py b/metagpt/provider/ollama_api.py index e913f3d0d..90a50a154 100644 --- a/metagpt/provider/ollama_api.py +++ b/metagpt/provider/ollama_api.py @@ -19,7 +19,8 @@ from metagpt.logs import log_llm_stream, logger from metagpt.provider.base_gpt_api import BaseGPTAPI from metagpt.provider.general_api_requestor import GeneralAPIRequestor from metagpt.provider.llm_provider_registry import register_provider -from metagpt.provider.openai_api import CostManager, log_and_reraise +from metagpt.provider.openai_api import log_and_reraise +from metagpt.utils.cost_manager import CostManager class OllamaCostManager(CostManager): @@ -56,6 +57,9 @@ class OllamaGPTAPI(BaseGPTAPI): self.model = config.ollama_api_model + def close(self): + pass + def _const_kwargs(self, messages: list[dict], stream: bool = False) -> dict: kwargs = {"model": self.model, "messages": messages, "options": {"temperature": 0.3}, "stream": stream} return kwargs @@ -143,7 +147,9 @@ class OllamaGPTAPI(BaseGPTAPI): retry=retry_if_exception_type(ConnectionError), retry_error_callback=log_and_reraise, ) - async def acompletion_text(self, messages: list[dict], stream=False) -> str: + async def acompletion_text( + self, messages: list[dict], stream=False, generator: bool = False, timeout: int = 3 + ) -> str: """response in async with stream or non-stream mode""" if stream: return await self._achat_completion_stream(messages) diff --git a/metagpt/provider/open_llm_api.py b/metagpt/provider/open_llm_api.py index bada0e294..dd1491780 100644 --- a/metagpt/provider/open_llm_api.py +++ b/metagpt/provider/open_llm_api.py @@ -2,12 +2,14 @@ # -*- coding: utf-8 -*- # @Desc : self-host open llm model with openai-compatible interface -import openai +from openai.types import CompletionUsage -from metagpt.config import CONFIG, LLMProviderEnum +from metagpt.config import CONFIG, Config, LLMProviderEnum from metagpt.logs import logger from metagpt.provider.llm_provider_registry import register_provider -from metagpt.provider.openai_api import CostManager, OpenAIGPTAPI, RateLimiter +from metagpt.provider.openai_api import OpenAIGPTAPI, RateLimiter +from metagpt.utils.cost_manager import CostManager, Costs +from metagpt.utils.token_counter import count_message_tokens, count_string_tokens class OpenLLMCostManager(CostManager): @@ -26,7 +28,7 @@ class OpenLLMCostManager(CostManager): self.total_completion_tokens += completion_tokens logger.info( - f"Max budget: ${CONFIG.max_budget:.3f} | " + f"Max budget: ${CONFIG.max_budget:.3f} | reference " f"prompt_tokens: {prompt_tokens}, completion_tokens: {completion_tokens}" ) CONFIG.total_cost = self.total_cost @@ -35,14 +37,43 @@ class OpenLLMCostManager(CostManager): @register_provider(LLMProviderEnum.OPEN_LLM) class OpenLLMGPTAPI(OpenAIGPTAPI): def __init__(self): - self.__init_openllm(CONFIG) - self.llm = openai - self.model = CONFIG.open_llm_api_model + self.config: Config = CONFIG + self.__init_openllm() self.auto_max_tokens = False self._cost_manager = OpenLLMCostManager() RateLimiter.__init__(self, rpm=self.rpm) - def __init_openllm(self, config: "Config"): - openai.api_key = "sk-xx" # self-host api doesn't need api-key, use the default value - openai.api_base = config.open_llm_api_base - self.rpm = int(config.get("RPM", 10)) + def __init_openllm(self): + self.is_azure = False + self.rpm = int(self.config.get("RPM", 10)) + self._make_client() + self.model = self.config.open_llm_api_model # `self.model` should after `_make_client` to rewrite it + + def _make_client_kwargs(self) -> (dict, dict): + kwargs = dict(api_key="sk-xxx", base_url=self.config.open_llm_api_base) + async_kwargs = kwargs.copy() + return kwargs, async_kwargs + + def _calc_usage(self, messages: list[dict], rsp: str) -> CompletionUsage: + usage = CompletionUsage(prompt_tokens=0, completion_tokens=0, total_tokens=0) + if not CONFIG.calc_usage: + return usage + + try: + usage.prompt_tokens = count_message_tokens(messages, "open-llm-model") + usage.completion_tokens = count_string_tokens(rsp, "open-llm-model") + except Exception as e: + logger.error(f"usage calculation failed!: {e}") + + return usage + + def _update_costs(self, usage: CompletionUsage): + if self.config.calc_usage and usage: + try: + # use OpenLLMCostManager not CONFIG.cost_manager + self._cost_manager.update_cost(usage.prompt_tokens, usage.completion_tokens, self.model) + except Exception as e: + logger.error(f"updating costs failed!, exp: {e}") + + def get_costs(self) -> Costs: + return self._cost_manager.get_costs() diff --git a/metagpt/provider/openai_api.py b/metagpt/provider/openai_api.py index 0b6fdd869..405d523e5 100644 --- a/metagpt/provider/openai_api.py +++ b/metagpt/provider/openai_api.py @@ -3,20 +3,19 @@ @Time : 2023/5/5 23:08 @Author : alexanderwu @File : openai.py +@Modified By: mashenquan, 2023/8/20. Remove global configuration `CONFIG`, enable configuration support for business isolation; + Change cost control from global to company level. +@Modified By: mashenquan, 2023/11/21. Fix bug: ReadTimeout. +@Modified By: mashenquan, 2023/12/1. Fix bug: Unclosed connection caused by openai 0.x. """ + import asyncio import json import time -from typing import NamedTuple, Union +from typing import AsyncIterator, List, Union -from openai import ( - APIConnectionError, - AsyncAzureOpenAI, - AsyncOpenAI, - AsyncStream, - AzureOpenAI, - OpenAI, -) +import openai +from openai import APIConnectionError, AsyncOpenAI, AsyncStream, OpenAI from openai._base_client import AsyncHttpxClientWrapper, SyncHttpxClientWrapper from openai.types import CompletionUsage from openai.types.chat import ChatCompletion, ChatCompletionChunk @@ -29,15 +28,15 @@ from tenacity import ( ) from metagpt.config import CONFIG, Config, LLMProviderEnum +from metagpt.const import DEFAULT_MAX_TOKENS, DEFAULT_TOKEN_SIZE from metagpt.logs import log_llm_stream, logger from metagpt.provider.base_gpt_api import BaseGPTAPI from metagpt.provider.constant import GENERAL_FUNCTION_SCHEMA, GENERAL_TOOL_CHOICE from metagpt.provider.llm_provider_registry import register_provider from metagpt.schema import Message +from metagpt.utils.cost_manager import Costs from metagpt.utils.exceptions import handle_exception -from metagpt.utils.singleton import Singleton from metagpt.utils.token_counter import ( - TOKEN_COSTS, count_message_tokens, count_string_tokens, get_max_completion_tokens, @@ -69,75 +68,6 @@ class RateLimiter: self.last_call_time = time.time() -class Costs(NamedTuple): - total_prompt_tokens: int - total_completion_tokens: int - total_cost: float - total_budget: float - - -class CostManager(metaclass=Singleton): - """计算使用接口的开销""" - - def __init__(self): - self.total_prompt_tokens = 0 - self.total_completion_tokens = 0 - self.total_cost = 0 - self.total_budget = 0 - - def update_cost(self, prompt_tokens, completion_tokens, model): - """ - Update the total cost, prompt tokens, and completion tokens. - - Args: - prompt_tokens (int): The number of tokens used in the prompt. - completion_tokens (int): The number of tokens used in the completion. - model (str): The model used for the API call. - """ - self.total_prompt_tokens += prompt_tokens - self.total_completion_tokens += completion_tokens - cost = ( - prompt_tokens * TOKEN_COSTS[model]["prompt"] + completion_tokens * TOKEN_COSTS[model]["completion"] - ) / 1000 - self.total_cost += cost - logger.info( - f"Total running cost: ${self.total_cost:.3f} | Max budget: ${CONFIG.max_budget:.3f} | " - f"Current cost: ${cost:.3f}, prompt_tokens: {prompt_tokens}, completion_tokens: {completion_tokens}" - ) - CONFIG.total_cost = self.total_cost - - def get_total_prompt_tokens(self): - """ - Get the total number of prompt tokens. - - Returns: - int: The total number of prompt tokens. - """ - return self.total_prompt_tokens - - def get_total_completion_tokens(self): - """ - Get the total number of completion tokens. - - Returns: - int: The total number of completion tokens. - """ - return self.total_completion_tokens - - def get_total_cost(self): - """ - Get the total cost of API calls. - - Returns: - float: The total cost of API calls. - """ - return self.total_cost - - def get_costs(self) -> Costs: - """Get all costs""" - return Costs(self.total_prompt_tokens, self.total_completion_tokens, self.total_cost, self.total_budget) - - def log_and_reraise(retry_state): logger.error(f"Retry attempts exhausted. Last exception: {retry_state.outcome.exception()}") logger.warning( @@ -157,37 +87,23 @@ class OpenAIGPTAPI(BaseGPTAPI, RateLimiter): def __init__(self): self.config: Config = CONFIG - self.__init_openai() + self._init_openai() self.auto_max_tokens = False - self._cost_manager = CostManager() RateLimiter.__init__(self, rpm=self.rpm) - def __init_openai(self): - self.is_azure = self.config.openai_api_type == "azure" - self.model = self.config.deployment_name if self.is_azure else self.config.openai_api_model - self.rpm = int(self.config.get("RPM", 10)) + def _init_openai(self): + self.rpm = int(self.config.RPM or 10) self._make_client() def _make_client(self): kwargs, async_kwargs = self._make_client_kwargs() - - if self.is_azure: - self.client = AzureOpenAI(**kwargs) - self.async_client = AsyncAzureOpenAI(**async_kwargs) - else: - self.client = OpenAI(**kwargs) - self.async_client = AsyncOpenAI(**async_kwargs) + # https://github.com/openai/openai-python#async-usage + self.client = OpenAI(**kwargs) + self.async_client = AsyncOpenAI(**async_kwargs) + self.model = self.config.OPENAI_API_MODEL # Used in _calc_usage & _cons_kwargs def _make_client_kwargs(self) -> (dict, dict): - if self.is_azure: - kwargs = dict( - api_key=self.config.openai_api_key, - api_version=self.config.openai_api_version, - azure_endpoint=self.config.openai_base_url, - ) - else: - kwargs = dict(api_key=self.config.openai_api_key, base_url=self.config.openai_base_url) - + kwargs = dict(api_key=self.config.OPENAI_API_KEY, base_url=self.config.OPENAI_BASE_URL) async_kwargs = kwargs.copy() # to use proxy, openai v1 needs http_client @@ -202,64 +118,51 @@ class OpenAIGPTAPI(BaseGPTAPI, RateLimiter): params = {} if self.config.openai_proxy: params = {"proxies": self.config.openai_proxy} - if self.config.openai_base_url: - params["base_url"] = self.config.openai_base_url + if self.config.OPENAI_BASE_URL: + params["base_url"] = self.config.OPENAI_BASE_URL return params - async def _achat_completion_stream(self, messages: list[dict]) -> str: + async def _achat_completion_stream(self, messages: list[dict], timeout=3) -> AsyncIterator[str]: response: AsyncStream[ChatCompletionChunk] = await self.async_client.chat.completions.create( - **self._cons_kwargs(messages), stream=True + **self._cons_kwargs(messages, timeout=timeout), stream=True ) - # create variables to collect the stream of chunks - collected_chunks = [] - collected_messages = [] - # iterate through the stream of events async for chunk in response: - collected_chunks.append(chunk) # save the event response - if chunk.choices: - chunk_message = chunk.choices[0].delta # extract the message - collected_messages.append(chunk_message) # save the message - if chunk_message.content: - log_llm_stream(chunk_message.content) - print() + chunk_message = chunk.choices[0].delta.content or "" if chunk.choices else "" # extract the message + yield chunk_message - full_reply_content = "".join([m.content for m in collected_messages if m.content]) - usage = self._calc_usage(messages, full_reply_content) - self._update_costs(usage) - return full_reply_content - - def _cons_kwargs(self, messages: list[dict], **configs) -> dict: + def _cons_kwargs(self, messages: list[dict], timeout=3, **configs) -> dict: kwargs = { "messages": messages, "max_tokens": self.get_max_tokens(messages), "n": 1, "stop": None, "temperature": 0.3, - "timeout": 3, "model": self.model, } if configs: kwargs.update(configs) + kwargs["timeout"] = max(CONFIG.timeout, timeout) return kwargs - async def _achat_completion(self, messages: list[dict]) -> ChatCompletion: - rsp: ChatCompletion = await self.async_client.chat.completions.create(**self._cons_kwargs(messages)) + async def _achat_completion(self, messages: list[dict], timeout=3) -> ChatCompletion: + kwargs = self._cons_kwargs(messages, timeout=timeout) + rsp: ChatCompletion = await self.async_client.chat.completions.create(**kwargs) self._update_costs(rsp.usage) return rsp - def _chat_completion(self, messages: list[dict]) -> ChatCompletion: - rsp: ChatCompletion = self.client.chat.completions.create(**self._cons_kwargs(messages)) + def _chat_completion(self, messages: list[dict], timeout=3) -> ChatCompletion: + rsp: ChatCompletion = self.client.chat.completions.create(**self._cons_kwargs(messages, timeout=timeout)) self._update_costs(rsp.usage) return rsp - def completion(self, messages: list[dict]) -> ChatCompletion: - return self._chat_completion(messages) + def completion(self, messages: list[dict], timeout=3) -> ChatCompletion: + return self._chat_completion(messages, timeout=timeout) - async def acompletion(self, messages: list[dict]) -> ChatCompletion: - return await self._achat_completion(messages) + async def acompletion(self, messages: list[dict], timeout=3) -> ChatCompletion: + return await self._achat_completion(messages, timeout=timeout) @retry( wait=wait_random_exponential(min=1, max=60), @@ -268,14 +171,25 @@ class OpenAIGPTAPI(BaseGPTAPI, RateLimiter): retry=retry_if_exception_type(APIConnectionError), retry_error_callback=log_and_reraise, ) - async def acompletion_text(self, messages: list[dict], stream=False) -> str: + async def acompletion_text(self, messages: list[dict], stream=False, timeout=3) -> str: """when streaming, print each token in place.""" if stream: - return await self._achat_completion_stream(messages) - rsp = await self._achat_completion(messages) + resp = self._achat_completion_stream(messages, timeout=timeout) + + collected_messages = [] + async for i in resp: + log_llm_stream(i) + collected_messages.append(i) + + full_reply_content = "".join(collected_messages) + usage = self._calc_usage(messages, full_reply_content) + self._update_costs(usage) + return full_reply_content + + rsp = await self._achat_completion(messages, timeout=timeout) return self.get_choice_text(rsp) - def _func_configs(self, messages: list[dict], **kwargs) -> dict: + def _func_configs(self, messages: list[dict], timeout=3, **kwargs) -> dict: """ Note: Keep kwargs consistent with the parameters in the https://platform.openai.com/docs/api-reference/chat/create """ @@ -286,17 +200,16 @@ class OpenAIGPTAPI(BaseGPTAPI, RateLimiter): } kwargs.update(configs) - return self._cons_kwargs(messages, **kwargs) + return self._cons_kwargs(messages=messages, timeout=timeout, **kwargs) - def _chat_completion_function(self, messages: list[dict], **kwargs) -> ChatCompletion: + def _chat_completion_function(self, messages: list[dict], timeout=3, **kwargs) -> ChatCompletion: rsp: ChatCompletion = self.client.chat.completions.create(**self._func_configs(messages, **kwargs)) self._update_costs(rsp.usage) return rsp - async def _achat_completion_function(self, messages: list[dict], **chat_configs) -> ChatCompletion: - rsp: ChatCompletion = await self.async_client.chat.completions.create( - **self._func_configs(messages, **chat_configs) - ) + async def _achat_completion_function(self, messages: list[dict], timeout=3, **chat_configs) -> ChatCompletion: + kwargs = self._func_configs(messages=messages, timeout=timeout, **chat_configs) + rsp: ChatCompletion = await self.async_client.chat.completions.create(**kwargs) self._update_costs(rsp.usage) return rsp @@ -349,8 +262,12 @@ class OpenAIGPTAPI(BaseGPTAPI, RateLimiter): >>> rsp = await llm.aask_code(msg) # -> {'language': 'python', 'code': "print('Hello, World!')"} """ messages = self._process_message(messages) - rsp = await self._achat_completion_function(messages, **kwargs) - return self.get_choice_function_arguments(rsp) + try: + rsp = await self._achat_completion_function(messages, **kwargs) + return self.get_choice_function_arguments(rsp) + except openai.BadRequestError as e: + logger.error(f"API TYPE:{CONFIG.OPENAI_API_TYPE}, err:{e}") + raise e def get_choice_function_arguments(self, rsp: ChatCompletion) -> dict: """Required to provide the first function arguments of choice. @@ -380,7 +297,7 @@ class OpenAIGPTAPI(BaseGPTAPI, RateLimiter): return usage - async def acompletion_batch(self, batch: list[list[dict]]) -> list[ChatCompletion]: + async def acompletion_batch(self, batch: list[list[dict]], timeout=3) -> list[ChatCompletion]: """Return full JSON""" split_batches = self.split_batches(batch) all_results = [] @@ -389,16 +306,16 @@ class OpenAIGPTAPI(BaseGPTAPI, RateLimiter): logger.info(small_batch) await self.wait_if_needed(len(small_batch)) - future = [self.acompletion(prompt) for prompt in small_batch] + future = [self.acompletion(prompt, timeout=timeout) for prompt in small_batch] results = await asyncio.gather(*future) logger.info(results) all_results.extend(results) return all_results - async def acompletion_batch_text(self, batch: list[list[dict]]) -> list[str]: + async def acompletion_batch_text(self, batch: list[list[dict]], timeout=3) -> list[str]: """Only return plain text""" - raw_results = await self.acompletion_batch(batch) + raw_results = await self.acompletion_batch(batch, timeout=timeout) results = [] for idx, raw_result in enumerate(raw_results, start=1): result = self.get_choice_text(raw_result) @@ -409,18 +326,101 @@ class OpenAIGPTAPI(BaseGPTAPI, RateLimiter): def _update_costs(self, usage: CompletionUsage): if CONFIG.calc_usage and usage: try: - self._cost_manager.update_cost(usage.prompt_tokens, usage.completion_tokens, self.model) + CONFIG.cost_manager.update_cost(usage.prompt_tokens, usage.completion_tokens, self.model) except Exception as e: - logger.error("updating costs failed!", e) + logger.error(f"updating costs failed!, exp: {e}") def get_costs(self) -> Costs: - return self._cost_manager.get_costs() + return CONFIG.cost_manager.get_costs() def get_max_tokens(self, messages: list[dict]): if not self.auto_max_tokens: return CONFIG.max_tokens_rsp return get_max_completion_tokens(messages, self.model, CONFIG.max_tokens_rsp) + def moderation(self, content: Union[str, list[str]]): + return self.client.moderations.create(input=content) + @handle_exception async def amoderation(self, content: Union[str, list[str]]): return await self.async_client.moderations.create(input=content) + + async def close(self): + """Close connection""" + if self.client: + self.client.close() + self.client = None + if self.async_client: + await self.async_client.close() + self.async_client = None + + async def summarize(self, text: str, max_words=200, keep_language: bool = False, limit: int = -1) -> str: + max_token_count = DEFAULT_MAX_TOKENS + max_count = 100 + text_length = len(text) + if limit > 0 and text_length < limit: + return text + summary = "" + while max_count > 0: + if text_length < max_token_count: + summary = await self._get_summary(text=text, max_words=max_words, keep_language=keep_language) + break + + padding_size = 20 if max_token_count > 20 else 0 + text_windows = self.split_texts(text, window_size=max_token_count - padding_size) + part_max_words = min(int(max_words / len(text_windows)) + 1, 100) + summaries = [] + for ws in text_windows: + response = await self._get_summary(text=ws, max_words=part_max_words, keep_language=keep_language) + summaries.append(response) + if len(summaries) == 1: + summary = summaries[0] + break + + # Merged and retry + text = "\n".join(summaries) + text_length = len(text) + + max_count -= 1 # safeguard + return summary + + async def _get_summary(self, text: str, max_words=20, keep_language: bool = False): + """Generate text summary""" + if len(text) < max_words: + return text + if keep_language: + command = f".Translate the above content into a summary of less than {max_words} words in language of the content strictly." + else: + command = f"Translate the above content into a summary of less than {max_words} words." + msg = text + "\n\n" + command + logger.debug(f"summary ask:{msg}") + response = await self.aask(msg=msg, system_msgs=[]) + logger.debug(f"summary rsp: {response}") + return response + + @staticmethod + def split_texts(text: str, window_size) -> List[str]: + """Splitting long text into sliding windows text""" + if window_size <= 0: + window_size = DEFAULT_TOKEN_SIZE + total_len = len(text) + if total_len <= window_size: + return [text] + + padding_size = 20 if window_size > 20 else 0 + windows = [] + idx = 0 + data_len = window_size - padding_size + while idx < total_len: + if window_size + idx > total_len: # 不足一个滑窗 + windows.append(text[idx:]) + break + # 每个窗口少算padding_size自然就可实现滑窗功能, 比如: [1, 2, 3, 4, 5, 6, 7, ....] + # window_size=3, padding_size=1： + # [1, 2, 3], [3, 4, 5], [5, 6, 7], .... + # idx=2, | idx=5 | idx=8 | ... + w = text[idx : idx + window_size] + windows.append(w) + idx += data_len + + return windows diff --git a/metagpt/provider/spark_api.py b/metagpt/provider/spark_api.py index 484fa7956..70076bc86 100644 --- a/metagpt/provider/spark_api.py +++ b/metagpt/provider/spark_api.py @@ -26,16 +26,19 @@ from metagpt.provider.llm_provider_registry import register_provider @register_provider(LLMProviderEnum.SPARK) -class SparkAPI(BaseGPTAPI): +class SparkGPTAPI(BaseGPTAPI): def __init__(self): logger.warning("当前方法无法支持异步运行。当你使用acompletion时，并不能并行访问。") + def close(self): + pass + def ask(self, msg: str) -> str: message = [self._default_system_msg(), self._user_msg(msg)] rsp = self.completion(message) return rsp - async def aask(self, msg: str, system_msgs: Optional[list[str]] = None) -> str: + async def aask(self, msg: str, system_msgs: Optional[list[str]] = None, stream: bool = True) -> str: if system_msgs: message = self._system_msgs(system_msgs) + [self._user_msg(msg)] else: @@ -47,7 +50,9 @@ class SparkAPI(BaseGPTAPI): def get_choice_text(self, rsp: dict) -> str: return rsp["payload"]["choices"]["text"][-1]["content"] - async def acompletion_text(self, messages: list[dict], stream=False) -> str: + async def acompletion_text( + self, messages: list[dict], stream=False, generator: bool = False, timeout: int = 3 + ) -> str: # 不支持 logger.error("该功能禁用。") w = GetMessageFromWeb(messages) diff --git a/metagpt/provider/zhipuai_api.py b/metagpt/provider/zhipuai_api.py index 650720d6f..8d57cd444 100644 --- a/metagpt/provider/zhipuai_api.py +++ b/metagpt/provider/zhipuai_api.py @@ -5,7 +5,6 @@ import json from enum import Enum -import openai import zhipuai from requests import ConnectionError from tenacity import ( @@ -20,7 +19,7 @@ from metagpt.config import CONFIG, LLMProviderEnum from metagpt.logs import log_llm_stream, logger from metagpt.provider.base_gpt_api import BaseGPTAPI from metagpt.provider.llm_provider_registry import register_provider -from metagpt.provider.openai_api import CostManager, log_and_reraise +from metagpt.provider.openai_api import log_and_reraise from metagpt.provider.zhipuai.zhipu_model_api import ZhiPuModelAPI @@ -44,12 +43,12 @@ class ZhiPuAIGPTAPI(BaseGPTAPI): self.__init_zhipuai(CONFIG) self.llm = ZhiPuModelAPI self.model = "chatglm_turbo" # so far only one model, just use it - self._cost_manager = CostManager() def __init_zhipuai(self, config: CONFIG): assert config.zhipuai_api_key zhipuai.api_key = config.zhipuai_api_key - openai.api_key = zhipuai.api_key # due to use openai sdk, set the api_key but it will't be used. + # due to use openai sdk, set the api_key but it will't be used. + # openai.api_key = zhipuai.api_key # due to use openai sdk, set the api_key but it will't be used. def _const_kwargs(self, messages: list[dict]) -> dict: kwargs = {"model": self.model, "prompt": messages, "temperature": 0.3} @@ -61,32 +60,35 @@ class ZhiPuAIGPTAPI(BaseGPTAPI): try: prompt_tokens = int(usage.get("prompt_tokens", 0)) completion_tokens = int(usage.get("completion_tokens", 0)) - self._cost_manager.update_cost(prompt_tokens, completion_tokens, self.model) + CONFIG.cost_manager.update_cost(prompt_tokens, completion_tokens, self.model) except Exception as e: logger.error(f"zhipuai updats costs failed! exp: {e}") + def close(self): + pass + def get_choice_text(self, resp: dict) -> str: """get the first text of choice from llm response""" assist_msg = resp.get("data", {}).get("choices", [{"role": "error"}])[-1] assert assist_msg["role"] == "assistant" return assist_msg.get("content") - def completion(self, messages: list[dict]) -> dict: + def completion(self, messages: list[dict], timeout=3) -> dict: resp = self.llm.invoke(**self._const_kwargs(messages)) usage = resp.get("data").get("usage") self._update_costs(usage) return resp - async def _achat_completion(self, messages: list[dict]) -> dict: + async def _achat_completion(self, messages: list[dict], timeout=3) -> dict: resp = await self.llm.ainvoke(**self._const_kwargs(messages)) usage = resp.get("data").get("usage") self._update_costs(usage) return resp - async def acompletion(self, messages: list[dict]) -> dict: - return await self._achat_completion(messages) + async def acompletion(self, messages: list[dict], timeout=3) -> dict: + return await self._achat_completion(messages, timeout=timeout) - async def _achat_completion_stream(self, messages: list[dict]) -> str: + async def _achat_completion_stream(self, messages: list[dict], timeout=3) -> str: response = await self.llm.asse_invoke(**self._const_kwargs(messages)) collected_content = [] usage = {} @@ -129,7 +131,7 @@ class ZhiPuAIGPTAPI(BaseGPTAPI): retry=retry_if_exception_type(ConnectionError), retry_error_callback=log_and_reraise, ) - async def acompletion_text(self, messages: list[dict], stream=False) -> str: + async def acompletion_text(self, messages: list[dict], stream=False, generator: bool = False, timeout=3) -> str: """response in async with stream or non-stream mode""" if stream: return await self._achat_completion_stream(messages) diff --git a/metagpt/repo_parser.py b/metagpt/repo_parser.py index 3524a5bce..9f3a1bac4 100644 --- a/metagpt/repo_parser.py +++ b/metagpt/repo_parser.py @@ -5,19 +5,49 @@ @Author : alexanderwu @File : repo_parser.py """ +from __future__ import annotations + import ast import json +import re +import subprocess from pathlib import Path from pprint import pformat +from typing import Dict, List, Optional, Tuple +import aiofiles import pandas as pd from pydantic import BaseModel, Field from metagpt.config import CONFIG from metagpt.logs import logger +from metagpt.utils.common import any_to_str from metagpt.utils.exceptions import handle_exception +class RepoFileInfo(BaseModel): + file: str + classes: List = Field(default_factory=list) + functions: List = Field(default_factory=list) + globals: List = Field(default_factory=list) + page_info: List = Field(default_factory=list) + + +class CodeBlockInfo(BaseModel): + lineno: int + end_lineno: int + type_name: str + tokens: List = Field(default_factory=list) + properties: Dict = Field(default_factory=dict) + + +class ClassInfo(BaseModel): + name: str + package: Optional[str] = None + attributes: Dict[str, str] = Field(default_factory=dict) + methods: Dict[str, str] = Field(default_factory=dict) + + class RepoParser(BaseModel): base_directory: Path = Field(default=None) @@ -27,31 +57,32 @@ class RepoParser(BaseModel): """Parse a Python file in the repository.""" return ast.parse(file_path.read_text()).body - def extract_class_and_function_info(self, tree, file_path): + def extract_class_and_function_info(self, tree, file_path) -> RepoFileInfo: """Extract class, function, and global variable information from the AST.""" - file_info = { - "file": str(file_path.relative_to(self.base_directory)), - "classes": [], - "functions": [], - "globals": [], - } - + file_info = RepoFileInfo(file=str(file_path.relative_to(self.base_directory))) for node in tree: + info = RepoParser.node_to_str(node) + file_info.page_info.append(info) if isinstance(node, ast.ClassDef): class_methods = [m.name for m in node.body if is_func(m)] - file_info["classes"].append({"name": node.name, "methods": class_methods}) + file_info.classes.append({"name": node.name, "methods": class_methods}) elif is_func(node): - file_info["functions"].append(node.name) + file_info.functions.append(node.name) elif isinstance(node, (ast.Assign, ast.AnnAssign)): for target in node.targets if isinstance(node, ast.Assign) else [node.target]: if isinstance(target, ast.Name): - file_info["globals"].append(target.id) + file_info.globals.append(target.id) return file_info - def generate_symbols(self): + def generate_symbols(self) -> List[RepoFileInfo]: files_classes = [] directory = self.base_directory - for path in directory.rglob("*.py"): + + matching_files = [] + extensions = ["*.py", "*.js"] + for ext in extensions: + matching_files += directory.rglob(ext) + for path in matching_files: tree = self._parse_file(path) file_info = self.extract_class_and_function_info(tree, path) files_classes.append(file_info) @@ -79,6 +110,215 @@ class RepoParser(BaseModel): elif mode == "csv": self.generate_dataframe_structure(output_path) + @staticmethod + def node_to_str(node) -> (int, int, str, str | Tuple): + if any_to_str(node) == any_to_str(ast.Expr): + return CodeBlockInfo( + lineno=node.lineno, + end_lineno=node.end_lineno, + type_name=any_to_str(node), + tokens=RepoParser._parse_expr(node), + ) + mappings = { + any_to_str(ast.Import): lambda x: [RepoParser._parse_name(n) for n in x.names], + any_to_str(ast.Assign): RepoParser._parse_assign, + any_to_str(ast.ClassDef): lambda x: x.name, + any_to_str(ast.FunctionDef): lambda x: x.name, + any_to_str(ast.ImportFrom): lambda x: { + "module": x.module, + "names": [RepoParser._parse_name(n) for n in x.names], + }, + any_to_str(ast.If): RepoParser._parse_if, + any_to_str(ast.AsyncFunctionDef): lambda x: x.name, + } + func = mappings.get(any_to_str(node)) + if func: + code_block = CodeBlockInfo(lineno=node.lineno, end_lineno=node.end_lineno, type_name=any_to_str(node)) + val = func(node) + if isinstance(val, dict): + code_block.properties = val + elif isinstance(val, list): + code_block.tokens = val + elif isinstance(val, str): + code_block.tokens = [val] + else: + raise NotImplementedError(f"Not implement:{val}") + return code_block + raise NotImplementedError(f"Not implement code block:{node.lineno}, {node.end_lineno}, {any_to_str(node)}") + + @staticmethod + def _parse_expr(node) -> List: + funcs = { + any_to_str(ast.Constant): lambda x: [any_to_str(x.value), RepoParser._parse_variable(x.value)], + any_to_str(ast.Call): lambda x: [any_to_str(x.value), RepoParser._parse_variable(x.value.func)], + } + func = funcs.get(any_to_str(node.value)) + if func: + return func(node) + raise NotImplementedError(f"Not implement: {node.value}") + + @staticmethod + def _parse_name(n): + if n.asname: + return f"{n.name} as {n.asname}" + return n.name + + @staticmethod + def _parse_if(n): + tokens = [RepoParser._parse_variable(n.test.left)] + for item in n.test.comparators: + tokens.append(RepoParser._parse_variable(item)) + return tokens + + @staticmethod + def _parse_variable(node): + funcs = { + any_to_str(ast.Constant): lambda x: x.value, + any_to_str(ast.Name): lambda x: x.id, + any_to_str(ast.Attribute): lambda x: f"{x.value.id}.{x.attr}", + } + func = funcs.get(any_to_str(node)) + if not func: + raise NotImplementedError(f"Not implement:{node}") + return func(node) + + @staticmethod + def _parse_assign(node): + return [RepoParser._parse_variable(t) for t in node.targets] + + async def rebuild_class_views(self, path: str | Path = None): + if not path: + path = self.base_directory + path = Path(path) + if not path.exists(): + return + command = f"pyreverse {str(path)} -o dot" + result = subprocess.run(command, shell=True, check=True, cwd=str(path)) + if result.returncode != 0: + raise ValueError(f"{result}") + class_view_pathname = path / "classes.dot" + class_views = await self._parse_classes(class_view_pathname) + packages_pathname = path / "packages.dot" + class_views = RepoParser._repair_namespaces(class_views=class_views, path=path) + class_view_pathname.unlink(missing_ok=True) + packages_pathname.unlink(missing_ok=True) + return class_views + + async def _parse_classes(self, class_view_pathname): + class_views = [] + if not class_view_pathname.exists(): + return class_views + async with aiofiles.open(str(class_view_pathname), mode="r") as reader: + lines = await reader.readlines() + for line in lines: + package_name, info = RepoParser._split_class_line(line) + if not package_name: + continue + class_name, members, functions = re.split(r"(?" + if begin_flag not in left or end_flag not in left: + return None, None + bix = left.find(begin_flag) + eix = left.rfind(end_flag) + info = left[bix + len(begin_flag) : eix] + info = re.sub(r"]*>", "\n", info) + return class_name, info + + @staticmethod + def _create_path_mapping(path: str | Path) -> Dict[str, str]: + mappings = { + str(path).replace("/", "."): str(path), + } + files = [] + try: + directory_path = Path(path) + if not directory_path.exists(): + return mappings + for file_path in directory_path.iterdir(): + if file_path.is_file(): + files.append(str(file_path)) + else: + subfolder_files = RepoParser._create_path_mapping(path=file_path) + mappings.update(subfolder_files) + except Exception as e: + logger.error(f"Error: {e}") + for f in files: + mappings[str(Path(f).with_suffix("")).replace("/", ".")] = str(f) + + return mappings + + @staticmethod + def _repair_namespaces(class_views: List[ClassInfo], path: str | Path) -> List[ClassInfo]: + if not class_views: + return [] + c = class_views[0] + full_key = str(path).lstrip("/").replace("/", ".") + root_namespace = RepoParser._find_root(full_key, c.package) + root_path = root_namespace.replace(".", "/") + + mappings = RepoParser._create_path_mapping(path=path) + new_mappings = {} + ix_root_namespace = len(root_namespace) + ix_root_path = len(root_path) + for k, v in mappings.items(): + nk = k[ix_root_namespace:] + nv = v[ix_root_path:] + new_mappings[nk] = nv + + for c in class_views: + c.package = RepoParser._repair_ns(c.package, new_mappings) + return class_views + + @staticmethod + def _repair_ns(package, mappings): + file_ns = package + while file_ns != "": + if file_ns not in mappings: + ix = file_ns.rfind(".") + file_ns = file_ns[0:ix] + continue + break + internal_ns = package[ix + 1 :] + ns = mappings[file_ns] + ":" + internal_ns.replace(".", ":") + return ns + + @staticmethod + def _find_root(full_key, package) -> str: + left = full_key + while left != "": + if left in package: + break + if "." not in left: + break + ix = left.find(".") + left = left[ix + 1 :] + ix = full_key.rfind(left) + return "." + full_key[0:ix] + def is_func(node): return isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)) diff --git a/metagpt/roles/assistant.py b/metagpt/roles/assistant.py new file mode 100644 index 000000000..00a576089 --- /dev/null +++ b/metagpt/roles/assistant.py @@ -0,0 +1,143 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +@Time : 2023/8/7 +@Author : mashenquan +@File : assistant.py +@Desc : I am attempting to incorporate certain symbol concepts from UML into MetaGPT, enabling it to have the + ability to freely construct flows through symbol concatenation. Simultaneously, I am also striving to + make these symbols configurable and standardized, making the process of building flows more convenient. + For more about `fork` node in activity diagrams, see: `https://www.uml-diagrams.org/activity-diagrams.html` + This file defines a `fork` style meta role capable of generating arbitrary roles at runtime based on a + configuration file. +@Modified By: mashenquan, 2023/8/22. A definition has been provided for the return value of _think: returning false + indicates that further reasoning cannot continue. + +""" +from enum import Enum +from pathlib import Path +from typing import Optional + +from pydantic import Field + +from metagpt.actions.skill_action import ArgumentsParingAction, SkillAction +from metagpt.actions.talk_action import TalkAction +from metagpt.config import CONFIG +from metagpt.learn.skill_loader import SkillsDeclaration +from metagpt.logs import logger +from metagpt.memory.brain_memory import BrainMemory +from metagpt.roles import Role +from metagpt.schema import Message + + +class MessageType(Enum): + Talk = "TALK" + Skill = "SKILL" + + +class Assistant(Role): + """Assistant for solving common issues.""" + + name: str = "Lily" + profile: str = "An assistant" + goal: str = "Help to solve problem" + constraints: str = "Talk in {language}" + desc: str = "" + memory: BrainMemory = Field(default_factory=BrainMemory) + skills: Optional[SkillsDeclaration] = None + + def __init__(self, **kwargs): + super().__init__(**kwargs) + self.constraints = self.constraints.format(language=kwargs.get("language") or CONFIG.language or "Chinese") + + async def think(self) -> bool: + """Everything will be done part by part.""" + last_talk = await self.refine_memory() + if not last_talk: + return False + if not self.skills: + skill_path = Path(CONFIG.SKILL_PATH) if CONFIG.SKILL_PATH else None + self.skills = await SkillsDeclaration.load(skill_yaml_file_name=skill_path) + + prompt = "" + skills = self.skills.get_skill_list() + for desc, name in skills.items(): + prompt += f"If the text explicitly want you to {desc}, return `[SKILL]: {name}` brief and clear. For instance: [SKILL]: {name}\n" + prompt += 'Otherwise, return `[TALK]: {talk}` brief and clear. For instance: if {talk} is "xxxx" return [TALK]: xxxx\n\n' + prompt += f"Now what specific action is explicitly mentioned in the text: {last_talk}\n" + rsp = await self._llm.aask(prompt, []) + logger.info(f"THINK: {prompt}\n, THINK RESULT: {rsp}\n") + return await self._plan(rsp, last_talk=last_talk) + + async def act(self) -> Message: + result = await self._rc.todo.run() + if not result: + return None + if isinstance(result, str): + msg = Message(content=result, role="assistant", cause_by=self._rc.todo) + elif isinstance(result, Message): + msg = result + else: + msg = Message( + content=result.content, instruct_content=result.instruct_content, cause_by=type(self._rc.todo) + ) + self.memory.add_answer(msg) + return msg + + async def talk(self, text): + self.memory.add_talk(Message(content=text)) + + async def _plan(self, rsp: str, **kwargs) -> bool: + skill, text = BrainMemory.extract_info(input_string=rsp) + handlers = { + MessageType.Talk.value: self.talk_handler, + MessageType.Skill.value: self.skill_handler, + } + handler = handlers.get(skill, self.talk_handler) + return await handler(text, **kwargs) + + async def talk_handler(self, text, **kwargs) -> bool: + history = self.memory.history_text + text = kwargs.get("last_talk") or text + self._rc.todo = TalkAction( + context=text, knowledge=self.memory.get_knowledge(), history_summary=history, llm=self._llm, **kwargs + ) + return True + + async def skill_handler(self, text, **kwargs) -> bool: + last_talk = kwargs.get("last_talk") + skill = self.skills.get_skill(text) + if not skill: + logger.info(f"skill not found: {text}") + return await self.talk_handler(text=last_talk, **kwargs) + action = ArgumentsParingAction(skill=skill, llm=self._llm, ask=last_talk, **kwargs) + await action.run(**kwargs) + if action.args is None: + return await self.talk_handler(text=last_talk, **kwargs) + self._rc.todo = SkillAction( + skill=skill, args=action.args, llm=self._llm, name=skill.name, desc=skill.description + ) + return True + + async def refine_memory(self) -> str: + last_talk = self.memory.pop_last_talk() + if last_talk is None: # No user feedback, unsure if past conversation is finished. + return None + if not self.memory.is_history_available: + return last_talk + history_summary = await self.memory.summarize(max_words=800, keep_language=True, llm=self._llm) + if last_talk and await self.memory.is_related(text1=last_talk, text2=history_summary, llm=self._llm): + # Merge relevant content. + merged = await self.memory.rewrite(sentence=last_talk, context=history_summary, llm=self._llm) + return f"{merged} {last_talk}" + + return last_talk + + def get_memory(self) -> str: + return self.memory.json() + + def load_memory(self, jsn): + try: + self.memory = BrainMemory(**jsn) + except Exception as e: + logger.exception(f"load error:{e}, data:{jsn}") diff --git a/metagpt/roles/engineer.py b/metagpt/roles/engineer.py index e0234f378..76c3d96b3 100644 --- a/metagpt/roles/engineer.py +++ b/metagpt/roles/engineer.py @@ -43,7 +43,7 @@ from metagpt.schema import ( Documents, Message, ) -from metagpt.utils.common import any_to_str, any_to_str_set +from metagpt.utils.common import any_to_name, any_to_str, any_to_str_set IS_PASS_PROMPT = """ {context} @@ -78,13 +78,17 @@ class Engineer(Role): n_borg: int = 1 use_code_review: bool = False code_todos: list = [] - summarize_todos = [] + summarize_todos: list = [] + next_todo_action: str = "" def __init__(self, **kwargs) -> None: super().__init__(**kwargs) self._init_actions([WriteCode]) self._watch([WriteTasks, SummarizeCode, WriteCode, WriteCodeReview, FixBug]) + self.code_todos = [] + self.summarize_todos = [] + self.next_todo_action = any_to_name(WriteCode) @staticmethod def _parse_tasks(task_msg: Document) -> list[str]: @@ -128,8 +132,10 @@ class Engineer(Role): if self._rc.todo is None: return None if isinstance(self._rc.todo, WriteCode): + self.next_todo_action = any_to_name(SummarizeCode) return await self._act_write_code() if isinstance(self._rc.todo, SummarizeCode): + self.next_todo_action = any_to_name(WriteCode) return await self._act_summarize() return None @@ -301,3 +307,8 @@ class Engineer(Role): self.summarize_todos.append(SummarizeCode(context=ctx, llm=self._llm)) if self.summarize_todos: self._rc.todo = self.summarize_todos[0] + + @property + def todo(self) -> str: + """AgentStore uses this attribute to display to the user what actions the current role should take.""" + return self.next_todo_action diff --git a/metagpt/roles/product_manager.py b/metagpt/roles/product_manager.py index c794ad2eb..5412dc2b5 100644 --- a/metagpt/roles/product_manager.py +++ b/metagpt/roles/product_manager.py @@ -7,11 +7,11 @@ @Modified By: mashenquan, 2023/11/27. Add `PrepareDocuments` action according to Section 2.2.3.5.1 of RFC 135. """ - from metagpt.actions import UserRequirement, WritePRD from metagpt.actions.prepare_documents import PrepareDocuments from metagpt.config import CONFIG from metagpt.roles.role import Role +from metagpt.utils.common import any_to_name class ProductManager(Role): @@ -29,20 +29,28 @@ class ProductManager(Role): profile: str = "Product Manager" goal: str = "efficiently create a successful product that meets market demands and user expectations" constraints: str = "utilize the same language as the user requirements for seamless communication" + todo_action: str = "" def __init__(self, **kwargs) -> None: super().__init__(**kwargs) self._init_actions([PrepareDocuments, WritePRD]) self._watch([UserRequirement, PrepareDocuments]) + self.todo_action = any_to_name(PrepareDocuments) - async def _think(self) -> None: + async def _think(self) -> bool: """Decide what to do""" if CONFIG.git_repo: self._set_state(1) else: self._set_state(0) - return self._rc.todo + self.todo_action = any_to_name(WritePRD) + return bool(self._rc.todo) async def _observe(self, ignore_memory=False) -> int: return await super()._observe(ignore_memory=True) + + @property + def todo(self) -> str: + """AgentStore uses this attribute to display to the user what actions the current role should take.""" + return self.todo_action diff --git a/metagpt/roles/researcher.py b/metagpt/roles/researcher.py index 27f046878..f981d72a7 100644 --- a/metagpt/roles/researcher.py +++ b/metagpt/roles/researcher.py @@ -1,5 +1,6 @@ #!/usr/bin/env python """ +@Modified By: mashenquan, 2023/8/22. A definition has been provided for the return value of _think: returning false indicates that further reasoning cannot continue. @Modified By: mashenquan, 2023-11-1. According to Chapter 2.2.1 and 2.2.2 of RFC 116, change the data type of the `cause_by` value in the `Message` to a string to support the new message distribution feature. """ @@ -39,6 +40,17 @@ class Researcher(Role): if self.language not in ("en-us", "zh-cn"): logger.warning(f"The language `{self.language}` has not been tested, it may not work.") + async def _think(self) -> bool: + if self._rc.todo is None: + self._set_state(0) + return True + + if self._rc.state + 1 < len(self._states): + self._set_state(self._rc.state + 1) + else: + self._rc.todo = None + return False + async def _act(self) -> Message: logger.info(f"{self._setting}: to do {self._rc.todo}({self._rc.todo.name})") todo = self._rc.todo diff --git a/metagpt/roles/role.py b/metagpt/roles/role.py index fe61b9878..3e5f268f8 100644 --- a/metagpt/roles/role.py +++ b/metagpt/roles/role.py @@ -4,6 +4,7 @@ @Time : 2023/5/11 14:42 @Author : alexanderwu @File : role.py +@Modified By: mashenquan, 2023/8/22. A definition has been provided for the return value of _think: returning false indicates that further reasoning cannot continue. @Modified By: mashenquan, 2023-11-1. According to Chapter 2.2.1 and 2.2.2 of RFC 116: 1. Merge the `recv` functionality into the `_observe` function. Future message reading operations will be consolidated within the `_observe` function. @@ -38,6 +39,7 @@ from metagpt.memory import Memory from metagpt.provider.base_gpt_api import BaseGPTAPI from metagpt.schema import Message, MessageQueue from metagpt.utils.common import ( + any_to_name, any_to_str, import_class, read_json_file, @@ -118,7 +120,7 @@ class RoleContext(BaseModel): @property def important_memory(self) -> list[Message]: - """Get the information corresponding to the watched actions""" + """Retrieve information corresponding to the attention action.""" return self.memory.get_by_actions(self.watch) @property @@ -317,6 +319,9 @@ class Role(BaseModel): # check RoleContext after adding watch actions self._rc.check(self._role_id) + def is_watch(self, caused_by: str): + return caused_by in self._rc.watch + def subscribe(self, tags: Set[str]): """Used to receive Messages with certain tags from the environment. Message will be put into personal message buffer to be further processed in _observe. By default, a Role subscribes Messages with a tag of its own name @@ -340,6 +345,11 @@ class Role(BaseModel): env.set_subscription(self, self.subscription) self.refresh_system_message() # add env message to system message + @property + def action_count(self): + """Return number of action""" + return len(self._actions) + def _get_prefix(self): """Get the role prefix""" if self.desc: @@ -356,16 +366,18 @@ class Role(BaseModel): prefix += env_desc return prefix - async def _think(self) -> None: - """Think about what to do and decide on the next action""" + async def _think(self) -> bool: + """Consider what to do and decide on the next course of action. Return false if nothing can be done.""" if len(self._actions) == 1: # If there is only one action, then only this one can be performed self._set_state(0) - return + + return True + if self.recovered and self._rc.state >= 0: self._set_state(self._rc.state) # action to run from recovered state - self.recovered = False # avoid max_react_loop out of work - return + self.set_recovered(False) # avoid max_react_loop out of work + return True prompt = self._get_prefix() prompt += STATE_TEMPLATE.format( @@ -387,6 +399,7 @@ class Role(BaseModel): if next_state == -1: logger.info(f"End actions with {next_state=}") self._set_state(next_state) + return True async def _act(self) -> Message: logger.info(f"{self._setting}: to do {self._rc.todo}({self._rc.todo.name})") @@ -420,17 +433,17 @@ class Role(BaseModel): async def _observe(self, ignore_memory=False) -> int: """Prepare new messages for processing from the message buffer and other sources.""" # Read unprocessed messages from the msg buffer. - news = self._rc.msg_buffer.pop_all() + news = [] if self.recovered: news = [self.latest_observed_msg] if self.latest_observed_msg else [] - else: - self.latest_observed_msg = news[-1] if len(news) > 0 else None # record the latest observed msg - + if not news: + news = self._rc.msg_buffer.pop_all() # Store the read messages in your own memory to prevent duplicate processing. old_messages = [] if ignore_memory else self._rc.memory.get() self._rc.memory.add_batch(news) # Filter out messages of interest. - self._rc.news = self._find_news(news, old_messages) + self._rc.news = [n for n in news if n.cause_by in self._rc.watch and n not in old_messages] + self.latest_observed_msg = self._rc.news[-1] if self._rc.news else None # record the latest observed msg # Design Rules: # If you need to further categorize Message objects, you can do so using the Message.set_meta function. @@ -440,6 +453,29 @@ class Role(BaseModel): logger.debug(f"{self._setting} observed: {news_text}") return len(self._rc.news) + # async def _observe(self, ignore_memory=False) -> int: + # """Prepare new messages for processing from the message buffer and other sources.""" + # # Read unprocessed messages from the msg buffer. + # news = self._rc.msg_buffer.pop_all() + # if self.recovered: + # news = [self.latest_observed_msg] if self.latest_observed_msg else [] + # else: + # self.latest_observed_msg = news[-1] if len(news) > 0 else None # record the latest observed msg + # + # # Store the read messages in your own memory to prevent duplicate processing. + # old_messages = [] if ignore_memory else self._rc.memory.get() + # self._rc.memory.add_batch(news) + # # Filter out messages of interest. + # self._rc.news = self._find_news(news, old_messages) + # + # # Design Rules: + # # If you need to further categorize Message objects, you can do so using the Message.set_meta function. + # # msg_buffer is a receiving buffer, avoid adding message data and operations to msg_buffer. + # news_text = [f"{i.role}: {i.content[:20]}..." for i in self._rc.news] + # if news_text: + # logger.debug(f"{self._setting} observed: {news_text}") + # return len(self._rc.news) + def publish_message(self, msg): """If the role belongs to env, then the role's messages will be broadcast to env""" if not msg: @@ -498,23 +534,6 @@ class Role(BaseModel): self._set_state(state=-1) # current reaction is complete, reset state to -1 and todo back to None return rsp - # # Replaced by run() - # def recv(self, message: Message) -> None: - # """add message to history.""" - # # self._history += f"\n{message}" - # # self._context = self._history - # if message in self._rc.memory.get(): - # return - # self._rc.memory.add(message) - - # # Replaced by run() - # async def handle(self, message: Message) -> Message: - # """Receive information and reply with actions""" - # # logger.debug(f"{self.name=}, {self.profile=}, {message.role=}") - # self.recv(message) - # - # return await self._react() - def get_memories(self, k=0) -> list[Message]: """A wrapper to return the most recent k memories of this role, return all when k=0""" return self._rc.memory.get(k=k) @@ -551,3 +570,20 @@ class Role(BaseModel): def is_idle(self) -> bool: """If true, all actions have been executed.""" return not self._rc.news and not self._rc.todo and self._rc.msg_buffer.empty() + + async def think(self) -> Action: + """The exported `think` function""" + await self._think() + return self._rc.todo + + async def act(self) -> ActionOutput: + """The exported `act` function""" + msg = await self._act() + return ActionOutput(content=msg.content, instruct_content=msg.instruct_content) + + @property + def todo(self) -> str: + """AgentStore uses this attribute to display to the user what actions the current role should take.""" + if self._actions: + return any_to_name(self._actions[0]) + return "" diff --git a/metagpt/roles/sales.py b/metagpt/roles/sales.py index 1ef93f6f3..73075f276 100644 --- a/metagpt/roles/sales.py +++ b/metagpt/roles/sales.py @@ -15,14 +15,15 @@ from metagpt.tools import SearchEngineType class Sales(Role): - name: str = "Xiaomei" - profile: str = "Retail sales guide" - desc: str = "I am a sales guide in retail. My name is Xiaomei. I will answer some customer questions next, and I " - "will answer questions only based on the information in the knowledge base." - "If I feel that you can't get the answer from the reference material, then I will directly reply that" - " I don't know, and I won't tell you that this is from the knowledge base," - "but pretend to be what I know. Note that each of my replies will be replied in the tone of a " - "professional guide" + name: str = "John Smith" + profile: str = "Retail Sales Guide" + desc: str = ( + "As a Retail Sales Guide, my name is John Smith. I specialize in addressing customer inquiries with " + "expertise and precision. My responses are based solely on the information available in our knowledge" + " base. In instances where your query extends beyond this scope, I'll honestly indicate my inability " + "to provide an answer, rather than speculate or assume. Please note, each of my replies will be " + "delivered with the professionalism and courtesy expected of a seasoned sales guide." + ) store: Optional[BaseStore] = None diff --git a/metagpt/roles/teacher.py b/metagpt/roles/teacher.py new file mode 100644 index 000000000..3f70200ea --- /dev/null +++ b/metagpt/roles/teacher.py @@ -0,0 +1,118 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +@Time : 2023/7/27 +@Author : mashenquan +@File : teacher.py +@Desc : Used by Agent Store +@Modified By: mashenquan, 2023/8/22. A definition has been provided for the return value of _think: returning false indicates that further reasoning cannot continue. + +""" + +import re + +import aiofiles + +from metagpt.actions import UserRequirement +from metagpt.actions.write_teaching_plan import TeachingPlanBlock, WriteTeachingPlanPart +from metagpt.config import CONFIG +from metagpt.logs import logger +from metagpt.roles import Role +from metagpt.schema import Message +from metagpt.utils.common import any_to_str + + +class Teacher(Role): + """Support configurable teacher roles, + with native and teaching languages being replaceable through configurations.""" + + name: str = "Lily" + profile: str = "{teaching_language} Teacher" + goal: str = "writing a {language} teaching plan part by part" + constraints: str = "writing in {language}" + desc: str = "" + + def __init__(self, **kwargs): + super().__init__(**kwargs) + self.name = WriteTeachingPlanPart.format_value(self.name) + self.profile = WriteTeachingPlanPart.format_value(self.profile) + self.goal = WriteTeachingPlanPart.format_value(self.goal) + self.constraints = WriteTeachingPlanPart.format_value(self.constraints) + self.desc = WriteTeachingPlanPart.format_value(self.desc) + + async def _think(self) -> bool: + """Everything will be done part by part.""" + if not self._actions: + if not self._rc.news or self._rc.news[0].cause_by != any_to_str(UserRequirement): + raise ValueError("Lesson content invalid.") + actions = [] + print(TeachingPlanBlock.TOPICS) + for topic in TeachingPlanBlock.TOPICS: + act = WriteTeachingPlanPart(context=self._rc.news[0].content, topic=topic, llm=self._llm) + actions.append(act) + self._init_actions(actions) + + if self._rc.todo is None: + self._set_state(0) + return True + + if self._rc.state + 1 < len(self._states): + self._set_state(self._rc.state + 1) + return True + + self._rc.todo = None + return False + + async def _react(self) -> Message: + ret = Message(content="") + while True: + await self._think() + if self._rc.todo is None: + break + logger.debug(f"{self._setting}: {self._rc.state=}, will do {self._rc.todo}") + msg = await self._act() + if ret.content != "": + ret.content += "\n\n\n" + ret.content += msg.content + logger.info(ret.content) + await self.save(ret.content) + return ret + + async def save(self, content): + """Save teaching plan""" + filename = Teacher.new_file_name(self.course_title) + pathname = CONFIG.workspace_path / "teaching_plan" + pathname.mkdir(exist_ok=True) + pathname = pathname / filename + try: + async with aiofiles.open(str(pathname), mode="w", encoding="utf-8") as writer: + await writer.write(content) + except Exception as e: + logger.error(f"Save failed：{e}") + logger.info(f"Save to:{pathname}") + + @staticmethod + def new_file_name(lesson_title, ext=".md"): + """Create a related file name based on `lesson_title` and `ext`.""" + # Define the special characters that need to be replaced. + illegal_chars = r'[#@$%!*&\\/:*?"<>|\n\t \']' + # Replace the special characters with underscores. + filename = re.sub(illegal_chars, "_", lesson_title) + ext + return re.sub(r"_+", "_", filename) + + @property + def course_title(self): + """Return course title of teaching plan""" + default_title = "teaching_plan" + for act in self._actions: + if act.topic != TeachingPlanBlock.COURSE_TITLE: + continue + if act.rsp is None: + return default_title + title = act.rsp.lstrip("# \n") + if "\n" in title: + ix = title.index("\n") + title = title[0:ix] + return title + + return default_title diff --git a/metagpt/schema.py b/metagpt/schema.py index 51921763d..c60247aa1 100644 --- a/metagpt/schema.py +++ b/metagpt/schema.py @@ -23,7 +23,7 @@ from abc import ABC from asyncio import Queue, QueueEmpty, wait_for from json import JSONDecodeError from pathlib import Path -from typing import Any, Dict, List, Optional, Set, Type, TypedDict, TypeVar +from typing import Any, Dict, List, Optional, Set, Type, TypeVar from pydantic import BaseModel, Field @@ -46,7 +46,7 @@ from metagpt.utils.serialize import ( ) -class RawMessage(TypedDict): +class SimpleMessage(BaseModel): content: str role: str @@ -162,8 +162,7 @@ class Message(BaseModel): # prefix = '-'.join([self.role, str(self.cause_by)]) if self.instruct_content: return f"{self.role}: {self.instruct_content.dict()}" - else: - return f"{self.role}: {self.content}" + return f"{self.role}: {self.content}" def __repr__(self): return self.__str__() @@ -180,8 +179,19 @@ class Message(BaseModel): @handle_exception(exception_type=JSONDecodeError, default_return=None) def load(val): """Convert the json string to object.""" - i = json.loads(val) - return Message(**i) + + try: + m = json.loads(val) + id = m.get("id") + if "id" in m: + del m["id"] + msg = Message(**m) + if id: + msg.id = id + return msg + except JSONDecodeError as err: + logger.error(f"parse json failed: {val}, error:{err}") + return None class UserMessage(Message): diff --git a/metagpt/team.py b/metagpt/team.py index 879da0aca..fd9af9045 100644 --- a/metagpt/team.py +++ b/metagpt/team.py @@ -90,9 +90,12 @@ class Team(BaseModel): CONFIG.max_budget = investment logger.info(f"Investment: ${investment}.") - def _check_balance(self): - if CONFIG.total_cost > CONFIG.max_budget: - raise NoMoneyException(CONFIG.total_cost, f"Insufficient funds: {CONFIG.max_budget}") + @staticmethod + def _check_balance(): + if CONFIG.cost_manager.total_cost > CONFIG.cost_manager.max_budget: + raise NoMoneyException( + CONFIG.cost_manager.total_cost, f"Insufficient funds: {CONFIG.cost_manager.max_budget}" + ) def run_project(self, idea, send_to: str = ""): """Run a project from publishing user requirement.""" @@ -100,7 +103,8 @@ class Team(BaseModel): # Human requirement. self.env.publish_message( - Message(role="Human", content=idea, cause_by=UserRequirement, send_to=send_to or MESSAGE_ROUTE_TO_ALL) + Message(role="Human", content=idea, cause_by=UserRequirement, send_to=send_to or MESSAGE_ROUTE_TO_ALL), + peekable=False, ) def start_project(self, idea, send_to: str = ""): @@ -120,7 +124,7 @@ class Team(BaseModel): logger.info(self.json(ensure_ascii=False)) @serialize_decorator - async def run(self, n_round=3, idea="", send_to=""): + async def run(self, n_round=3, idea="", send_to="", auto_archive=True): """Run company until target round or no money""" if idea: self.run_project(idea=idea, send_to=send_to) @@ -132,6 +136,5 @@ class Team(BaseModel): self._check_balance() await self.env.run() - if CONFIG.git_repo: - CONFIG.git_repo.archive() + self.env.archive(auto_archive) return self.env.history diff --git a/metagpt/tools/__init__.py b/metagpt/tools/__init__.py index d98087e4b..aab8c990c 100644 --- a/metagpt/tools/__init__.py +++ b/metagpt/tools/__init__.py @@ -22,3 +22,8 @@ class WebBrowserEngineType(Enum): PLAYWRIGHT = "playwright" SELENIUM = "selenium" CUSTOM = "custom" + + @classmethod + def __missing__(cls, key): + """Default type conversion""" + return cls.CUSTOM diff --git a/metagpt/tools/azure_tts.py b/metagpt/tools/azure_tts.py index e59d98016..8fdb10c13 100644 --- a/metagpt/tools/azure_tts.py +++ b/metagpt/tools/azure_tts.py @@ -4,39 +4,110 @@ @Time : 2023/6/9 22:22 @Author : Leo Xiao @File : azure_tts.py +@Modified by: mashenquan, 2023/8/17. Azure TTS OAS3 api, which provides text-to-speech functionality """ +import asyncio +import base64 +from pathlib import Path +from uuid import uuid4 + +import aiofiles from azure.cognitiveservices.speech import AudioConfig, SpeechConfig, SpeechSynthesizer -from metagpt.config import CONFIG +from metagpt.config import CONFIG, Config +from metagpt.logs import logger class AzureTTS: - """https://learn.microsoft.com/zh-cn/azure/cognitive-services/speech-service/language-support?tabs=tts#voice-styles-and-roles""" + """Azure Text-to-Speech""" - @classmethod - def synthesize_speech(cls, lang, voice, role, text, output_file): - subscription_key = CONFIG.get("AZURE_TTS_SUBSCRIPTION_KEY") - region = CONFIG.get("AZURE_TTS_REGION") - speech_config = SpeechConfig(subscription=subscription_key, region=region) + def __init__(self, subscription_key, region): + """ + :param subscription_key: key is used to access your Azure AI service API, see: `https://portal.azure.com/` > `Resource Management` > `Keys and Endpoint` + :param region: This is the location (or region) of your resource. You may need to use this field when making calls to this API. + """ + self.subscription_key = subscription_key if subscription_key else CONFIG.AZURE_TTS_SUBSCRIPTION_KEY + self.region = region if region else CONFIG.AZURE_TTS_REGION + # 参数参考：https://learn.microsoft.com/zh-cn/azure/cognitive-services/speech-service/language-support?tabs=tts#voice-styles-and-roles + async def synthesize_speech(self, lang, voice, text, output_file): + speech_config = SpeechConfig(subscription=self.subscription_key, region=self.region) speech_config.speech_synthesis_voice_name = voice audio_config = AudioConfig(filename=output_file) synthesizer = SpeechSynthesizer(speech_config=speech_config, audio_config=audio_config) - # if voice=="zh-CN-YunxiNeural": - ssml_string = f""" - - - - {text} - - - - """ + # More detail: https://learn.microsoft.com/en-us/azure/ai-services/speech-service/speech-synthesis-markup-voice + ssml_string = ( + "" + f"{text}" + ) - synthesizer.speak_ssml_async(ssml_string).get() + return synthesizer.speak_ssml_async(ssml_string).get() + + @staticmethod + def role_style_text(role, style, text): + return f'{text}' + + @staticmethod + def role_text(role, text): + return f'{text}' + + @staticmethod + def style_text(style, text): + return f'{text}' + + +# Export +async def oas3_azsure_tts(text, lang="", voice="", style="", role="", subscription_key="", region=""): + """Text to speech + For more details, check out:`https://learn.microsoft.com/en-us/azure/ai-services/speech-service/language-support?tabs=tts` + + :param lang: The value can contain a language code such as en (English), or a locale such as en-US (English - United States). For more details, checkout: `https://learn.microsoft.com/en-us/azure/ai-services/speech-service/language-support?tabs=tts` + :param voice: For more details, checkout: `https://learn.microsoft.com/en-us/azure/ai-services/speech-service/language-support?tabs=tts`, `https://speech.microsoft.com/portal/voicegallery` + :param style: Speaking style to express different emotions like cheerfulness, empathy, and calm. For more details, checkout: `https://learn.microsoft.com/en-us/azure/ai-services/speech-service/language-support?tabs=tts` + :param role: With roles, the same voice can act as a different age and gender. For more details, checkout: `https://learn.microsoft.com/en-us/azure/ai-services/speech-service/language-support?tabs=tts` + :param text: The text used for voice conversion. + :param subscription_key: key is used to access your Azure AI service API, see: `https://portal.azure.com/` > `Resource Management` > `Keys and Endpoint` + :param region: This is the location (or region) of your resource. You may need to use this field when making calls to this API. + :return: Returns the Base64-encoded .wav file data if successful, otherwise an empty string. + + """ + if not text: + return "" + + if not lang: + lang = "zh-CN" + if not voice: + voice = "zh-CN-XiaomoNeural" + if not role: + role = "Girl" + if not style: + style = "affectionate" + if not subscription_key: + subscription_key = CONFIG.AZURE_TTS_SUBSCRIPTION_KEY + if not region: + region = CONFIG.AZURE_TTS_REGION + + xml_value = AzureTTS.role_style_text(role=role, style=style, text=text) + tts = AzureTTS(subscription_key=subscription_key, region=region) + filename = Path(__file__).resolve().parent / (str(uuid4()).replace("-", "") + ".wav") + try: + await tts.synthesize_speech(lang=lang, voice=voice, text=xml_value, output_file=str(filename)) + async with aiofiles.open(filename, mode="rb") as reader: + data = await reader.read() + base64_string = base64.b64encode(data).decode("utf-8") + filename.unlink() + except Exception as e: + logger.error(f"text:{text}, error:{e}") + return "" + + return base64_string if __name__ == "__main__": - azure_tts = AzureTTS() - azure_tts.synthesize_speech("zh-CN", "zh-CN-YunxiNeural", "Boy", "Hello, I am Kaka", "output.wav") + Config() + loop = asyncio.new_event_loop() + v = loop.create_task(oas3_azsure_tts("测试，test")) + loop.run_until_complete(v) + print(v) diff --git a/metagpt/tools/hello.py b/metagpt/tools/hello.py new file mode 100644 index 000000000..8a21e1b4e --- /dev/null +++ b/metagpt/tools/hello.py @@ -0,0 +1,27 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +@Time : 2023/5/2 16:03 +@Author : mashenquan +@File : hello.py +@Desc : Implement the OpenAPI Specification 3.0 demo and use the following command to test the HTTP service: + + curl -X 'POST' \ + 'http://localhost:8080/openapi/greeting/dave' \ + -H 'accept: text/plain' \ + -H 'Content-Type: application/json' \ + -d '{}' +""" + +import connexion + + +# openapi implement +async def post_greeting(name: str) -> str: + return f"Hello {name}\n" + + +if __name__ == "__main__": + app = connexion.AioHttpApp(__name__, specification_dir="../../.well-known/") + app.add_api("openapi.yaml", arguments={"title": "Hello World Example"}) + app.run(port=8080) diff --git a/metagpt/tools/iflytek_tts.py b/metagpt/tools/iflytek_tts.py new file mode 100644 index 000000000..cb87d2e7f --- /dev/null +++ b/metagpt/tools/iflytek_tts.py @@ -0,0 +1,162 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +@Time : 2023/8/17 +@Author : mashenquan +@File : iflytek_tts.py +@Desc : iFLYTEK TTS OAS3 api, which provides text-to-speech functionality +""" +import asyncio +import base64 +import hashlib +import hmac +import json +import uuid +from datetime import datetime +from enum import Enum +from pathlib import Path +from time import mktime +from typing import Optional +from urllib.parse import urlencode +from wsgiref.handlers import format_date_time + +import aiofiles +import websockets as websockets +from pydantic import BaseModel + +from metagpt.config import CONFIG +from metagpt.logs import logger + + +class IFlyTekTTSStatus(Enum): + STATUS_FIRST_FRAME = 0 # The first frame + STATUS_CONTINUE_FRAME = 1 # The intermediate frame + STATUS_LAST_FRAME = 2 # The last frame + + +class AudioData(BaseModel): + audio: str + status: int + ced: str + + +class IFlyTekTTSResponse(BaseModel): + code: int + message: str + data: Optional[AudioData] = None + sid: str + + +DEFAULT_IFLYTEK_VOICE = "xiaoyan" + + +class IFlyTekTTS(object): + def __init__(self, app_id: str, api_key: str, api_secret: str): + """ + :param app_id: Application ID is used to access your iFlyTek service API, see: `https://console.xfyun.cn/services/tts` + :param api_key: WebAPI argument, see: `https://console.xfyun.cn/services/tts` + :param api_secret: WebAPI argument, see: `https://console.xfyun.cn/services/tts` + """ + self.app_id = app_id or CONFIG.IFLYTEK_APP_ID + self.api_key = api_key or CONFIG.IFLYTEK_API_KEY + self.api_secret = api_secret or CONFIG.API_SECRET + + async def synthesize_speech(self, text, output_file: str, voice=DEFAULT_IFLYTEK_VOICE): + url = self._create_url() + data = { + "common": {"app_id": self.app_id}, + "business": {"aue": "lame", "sfl": 1, "auf": "audio/L16;rate=16000", "vcn": voice, "tte": "utf8"}, + "data": {"status": 2, "text": str(base64.b64encode(text.encode("utf-8")), "UTF8")}, + } + req = json.dumps(data) + async with websockets.connect(url) as websocket: + # send request + await websocket.send(req) + + # receive frames + async with aiofiles.open(str(output_file), "w") as writer: + while True: + v = await websocket.recv() + rsp = IFlyTekTTSResponse(**json.loads(v)) + if rsp.data: + await writer.write(rsp.data.audio) + if rsp.data.status != IFlyTekTTSStatus.STATUS_LAST_FRAME.value: + continue + break + + def _create_url(self): + """Create request url""" + url = "wss://tts-api.xfyun.cn/v2/tts" + # Generate a timestamp in RFC1123 format + now = datetime.now() + date = format_date_time(mktime(now.timetuple())) + + signature_origin = "host: " + "ws-api.xfyun.cn" + "\n" + signature_origin += "date: " + date + "\n" + signature_origin += "GET " + "/v2/tts " + "HTTP/1.1" + # Perform HMAC-SHA256 encryption + signature_sha = hmac.new( + self.api_secret.encode("utf-8"), signature_origin.encode("utf-8"), digestmod=hashlib.sha256 + ).digest() + signature_sha = base64.b64encode(signature_sha).decode(encoding="utf-8") + + authorization_origin = 'api_key="%s", algorithm="%s", headers="%s", signature="%s"' % ( + self.api_key, + "hmac-sha256", + "host date request-line", + signature_sha, + ) + authorization = base64.b64encode(authorization_origin.encode("utf-8")).decode(encoding="utf-8") + # Combine the authentication parameters of the request into a dictionary. + v = {"authorization": authorization, "date": date, "host": "ws-api.xfyun.cn"} + # Concatenate the authentication parameters to generate the URL. + url = url + "?" + urlencode(v) + return url + + +# Export +async def oas3_iflytek_tts(text: str, voice: str = "", app_id: str = "", api_key: str = "", api_secret: str = ""): + """Text to speech + For more details, check out:`https://www.xfyun.cn/doc/tts/online_tts/API.html` + + :param voice: Default `xiaoyan`. For more details, checkout: `https://www.xfyun.cn/doc/tts/online_tts/API.html#%E6%8E%A5%E5%8F%A3%E8%B0%83%E7%94%A8%E6%B5%81%E7%A8%8B` + :param text: The text used for voice conversion. + :param app_id: Application ID is used to access your iFlyTek service API, see: `https://console.xfyun.cn/services/tts` + :param api_key: WebAPI argument, see: `https://console.xfyun.cn/services/tts` + :param api_secret: WebAPI argument, see: `https://console.xfyun.cn/services/tts` + :return: Returns the Base64-encoded .mp3 file data if successful, otherwise an empty string. + + """ + if not app_id: + app_id = CONFIG.IFLYTEK_APP_ID + if not api_key: + api_key = CONFIG.IFLYTEK_API_KEY + if not api_secret: + api_secret = CONFIG.IFLYTEK_API_SECRET + if not voice: + voice = CONFIG.IFLYTEK_VOICE or DEFAULT_IFLYTEK_VOICE + + filename = Path(__file__).parent / (uuid.uuid4().hex + ".mp3") + try: + tts = IFlyTekTTS(app_id=app_id, api_key=api_key, api_secret=api_secret) + await tts.synthesize_speech(text=text, output_file=str(filename), voice=voice) + async with aiofiles.open(str(filename), mode="r") as reader: + base64_string = await reader.read() + except Exception as e: + logger.error(f"text:{text}, error:{e}") + base64_string = "" + finally: + filename.unlink() + + return base64_string + + +if __name__ == "__main__": + asyncio.get_event_loop().run_until_complete( + oas3_iflytek_tts( + text="你好，hello", + app_id="f7acef62", + api_key="fda72e3aa286042a492525816a5efa08", + api_secret="ZDk3NjdiMDBkODJlOWQ1NjRjMGI2NDY4", + ) + ) diff --git a/metagpt/tools/metagpt_oas3_api_svc.py b/metagpt/tools/metagpt_oas3_api_svc.py new file mode 100644 index 000000000..2ff4c8225 --- /dev/null +++ b/metagpt/tools/metagpt_oas3_api_svc.py @@ -0,0 +1,44 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +@Time : 2023/8/17 +@Author : mashenquan +@File : metagpt_oas3_api_svc.py +@Desc : MetaGPT OpenAPI Specification 3.0 REST API service +""" +import asyncio +import sys +from pathlib import Path + +import connexion + +sys.path.append(str(Path(__file__).resolve().parent.parent.parent)) # fix-bug: No module named 'metagpt' + + +def oas_http_svc(): + """Start the OAS 3.0 OpenAPI HTTP service""" + app = connexion.AioHttpApp(__name__, specification_dir="../../.well-known/") + app.add_api("metagpt_oas3_api.yaml") + app.add_api("openapi.yaml") + app.run(port=8080) + + +async def async_main(): + """Start the OAS 3.0 OpenAPI HTTP service in the background.""" + loop = asyncio.get_event_loop() + loop.run_in_executor(None, oas_http_svc) + + # TODO: replace following codes: + while True: + await asyncio.sleep(1) + print("sleep") + + +def main(): + print("http://localhost:8080/oas3/ui/") + oas_http_svc() + + +if __name__ == "__main__": + # asyncio.run(async_main()) + main() diff --git a/metagpt/tools/metagpt_text_to_image.py b/metagpt/tools/metagpt_text_to_image.py new file mode 100644 index 000000000..50c0edcba --- /dev/null +++ b/metagpt/tools/metagpt_text_to_image.py @@ -0,0 +1,110 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +@Time : 2023/8/18 +@Author : mashenquan +@File : metagpt_text_to_image.py +@Desc : MetaGPT Text-to-Image OAS3 api, which provides text-to-image functionality. +""" +import asyncio +import base64 +from typing import Dict, List + +import aiohttp +import requests +from pydantic import BaseModel + +from metagpt.config import CONFIG, Config +from metagpt.logs import logger + + +class MetaGPTText2Image: + def __init__(self, model_url): + """ + :param model_url: Model reset api url + """ + self.model_url = model_url if model_url else CONFIG.METAGPT_TEXT_TO_IMAGE_MODEL + + async def text_2_image(self, text, size_type="512x512"): + """Text to image + + :param text: The text used for image conversion. + :param size_type: One of ['512x512', '512x768'] + :return: The image data is returned in Base64 encoding. + """ + + headers = {"Content-Type": "application/json"} + dims = size_type.split("x") + data = { + "prompt": text, + "negative_prompt": "(easynegative:0.8),black, dark,Low resolution", + "override_settings": {"sd_model_checkpoint": "galaxytimemachinesGTM_photoV20"}, + "seed": -1, + "batch_size": 1, + "n_iter": 1, + "steps": 20, + "cfg_scale": 11, + "width": int(dims[0]), + "height": int(dims[1]), # 768, + "restore_faces": False, + "tiling": False, + "do_not_save_samples": False, + "do_not_save_grid": False, + "enable_hr": False, + "hr_scale": 2, + "hr_upscaler": "Latent", + "hr_second_pass_steps": 0, + "hr_resize_x": 0, + "hr_resize_y": 0, + "hr_upscale_to_x": 0, + "hr_upscale_to_y": 0, + "truncate_x": 0, + "truncate_y": 0, + "applied_old_hires_behavior_to": None, + "eta": None, + "sampler_index": "DPM++ SDE Karras", + "alwayson_scripts": {}, + } + + class ImageResult(BaseModel): + images: List + parameters: Dict + + try: + async with aiohttp.ClientSession() as session: + async with session.post(self.model_url, headers=headers, json=data) as response: + result = ImageResult(**await response.json()) + if len(result.images) == 0: + return "" + return result.images[0] + except requests.exceptions.RequestException as e: + logger.error(f"An error occurred:{e}") + return "" + + +# Export +async def oas3_metagpt_text_to_image(text, size_type: str = "512x512", model_url=""): + """Text to image + + :param text: The text used for image conversion. + :param model_url: Model reset api + :param size_type: One of ['512x512', '512x768'] + :return: The image data is returned in Base64 encoding. + """ + if not text: + return "" + if not model_url: + model_url = CONFIG.METAGPT_TEXT_TO_IMAGE_MODEL_URL + return await MetaGPTText2Image(model_url).text_2_image(text, size_type=size_type) + + +if __name__ == "__main__": + Config() + loop = asyncio.new_event_loop() + task = loop.create_task(oas3_metagpt_text_to_image("Panda emoji")) + v = loop.run_until_complete(task) + print(v) + data = base64.b64decode(v) + with open("tmp.png", mode="wb") as writer: + writer.write(data) + print(v) diff --git a/metagpt/tools/openai_text_to_embedding.py b/metagpt/tools/openai_text_to_embedding.py new file mode 100644 index 000000000..fb6fbc653 --- /dev/null +++ b/metagpt/tools/openai_text_to_embedding.py @@ -0,0 +1,90 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +@Time : 2023/8/18 +@Author : mashenquan +@File : openai_text_to_embedding.py +@Desc : OpenAI Text-to-Embedding OAS3 api, which provides text-to-embedding functionality. + For more details, checkout: `https://platform.openai.com/docs/api-reference/embeddings/object` +""" +import asyncio +from typing import List + +import aiohttp +import requests +from pydantic import BaseModel + +from metagpt.config import CONFIG, Config +from metagpt.logs import logger + + +class Embedding(BaseModel): + """Represents an embedding vector returned by embedding endpoint.""" + + object: str # The object type, which is always "embedding". + embedding: List[ + float + ] # The embedding vector, which is a list of floats. The length of vector depends on the model as listed in the embedding guide. + index: int # The index of the embedding in the list of embeddings. + + +class Usage(BaseModel): + prompt_tokens: int + total_tokens: int + + +class ResultEmbedding(BaseModel): + object: str + data: List[Embedding] + model: str + usage: Usage + + +class OpenAIText2Embedding: + def __init__(self, openai_api_key): + """ + :param openai_api_key: OpenAI API key, For more details, checkout: `https://platform.openai.com/account/api-keys` + """ + self.openai_api_key = openai_api_key if openai_api_key else CONFIG.OPENAI_API_KEY + + async def text_2_embedding(self, text, model="text-embedding-ada-002"): + """Text to embedding + + :param text: The text used for embedding. + :param model: One of ['text-embedding-ada-002'], ID of the model to use. For more details, checkout: `https://api.openai.com/v1/models`. + :return: A json object of :class:`ResultEmbedding` class if successful, otherwise `{}`. + """ + + headers = {"Content-Type": "application/json", "Authorization": f"Bearer {self.openai_api_key}"} + data = {"input": text, "model": model} + try: + async with aiohttp.ClientSession() as session: + async with session.post("https://api.openai.com/v1/embeddings", headers=headers, json=data) as response: + return await response.json() + except requests.exceptions.RequestException as e: + logger.error(f"An error occurred:{e}") + return {} + + +# Export +async def oas3_openai_text_to_embedding(text, model="text-embedding-ada-002", openai_api_key=""): + """Text to embedding + + :param text: The text used for embedding. + :param model: One of ['text-embedding-ada-002'], ID of the model to use. For more details, checkout: `https://api.openai.com/v1/models`. + :param openai_api_key: OpenAI API key, For more details, checkout: `https://platform.openai.com/account/api-keys` + :return: A json object of :class:`ResultEmbedding` class if successful, otherwise `{}`. + """ + if not text: + return "" + if not openai_api_key: + openai_api_key = CONFIG.OPENAI_API_KEY + return await OpenAIText2Embedding(openai_api_key).text_2_embedding(text, model=model) + + +if __name__ == "__main__": + Config() + loop = asyncio.new_event_loop() + task = loop.create_task(oas3_openai_text_to_embedding("Panda emoji")) + v = loop.run_until_complete(task) + print(v) diff --git a/metagpt/tools/openai_text_to_image.py b/metagpt/tools/openai_text_to_image.py new file mode 100644 index 000000000..71381d8f2 --- /dev/null +++ b/metagpt/tools/openai_text_to_image.py @@ -0,0 +1,86 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +@Time : 2023/8/17 +@Author : mashenquan +@File : openai_text_to_image.py +@Desc : OpenAI Text-to-Image OAS3 api, which provides text-to-image functionality. +""" +import asyncio +import base64 + +import aiohttp +import requests + +from metagpt.config import Config +from metagpt.llm import LLM +from metagpt.logs import logger + + +class OpenAIText2Image: + def __init__(self): + """ + :param openai_api_key: OpenAI API key, For more details, checkout: `https://platform.openai.com/account/api-keys` + """ + self._llm = LLM() + self._client = self._llm.async_client + + def __del__(self): + if self._llm: + self._llm.close() + + async def text_2_image(self, text, size_type="1024x1024"): + """Text to image + + :param text: The text used for image conversion. + :param size_type: One of ['256x256', '512x512', '1024x1024'] + :return: The image data is returned in Base64 encoding. + """ + try: + result = await self._client.images.generate(prompt=text, n=1, size=size_type) + except Exception as e: + logger.error(f"An error occurred:{e}") + return "" + if result and len(result.data) > 0: + return await OpenAIText2Image.get_image_data(result.data[0].url) + return "" + + @staticmethod + async def get_image_data(url): + """Fetch image data from a URL and encode it as Base64 + + :param url: Image url + :return: Base64-encoded image data. + """ + try: + async with aiohttp.ClientSession() as session: + async with session.get(url) as response: + response.raise_for_status() # 如果是 4xx 或 5xx 响应，会引发异常 + image_data = await response.read() + base64_image = base64.b64encode(image_data).decode("utf-8") + return base64_image + + except requests.exceptions.RequestException as e: + logger.error(f"An error occurred:{e}") + return "" + + +# Export +async def oas3_openai_text_to_image(text, size_type: str = "1024x1024"): + """Text to image + + :param text: The text used for image conversion. + :param size_type: One of ['256x256', '512x512', '1024x1024'] + :return: The image data is returned in Base64 encoding. + """ + if not text: + return "" + return await OpenAIText2Image().text_2_image(text, size_type=size_type) + + +if __name__ == "__main__": + Config() + loop = asyncio.new_event_loop() + task = loop.create_task(oas3_openai_text_to_image("Panda emoji")) + v = loop.run_until_complete(task) + print(v) diff --git a/metagpt/tools/sd_engine.py b/metagpt/tools/sd_engine.py index a84812f7c..c4d9d2df4 100644 --- a/metagpt/tools/sd_engine.py +++ b/metagpt/tools/sd_engine.py @@ -6,7 +6,6 @@ import asyncio import base64 import io import json -import os from os.path import join from typing import List @@ -14,8 +13,7 @@ from aiohttp import ClientSession from PIL import Image, PngImagePlugin from metagpt.config import CONFIG - -# from metagpt.const import WORKSPACE_ROOT +from metagpt.const import SD_OUTPUT_FILE_REPO from metagpt.logs import logger payload = { @@ -79,10 +77,10 @@ class SDEngine: return self.payload def _save(self, imgs, save_name=""): - save_dir = CONFIG.workspace_path / "resources" / "SD_Output" - if not os.path.exists(save_dir): - os.makedirs(save_dir, exist_ok=True) - batch_decode_base64_to_image(imgs, save_dir, save_name=save_name) + save_dir = CONFIG.workspace_path / SD_OUTPUT_FILE_REPO + if not save_dir.exists(): + save_dir.mkdir(parents=True, exist_ok=True) + batch_decode_base64_to_image(imgs, str(save_dir), save_name=save_name) async def run_t2i(self, prompts: List): # Asynchronously run the SD API for multiple prompts diff --git a/metagpt/tools/web_browser_engine.py b/metagpt/tools/web_browser_engine.py index 453d87f31..ad753c634 100644 --- a/metagpt/tools/web_browser_engine.py +++ b/metagpt/tools/web_browser_engine.py @@ -1,4 +1,7 @@ #!/usr/bin/env python +""" +@Modified By: mashenquan, 2023/8/20. Remove global configuration `CONFIG`, enable configuration support for business isolation. +""" from __future__ import annotations @@ -17,14 +20,16 @@ class WebBrowserEngine: run_func: Callable[..., Coroutine[Any, Any, WebPage | list[WebPage]]] | None = None, ): engine = engine or CONFIG.web_browser_engine + if engine is None: + raise NotImplementedError - if engine == WebBrowserEngineType.PLAYWRIGHT: + if WebBrowserEngineType(engine) is WebBrowserEngineType.PLAYWRIGHT: module = "metagpt.tools.web_browser_engine_playwright" run_func = importlib.import_module(module).PlaywrightWrapper().run - elif engine == WebBrowserEngineType.SELENIUM: + elif WebBrowserEngineType(engine) is WebBrowserEngineType.SELENIUM: module = "metagpt.tools.web_browser_engine_selenium" run_func = importlib.import_module(module).SeleniumWrapper().run - elif engine == WebBrowserEngineType.CUSTOM: + elif WebBrowserEngineType(engine) is WebBrowserEngineType.CUSTOM: run_func = run_func else: raise NotImplementedError @@ -47,6 +52,6 @@ if __name__ == "__main__": import fire async def main(url: str, *urls: str, engine_type: Literal["playwright", "selenium"] = "playwright", **kwargs): - return await WebBrowserEngine(WebBrowserEngineType(engine_type), **kwargs).run(url, *urls) + return await WebBrowserEngine(engine=WebBrowserEngineType(engine_type), **kwargs).run(url, *urls) fire.Fire(main) diff --git a/metagpt/tools/web_browser_engine_playwright.py b/metagpt/tools/web_browser_engine_playwright.py index 030e7701b..8eecc4f40 100644 --- a/metagpt/tools/web_browser_engine_playwright.py +++ b/metagpt/tools/web_browser_engine_playwright.py @@ -1,4 +1,8 @@ #!/usr/bin/env python +""" +@Modified By: mashenquan, 2023/8/20. Remove global configuration `CONFIG`, enable configuration support for business isolation. +""" + from __future__ import annotations import asyncio @@ -144,6 +148,6 @@ if __name__ == "__main__": import fire async def main(url: str, *urls: str, browser_type: str = "chromium", **kwargs): - return await PlaywrightWrapper(browser_type, **kwargs).run(url, *urls) + return await PlaywrightWrapper(browser_type=browser_type, **kwargs).run(url, *urls) fire.Fire(main) diff --git a/metagpt/tools/web_browser_engine_selenium.py b/metagpt/tools/web_browser_engine_selenium.py index decab2b7d..628c8dea2 100644 --- a/metagpt/tools/web_browser_engine_selenium.py +++ b/metagpt/tools/web_browser_engine_selenium.py @@ -1,11 +1,15 @@ #!/usr/bin/env python +""" +@Modified By: mashenquan, 2023/8/20. Remove global configuration `CONFIG`, enable configuration support for business isolation. +""" + from __future__ import annotations import asyncio import importlib from concurrent import futures from copy import deepcopy -from typing import Literal +from typing import Dict, Literal from selenium.webdriver.common.by import By from selenium.webdriver.support import expected_conditions as EC @@ -29,6 +33,7 @@ class SeleniumWrapper: def __init__( self, + options: Dict, browser_type: Literal["chrome", "firefox", "edge", "ie"] | None = None, launch_kwargs: dict | None = None, *, @@ -120,6 +125,6 @@ if __name__ == "__main__": import fire async def main(url: str, *urls: str, browser_type: str = "chrome", **kwargs): - return await SeleniumWrapper(browser_type, **kwargs).run(url, *urls) + return await SeleniumWrapper(browser_type=browser_type, **kwargs).run(url, *urls) fire.Fire(main) diff --git a/metagpt/utils/common.py b/metagpt/utils/common.py index 8db7a80a1..09cc092fc 100644 --- a/metagpt/utils/common.py +++ b/metagpt/utils/common.py @@ -23,7 +23,7 @@ import sys import traceback import typing from pathlib import Path -from typing import Any, List, Tuple, Union, get_args, get_origin +from typing import Any, Callable, List, Tuple, Union, get_args, get_origin import aiofiles import loguru @@ -48,7 +48,7 @@ def check_cmd_exists(command) -> int: return result -def require_python_version(req_version: tuple[int]) -> bool: +def require_python_version(req_version: Tuple) -> bool: if not (2 <= len(req_version) <= 3): raise ValueError("req_version should be (3, 9) or (3, 10, 13)") return True if sys.version_info > req_version else False @@ -367,7 +367,7 @@ def get_class_name(cls) -> str: return f"{cls.__module__}.{cls.__name__}" -def any_to_str(val: str | typing.Callable) -> str: +def any_to_str(val: str | Callable) -> str: """Return the class name or the class name of the object, or 'val' if it's a string type.""" if isinstance(val, str): return val @@ -406,6 +406,21 @@ def is_subscribed(message: "Message", tags: set): return False +def any_to_name(val): + """ + Convert a value to its name by extracting the last part of the dotted path. + + :param val: The value to convert. + + :return: The name of the value. + """ + return any_to_str(val).split(".")[-1] + + +def concat_namespace(*args) -> str: + return ":".join(str(value) for value in args) + + def general_after_log(i: "loguru.Logger", sec_format: str = "%0.3f") -> typing.Callable[["RetryCallState"], None]: """ Generates a logging function to be used after a call is retried. @@ -520,3 +535,20 @@ async def aread(file_path: str) -> str: async with aiofiles.open(str(file_path), mode="r") as reader: content = await reader.read() return content + + +async def read_file_block(filename: str | Path, lineno: int, end_lineno: int): + if not Path(filename).exists(): + return "" + lines = [] + async with aiofiles.open(str(filename), mode="r") as reader: + ix = 0 + while ix < end_lineno: + ix += 1 + line = await reader.readline() + if ix < lineno: + continue + if ix > end_lineno: + break + lines.append(line) + return "".join(lines) diff --git a/metagpt/utils/cost_manager.py b/metagpt/utils/cost_manager.py new file mode 100644 index 000000000..ce53f2285 --- /dev/null +++ b/metagpt/utils/cost_manager.py @@ -0,0 +1,82 @@ +# -*- coding: utf-8 -*- +""" +@Time : 2023/8/28 +@Author : mashenquan +@File : openai.py +@Desc : mashenquan, 2023/8/28. Separate the `CostManager` class to support user-level cost accounting. +""" + +from typing import NamedTuple + +from pydantic import BaseModel + +from metagpt.logs import logger +from metagpt.utils.token_counter import TOKEN_COSTS + + +class Costs(NamedTuple): + total_prompt_tokens: int + total_completion_tokens: int + total_cost: float + total_budget: float + + +class CostManager(BaseModel): + """Calculate the overhead of using the interface.""" + + total_prompt_tokens: int = 0 + total_completion_tokens: int = 0 + total_budget: float = 0 + max_budget: float = 10.0 + total_cost: float = 0 + + def update_cost(self, prompt_tokens, completion_tokens, model): + """ + Update the total cost, prompt tokens, and completion tokens. + + Args: + prompt_tokens (int): The number of tokens used in the prompt. + completion_tokens (int): The number of tokens used in the completion. + model (str): The model used for the API call. + """ + self.total_prompt_tokens += prompt_tokens + self.total_completion_tokens += completion_tokens + cost = ( + prompt_tokens * TOKEN_COSTS[model]["prompt"] + completion_tokens * TOKEN_COSTS[model]["completion"] + ) / 1000 + self.total_cost += cost + logger.info( + f"Total running cost: ${self.total_cost:.3f} | Max budget: ${self.max_budget:.3f} | " + f"Current cost: ${cost:.3f}, prompt_tokens: {prompt_tokens}, completion_tokens: {completion_tokens}" + ) + + def get_total_prompt_tokens(self): + """ + Get the total number of prompt tokens. + + Returns: + int: The total number of prompt tokens. + """ + return self.total_prompt_tokens + + def get_total_completion_tokens(self): + """ + Get the total number of completion tokens. + + Returns: + int: The total number of completion tokens. + """ + return self.total_completion_tokens + + def get_total_cost(self): + """ + Get the total cost of API calls. + + Returns: + float: The total cost of API calls. + """ + return self.total_cost + + def get_costs(self) -> Costs: + """Get all costs""" + return Costs(self.total_prompt_tokens, self.total_completion_tokens, self.total_cost, self.total_budget) diff --git a/metagpt/utils/di_graph_repository.py b/metagpt/utils/di_graph_repository.py new file mode 100644 index 000000000..08f4327fa --- /dev/null +++ b/metagpt/utils/di_graph_repository.py @@ -0,0 +1,84 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +@Time : 2023/12/19 +@Author : mashenquan +@File : di_graph_repository.py +@Desc : Graph repository based on DiGraph +""" +from __future__ import annotations + +import json +from pathlib import Path +from typing import List + +import aiofiles +import networkx + +from metagpt.utils.graph_repository import SPO, GraphRepository + + +class DiGraphRepository(GraphRepository): + def __init__(self, name: str, **kwargs): + super().__init__(name=name, **kwargs) + self._repo = networkx.DiGraph() + + async def insert(self, subject: str, predicate: str, object_: str): + self._repo.add_edge(subject, object_, predicate=predicate) + + async def upsert(self, subject: str, predicate: str, object_: str): + pass + + async def update(self, subject: str, predicate: str, object_: str): + pass + + async def select(self, subject: str = None, predicate: str = None, object_: str = None) -> List[SPO]: + result = [] + for s, o, p in self._repo.edges(data="predicate"): + if subject and subject != s: + continue + if predicate and predicate != p: + continue + if object_ and object_ != o: + continue + result.append(SPO(subject=s, predicate=p, object_=o)) + return result + + def json(self) -> str: + m = networkx.node_link_data(self._repo) + data = json.dumps(m) + return data + + async def save(self, path: str | Path = None): + data = self.json() + path = path or self._kwargs.get("root") + if not path.exists(): + path.mkdir(parents=True, exist_ok=True) + pathname = Path(path) / self.name + async with aiofiles.open(str(pathname.with_suffix(".json")), mode="w", encoding="utf-8") as writer: + await writer.write(data) + + async def load(self, pathname: str | Path): + async with aiofiles.open(str(pathname), mode="r", encoding="utf-8") as reader: + data = await reader.read(-1) + m = json.loads(data) + self._repo = networkx.node_link_graph(m) + + @staticmethod + async def load_from(pathname: str | Path) -> GraphRepository: + pathname = Path(pathname) + name = pathname.with_suffix("").name + root = pathname.parent + graph = DiGraphRepository(name=name, root=root) + if pathname.exists(): + await graph.load(pathname=pathname) + return graph + + @property + def root(self) -> str: + return self._kwargs.get("root") + + @property + def pathname(self) -> Path: + p = Path(self.root) / self.name + return p.with_suffix(".json") diff --git a/metagpt/utils/graph_repository.py b/metagpt/utils/graph_repository.py new file mode 100644 index 000000000..37da3dee4 --- /dev/null +++ b/metagpt/utils/graph_repository.py @@ -0,0 +1,150 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +@Time : 2023/12/19 +@Author : mashenquan +@File : graph_repository.py +@Desc : Superclass for graph repository. +""" + +from abc import ABC, abstractmethod +from pathlib import Path +from typing import List + +from pydantic import BaseModel + +from metagpt.repo_parser import ClassInfo, RepoFileInfo +from metagpt.utils.common import concat_namespace + + +class GraphKeyword: + IS = "is" + CLASS = "class" + FUNCTION = "function" + SOURCE_CODE = "source_code" + NULL = "" + GLOBAL_VARIABLE = "global_variable" + CLASS_FUNCTION = "class_function" + CLASS_PROPERTY = "class_property" + HAS_CLASS = "has_class" + HAS_PAGE_INFO = "has_page_info" + HAS_CLASS_VIEW = "has_class_view" + HAS_SEQUENCE_VIEW = "has_sequence_view" + HAS_ARGS_DESC = "has_args_desc" + HAS_TYPE_DESC = "has_type_desc" + + +class SPO(BaseModel): + subject: str + predicate: str + object_: str + + +class GraphRepository(ABC): + def __init__(self, name: str, **kwargs): + self._repo_name = name + self._kwargs = kwargs + + @abstractmethod + async def insert(self, subject: str, predicate: str, object_: str): + pass + + @abstractmethod + async def upsert(self, subject: str, predicate: str, object_: str): + pass + + @abstractmethod + async def update(self, subject: str, predicate: str, object_: str): + pass + + @abstractmethod + async def select(self, subject: str = None, predicate: str = None, object_: str = None) -> List[SPO]: + pass + + @property + def name(self) -> str: + return self._repo_name + + @staticmethod + async def update_graph_db_with_file_info(graph_db: "GraphRepository", file_info: RepoFileInfo): + await graph_db.insert(subject=file_info.file, predicate=GraphKeyword.IS, object_=GraphKeyword.SOURCE_CODE) + file_types = {".py": "python", ".js": "javascript"} + file_type = file_types.get(Path(file_info.file).suffix, GraphKeyword.NULL) + await graph_db.insert(subject=file_info.file, predicate=GraphKeyword.IS, object_=file_type) + for c in file_info.classes: + class_name = c.get("name", "") + await graph_db.insert( + subject=file_info.file, + predicate=GraphKeyword.HAS_CLASS, + object_=concat_namespace(file_info.file, class_name), + ) + await graph_db.insert( + subject=concat_namespace(file_info.file, class_name), + predicate=GraphKeyword.IS, + object_=GraphKeyword.CLASS, + ) + methods = c.get("methods", []) + for fn in methods: + await graph_db.insert( + subject=concat_namespace(file_info.file, class_name, fn), + predicate=GraphKeyword.IS, + object_=GraphKeyword.CLASS_FUNCTION, + ) + for f in file_info.functions: + await graph_db.insert( + subject=concat_namespace(file_info.file, f), predicate=GraphKeyword.IS, object_=GraphKeyword.FUNCTION + ) + for g in file_info.globals: + await graph_db.insert( + subject=concat_namespace(file_info.file, g), + predicate=GraphKeyword.IS, + object_=GraphKeyword.GLOBAL_VARIABLE, + ) + for code_block in file_info.page_info: + if code_block.tokens: + await graph_db.insert( + subject=concat_namespace(file_info.file, *code_block.tokens), + predicate=GraphKeyword.HAS_PAGE_INFO, + object_=code_block.json(ensure_ascii=False), + ) + for k, v in code_block.properties.items(): + await graph_db.insert( + subject=concat_namespace(file_info.file, k, v), + predicate=GraphKeyword.HAS_PAGE_INFO, + object_=code_block.json(ensure_ascii=False), + ) + + @staticmethod + async def update_graph_db_with_class_views(graph_db: "GraphRepository", class_views: List[ClassInfo]): + for c in class_views: + filename, class_name = c.package.split(":", 1) + await graph_db.insert(subject=filename, predicate=GraphKeyword.IS, object_=GraphKeyword.SOURCE_CODE) + file_types = {".py": "python", ".js": "javascript"} + file_type = file_types.get(Path(filename).suffix, GraphKeyword.NULL) + await graph_db.insert(subject=filename, predicate=GraphKeyword.IS, object_=file_type) + await graph_db.insert(subject=filename, predicate=GraphKeyword.HAS_CLASS, object_=class_name) + await graph_db.insert( + subject=c.package, + predicate=GraphKeyword.IS, + object_=GraphKeyword.CLASS, + ) + for vn, vt in c.attributes.items(): + await graph_db.insert( + subject=concat_namespace(c.package, vn), + predicate=GraphKeyword.IS, + object_=GraphKeyword.CLASS_PROPERTY, + ) + await graph_db.insert( + subject=concat_namespace(c.package, vn), predicate=GraphKeyword.HAS_TYPE_DESC, object_=vt + ) + for fn, desc in c.methods.items(): + await graph_db.insert( + subject=concat_namespace(c.package, fn), + predicate=GraphKeyword.IS, + object_=GraphKeyword.CLASS_FUNCTION, + ) + await graph_db.insert( + subject=concat_namespace(c.package, fn), + predicate=GraphKeyword.HAS_ARGS_DESC, + object_=desc, + ) diff --git a/metagpt/utils/make_sk_kernel.py b/metagpt/utils/make_sk_kernel.py index de84e3630..e0272ea13 100644 --- a/metagpt/utils/make_sk_kernel.py +++ b/metagpt/utils/make_sk_kernel.py @@ -18,17 +18,15 @@ from metagpt.config import CONFIG def make_sk_kernel(): kernel = sk.Kernel() - if CONFIG.openai_api_type == "azure": + if CONFIG.OPENAI_API_TYPE == "azure": kernel.add_chat_service( "chat_completion", - AzureChatCompletion( - deployment_name=CONFIG.deployment_name, endpoint=CONFIG.openai_base_url, api_key=CONFIG.openai_api_key - ), + AzureChatCompletion(CONFIG.DEPLOYMENT_NAME, CONFIG.OPENAI_BASE_URL, CONFIG.OPENAI_API_KEY), ) else: kernel.add_chat_service( "chat_completion", - OpenAIChatCompletion(model_id=CONFIG.openai_api_model, api_key=CONFIG.openai_api_key), + OpenAIChatCompletion(CONFIG.OPENAI_API_MODEL, CONFIG.OPENAI_API_KEY), ) return kernel diff --git a/metagpt/utils/mermaid.py b/metagpt/utils/mermaid.py index eb85a3f90..9aefeb5aa 100644 --- a/metagpt/utils/mermaid.py +++ b/metagpt/utils/mermaid.py @@ -4,11 +4,14 @@ @Time : 2023/7/4 10:53 @Author : alexanderwu alitrack @File : mermaid.py +@Modified By: mashenquan, 2023/8/20. Remove global configuration `CONFIG`, enable configuration support for business isolation. """ import asyncio import os from pathlib import Path +import aiofiles + from metagpt.config import CONFIG from metagpt.const import METAGPT_ROOT from metagpt.logs import logger @@ -29,7 +32,9 @@ async def mermaid_to_file(mermaid_code, output_file_without_suffix, width=2048, if dir_name and not os.path.exists(dir_name): os.makedirs(dir_name) tmp = Path(f"{output_file_without_suffix}.mmd") - tmp.write_text(mermaid_code, encoding="utf-8") + async with aiofiles.open(tmp, "w", encoding="utf-8") as f: + await f.write(mermaid_code) + # tmp.write_text(mermaid_code, encoding="utf-8") engine = CONFIG.mermaid_engine.lower() if engine == "nodejs": @@ -88,7 +93,8 @@ async def mermaid_to_file(mermaid_code, output_file_without_suffix, width=2048, return 0 -MMC1 = """classDiagram +MMC1 = """ +classDiagram class Main { -SearchEngine search_engine +main() str @@ -118,9 +124,11 @@ MMC1 = """classDiagram SearchEngine --> Index SearchEngine --> Ranking SearchEngine --> Summary - Index --> KnowledgeBase""" + Index --> KnowledgeBase +""" -MMC2 = """sequenceDiagram +MMC2 = """ +sequenceDiagram participant M as Main participant SE as SearchEngine participant I as Index @@ -136,11 +144,11 @@ MMC2 = """sequenceDiagram R-->>SE: return ranked_results SE->>S: summarize_results(ranked_results) S-->>SE: return summary - SE-->>M: return summary""" - + SE-->>M: return summary +""" if __name__ == "__main__": loop = asyncio.new_event_loop() result = loop.run_until_complete(mermaid_to_file(MMC1, METAGPT_ROOT / f"{CONFIG.mermaid_engine}/1")) - result = loop.run_until_complete(mermaid_to_file(MMC2, METAGPT_ROOT / f"{CONFIG.mermaid_engine}/1")) + result = loop.run_until_complete(mermaid_to_file(MMC2, METAGPT_ROOT / f"{CONFIG.mermaid_engine}/2")) loop.close() diff --git a/metagpt/utils/redis.py b/metagpt/utils/redis.py new file mode 100644 index 000000000..c344b67ac --- /dev/null +++ b/metagpt/utils/redis.py @@ -0,0 +1,219 @@ +# !/usr/bin/python3 +# -*- coding: utf-8 -*- +# @Author: Hui +# @Desc: { redis client } +# @Date: 2022/11/28 10:12 +import json +import traceback +from datetime import timedelta +from enum import Enum +from typing import Awaitable, Callable, Dict, Optional, Union + +from redis import asyncio as aioredis + +from metagpt.config import CONFIG +from metagpt.logs import logger + + +class RedisTypeEnum(Enum): + """Redis 数据类型""" + + String = "String" + List = "List" + Hash = "Hash" + Set = "Set" + ZSet = "ZSet" + + +def make_url( + dialect: str, + *, + user: Optional[str] = None, + password: Optional[str] = None, + host: Optional[str] = None, + port: Optional[Union[str, int]] = None, + name: Optional[Union[str, int]] = None, +) -> str: + url_parts = [f"{dialect}://"] + if user or password: + if user: + url_parts.append(user) + if password: + url_parts.append(f":{password}") + url_parts.append("@") + + if not host and not dialect.startswith("sqlite"): + host = "127.0.0.1" + + if host: + url_parts.append(f"{host}") + if port: + url_parts.append(f":{port}") + + # 比如redis可能传入0 + if name is not None: + url_parts.append(f"/{name}") + return "".join(url_parts) + + +class RedisAsyncClient(aioredis.Redis): + """异步的客户端 + 例子:: + + rdb = RedisAsyncClient() + print(rdb.url) + + Args: + host: 服务器地址 + port: 服务器端口 + user: 用户名 + db: 数据库 + password: 密码 + decode_responses: 字符串输入被编码成utf8存储在Redis里了，而取出来的时候还是被编码后的bytes，需要显示的decode才能变成字符串 + health_check_interval: 定时检测连接，防止出现ConnectionErrors (104, Connection reset by peer) + """ + + def __init__( + self, + host: str = "localhost", + port: int = 6379, + db: int = 0, + password: str = None, + decode_responses=True, + health_check_interval=10, + socket_connect_timeout=5, + retry_on_timeout=True, + socket_keepalive=True, + **kwargs, + ): + super().__init__( + host=host, + port=port, + db=db, + password=password, + decode_responses=decode_responses, + health_check_interval=health_check_interval, + socket_connect_timeout=socket_connect_timeout, + retry_on_timeout=retry_on_timeout, + socket_keepalive=socket_keepalive, + **kwargs, + ) + self.url = make_url("redis", host=host, port=port, name=db, password=password) + + +class RedisCacheInfo(object): + """统一缓存信息类""" + + def __init__(self, key, timeout: Union[int, timedelta] = timedelta(seconds=60), data_type=RedisTypeEnum.String): + """ + 缓存信息类初始化 + Args: + key: 缓存的key + timeout: 缓存过期时间, 单位秒 + data_type: 缓存采用的数据结构 (不传并不影响，用于标记业务采用的是什么数据结构) + """ + self.key = key + self.timeout = timeout + self.data_type = data_type + + def __str__(self): + return f"cache key {self.key} timeout {self.timeout}s" + + +class RedisManager: + client: RedisAsyncClient = None + + @classmethod + def init_redis_conn(cls, host, port, password, db): + """初始化redis 连接""" + if cls.client is None: + cls.client = RedisAsyncClient(host=host, port=port, password=password, db=db) + + @classmethod + async def set_with_cache_info(cls, redis_cache_info: RedisCacheInfo, value): + """ + 根据 RedisCacheInfo 设置 Redis 缓存 + :param redis_cache_info: RedisCacheInfo缓存信息对象 + :param value: 缓存的值 + :return: + """ + await cls.client.setex(redis_cache_info.key, redis_cache_info.timeout, value) + + @classmethod + async def get_with_cache_info(cls, redis_cache_info: RedisCacheInfo): + """ + 根据 RedisCacheInfo 获取 Redis 缓存 + :param redis_cache_info: RedisCacheInfo 缓存信息对象 + :return: + """ + cache_info = await cls.client.get(redis_cache_info.key) + return cache_info + + @classmethod + async def del_with_cache_info(cls, redis_cache_info: RedisCacheInfo): + """ + 根据 RedisCacheInfo 删除 Redis 缓存 + :param redis_cache_info: RedisCacheInfo缓存信息对象 + :return: + """ + await cls.client.delete(redis_cache_info.key) + + @staticmethod + async def get_or_set_cache(cache_info: RedisCacheInfo, fetch_data_func: Callable[[], Awaitable[dict]]) -> dict: + """ + 获取缓存数据，如果缓存不存在，则从提供的函数中获取并设置缓存 + 当前版本仅支持 json 形式的 string 格式数据 + """ + + serialized_data = await RedisManager.get_with_cache_info(cache_info) + + if serialized_data: + return json.loads(serialized_data) + + data = await fetch_data_func() + try: + serialized_data = json.dumps(data) + await RedisManager.set_with_cache_info(cache_info, serialized_data) + except Exception as e: + logger.warning(f"数据 {data} 通过 json 进行序列化缓存失败:{e}") + + return data + + @classmethod + def is_valid(cls): + return cls.client is not None + + +class Redis: + def __init__(self, conf: Dict = None): + try: + host = CONFIG.REDIS_HOST + port = int(CONFIG.REDIS_PORT) + pwd = CONFIG.REDIS_PASSWORD + db = CONFIG.REDIS_DB + RedisManager.init_redis_conn(host=host, port=port, password=pwd, db=db) + except Exception as e: + logger.warning(f"Redis initialization has failed:{e}") + + def is_valid(self): + return RedisManager.is_valid() + + async def get(self, key: str) -> str: + if not self.is_valid() or not key: + return None + try: + v = await RedisManager.get_with_cache_info(redis_cache_info=RedisCacheInfo(key=key)) + return v + except Exception as e: + logger.exception(f"{e}, stack:{traceback.format_exc()}") + return None + + async def set(self, key: str, data: str, timeout_sec: int): + if not self.is_valid() or not key: + return + try: + await RedisManager.set_with_cache_info( + redis_cache_info=RedisCacheInfo(key=key, timeout=timeout_sec), value=data + ) + except Exception as e: + logger.exception(f"{e}, stack:{traceback.format_exc()}") diff --git a/metagpt/utils/repair_llm_raw_output.py b/metagpt/utils/repair_llm_raw_output.py index 87fd0efd0..a96c3dce0 100644 --- a/metagpt/utils/repair_llm_raw_output.py +++ b/metagpt/utils/repair_llm_raw_output.py @@ -230,9 +230,11 @@ def run_after_exp_and_passon_next_retry(logger: "loguru.Logger") -> Callable[["R elif retry_state.kwargs: func_param_output = retry_state.kwargs.get("output", "") exp_str = str(retry_state.outcome.exception()) + + fix_str = "try to fix it, " if CONFIG.repair_llm_output else "" logger.warning( f"parse json from content inside [CONTENT][/CONTENT] failed at retry " - f"{retry_state.attempt_number}, try to fix it, exp: {exp_str}" + f"{retry_state.attempt_number}, {fix_str}exp: {exp_str}" ) repaired_output = repair_invalid_json(func_param_output, exp_str) diff --git a/metagpt/utils/s3.py b/metagpt/utils/s3.py new file mode 100644 index 000000000..9accfcade --- /dev/null +++ b/metagpt/utils/s3.py @@ -0,0 +1,170 @@ +import base64 +import os.path +import traceback +import uuid +from pathlib import Path +from typing import Optional + +import aioboto3 +import aiofiles + +from metagpt.config import CONFIG +from metagpt.const import BASE64_FORMAT +from metagpt.logs import logger + + +class S3: + """A class for interacting with Amazon S3 storage.""" + + def __init__(self): + self.session = aioboto3.Session() + self.auth_config = { + "service_name": "s3", + "aws_access_key_id": CONFIG.S3_ACCESS_KEY, + "aws_secret_access_key": CONFIG.S3_SECRET_KEY, + "endpoint_url": CONFIG.S3_ENDPOINT_URL, + } + + async def upload_file( + self, + bucket: str, + local_path: str, + object_name: str, + ) -> None: + """Upload a file from the local path to the specified path of the storage bucket specified in s3. + + Args: + bucket: The name of the S3 storage bucket. + local_path: The local file path, including the file name. + object_name: The complete path of the uploaded file to be stored in S3, including the file name. + + Raises: + Exception: If an error occurs during the upload process, an exception is raised. + """ + try: + async with self.session.client(**self.auth_config) as client: + async with aiofiles.open(local_path, mode="rb") as reader: + body = await reader.read() + await client.put_object(Body=body, Bucket=bucket, Key=object_name) + logger.info(f"Successfully uploaded the file to path {object_name} in bucket {bucket} of s3.") + except Exception as e: + logger.error(f"Failed to upload the file to path {object_name} in bucket {bucket} of s3: {e}") + raise e + + async def get_object_url( + self, + bucket: str, + object_name: str, + ) -> str: + """Get the URL for a downloadable or preview file stored in the specified S3 bucket. + + Args: + bucket: The name of the S3 storage bucket. + object_name: The complete path of the file stored in S3, including the file name. + + Returns: + The URL for the downloadable or preview file. + + Raises: + Exception: If an error occurs while retrieving the URL, an exception is raised. + """ + try: + async with self.session.client(**self.auth_config) as client: + file = await client.get_object(Bucket=bucket, Key=object_name) + return str(file["Body"].url) + except Exception as e: + logger.error(f"Failed to get the url for a downloadable or preview file: {e}") + raise e + + async def get_object( + self, + bucket: str, + object_name: str, + ) -> bytes: + """Get the binary data of a file stored in the specified S3 bucket. + + Args: + bucket: The name of the S3 storage bucket. + object_name: The complete path of the file stored in S3, including the file name. + + Returns: + The binary data of the requested file. + + Raises: + Exception: If an error occurs while retrieving the file data, an exception is raised. + """ + try: + async with self.session.client(**self.auth_config) as client: + s3_object = await client.get_object(Bucket=bucket, Key=object_name) + return await s3_object["Body"].read() + except Exception as e: + logger.error(f"Failed to get the binary data of the file: {e}") + raise e + + async def download_file( + self, bucket: str, object_name: str, local_path: str, chunk_size: Optional[int] = 128 * 1024 + ) -> None: + """Download an S3 object to a local file. + + Args: + bucket: The name of the S3 storage bucket. + object_name: The complete path of the file stored in S3, including the file name. + local_path: The local file path where the S3 object will be downloaded. + chunk_size: The size of data chunks to read and write at a time. Default is 128 KB. + + Raises: + Exception: If an error occurs during the download process, an exception is raised. + """ + try: + async with self.session.client(**self.auth_config) as client: + s3_object = await client.get_object(Bucket=bucket, Key=object_name) + stream = s3_object["Body"] + async with aiofiles.open(local_path, mode="wb") as writer: + while True: + file_data = await stream.read(chunk_size) + if not file_data: + break + await writer.write(file_data) + except Exception as e: + logger.error(f"Failed to download the file from S3: {e}") + raise e + + async def cache(self, data: str, file_ext: str, format: str = "") -> str: + """Save data to remote S3 and return url""" + object_name = uuid.uuid4().hex + file_ext + path = Path(__file__).parent + pathname = path / object_name + try: + async with aiofiles.open(str(pathname), mode="wb") as file: + if format == BASE64_FORMAT: + data = base64.b64decode(data) + await file.write(data) + + bucket = CONFIG.S3_BUCKET + object_pathname = CONFIG.S3_BUCKET or "system" + object_pathname += f"/{object_name}" + object_pathname = os.path.normpath(object_pathname) + await self.upload_file(bucket=bucket, local_path=str(pathname), object_name=object_pathname) + pathname.unlink(missing_ok=True) + + return await self.get_object_url(bucket=bucket, object_name=object_pathname) + except Exception as e: + logger.exception(f"{e}, stack:{traceback.format_exc()}") + pathname.unlink(missing_ok=True) + return None + + @property + def is_valid(self): + is_invalid = ( + not CONFIG.S3_ACCESS_KEY + or CONFIG.S3_ACCESS_KEY == "YOUR_S3_ACCESS_KEY" + or not CONFIG.S3_SECRET_KEY + or CONFIG.S3_SECRET_KEY == "YOUR_S3_SECRET_KEY" + or not CONFIG.S3_ENDPOINT_URL + or CONFIG.S3_ENDPOINT_URL == "YOUR_S3_ENDPOINT_URL" + or not CONFIG.S3_BUCKET + or CONFIG.S3_BUCKET == "YOUR_S3_BUCKET" + ) + if is_invalid: + logger.info("S3 is invalid") + return not is_invalid diff --git a/metagpt/utils/token_counter.py b/metagpt/utils/token_counter.py index 94b8d76d2..a1b74a074 100644 --- a/metagpt/utils/token_counter.py +++ b/metagpt/utils/token_counter.py @@ -84,6 +84,13 @@ def count_message_tokens(messages, model="gpt-3.5-turbo-0613"): elif "gpt-4" == model: print("Warning: gpt-4 may update over time. Returning num tokens assuming gpt-4-0613.") return count_message_tokens(messages, model="gpt-4-0613") + elif "open-llm-model" == model: + """ + For self-hosted open_llm api, they include lots of different models. The message tokens calculation is + inaccurate. It's a reference result. + """ + tokens_per_message = 0 # ignore conversation message template prefix + tokens_per_name = 0 else: raise NotImplementedError( f"num_tokens_from_messages() is not implemented for model {model}. " @@ -112,7 +119,11 @@ def count_string_tokens(string: str, model_name: str) -> int: Returns: int: The number of tokens in the text string. """ - encoding = tiktoken.encoding_for_model(model_name) + try: + encoding = tiktoken.encoding_for_model(model_name) + except KeyError: + print("Warning: model not found. Using cl100k_base encoding.") + encoding = tiktoken.get_encoding("cl100k_base") return len(encoding.encode(string)) diff --git a/requirements.txt b/requirements.txt index 9954a9941..5cb01ab99 100644 --- a/requirements.txt +++ b/requirements.txt @@ -31,11 +31,11 @@ tenacity==8.2.2 tiktoken==0.5.2 tqdm==4.64.0 #unstructured[local-inference] -# playwright # selenium>4 # webdriver_manager<3.9 anthropic==0.3.6 typing-inspect==0.8.0 +aiofiles typing_extensions==4.7.0 libcst==1.0.1 qdrant-client==1.4.0 @@ -44,9 +44,18 @@ pytest-mock==3.11.1 ta==0.10.2 semantic-kernel==0.4.0.dev0 wrapt==1.15.0 -websocket-client==0.58.0 +#aiohttp_jinja2 +#azure-cognitiveservices-speech~=1.31.0 +#aioboto3~=11.3.0 +#redis==4.3.5 +websocket-client==1.6.2 aiofiles==23.2.1 gitpython==3.1.40 zhipuai==1.0.7 +socksio~=1.0.0 gitignore-parser==0.1.9 +# connexion[swagger-ui] +websockets~=12.0 +networkx~=3.2.1 google-generativeai==0.3.1 +playwright==1.40.0 \ No newline at end of file diff --git a/setup.py b/setup.py index 8ef2a6946..2163b4233 100644 --- a/setup.py +++ b/setup.py @@ -1,8 +1,6 @@ -"""wutils: handy tools -""" +"""Setup script for MetaGPT.""" import subprocess -from codecs import open -from os import path +from pathlib import Path from setuptools import Command, find_packages, setup @@ -20,13 +18,9 @@ class InstallMermaidCLI(Command): print(f"Error occurred: {e.output}") -here = path.abspath(path.dirname(__file__)) - -with open(path.join(here, "README.md"), encoding="utf-8") as f: - long_description = f.read() - -with open(path.join(here, "requirements.txt"), encoding="utf-8") as f: - requirements = [line.strip() for line in f if line] +here = Path(__file__).resolve().parent +long_description = (here / "README.md").read_text(encoding="utf-8") +requirements = (here / "requirements.txt").read_text(encoding="utf-8").splitlines() setup( name="metagpt", @@ -49,6 +43,8 @@ setup( "search-ddg": ["duckduckgo-search==3.8.5"], "pyppeteer": ["pyppeteer>=1.0.2"], "ocr": ["paddlepaddle==2.4.2", "paddleocr>=2.0.1", "tabulate==0.9.0"], + "dev": ["pylint~=3.0.3", "black~=23.3.0", "isort~=5.12.0", "pre-commit~=3.6.0"], + "test": ["pytest", "pytest-cov", "pytest-asyncio", "pytest-mock"], }, cmdclass={ "install_mermaid": InstallMermaidCLI, diff --git a/tests/conftest.py b/tests/conftest.py index b22e43e79..a4e57a3f3 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -13,17 +13,17 @@ from unittest.mock import Mock import pytest -from metagpt.config import CONFIG +from metagpt.config import CONFIG, Config from metagpt.const import DEFAULT_WORKSPACE_ROOT +from metagpt.llm import LLM from metagpt.logs import logger -from metagpt.provider.openai_api import OpenAIGPTAPI as GPTAPI from metagpt.utils.git_repository import GitRepository class Context: def __init__(self): self._llm_ui = None - self._llm_api = GPTAPI() + self._llm_api = LLM(provider=CONFIG.get_default_llm_provider_enum()) @property def llm_api(self): @@ -96,3 +96,8 @@ def setup_and_teardown_git_repo(request): # Register the function for destroying the environment. request.addfinalizer(fin) + + +@pytest.fixture(scope="session", autouse=True) +def init_config(): + Config() diff --git a/tests/metagpt/actions/mock_json.py b/tests/metagpt/actions/mock_json.py new file mode 100644 index 000000000..875d74d3c --- /dev/null +++ b/tests/metagpt/actions/mock_json.py @@ -0,0 +1,143 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +@Time : 2023/12/24 20:32 +@Author : alexanderwu +@File : mock_json.py +""" + +PRD = { + "Language": "zh_cn", + "Programming Language": "Python", + "Original Requirements": "写一个简单的cli贪吃蛇", + "Project Name": "cli_snake", + "Product Goals": ["创建一个简单易用的贪吃蛇游戏", "提供良好的用户体验", "支持不同难度级别"], + "User Stories": [ + "作为玩家，我希望能够选择不同的难度级别", + "作为玩家，我希望在每局游戏结束后能够看到我的得分", + "作为玩家，我希望在输掉游戏后能够重新开始", + "作为玩家，我希望看到简洁美观的界面", + "作为玩家，我希望能够在手机上玩游戏", + ], + "Competitive Analysis": ["贪吃蛇游戏A：界面简单，缺乏响应式特性", "贪吃蛇游戏B：美观且响应式的界面，显示最高得分", "贪吃蛇游戏C：响应式界面，显示最高得分，但有很多广告"], + "Competitive Quadrant Chart": 'quadrantChart\n title "Reach and engagement of campaigns"\n x-axis "Low Reach" --> "High Reach"\n y-axis "Low Engagement" --> "High Engagement"\n quadrant-1 "We should expand"\n quadrant-2 "Need to promote"\n quadrant-3 "Re-evaluate"\n quadrant-4 "May be improved"\n "Game A": [0.3, 0.6]\n "Game B": [0.45, 0.23]\n "Game C": [0.57, 0.69]\n "Game D": [0.78, 0.34]\n "Game E": [0.40, 0.34]\n "Game F": [0.35, 0.78]\n "Our Target Product": [0.5, 0.6]', + "Requirement Analysis": "", + "Requirement Pool": [["P0", "主要代码..."], ["P0", "游戏算法..."]], + "UI Design draft": "基本功能描述，简单的风格和布局。", + "Anything UNCLEAR": "", +} + + +DESIGN = { + "Implementation approach": "我们将使用Python编程语言，并选择合适的开源框架来实现贪吃蛇游戏。我们将分析需求中的难点，并选择合适的开源框架来简化开发流程。", + "File list": ["main.py", "game.py"], + "Data structures and interfaces": "\nclassDiagram\n class Game {\n -int width\n -int height\n -int score\n -int speed\n -List snake\n -Point food\n +__init__(width: int, height: int, speed: int)\n +start_game()\n +change_direction(direction: str)\n +game_over()\n +update_snake()\n +update_food()\n +check_collision()\n }\n class Point {\n -int x\n -int y\n +__init__(x: int, y: int)\n }\n Game --> Point\n", + "Program call flow": "\nsequenceDiagram\n participant M as Main\n participant G as Game\n M->>G: start_game()\n M->>G: change_direction(direction)\n G->>G: update_snake()\n G->>G: update_food()\n G->>G: check_collision()\n G-->>G: game_over()\n", + "Anything UNCLEAR": "", +} + + +TASKS = { + "Required Python packages": ["pygame==2.0.1"], + "Required Other language third-party packages": ["No third-party dependencies required"], + "Logic Analysis": [ + ["game.py", "Contains Game class and related functions for game logic"], + ["main.py", "Contains the main function, imports Game class from game.py"], + ], + "Task list": ["game.py", "main.py"], + "Full API spec": "", + "Shared Knowledge": "'game.py' contains functions shared across the project.", + "Anything UNCLEAR": "", +} + + +FILE_GAME = """## game.py + +import pygame +import random + +class Point: + def __init__(self, x: int, y: int): + self.x = x + self.y = y + +class Game: + def __init__(self, width: int, height: int, speed: int): + self.width = width + self.height = height + self.score = 0 + self.speed = speed + self.snake = [Point(width // 2, height // 2)] + self.food = self._create_food() + + def start_game(self): + pygame.init() + self._display = pygame.display.set_mode((self.width, self.height)) + pygame.display.set_caption('Snake Game') + self._clock = pygame.time.Clock() + self._running = True + + while self._running: + self._handle_events() + self._update_snake() + self._update_food() + self._check_collision() + self._draw_screen() + self._clock.tick(self.speed) + + def change_direction(self, direction: str): + # Update the direction of the snake based on user input + pass + + def game_over(self): + # Display game over message and handle game over logic + pass + + def _create_food(self) -> Point: + # Create and return a new food Point + return Point(random.randint(0, self.width - 1), random.randint(0, self.height - 1)) + + def _handle_events(self): + for event in pygame.event.get(): + if event.type == pygame.QUIT: + self._running = False + + def _update_snake(self): + # Update the position of the snake based on its direction + pass + + def _update_food(self): + # Update the position of the food if the snake eats it + pass + + def _check_collision(self): + # Check for collision between the snake and the walls or itself + pass + + def _draw_screen(self): + self._display.fill((0, 0, 0)) # Clear the screen + # Draw the snake and food on the screen + pygame.display.update() + +if __name__ == "__main__": + game = Game(800, 600, 15) + game.start_game() +""" + +FILE_GAME_CR_1 = """## Code Review: game.py +1. Yes, the code is implemented as per the requirements. It initializes the game with the specified width, height, and speed, and starts the game loop. +2. No, the logic for handling events and updating the snake, food, and collision is not implemented. To correct this, we need to implement the logic for handling events, updating the snake and food positions, and checking for collisions. +3. Yes, the existing code follows the "Data structures and interfaces" by defining the Game and Point classes with the specified attributes and methods. +4. No, several functions such as change_direction, game_over, _update_snake, _update_food, and _check_collision are not implemented. These functions need to be implemented to complete the game logic. +5. Yes, all necessary pre-dependencies have been imported. The required pygame package is imported at the beginning of the file. +6. No, methods from other files are not being reused as there are no other files being imported or referenced in the current code. + +## Actions +1. Implement the logic for handling events, updating the snake and food positions, and checking for collisions within the Game class. +2. Implement the change_direction and game_over methods to handle user input and game over logic. +3. Implement the _update_snake method to update the position of the snake based on its direction. +4. Implement the _update_food method to update the position of the food if the snake eats it. +5. Implement the _check_collision method to check for collision between the snake and the walls or itself. + +## Code Review Result +LBTM""" diff --git a/tests/metagpt/actions/mock.py b/tests/metagpt/actions/mock_markdown.py similarity index 99% rename from tests/metagpt/actions/mock.py rename to tests/metagpt/actions/mock_markdown.py index f6602a82b..c5d984146 100644 --- a/tests/metagpt/actions/mock.py +++ b/tests/metagpt/actions/mock_markdown.py @@ -3,7 +3,7 @@ """ @Time : 2023/5/18 23:51 @Author : alexanderwu -@File : mock.py +@File : mock_markdown.py """ PRD_SAMPLE = """## Original Requirements diff --git a/tests/metagpt/actions/test_action.py b/tests/metagpt/actions/test_action.py index 9775630cc..f750b5e6f 100644 --- a/tests/metagpt/actions/test_action.py +++ b/tests/metagpt/actions/test_action.py @@ -5,9 +5,16 @@ @Author : alexanderwu @File : test_action.py """ -from metagpt.actions import Action, WritePRD, WriteTest +from metagpt.actions import Action, ActionType, WritePRD, WriteTest def test_action_repr(): actions = [Action(), WriteTest(), WritePRD()] assert "WriteTest" in str(actions) + + +def test_action_type(): + assert ActionType.WRITE_PRD.value == WritePRD + assert ActionType.WRITE_TEST.value == WriteTest + assert ActionType.WRITE_PRD.name == "WRITE_PRD" + assert ActionType.WRITE_TEST.name == "WRITE_TEST" diff --git a/tests/metagpt/actions/test_action_node.py b/tests/metagpt/actions/test_action_node.py index 5bafe2bf2..92d8a1bbc 100644 --- a/tests/metagpt/actions/test_action_node.py +++ b/tests/metagpt/actions/test_action_node.py @@ -5,6 +5,8 @@ @Author : alexanderwu @File : test_action_node.py """ +from typing import List, Tuple + import pytest from metagpt.actions import Action @@ -29,7 +31,7 @@ async def test_debate_two_roles(): team = Team(investment=10.0, env=env, roles=[biden, trump]) history = await team.run(idea="Topic: climate change. Under 80 words per message.", send_to="Biden", n_round=3) - assert "BidenSay" in history + assert "Biden" in history @pytest.mark.asyncio @@ -39,7 +41,7 @@ async def test_debate_one_role_in_env(): env = Environment(desc="US election live broadcast") team = Team(investment=10.0, env=env, roles=[biden]) history = await team.run(idea="Topic: climate change. Under 80 words per message.", send_to="Biden", n_round=3) - assert "Debate" in history + assert "Biden" in history @pytest.mark.asyncio @@ -86,3 +88,47 @@ async def test_action_node_two_layer(): assert node_b in root.children.values() json_template = root.compile(context="123", schema="json", mode="auto") assert "i-a" in json_template + + +t_dict = { + "Required Python third-party packages": '"""\nflask==1.1.2\npygame==2.0.1\n"""\n', + "Required Other language third-party packages": '"""\nNo third-party packages required for other languages.\n"""\n', + "Full API spec": '"""\nopenapi: 3.0.0\ninfo:\n title: Web Snake Game API\n version: 1.0.0\npaths:\n /game:\n get:\n summary: Get the current game state\n responses:\n \'200\':\n description: A JSON object of the game state\n post:\n summary: Send a command to the game\n requestBody:\n required: true\n content:\n application/json:\n schema:\n type: object\n properties:\n command:\n type: string\n responses:\n \'200\':\n description: A JSON object of the updated game state\n"""\n', + "Logic Analysis": [ + ["app.py", "Main entry point for the Flask application. Handles HTTP requests and responses."], + ["game.py", "Contains the Game and Snake classes. Handles the game logic."], + ["static/js/script.js", "Handles user interactions and updates the game UI."], + ["static/css/styles.css", "Defines the styles for the game UI."], + ["templates/index.html", "The main page of the web application. Displays the game UI."], + ], + "Task list": ["game.py", "app.py", "static/css/styles.css", "static/js/script.js", "templates/index.html"], + "Shared Knowledge": "\"\"\"\n'game.py' contains the Game and Snake classes which are responsible for the game logic. The Game class uses an instance of the Snake class.\n\n'app.py' is the main entry point for the Flask application. It creates an instance of the Game class and handles HTTP requests and responses.\n\n'static/js/script.js' is responsible for handling user interactions and updating the game UI based on the game state returned by 'app.py'.\n\n'static/css/styles.css' defines the styles for the game UI.\n\n'templates/index.html' is the main page of the web application. It displays the game UI and loads 'static/js/script.js' and 'static/css/styles.css'.\n\"\"\"\n", + "Anything UNCLEAR": "We need clarification on how the high score should be stored. Should it persist across sessions (stored in a database or a file) or should it reset every time the game is restarted? Also, should the game speed increase as the snake grows, or should it remain constant throughout the game?", +} + +WRITE_TASKS_OUTPUT_MAPPING = { + "Required Python third-party packages": (str, ...), + "Required Other language third-party packages": (str, ...), + "Full API spec": (str, ...), + "Logic Analysis": (List[Tuple[str, str]], ...), + "Task list": (List[str], ...), + "Shared Knowledge": (str, ...), + "Anything UNCLEAR": (str, ...), +} + + +def test_create_model_class(): + test_class = ActionNode.create_model_class("test_class", WRITE_TASKS_OUTPUT_MAPPING) + assert test_class.__name__ == "test_class" + + +def test_create_model_class_with_mapping(): + t = ActionNode.create_model_class("test_class_1", WRITE_TASKS_OUTPUT_MAPPING) + t1 = t(**t_dict) + value = t1.dict()["Task list"] + assert value == ["game.py", "app.py", "static/css/styles.css", "static/js/script.js", "templates/index.html"] + + +if __name__ == "__main__": + test_create_model_class() + test_create_model_class_with_mapping() diff --git a/tests/metagpt/actions/test_action_output.py b/tests/metagpt/actions/test_action_output.py deleted file mode 100644 index f1765cb03..000000000 --- a/tests/metagpt/actions/test_action_output.py +++ /dev/null @@ -1,53 +0,0 @@ -#!/usr/bin/env python -# coding: utf-8 -""" -@Time : 2023/7/11 10:49 -@Author : chengmaoyu -@File : test_action_output -""" -from typing import List, Tuple - -from metagpt.actions.action_node import ActionNode - -t_dict = { - "Required Python third-party packages": '"""\nflask==1.1.2\npygame==2.0.1\n"""\n', - "Required Other language third-party packages": '"""\nNo third-party packages required for other languages.\n"""\n', - "Full API spec": '"""\nopenapi: 3.0.0\ninfo:\n title: Web Snake Game API\n version: 1.0.0\npaths:\n /game:\n get:\n summary: Get the current game state\n responses:\n \'200\':\n description: A JSON object of the game state\n post:\n summary: Send a command to the game\n requestBody:\n required: true\n content:\n application/json:\n schema:\n type: object\n properties:\n command:\n type: string\n responses:\n \'200\':\n description: A JSON object of the updated game state\n"""\n', - "Logic Analysis": [ - ["app.py", "Main entry point for the Flask application. Handles HTTP requests and responses."], - ["game.py", "Contains the Game and Snake classes. Handles the game logic."], - ["static/js/script.js", "Handles user interactions and updates the game UI."], - ["static/css/styles.css", "Defines the styles for the game UI."], - ["templates/index.html", "The main page of the web application. Displays the game UI."], - ], - "Task list": ["game.py", "app.py", "static/css/styles.css", "static/js/script.js", "templates/index.html"], - "Shared Knowledge": "\"\"\"\n'game.py' contains the Game and Snake classes which are responsible for the game logic. The Game class uses an instance of the Snake class.\n\n'app.py' is the main entry point for the Flask application. It creates an instance of the Game class and handles HTTP requests and responses.\n\n'static/js/script.js' is responsible for handling user interactions and updating the game UI based on the game state returned by 'app.py'.\n\n'static/css/styles.css' defines the styles for the game UI.\n\n'templates/index.html' is the main page of the web application. It displays the game UI and loads 'static/js/script.js' and 'static/css/styles.css'.\n\"\"\"\n", - "Anything UNCLEAR": "We need clarification on how the high score should be stored. Should it persist across sessions (stored in a database or a file) or should it reset every time the game is restarted? Also, should the game speed increase as the snake grows, or should it remain constant throughout the game?", -} - -WRITE_TASKS_OUTPUT_MAPPING = { - "Required Python third-party packages": (str, ...), - "Required Other language third-party packages": (str, ...), - "Full API spec": (str, ...), - "Logic Analysis": (List[Tuple[str, str]], ...), - "Task list": (List[str], ...), - "Shared Knowledge": (str, ...), - "Anything UNCLEAR": (str, ...), -} - - -def test_create_model_class(): - test_class = ActionNode.create_model_class("test_class", WRITE_TASKS_OUTPUT_MAPPING) - assert test_class.__name__ == "test_class" - - -def test_create_model_class_with_mapping(): - t = ActionNode.create_model_class("test_class_1", WRITE_TASKS_OUTPUT_MAPPING) - t1 = t(**t_dict) - value = t1.dict()["Task list"] - assert value == ["game.py", "app.py", "static/css/styles.css", "static/js/script.js", "templates/index.html"] - - -if __name__ == "__main__": - test_create_model_class() - test_create_model_class_with_mapping() diff --git a/tests/metagpt/actions/test_clone_function.py b/tests/metagpt/actions/test_clone_function.py index 44248eb80..93ead48bd 100644 --- a/tests/metagpt/actions/test_clone_function.py +++ b/tests/metagpt/actions/test_clone_function.py @@ -1,6 +1,13 @@ +import os +import tempfile + import pytest -from metagpt.actions.clone_function import CloneFunction, run_function_code +from metagpt.actions.clone_function import ( + CloneFunction, + run_function_code, + run_function_script, +) source_code = """ import pandas as pd @@ -55,3 +62,40 @@ async def test_clone_function(): assert not msg expected_df = get_expected_res() assert df.equals(expected_df) + + +def test_run_function_script(): + # 创建一个临时文件并写入脚本内容 + script_content = """def valid_function(arg1, arg2):\n return arg1 + arg2\n""" + with tempfile.NamedTemporaryFile(mode="w+", suffix=".py", delete=False) as temp_file: + temp_file.write(script_content) + temp_file_path = temp_file.name + + invalid_script_content = """def valid_function(arg1, arg2)\n return arg1 + arg2\n""" + with tempfile.NamedTemporaryFile(mode="w+", suffix=".py", delete=False) as error_temp_file: + error_temp_file.write(invalid_script_content) + error_temp_file_path = error_temp_file.name + + try: + # 正常情况下运行脚本 + result, _ = run_function_script(temp_file_path, "valid_function", 1, arg2=2) + assert result == 3 + + # 不存在的脚本路径 + with pytest.raises(FileNotFoundError): + run_function_script("nonexistent/path/script.py", "valid_function", 1, arg2=2) + + # 无效的脚本内容 + result, traceback = run_function_script(error_temp_file_path, "invalid_function", 1, arg2=2) + assert not result + assert "SyntaxError" in traceback + + # 函数调用失败的情况 + result, traceback = run_function_script(temp_file_path, "function_that_raises_exception", 1, arg2=2) + assert not result + assert "KeyError" in traceback + + finally: + # 删除临时文件 + if os.path.exists(temp_file_path): + os.remove(temp_file_path) diff --git a/tests/metagpt/actions/test_design_api.py b/tests/metagpt/actions/test_design_api.py index e90707d1a..8d4720570 100644 --- a/tests/metagpt/actions/test_design_api.py +++ b/tests/metagpt/actions/test_design_api.py @@ -13,7 +13,7 @@ from metagpt.const import PRDS_FILE_REPO from metagpt.logs import logger from metagpt.schema import Message from metagpt.utils.file_repository import FileRepository -from tests.metagpt.actions.mock import PRD_SAMPLE +from tests.metagpt.actions.mock_markdown import PRD_SAMPLE @pytest.mark.asyncio @@ -22,9 +22,9 @@ async def test_design_api(): for prd in inputs: await FileRepository.save_file("new_prd.txt", content=prd, relative_path=PRDS_FILE_REPO) - design_api = WriteDesign("design_api") + design_api = WriteDesign() - result = await design_api.run([Message(content=prd, instruct_content=None)]) + result = await design_api.run(Message(content=prd, instruct_content=None)) logger.info(result) assert result diff --git a/tests/metagpt/actions/test_design_api_review.py b/tests/metagpt/actions/test_design_api_review.py index 5cdc37357..cfc29056f 100644 --- a/tests/metagpt/actions/test_design_api_review.py +++ b/tests/metagpt/actions/test_design_api_review.py @@ -26,7 +26,7 @@ API列表: """ _ = "API设计看起来非常合理，满足了PRD中的所有需求。" - design_api_review = DesignReview("design_api_review") + design_api_review = DesignReview() result = await design_api_review.run(prd, api_design) diff --git a/tests/metagpt/actions/test_fix_bug.py b/tests/metagpt/actions/test_fix_bug.py new file mode 100644 index 000000000..b2dc8d0f4 --- /dev/null +++ b/tests/metagpt/actions/test_fix_bug.py @@ -0,0 +1,17 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +@Time : 2023/12/25 22:38 +@Author : alexanderwu +@File : test_fix_bug.py +""" + +import pytest + +from metagpt.actions.fix_bug import FixBug + + +@pytest.mark.asyncio +async def test_fix_bug(): + fix_bug = FixBug() + assert fix_bug.name == "FixBug" diff --git a/tests/metagpt/actions/test_project_management.py b/tests/metagpt/actions/test_project_management.py index 13e6d2247..88263ff29 100644 --- a/tests/metagpt/actions/test_project_management.py +++ b/tests/metagpt/actions/test_project_management.py @@ -6,10 +6,26 @@ @File : test_project_management.py """ +import pytest -class TestCreateProjectPlan: - pass +from metagpt.actions.project_management import WriteTasks +from metagpt.config import CONFIG +from metagpt.const import PRDS_FILE_REPO, SYSTEM_DESIGN_FILE_REPO +from metagpt.logs import logger +from metagpt.schema import Message +from metagpt.utils.file_repository import FileRepository +from tests.metagpt.actions.mock_json import DESIGN, PRD -class TestAssignTasks: - pass +@pytest.mark.asyncio +async def test_design_api(): + await FileRepository.save_file("1.txt", content=str(PRD), relative_path=PRDS_FILE_REPO) + await FileRepository.save_file("1.txt", content=str(DESIGN), relative_path=SYSTEM_DESIGN_FILE_REPO) + logger.info(CONFIG.git_repo) + + action = WriteTasks() + + result = await action.run(Message(content="", instruct_content=None)) + logger.info(result) + + assert result diff --git a/tests/metagpt/actions/test_rebuild_class_view.py b/tests/metagpt/actions/test_rebuild_class_view.py new file mode 100644 index 000000000..955c6ae3b --- /dev/null +++ b/tests/metagpt/actions/test_rebuild_class_view.py @@ -0,0 +1,24 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +@Time : 2023/12/20 +@Author : mashenquan +@File : test_rebuild_class_view.py +@Desc : Unit tests for rebuild_class_view.py +""" +from pathlib import Path + +import pytest + +from metagpt.actions.rebuild_class_view import RebuildClassView +from metagpt.llm import LLM + + +@pytest.mark.asyncio +async def test_rebuild(): + action = RebuildClassView(name="RedBean", context=Path(__file__).parent.parent, llm=LLM()) + await action.run() + + +if __name__ == "__main__": + pytest.main([__file__, "-s"]) diff --git a/tests/metagpt/actions/test_skill_action.py b/tests/metagpt/actions/test_skill_action.py new file mode 100644 index 000000000..ab764930c --- /dev/null +++ b/tests/metagpt/actions/test_skill_action.py @@ -0,0 +1,65 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +@Time : 2023/9/19 +@Author : mashenquan +@File : test_skill_action.py +@Desc : Unit tests. +""" +import pytest + +from metagpt.actions.skill_action import ArgumentsParingAction, SkillAction +from metagpt.learn.skill_loader import Example, Parameter, Returns, Skill + + +class TestSkillAction: + skill = Skill( + name="text_to_image", + description="Create a drawing based on the text.", + id="text_to_image.text_to_image", + x_prerequisite={ + "configurations": { + "OPENAI_API_KEY": { + "type": "string", + "description": "OpenAI API key, For more details, checkout: `https://platform.openai.com/account/api-keys`", + }, + "METAGPT_TEXT_TO_IMAGE_MODEL_URL": {"type": "string", "description": "Model url."}, + }, + "required": {"oneOf": ["OPENAI_API_KEY", "METAGPT_TEXT_TO_IMAGE_MODEL_URL"]}, + }, + parameters={ + "text": Parameter(type="string", description="The text used for image conversion."), + "size_type": Parameter(type="string", description="size type"), + }, + examples=[ + Example(ask="Draw a girl", answer='text_to_image(text="Draw a girl", size_type="512x512")'), + Example(ask="Draw an apple", answer='text_to_image(text="Draw an apple", size_type="512x512")'), + ], + returns=Returns(type="string", format="base64"), + ) + + @pytest.mark.asyncio + async def test_parser(self): + args = ArgumentsParingAction.parse_arguments( + skill_name="text_to_image", txt='`text_to_image(text="Draw an apple", size_type="512x512")`' + ) + assert args.get("text") == "Draw an apple" + assert args.get("size_type") == "512x512" + + @pytest.mark.asyncio + async def test_parser_action(self): + parser_action = ArgumentsParingAction(skill=self.skill, ask="Draw an apple") + rsp = await parser_action.run() + assert rsp + assert parser_action.args + assert parser_action.args.get("text") == "Draw an apple" + assert parser_action.args.get("size_type") == "512x512" + + action = SkillAction(skill=self.skill, args=parser_action.args) + rsp = await action.run() + assert rsp + assert "image/png;base64," in rsp.content + + +if __name__ == "__main__": + pytest.main([__file__, "-s"]) diff --git a/tests/metagpt/actions/test_write_code.py b/tests/metagpt/actions/test_write_code.py index 54229089c..ba7cb6f2d 100644 --- a/tests/metagpt/actions/test_write_code.py +++ b/tests/metagpt/actions/test_write_code.py @@ -9,10 +9,10 @@ import pytest from metagpt.actions.write_code import WriteCode -from metagpt.llm import LLM from metagpt.logs import logger +from metagpt.provider.openai_api import OpenAIGPTAPI as LLM from metagpt.schema import CodingContext, Document -from tests.metagpt.actions.mock import TASKS_2, WRITE_CODE_PROMPT_SAMPLE +from tests.metagpt.actions.mock_markdown import TASKS_2, WRITE_CODE_PROMPT_SAMPLE @pytest.mark.asyncio diff --git a/tests/metagpt/actions/test_write_teaching_plan.py b/tests/metagpt/actions/test_write_teaching_plan.py new file mode 100644 index 000000000..3f25b2167 --- /dev/null +++ b/tests/metagpt/actions/test_write_teaching_plan.py @@ -0,0 +1,58 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +@Time : 2023/7/28 17:25 +@Author : mashenquan +@File : test_write_teaching_plan.py +""" + +import asyncio +from typing import Optional + +from langchain.llms.base import LLM +from pydantic import BaseModel + +from metagpt.actions.write_teaching_plan import WriteTeachingPlanPart +from metagpt.config import Config +from metagpt.schema import Message + + +class MockWriteTeachingPlanPart(WriteTeachingPlanPart): + def __init__(self, options, name: str = "", context=None, llm: LLM = None, topic="", language="Chinese"): + super().__init__(options, name, context, llm, topic, language) + + async def _aask(self, prompt: str, system_msgs: Optional[list[str]] = None) -> str: + return f"{WriteTeachingPlanPart.DATA_BEGIN_TAG}\nprompt\n{WriteTeachingPlanPart.DATA_END_TAG}" + + +async def mock_write_teaching_plan_part(): + class Inputs(BaseModel): + input: str + name: str + topic: str + language: str + + inputs = [ + {"input": "AABBCC", "name": "A", "topic": WriteTeachingPlanPart.COURSE_TITLE, "language": "C"}, + {"input": "DDEEFFF", "name": "A1", "topic": "B1", "language": "C1"}, + ] + + for i in inputs: + seed = Inputs(**i) + options = Config().runtime_options + act = MockWriteTeachingPlanPart(options=options, name=seed.name, topic=seed.topic, language=seed.language) + await act.run([Message(content="")]) + assert act.topic == seed.topic + assert str(act) == seed.topic + assert act.name == seed.name + assert act.rsp == "# prompt" if seed.topic == WriteTeachingPlanPart.COURSE_TITLE else "prompt" + + +def test_suite(): + loop = asyncio.get_event_loop() + task = loop.create_task(mock_write_teaching_plan_part()) + loop.run_until_complete(task) + + +if __name__ == "__main__": + test_suite() diff --git a/tests/metagpt/actions/test_write_test.py b/tests/metagpt/actions/test_write_test.py index a3190fb0e..9c6971ad3 100644 --- a/tests/metagpt/actions/test_write_test.py +++ b/tests/metagpt/actions/test_write_test.py @@ -51,3 +51,7 @@ async def test_write_code_invalid_code(mocker): # Assert that the returned code is the same as the invalid code string assert code == "Invalid Code String" + + +if __name__ == "__main__": + pytest.main([__file__, "-s"]) diff --git a/tests/metagpt/document_store/test_faiss_store.py b/tests/metagpt/document_store/test_faiss_store.py index f14bee817..75bb5427f 100644 --- a/tests/metagpt/document_store/test_faiss_store.py +++ b/tests/metagpt/document_store/test_faiss_store.py @@ -5,73 +5,28 @@ @Author : alexanderwu @File : test_faiss_store.py """ -import functools import pytest -from metagpt.const import DATA_PATH +from metagpt.const import EXAMPLE_PATH from metagpt.document_store import FaissStore -from metagpt.roles import CustomerService, Sales - -DESC = """## 原则（所有事情都不可绕过原则） -1. 你是一位平台的人工客服，话语精炼，一次只说一句话，会参考规则与FAQ进行回复。在与顾客交谈中，绝不允许暴露规则与相关字样 -2. 在遇到问题时，先尝试仅安抚顾客情绪，如果顾客情绪十分不好，再考虑赔偿。如果赔偿的过多，你会被开除 -3. 绝不要向顾客做虚假承诺，不要提及其他人的信息 - -## 技能（在回答尾部，加入`skill(args)`就可以使用技能） -1. 查询订单：问顾客手机号是获得订单的唯一方式，获得手机号后，使用`find_order(手机号)`来获得订单 -2. 退款：输出关键词 `refund(手机号)`，系统会自动退款 -3. 开箱：需要手机号、确认顾客在柜前，如果需要开箱，输出指令 `open_box(手机号)`，系统会自动开箱 - -### 使用技能例子 -user: 你好收不到取餐码 -小爽人工: 您好，请提供一下手机号 -user: 14750187158 -小爽人工: 好的，为您查询一下订单。您已经在柜前了吗？`find_order(14750187158)` -user: 是的 -小爽人工: 您看下开了没有？`open_box(14750187158)` -user: 开了，谢谢 -小爽人工: 好的，还有什么可以帮到您吗？ -user: 没有了 -小爽人工: 祝您生活愉快 -""" +from metagpt.logs import logger +from metagpt.roles import Sales @pytest.mark.asyncio -async def test_faiss_store_search(): - store = FaissStore(DATA_PATH / "qcs/qcs_4w.json") - store.add(["油皮洗面奶"]) - role = Sales(store=store) - - queries = ["油皮洗面奶", "介绍下欧莱雅的"] - for query in queries: - rsp = await role.run(query) - assert rsp - - -def customer_service(): - store = FaissStore(DATA_PATH / "st/faq.xlsx", content_col="Question", meta_col="Answer") - store.search = functools.partial(store.search, expand_cols=True) - role = CustomerService(profile="小爽人工", desc=DESC, store=store) - return role +async def test_search_json(): + store = FaissStore(EXAMPLE_PATH / "example.json") + role = Sales(profile="Sales", store=store) + query = "Which facial cleanser is good for oily skin?" + result = await role.run(query) + logger.info(result) @pytest.mark.asyncio -async def test_faiss_store_customer_service(): - allq = [ - # ["我的餐怎么两小时都没到", "退货吧"], - [ - "你好收不到取餐码，麻烦帮我开箱", - "14750187158", - ] - ] - role = customer_service() - for queries in allq: - for query in queries: - rsp = await role.run(query) - assert rsp - - -def test_faiss_store_no_file(): - with pytest.raises(FileNotFoundError): - FaissStore(DATA_PATH / "wtf.json") +async def test_search_xlsx(): + store = FaissStore(EXAMPLE_PATH / "example.xlsx") + role = Sales(profile="Sales", store=store) + query = "Which facial cleanser is good for oily skin?" + result = await role.run(query) + logger.info(result) diff --git a/tests/metagpt/learn/__init__.py b/tests/metagpt/learn/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/tests/metagpt/learn/test_google_search.py b/tests/metagpt/learn/test_google_search.py new file mode 100644 index 000000000..da32e8923 --- /dev/null +++ b/tests/metagpt/learn/test_google_search.py @@ -0,0 +1,27 @@ +import asyncio + +from pydantic import BaseModel + +from metagpt.learn.google_search import google_search + + +async def mock_google_search(): + class Input(BaseModel): + input: str + + inputs = [{"input": "ai agent"}] + + for i in inputs: + seed = Input(**i) + result = await google_search(seed.input) + assert result != "" + + +def test_suite(): + loop = asyncio.get_event_loop() + task = loop.create_task(mock_google_search()) + loop.run_until_complete(task) + + +if __name__ == "__main__": + test_suite() diff --git a/tests/metagpt/learn/test_skill_loader.py b/tests/metagpt/learn/test_skill_loader.py new file mode 100644 index 000000000..0aac80a66 --- /dev/null +++ b/tests/metagpt/learn/test_skill_loader.py @@ -0,0 +1,43 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +@Time : 2023/9/19 +@Author : mashenquan +@File : test_skill_loader.py +@Desc : Unit tests. +""" +import pytest + +from metagpt.config import CONFIG +from metagpt.learn.skill_loader import SkillsDeclaration + + +@pytest.mark.asyncio +async def test_suite(): + CONFIG.agent_skills = [ + {"id": 1, "name": "text_to_speech", "type": "builtin", "config": {}, "enabled": True}, + {"id": 2, "name": "text_to_image", "type": "builtin", "config": {}, "enabled": True}, + {"id": 3, "name": "ai_call", "type": "builtin", "config": {}, "enabled": True}, + {"id": 3, "name": "data_analysis", "type": "builtin", "config": {}, "enabled": True}, + {"id": 5, "name": "crawler", "type": "builtin", "config": {"engine": "ddg"}, "enabled": True}, + {"id": 6, "name": "knowledge", "type": "builtin", "config": {}, "enabled": True}, + {"id": 6, "name": "web_search", "type": "builtin", "config": {}, "enabled": True}, + ] + loader = await SkillsDeclaration.load() + skills = loader.get_skill_list() + assert skills + assert len(skills) >= 3 + for desc, name in skills.items(): + assert desc + assert name + + entity = loader.entities.get("Assistant") + assert entity + assert entity.skills + for sk in entity.skills: + assert sk + assert sk.arguments + + +if __name__ == "__main__": + pytest.main([__file__, "-s"]) diff --git a/tests/metagpt/learn/test_text_to_embedding.py b/tests/metagpt/learn/test_text_to_embedding.py new file mode 100644 index 000000000..e3d20a759 --- /dev/null +++ b/tests/metagpt/learn/test_text_to_embedding.py @@ -0,0 +1,38 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +@Time : 2023/8/18 +@Author : mashenquan +@File : test_text_to_embedding.py +@Desc : Unit tests. +""" + +import asyncio + +from pydantic import BaseModel + +from metagpt.learn.text_to_embedding import text_to_embedding +from metagpt.tools.openai_text_to_embedding import ResultEmbedding + + +async def mock_text_to_embedding(): + class Input(BaseModel): + input: str + + inputs = [{"input": "Panda emoji"}] + + for i in inputs: + seed = Input(**i) + data = await text_to_embedding(seed.input) + v = ResultEmbedding(**data) + assert len(v.data) > 0 + + +def test_suite(): + loop = asyncio.get_event_loop() + task = loop.create_task(mock_text_to_embedding()) + loop.run_until_complete(task) + + +if __name__ == "__main__": + test_suite() diff --git a/tests/metagpt/learn/test_text_to_image.py b/tests/metagpt/learn/test_text_to_image.py new file mode 100644 index 000000000..a6cbc45bf --- /dev/null +++ b/tests/metagpt/learn/test_text_to_image.py @@ -0,0 +1,42 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +@Time : 2023/8/18 +@Author : mashenquan +@File : test_text_to_image.py +@Desc : Unit tests. +""" + +import base64 + +import pytest +from pydantic import BaseModel + +from metagpt.learn.text_to_image import text_to_image + + +@pytest.mark.asyncio +async def test(): + class Input(BaseModel): + input: str + size_type: str + + inputs = [{"input": "Panda emoji", "size_type": "512x512"}] + + for i in inputs: + seed = Input(**i) + base64_data = await text_to_image(seed.input) + assert base64_data != "" + print(f"{seed.input} -> {base64_data}") + flags = ";base64," + assert flags in base64_data + ix = base64_data.find(flags) + len(flags) + declaration = base64_data[0:ix] + assert declaration + data = base64_data[ix:] + assert data + assert base64.b64decode(data, validate=True) + + +if __name__ == "__main__": + pytest.main([__file__, "-s"]) diff --git a/tests/metagpt/learn/test_text_to_speech.py b/tests/metagpt/learn/test_text_to_speech.py new file mode 100644 index 000000000..42b6839fa --- /dev/null +++ b/tests/metagpt/learn/test_text_to_speech.py @@ -0,0 +1,45 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +@Time : 2023/8/18 +@Author : mashenquan +@File : test_text_to_speech.py +@Desc : Unit tests. +""" +import asyncio +import base64 + +from pydantic import BaseModel + +from metagpt.learn.text_to_speech import text_to_speech + + +async def mock_text_to_speech(): + class Input(BaseModel): + input: str + + inputs = [{"input": "Panda emoji"}] + + for i in inputs: + seed = Input(**i) + base64_data = await text_to_speech(seed.input) + assert base64_data != "" + print(f"{seed.input} -> {base64_data}") + flags = ";base64," + assert flags in base64_data + ix = base64_data.find(flags) + len(flags) + declaration = base64_data[0:ix] + assert declaration + data = base64_data[ix:] + assert data + assert base64.b64decode(data, validate=True) + + +def test_suite(): + loop = asyncio.get_event_loop() + task = loop.create_task(mock_text_to_speech()) + loop.run_until_complete(task) + + +if __name__ == "__main__": + test_suite() diff --git a/tests/metagpt/memory/test_brain_memory.py b/tests/metagpt/memory/test_brain_memory.py new file mode 100644 index 000000000..32e58c70e --- /dev/null +++ b/tests/metagpt/memory/test_brain_memory.py @@ -0,0 +1,51 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +@Time : 2023/8/27 +@Author : mashenquan +@File : test_brain_memory.py +""" +# import json +# from typing import List +# +# import pydantic +# +# from metagpt.memory.brain_memory import BrainMemory +# from metagpt.schema import Message +# +# +# def test_json(): +# class Input(pydantic.BaseModel): +# history: List[str] +# solution: List[str] +# knowledge: List[str] +# stack: List[str] +# +# inputs = [{"history": ["a", "b"], "solution": ["c"], "knowledge": ["d", "e"], "stack": ["f"]}] +# +# for i in inputs: +# v = Input(**i) +# bm = BrainMemory() +# for h in v.history: +# msg = Message(content=h) +# bm.history.append(msg.dict()) +# for h in v.solution: +# msg = Message(content=h) +# bm.solution.append(msg.dict()) +# for h in v.knowledge: +# msg = Message(content=h) +# bm.knowledge.append(msg.dict()) +# for h in v.stack: +# msg = Message(content=h) +# bm.stack.append(msg.dict()) +# s = bm.json() +# m = json.loads(s) +# bm = BrainMemory(**m) +# assert bm +# for v in bm.history: +# msg = Message(**v) +# assert msg +# +# +# if __name__ == "__main__": +# test_json() diff --git a/tests/metagpt/memory/test_longterm_memory.py b/tests/metagpt/memory/test_longterm_memory.py index b6ae0ac79..ac33552b3 100644 --- a/tests/metagpt/memory/test_longterm_memory.py +++ b/tests/metagpt/memory/test_longterm_memory.py @@ -2,22 +2,25 @@ # -*- coding: utf-8 -*- """ @Desc : unittest of `metagpt/memory/longterm_memory.py` +@Modified By: mashenquan, 2023/8/20. Remove global configuration `CONFIG`, enable configuration support for business isolation. """ +import os + from metagpt.actions import UserRequirement from metagpt.config import CONFIG -from metagpt.memory import LongTermMemory +from metagpt.memory.longterm_memory import LongTermMemory from metagpt.roles.role import RoleContext from metagpt.schema import Message def test_ltm_search(): assert hasattr(CONFIG, "long_term_memory") is True - openai_api_key = CONFIG.openai_api_key - assert len(openai_api_key) > 20 + os.environ.setdefault("OPENAI_API_KEY", CONFIG.openai_api_key) + assert len(CONFIG.openai_api_key) > 20 role_id = "UTUserLtm(Product Manager)" - rc = RoleContext(watch=[UserRequirement]) + rc = RoleContext(watch={"metagpt.actions.add_requirement.UserRequirement"}) ltm = LongTermMemory() ltm.recover_memory(role_id, rc) @@ -28,6 +31,7 @@ def test_ltm_search(): ltm.add(message) sim_idea = "Write a game of cli snake" + sim_message = Message(role="User", content=sim_idea, cause_by=UserRequirement) news = ltm.find_news([sim_message]) assert len(news) == 0 diff --git a/tests/metagpt/memory/test_memory.py b/tests/metagpt/memory/test_memory.py new file mode 100644 index 000000000..36d7ad488 --- /dev/null +++ b/tests/metagpt/memory/test_memory.py @@ -0,0 +1,57 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +# @Desc : the unittest of Memory + +from metagpt.actions import UserRequirement +from metagpt.memory.memory import Memory +from metagpt.schema import Message + + +def test_memory(): + memory = Memory() + + message1 = Message(content="test message1", role="user1") + message2 = Message(content="test message2", role="user2") + message3 = Message(content="test message3", role="user1") + memory.add(message1) + assert memory.count() == 1 + + memory.delete_newest() + assert memory.count() == 0 + + memory.add_batch([message1, message2]) + assert memory.count() == 2 + assert len(memory.index.get(message1.cause_by)) == 2 + + messages = memory.get_by_role("user1") + assert messages[0].content == message1.content + + messages = memory.get_by_content("test message") + assert len(messages) == 2 + + messages = memory.get_by_action(UserRequirement) + assert len(messages) == 2 + + messages = memory.get_by_actions([UserRequirement]) + assert len(messages) == 2 + + messages = memory.try_remember("test message") + assert len(messages) == 2 + + messages = memory.get(k=1) + assert len(messages) == 1 + + messages = memory.get(k=5) + assert len(messages) == 2 + + messages = memory.find_news([message3]) + assert len(messages) == 1 + + memory.delete(message1) + assert memory.count() == 1 + messages = memory.get_by_role("user2") + assert messages[0].content == message2.content + + memory.clear() + assert memory.count() == 0 + assert len(memory.index) == 0 diff --git a/tests/metagpt/memory/test_memory_storage.py b/tests/metagpt/memory/test_memory_storage.py index 7b74eb512..f1cc12aac 100644 --- a/tests/metagpt/memory/test_memory_storage.py +++ b/tests/metagpt/memory/test_memory_storage.py @@ -4,20 +4,28 @@ @Desc : the unittests of metagpt/memory/memory_storage.py """ - +import os +import shutil +from pathlib import Path from typing import List from metagpt.actions import UserRequirement, WritePRD from metagpt.actions.action_node import ActionNode +from metagpt.config import CONFIG +from metagpt.const import DATA_PATH from metagpt.memory.memory_storage import MemoryStorage from metagpt.schema import Message +os.environ.setdefault("OPENAI_API_KEY", CONFIG.openai_api_key) + def test_idea_message(): idea = "Write a cli snake game" role_id = "UTUser1(Product Manager)" message = Message(role="User", content=idea, cause_by=UserRequirement) + shutil.rmtree(Path(DATA_PATH / f"role_mem/{role_id}/")) + memory_storage: MemoryStorage = MemoryStorage() messages = memory_storage.recover_memory(role_id) assert len(messages) == 0 @@ -27,12 +35,12 @@ def test_idea_message(): sim_idea = "Write a game of cli snake" sim_message = Message(role="User", content=sim_idea, cause_by=UserRequirement) - new_messages = memory_storage.search(sim_message) + new_messages = memory_storage.search_dissimilar(sim_message) assert len(new_messages) == 0 # similar, return [] new_idea = "Write a 2048 web game" new_message = Message(role="User", content=new_idea, cause_by=UserRequirement) - new_messages = memory_storage.search(new_message) + new_messages = memory_storage.search_dissimilar(new_message) assert new_messages[0].content == message.content memory_storage.clean() @@ -50,6 +58,8 @@ def test_actionout_message(): content=content, instruct_content=ic_obj(**out_data), role="user", cause_by=WritePRD ) # WritePRD as test action + shutil.rmtree(Path(DATA_PATH / f"role_mem/{role_id}/")) + memory_storage: MemoryStorage = MemoryStorage() messages = memory_storage.recover_memory(role_id) assert len(messages) == 0 @@ -59,12 +69,12 @@ def test_actionout_message(): sim_conent = "The request is command-line interface (CLI) snake game" sim_message = Message(content=sim_conent, instruct_content=ic_obj(**out_data), role="user", cause_by=WritePRD) - new_messages = memory_storage.search(sim_message) + new_messages = memory_storage.search_dissimilar(sim_message) assert len(new_messages) == 0 # similar, return [] new_conent = "Incorporate basic features of a snake game such as scoring and increasing difficulty" new_message = Message(content=new_conent, instruct_content=ic_obj(**out_data), role="user", cause_by=WritePRD) - new_messages = memory_storage.search(new_message) + new_messages = memory_storage.search_dissimilar(new_message) assert new_messages[0].content == message.content memory_storage.clean() diff --git a/tests/metagpt/provider/test_anthropic_api.py b/tests/metagpt/provider/test_anthropic_api.py new file mode 100644 index 000000000..4d3de5320 --- /dev/null +++ b/tests/metagpt/provider/test_anthropic_api.py @@ -0,0 +1,29 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +# @Desc : the unittest of Claude2 + +import pytest + +from metagpt.provider.anthropic_api import Claude2 + +prompt = "who are you" +resp = "I'am Claude2" + + +def mock_llm_ask(self, msg: str) -> str: + return resp + + +async def mock_llm_aask(self, msg: str) -> str: + return resp + + +def test_claude2_ask(mocker): + mocker.patch("metagpt.provider.anthropic_api.Claude2.ask", mock_llm_ask) + assert resp == Claude2().ask(prompt) + + +@pytest.mark.asyncio +async def test_claude2_aask(mocker): + mocker.patch("metagpt.provider.anthropic_api.Claude2.aask", mock_llm_aask) + assert resp == await Claude2().aask(prompt) diff --git a/tests/metagpt/provider/test_base_gpt_api.py b/tests/metagpt/provider/test_base_gpt_api.py index 6cfe3b02d..aaa7b64ff 100644 --- a/tests/metagpt/provider/test_base_gpt_api.py +++ b/tests/metagpt/provider/test_base_gpt_api.py @@ -6,10 +6,106 @@ @File : test_base_gpt_api.py """ +import pytest + +from metagpt.provider.base_gpt_api import BaseGPTAPI from metagpt.schema import Message +default_chat_resp = { + "choices": [ + { + "index": 0, + "message": { + "role": "assistant", + "content": "I'am GPT", + }, + "finish_reason": "stop", + } + ] +} +prompt_msg = "who are you" +resp_content = default_chat_resp["choices"][0]["message"]["content"] -def test_message(): - message = Message(role="user", content="wtf") + +class MockBaseGPTAPI(BaseGPTAPI): + def completion(self, messages: list[dict], timeout=3): + return default_chat_resp + + async def acompletion(self, messages: list[dict], timeout=3): + return default_chat_resp + + async def acompletion_text(self, messages: list[dict], stream=False, generator: bool = False, timeout=3) -> str: + return resp_content + + async def close(self): + return default_chat_resp + + +def test_base_gpt_api(): + message = Message(role="user", content="hello") assert "role" in message.to_dict() assert "user" in str(message) + + base_gpt_api = MockBaseGPTAPI() + msg_prompt = base_gpt_api.messages_to_prompt([message]) + assert msg_prompt == "user: hello" + + msg_dict = base_gpt_api.messages_to_dict([message]) + assert msg_dict == [{"role": "user", "content": "hello"}] + + openai_funccall_resp = { + "choices": [ + { + "index": 0, + "message": { + "role": "assistant", + "content": "test", + "tool_calls": [ + { + "id": "call_Y5r6Ddr2Qc2ZrqgfwzPX5l72", + "type": "function", + "function": { + "name": "execute", + "arguments": '{\n "language": "python",\n "code": "print(\'Hello, World!\')"\n}', + }, + } + ], + }, + "finish_reason": "stop", + } + ] + } + func: dict = base_gpt_api.get_choice_function(openai_funccall_resp) + assert func == { + "name": "execute", + "arguments": '{\n "language": "python",\n "code": "print(\'Hello, World!\')"\n}', + } + + func_args: dict = base_gpt_api.get_choice_function_arguments(openai_funccall_resp) + assert func_args == {"language": "python", "code": "print('Hello, World!')"} + + choice_text = base_gpt_api.get_choice_text(openai_funccall_resp) + assert choice_text == openai_funccall_resp["choices"][0]["message"]["content"] + + resp = base_gpt_api.ask(prompt_msg) + assert resp == resp_content + + resp = base_gpt_api.ask_batch([prompt_msg]) + assert resp == resp_content + + resp = base_gpt_api.ask_code([prompt_msg]) + assert resp == resp_content + + +@pytest.mark.asyncio +async def test_async_base_gpt_api(): + base_gpt_api = MockBaseGPTAPI() + + resp = await base_gpt_api.aask(prompt_msg) + assert resp == resp_content + + resp = await base_gpt_api.aask_batch([prompt_msg]) + assert resp == resp_content + + resp = await base_gpt_api.aask_code([prompt_msg]) + assert resp == resp_content diff --git a/tests/metagpt/provider/test_fireworks_api.py b/tests/metagpt/provider/test_fireworks_api.py new file mode 100644 index 000000000..caf8b9f45 --- /dev/null +++ b/tests/metagpt/provider/test_fireworks_api.py @@ -0,0 +1,91 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +# @Desc : the unittest of fireworks api + +import pytest +from openai.types.chat.chat_completion import ( + ChatCompletion, + ChatCompletionMessage, + Choice, +) +from openai.types.completion_usage import CompletionUsage + +from metagpt.provider.fireworks_api import ( + MODEL_GRADE_TOKEN_COSTS, + FireworksCostManager, + FireWorksGPTAPI, +) + +resp_content = "I'm fireworks" +default_resp = ChatCompletion( + id="cmpl-a6652c1bb181caae8dd19ad8", + model="accounts/fireworks/models/llama-v2-13b-chat", + object="chat.completion", + created=1703300855, + choices=[ + Choice(finish_reason="stop", index=0, message=ChatCompletionMessage(role="assistant", content=resp_content)) + ], + usage=CompletionUsage(completion_tokens=110, prompt_tokens=92, total_tokens=202), +) + +prompt_msg = "who are you" +messages = [{"role": "user", "content": prompt_msg}] + + +def test_fireworks_costmanager(): + cost_manager = FireworksCostManager() + assert MODEL_GRADE_TOKEN_COSTS["-1"] == cost_manager.model_grade_token_costs("test") + assert MODEL_GRADE_TOKEN_COSTS["-1"] == cost_manager.model_grade_token_costs("xxx-81b-chat") + assert MODEL_GRADE_TOKEN_COSTS["16"] == cost_manager.model_grade_token_costs("llama-v2-13b-chat") + assert MODEL_GRADE_TOKEN_COSTS["16"] == cost_manager.model_grade_token_costs("xxx-15.5b-chat") + assert MODEL_GRADE_TOKEN_COSTS["16"] == cost_manager.model_grade_token_costs("xxx-16b-chat") + assert MODEL_GRADE_TOKEN_COSTS["80"] == cost_manager.model_grade_token_costs("xxx-80b-chat") + assert MODEL_GRADE_TOKEN_COSTS["mixtral-8x7b"] == cost_manager.model_grade_token_costs("mixtral-8x7b-chat") + + +def mock_llm_completion(self, messages: list[dict], timeout: int = 60) -> ChatCompletion: + return default_resp + + +async def mock_llm_acompletion(self, messgaes: list[dict], stream: bool = False, timeout: int = 60) -> ChatCompletion: + return default_resp + + +async def mock_llm_achat_completion_stream(self, messgaes: list[dict]) -> str: + return default_resp.choices[0].message.content + + +def test_fireworks_completion(mocker): + mocker.patch("metagpt.provider.fireworks_api.FireWorksGPTAPI.completion", mock_llm_completion) + fireworks_gpt = FireWorksGPTAPI() + + resp = fireworks_gpt.completion(messages) + assert resp.choices[0].message.content == resp_content + + resp = fireworks_gpt.ask(prompt_msg) + assert resp == resp_content + + +@pytest.mark.asyncio +async def test_fireworks_acompletion(mocker): + mocker.patch("metagpt.provider.fireworks_api.FireWorksGPTAPI.acompletion", mock_llm_acompletion) + mocker.patch("metagpt.provider.fireworks_api.FireWorksGPTAPI._achat_completion", mock_llm_acompletion) + mocker.patch( + "metagpt.provider.fireworks_api.FireWorksGPTAPI._achat_completion_stream", mock_llm_achat_completion_stream + ) + fireworks_gpt = FireWorksGPTAPI() + + resp = await fireworks_gpt.acompletion(messages, stream=False) + assert resp.choices[0].message.content in resp_content + + resp = await fireworks_gpt.aask(prompt_msg, stream=False) + assert resp == resp_content + + resp = await fireworks_gpt.acompletion_text(messages, stream=False) + assert resp == resp_content + + resp = await fireworks_gpt.acompletion_text(messages, stream=True) + assert resp == resp_content + + resp = await fireworks_gpt.aask(prompt_msg) + assert resp == resp_content diff --git a/tests/metagpt/provider/test_general_api_requestor.py b/tests/metagpt/provider/test_general_api_requestor.py new file mode 100644 index 000000000..28130fa65 --- /dev/null +++ b/tests/metagpt/provider/test_general_api_requestor.py @@ -0,0 +1,20 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +# @Desc : the unittest of APIRequestor + +import pytest + +from metagpt.provider.general_api_requestor import GeneralAPIRequestor + +api_requestor = GeneralAPIRequestor(base_url="http://www.baidu.com") + + +def test_api_requestor(): + resp, _, _ = api_requestor.request(method="get", url="/s?wd=baidu") + assert b"baidu" in resp + + +@pytest.mark.asyncio +async def test_async_api_requestor(): + resp, _, _ = await api_requestor.arequest(method="get", url="/s?wd=baidu") + assert b"baidu" in resp diff --git a/tests/metagpt/provider/test_google_gemini_api.py b/tests/metagpt/provider/test_google_gemini_api.py index 9c8cf46c0..aec7b8520 100644 --- a/tests/metagpt/provider/test_google_gemini_api.py +++ b/tests/metagpt/provider/test_google_gemini_api.py @@ -9,33 +9,62 @@ import pytest from metagpt.provider.google_gemini_api import GeminiGPTAPI -messages = [{"role": "user", "parts": "who are you"}] - @dataclass class MockGeminiResponse(ABC): text: str -default_resp = MockGeminiResponse(text="I'm gemini from google") +prompt_msg = "who are you" +messages = [{"role": "user", "parts": prompt_msg}] +resp_content = "I'm gemini from google" +default_resp = MockGeminiResponse(text=resp_content) -def mock_llm_ask(self, messages: list[dict]) -> MockGeminiResponse: +def mock_llm_completion(self, messages: list[dict], timeout: int = 60) -> MockGeminiResponse: return default_resp +async def mock_llm_acompletion( + self, messgaes: list[dict], stream: bool = False, timeout: int = 60 +) -> MockGeminiResponse: + return default_resp + + +async def mock_llm_achat_completion_stream(self, messgaes: list[dict]) -> str: + return resp_content + + def test_gemini_completion(mocker): - mocker.patch("metagpt.provider.google_gemini_api.GeminiGPTAPI.completion", mock_llm_ask) - resp = GeminiGPTAPI().completion(messages) - assert resp.text == default_resp.text + mocker.patch("metagpt.provider.google_gemini_api.GeminiGPTAPI.completion", mock_llm_completion) + gemini_gpt = GeminiGPTAPI() + resp = gemini_gpt.completion(messages) + assert resp.text == resp_content - -async def mock_llm_aask(self, messgaes: list[dict]) -> MockGeminiResponse: - return default_resp + resp = gemini_gpt.ask(prompt_msg) + assert resp == resp_content @pytest.mark.asyncio async def test_gemini_acompletion(mocker): - mocker.patch("metagpt.provider.google_gemini_api.GeminiGPTAPI.acompletion", mock_llm_aask) - resp = await GeminiGPTAPI().acompletion(messages) + mocker.patch("metagpt.provider.google_gemini_api.GeminiGPTAPI.acompletion", mock_llm_acompletion) + mocker.patch("metagpt.provider.google_gemini_api.GeminiGPTAPI._achat_completion", mock_llm_acompletion) + mocker.patch( + "metagpt.provider.google_gemini_api.GeminiGPTAPI._achat_completion_stream", mock_llm_achat_completion_stream + ) + gemini_gpt = GeminiGPTAPI() + + resp = await gemini_gpt.acompletion(messages) assert resp.text == default_resp.text + + resp = await gemini_gpt.aask(prompt_msg, stream=False) + assert resp == resp_content + + resp = await gemini_gpt.acompletion_text(messages, stream=False) + assert resp == resp_content + + resp = await gemini_gpt.acompletion_text(messages, stream=True) + assert resp == resp_content + + resp = await gemini_gpt.aask(prompt_msg) + assert resp == resp_content diff --git a/tests/metagpt/provider/test_human_provider.py b/tests/metagpt/provider/test_human_provider.py new file mode 100644 index 000000000..caab9f15f --- /dev/null +++ b/tests/metagpt/provider/test_human_provider.py @@ -0,0 +1,38 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +# @Desc : the unittest of HumanProvider + +import pytest + +from metagpt.provider.human_provider import HumanProvider + +resp_content = "test" + + +def mock_llm_ask(msg: str, timeout: int = 3) -> str: + return resp_content + + +async def mock_llm_aask(msg: str, timeout: int = 3) -> str: + return mock_llm_ask(msg) + + +def test_human_provider(mocker): + mocker.patch("metagpt.provider.human_provider.HumanProvider.ask", mock_llm_ask) + human_provider = HumanProvider() + + assert resp_content == human_provider.ask(None) + + assert not human_provider.completion(messages=[]) + + +@pytest.mark.asyncio +async def test_async_human_provider(mocker): + mocker.patch("metagpt.provider.human_provider.HumanProvider.aask", mock_llm_aask) + human_provider = HumanProvider() + + resp = await human_provider.aask(None) + assert resp_content == resp + + resp = await human_provider.acompletion([]) + assert not resp diff --git a/tests/metagpt/provider/test_metagpt_llm_api.py b/tests/metagpt/provider/test_metagpt_llm_api.py new file mode 100644 index 000000000..f454b08a7 --- /dev/null +++ b/tests/metagpt/provider/test_metagpt_llm_api.py @@ -0,0 +1,17 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +@Time : 2023/8/30 +@Author : mashenquan +@File : test_metagpt_llm_api.py +""" +from metagpt.provider.metagpt_api import MetaGPTAPI + + +def test_metagpt(): + llm = MetaGPTAPI() + assert llm + + +if __name__ == "__main__": + test_metagpt() diff --git a/tests/metagpt/provider/test_ollama_api.py b/tests/metagpt/provider/test_ollama_api.py index 2798f5cc3..d552d9f9e 100644 --- a/tests/metagpt/provider/test_ollama_api.py +++ b/tests/metagpt/provider/test_ollama_api.py @@ -4,30 +4,58 @@ import pytest +from metagpt.config import CONFIG from metagpt.provider.ollama_api import OllamaGPTAPI -messages = [{"role": "user", "content": "who are you"}] +prompt_msg = "who are you" +messages = [{"role": "user", "content": prompt_msg}] + +resp_content = "I'm ollama" +default_resp = {"message": {"role": "assistant", "content": resp_content}} + +CONFIG.ollama_api_base = "http://xxx" -default_resp = {"message": {"role": "assisant", "content": "I'm ollama"}} - - -def mock_llm_ask(self, messages: list[dict]) -> dict: +def mock_llm_completion(self, messages: list[dict], timeout: int = 60) -> dict: return default_resp +async def mock_llm_acompletion(self, messgaes: list[dict], stream: bool = False, timeout: int = 60) -> dict: + return default_resp + + +async def mock_llm_achat_completion_stream(self, messgaes: list[dict]) -> str: + return resp_content + + def test_gemini_completion(mocker): - mocker.patch("metagpt.provider.ollama_api.OllamaGPTAPI.completion", mock_llm_ask) - resp = OllamaGPTAPI().completion(messages) + mocker.patch("metagpt.provider.ollama_api.OllamaGPTAPI.completion", mock_llm_completion) + ollama_gpt = OllamaGPTAPI() + resp = ollama_gpt.completion(messages) assert resp["message"]["content"] == default_resp["message"]["content"] - -async def mock_llm_aask(self, messgaes: list[dict]) -> dict: - return default_resp + resp = ollama_gpt.ask(prompt_msg) + assert resp == resp_content @pytest.mark.asyncio async def test_gemini_acompletion(mocker): - mocker.patch("metagpt.provider.ollama_api.OllamaGPTAPI.acompletion", mock_llm_aask) - resp = await OllamaGPTAPI().acompletion(messages) + mocker.patch("metagpt.provider.ollama_api.OllamaGPTAPI.acompletion", mock_llm_acompletion) + mocker.patch("metagpt.provider.ollama_api.OllamaGPTAPI._achat_completion", mock_llm_acompletion) + mocker.patch("metagpt.provider.ollama_api.OllamaGPTAPI._achat_completion_stream", mock_llm_achat_completion_stream) + ollama_gpt = OllamaGPTAPI() + + resp = await ollama_gpt.acompletion(messages) assert resp["message"]["content"] == default_resp["message"]["content"] + + resp = await ollama_gpt.aask(prompt_msg, stream=False) + assert resp == resp_content + + resp = await ollama_gpt.acompletion_text(messages, stream=False) + assert resp == resp_content + + resp = await ollama_gpt.acompletion_text(messages, stream=True) + assert resp == resp_content + + resp = await ollama_gpt.aask(prompt_msg) + assert resp == resp_content diff --git a/tests/metagpt/provider/test_openai.py b/tests/metagpt/provider/test_openai.py index 332d554cf..1f25951b1 100644 --- a/tests/metagpt/provider/test_openai.py +++ b/tests/metagpt/provider/test_openai.py @@ -85,14 +85,23 @@ def test_ask_code_list_str(): class TestOpenAI: @pytest.fixture def config(self): - return Mock(openai_api_key="test_key", openai_base_url="test_url", openai_proxy=None, openai_api_type="other") + return Mock( + openai_api_key="test_key", + OPENAI_API_KEY="test_key", + openai_base_url="test_url", + OPENAI_BASE_URL="test_url", + openai_proxy=None, + openai_api_type="other", + ) @pytest.fixture def config_azure(self): return Mock( openai_api_key="test_key", + OPENAI_API_KEY="test_key", openai_api_version="test_version", openai_base_url="test_url", + OPENAI_BASE_URL="test_url", openai_proxy=None, openai_api_type="azure", ) @@ -101,7 +110,9 @@ class TestOpenAI: def config_proxy(self): return Mock( openai_api_key="test_key", + OPENAI_API_KEY="test_key", openai_base_url="test_url", + OPENAI_BASE_URL="test_url", openai_proxy="http://proxy.com", openai_api_type="other", ) @@ -110,8 +121,10 @@ class TestOpenAI: def config_azure_proxy(self): return Mock( openai_api_key="test_key", + OPENAI_API_KEY="test_key", openai_api_version="test_version", openai_base_url="test_url", + OPENAI_BASE_URL="test_url", openai_proxy="http://proxy.com", openai_api_type="azure", ) @@ -129,8 +142,8 @@ class TestOpenAI: instance = OpenAIGPTAPI() instance.config = config_azure kwargs, async_kwargs = instance._make_client_kwargs() - assert kwargs == {"api_key": "test_key", "api_version": "test_version", "azure_endpoint": "test_url"} - assert async_kwargs == {"api_key": "test_key", "api_version": "test_version", "azure_endpoint": "test_url"} + assert kwargs == {"api_key": "test_key", "base_url": "test_url"} + assert async_kwargs == {"api_key": "test_key", "base_url": "test_url"} assert "http_client" not in kwargs assert "http_client" not in async_kwargs diff --git a/tests/metagpt/provider/test_spark_api.py b/tests/metagpt/provider/test_spark_api.py index 3b3dd67f4..61ae8cbec 100644 --- a/tests/metagpt/provider/test_spark_api.py +++ b/tests/metagpt/provider/test_spark_api.py @@ -1,11 +1,51 @@ -from metagpt.logs import logger -from metagpt.provider.spark_api import SparkAPI +#!/usr/bin/env python +# -*- coding: utf-8 -*- +# @Desc : the unittest of spark api + +import pytest + +from metagpt.provider.spark_api import SparkGPTAPI + +prompt_msg = "who are you" +resp_content = "I'm Spark" -def test_message(): - llm = SparkAPI() +def mock_llm_completion(self, messages: list[dict], timeout: int = 60) -> str: + return resp_content - logger.info(llm.ask('只回答"收到了"这三个字。')) - result = llm.ask("写一篇五百字的日记") - logger.info(result) - assert len(result) > 100 + +async def mock_llm_acompletion(self, messgaes: list[dict], stream: bool = False, timeout: int = 60) -> str: + return resp_content + + +def test_spark_completion(mocker): + mocker.patch("metagpt.provider.spark_api.SparkGPTAPI.completion", mock_llm_completion) + spark_gpt = SparkGPTAPI() + + resp = spark_gpt.completion([]) + assert resp == resp_content + + resp = spark_gpt.ask(prompt_msg) + assert resp == resp_content + + +@pytest.mark.asyncio +async def test_spark_acompletion(mocker): + mocker.patch("metagpt.provider.spark_api.SparkGPTAPI.acompletion", mock_llm_acompletion) + mocker.patch("metagpt.provider.spark_api.SparkGPTAPI.acompletion_text", mock_llm_acompletion) + spark_gpt = SparkGPTAPI() + + resp = await spark_gpt.acompletion([], stream=False) + assert resp == resp_content + + resp = await spark_gpt.aask(prompt_msg, stream=False) + assert resp == resp_content + + resp = await spark_gpt.acompletion_text([], stream=False) + assert resp == resp_content + + resp = await spark_gpt.acompletion_text([], stream=True) + assert resp == resp_content + + resp = await spark_gpt.aask(prompt_msg) + assert resp == resp_content diff --git a/tests/metagpt/provider/test_zhipuai_api.py b/tests/metagpt/provider/test_zhipuai_api.py index 4684e8887..ec02e1b47 100644 --- a/tests/metagpt/provider/test_zhipuai_api.py +++ b/tests/metagpt/provider/test_zhipuai_api.py @@ -4,34 +4,62 @@ import pytest +from metagpt.config import CONFIG from metagpt.provider.zhipuai_api import ZhiPuAIGPTAPI -default_resp = {"code": 200, "data": {"choices": [{"role": "assistant", "content": "I'm chatglm-turbo"}]}} +CONFIG.zhipuai_api_key = "xxx" -messages = [{"role": "user", "content": "who are you"}] +prompt_msg = "who are you" +messages = [{"role": "user", "content": prompt_msg}] + +resp_content = "I'm chatglm-turbo" +default_resp = {"code": 200, "data": {"choices": [{"role": "assistant", "content": resp_content}]}} -def mock_llm_ask(self, messages: list[dict]) -> dict: +def mock_llm_completion(self, messages: list[dict], timeout: int = 60) -> dict: return default_resp +async def mock_llm_acompletion(self, messgaes: list[dict], stream: bool = False, timeout: int = 60) -> dict: + return default_resp + + +async def mock_llm_achat_completion_stream(self, messgaes: list[dict]) -> str: + return resp_content + + def test_zhipuai_completion(mocker): - mocker.patch("metagpt.provider.zhipuai_api.ZhiPuAIGPTAPI.completion", mock_llm_ask) + mocker.patch("metagpt.provider.zhipuai_api.ZhiPuAIGPTAPI.completion", mock_llm_completion) + zhipu_gpt = ZhiPuAIGPTAPI() - resp = ZhiPuAIGPTAPI().completion(messages) + resp = zhipu_gpt.completion(messages) assert resp["code"] == 200 - assert "chatglm-turbo" in resp["data"]["choices"][0]["content"] + assert resp["data"]["choices"][0]["content"] == resp_content - -async def mock_llm_aask(self, messgaes: list[dict], stream: bool = False) -> dict: - return default_resp + resp = zhipu_gpt.ask(prompt_msg) + assert resp == resp_content @pytest.mark.asyncio async def test_zhipuai_acompletion(mocker): - mocker.patch("metagpt.provider.zhipuai_api.ZhiPuAIGPTAPI.acompletion_text", mock_llm_aask) + mocker.patch("metagpt.provider.zhipuai_api.ZhiPuAIGPTAPI.acompletion", mock_llm_acompletion) + mocker.patch("metagpt.provider.zhipuai_api.ZhiPuAIGPTAPI._achat_completion", mock_llm_acompletion) + mocker.patch( + "metagpt.provider.zhipuai_api.ZhiPuAIGPTAPI._achat_completion_stream", mock_llm_achat_completion_stream + ) + zhipu_gpt = ZhiPuAIGPTAPI() - resp = await ZhiPuAIGPTAPI().acompletion_text(messages, stream=False) + resp = await zhipu_gpt.acompletion(messages) + assert resp["data"]["choices"][0]["content"] == resp_content - assert resp["code"] == 200 - assert "chatglm-turbo" in resp["data"]["choices"][0]["content"] + resp = await zhipu_gpt.aask(prompt_msg, stream=False) + assert resp == resp_content + + resp = await zhipu_gpt.acompletion_text(messages, stream=False) + assert resp == resp_content + + resp = await zhipu_gpt.acompletion_text(messages, stream=True) + assert resp == resp_content + + resp = await zhipu_gpt.aask(prompt_msg) + assert resp == resp_content diff --git a/tests/metagpt/roles/mock.py b/tests/metagpt/roles/mock.py index 75f6b3b43..2ea036bb7 100644 --- a/tests/metagpt/roles/mock.py +++ b/tests/metagpt/roles/mock.py @@ -3,7 +3,7 @@ """ @Time : 2023/5/12 13:05 @Author : alexanderwu -@File : mock.py +@File : mock_markdown.py """ from metagpt.actions import UserRequirement, WriteDesign, WritePRD, WriteTasks from metagpt.schema import Message diff --git a/tests/metagpt/roles/test_assistant.py b/tests/metagpt/roles/test_assistant.py new file mode 100644 index 000000000..e2f8b7198 --- /dev/null +++ b/tests/metagpt/roles/test_assistant.py @@ -0,0 +1,100 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +@Time : 2023/12/25 +@Author : mashenquan +@File : test_asssistant.py +@Desc : Used by AgentStore. +""" +import pytest +from pydantic import BaseModel + +from metagpt.actions.skill_action import SkillAction +from metagpt.actions.talk_action import TalkAction +from metagpt.config import CONFIG +from metagpt.logs import logger +from metagpt.memory.brain_memory import BrainMemory +from metagpt.roles.assistant import Assistant +from metagpt.schema import Message +from metagpt.utils.common import any_to_str + + +@pytest.mark.asyncio +async def test_run(): + CONFIG.language = "Chinese" + + class Input(BaseModel): + memory: BrainMemory + language: str + agent_description: str + cause_by: str + + inputs = [ + { + "memory": { + "history": [ + { + "content": "who is tulin", + "role": "user", + "id": 1, + }, + {"content": "The one who eaten a poison apple.", "role": "assistant"}, + ], + "knowledge": [{"content": "tulin is a scientist."}], + "last_talk": "what's apple?", + }, + "language": "English", + "agent_description": "chatterbox", + "cause_by": any_to_str(TalkAction), + }, + { + "memory": { + "history": [ + { + "content": "can you draw me an picture?", + "role": "user", + "id": 1, + }, + {"content": "Yes, of course. What do you want me to draw", "role": "assistant"}, + ], + "knowledge": [{"content": "tulin is a scientist."}], + "last_talk": "Draw me an apple.", + }, + "language": "English", + "agent_description": "painter", + "cause_by": any_to_str(SkillAction), + }, + ] + CONFIG.agent_skills = [ + {"id": 1, "name": "text_to_speech", "type": "builtin", "config": {}, "enabled": True}, + {"id": 2, "name": "text_to_image", "type": "builtin", "config": {}, "enabled": True}, + {"id": 3, "name": "ai_call", "type": "builtin", "config": {}, "enabled": True}, + {"id": 3, "name": "data_analysis", "type": "builtin", "config": {}, "enabled": True}, + {"id": 5, "name": "crawler", "type": "builtin", "config": {"engine": "ddg"}, "enabled": True}, + {"id": 6, "name": "knowledge", "type": "builtin", "config": {}, "enabled": True}, + {"id": 6, "name": "web_search", "type": "builtin", "config": {}, "enabled": True}, + ] + + for i in inputs: + seed = Input(**i) + CONFIG.language = seed.language + CONFIG.agent_description = seed.agent_description + role = Assistant(language="Chinese") + role.memory = seed.memory # Restore historical conversation content. + while True: + has_action = await role.think() + if not has_action: + break + msg: Message = await role.act() + logger.info(msg) + assert msg + assert msg.cause_by == seed.cause_by + assert msg.content + # # Retrieve user terminal input. + # logger.info("Enter prompt") + # talk = input("You: ") + # await role.talk(talk) + + +if __name__ == "__main__": + pytest.main([__file__, "-s"]) diff --git a/tests/metagpt/roles/test_teacher.py b/tests/metagpt/roles/test_teacher.py new file mode 100644 index 000000000..521e59c96 --- /dev/null +++ b/tests/metagpt/roles/test_teacher.py @@ -0,0 +1,157 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +@Time : 2023/7/27 13:25 +@Author : mashenquan +@File : test_teacher.py +""" +import os +from typing import Dict, Optional + +import pytest +from pydantic import BaseModel + +from metagpt.config import CONFIG, Config +from metagpt.roles.teacher import Teacher +from metagpt.schema import Message + + +@pytest.mark.asyncio +async def test_init(): + class Inputs(BaseModel): + name: str + profile: str + goal: str + constraints: str + desc: str + kwargs: Optional[Dict] = None + expect_name: str + expect_profile: str + expect_goal: str + expect_constraints: str + expect_desc: str + + inputs = [ + { + "name": "Lily{language}", + "expect_name": "Lily{language}", + "profile": "X {teaching_language}", + "expect_profile": "X {teaching_language}", + "goal": "Do {something_big}, {language}", + "expect_goal": "Do {something_big}, {language}", + "constraints": "Do in {key1}, {language}", + "expect_constraints": "Do in {key1}, {language}", + "kwargs": {}, + "desc": "aaa{language}", + "expect_desc": "aaa{language}", + }, + { + "name": "Lily{language}", + "expect_name": "LilyCN", + "profile": "X {teaching_language}", + "expect_profile": "X EN", + "goal": "Do {something_big}, {language}", + "expect_goal": "Do sleep, CN", + "constraints": "Do in {key1}, {language}", + "expect_constraints": "Do in HaHa, CN", + "kwargs": {"language": "CN", "key1": "HaHa", "something_big": "sleep", "teaching_language": "EN"}, + "desc": "aaa{language}", + "expect_desc": "aaaCN", + }, + ] + + env = os.environ.copy() + for i in inputs: + seed = Inputs(**i) + os.environ.clear() + os.environ.update(env) + CONFIG = Config() + CONFIG.set_context(seed.kwargs) + print(CONFIG.options) + assert bool("language" in seed.kwargs) == bool("language" in CONFIG.options) + + teacher = Teacher( + name=seed.name, + profile=seed.profile, + goal=seed.goal, + constraints=seed.constraints, + desc=seed.desc, + ) + assert teacher.name == seed.expect_name + assert teacher.desc == seed.expect_desc + assert teacher.profile == seed.expect_profile + assert teacher.goal == seed.expect_goal + assert teacher.constraints == seed.expect_constraints + assert teacher.course_title == "teaching_plan" + + +@pytest.mark.asyncio +async def test_new_file_name(): + class Inputs(BaseModel): + lesson_title: str + ext: str + expect: str + + inputs = [ + {"lesson_title": "# @344\n12", "ext": ".md", "expect": "_344_12.md"}, + {"lesson_title": "1#@$%!*&\\/:*?\"<>|\n\t '1", "ext": ".cc", "expect": "1_1.cc"}, + ] + for i in inputs: + seed = Inputs(**i) + result = Teacher.new_file_name(seed.lesson_title, seed.ext) + assert result == seed.expect + + +@pytest.mark.asyncio +async def test_run(): + CONFIG.set_context({"language": "Chinese", "teaching_language": "English"}) + lesson = """ + UNIT 1 Making New Friends + TOPIC 1 Welcome to China! + Section A + + 1a Listen and number the following names. + Jane Mari Kangkang Michael + Look, listen and understand. Then practice the conversation. + Work in groups. Introduce yourself using + I ’m ... Then practice 1a + with your own hometown or the following places. + + 1b Listen and number the following names + Jane Michael Maria Kangkang + 1c Work in groups. Introduce yourself using I ’m ... Then practice 1a with your own hometown or the following places. + China the USA the UK Hong Kong Beijing + + 2a Look, listen and understand. Then practice the conversation + Hello! + Hello! + Hello! + Hello! Are you Maria? + No, I’m not. I’m Jane. + Oh, nice to meet you, Jane + Nice to meet you, too. + Hi, Maria! + Hi, Kangkang! + Welcome to China! + Thanks. + + 2b Work in groups. Make up a conversation with your own name and the + following structures. + A: Hello! / Good morning! / Hi! I’m ... Are you ... ? + B: ... + + 3a Listen, say and trace + Aa Bb Cc Dd Ee Ff Gg + + 3b Listen and number the following letters. Then circle the letters with the same sound as Bb. + Aa Bb Cc Dd Ee Ff Gg + + 3c Match the big letters with the small ones. Then write them on the lines. + """ + teacher = Teacher() + rsp = await teacher.run(Message(content=lesson)) + assert rsp + + +if __name__ == "__main__": + pytest.main([__file__, "-s"]) diff --git a/tests/metagpt/roles/ui_role.py b/tests/metagpt/roles/ui_role.py index 0932efa1f..51b346821 100644 --- a/tests/metagpt/roles/ui_role.py +++ b/tests/metagpt/roles/ui_role.py @@ -8,8 +8,6 @@ from functools import wraps from importlib import import_module from metagpt.actions import Action, ActionOutput, WritePRD - -# from metagpt.const import WORKSPACE_ROOT from metagpt.actions.action_node import ActionNode from metagpt.config import CONFIG from metagpt.logs import logger diff --git a/tests/metagpt/serialize_deserialize/test_role.py b/tests/metagpt/serialize_deserialize/test_role.py index 72da8a6fc..343f01ace 100644 --- a/tests/metagpt/serialize_deserialize/test_role.py +++ b/tests/metagpt/serialize_deserialize/test_role.py @@ -93,4 +93,8 @@ async def test_role_serdeser_interrupt(): assert new_role_a._rc.state == 1 with pytest.raises(Exception): - await role_c.run(with_message=Message(content="demo", cause_by=UserRequirement)) + await new_role_a.run(with_message=Message(content="demo", cause_by=UserRequirement)) + + +if __name__ == "__main__": + pytest.main([__file__, "-s"]) diff --git a/tests/metagpt/serialize_deserialize/test_serdeser_base.py b/tests/metagpt/serialize_deserialize/test_serdeser_base.py index a66813489..23c14e851 100644 --- a/tests/metagpt/serialize_deserialize/test_serdeser_base.py +++ b/tests/metagpt/serialize_deserialize/test_serdeser_base.py @@ -85,3 +85,4 @@ class RoleC(Role): self._init_actions([ActionOK, ActionRaise]) self._watch([UserRequirement]) self._rc.react_mode = RoleReactMode.BY_ORDER + self._rc.memory.ignore_id = True diff --git a/tests/metagpt/test_environment.py b/tests/metagpt/test_environment.py index 56e2b4fc3..3a899d6ff 100644 --- a/tests/metagpt/test_environment.py +++ b/tests/metagpt/test_environment.py @@ -4,6 +4,8 @@ @Time : 2023/5/12 00:47 @Author : alexanderwu @File : test_environment.py +@Modified By: mashenquan, 2023/8/20. Remove global configuration `CONFIG`, enable configuration support for business isolation. + """ from pathlib import Path @@ -11,9 +13,9 @@ from pathlib import Path import pytest from metagpt.actions import UserRequirement +from metagpt.config import CONFIG from metagpt.environment import Environment from metagpt.logs import logger -from metagpt.manager import Manager from metagpt.roles import Architect, ProductManager, Role from metagpt.schema import Message @@ -44,6 +46,10 @@ def test_get_roles(env: Environment): @pytest.mark.asyncio async def test_publish_and_process_message(env: Environment): + if CONFIG.git_repo: + CONFIG.git_repo.delete_repository() + CONFIG.git_repo = None + product_manager = ProductManager(name="Alice", profile="Product Manager", goal="做AI Native产品", constraints="资源有限") architect = Architect( name="Bob", profile="Architect", goal="设计一个可用、高效、较低成本的系统，包括数据结构与接口", constraints="资源有限，需要节省成本" @@ -51,9 +57,11 @@ async def test_publish_and_process_message(env: Environment): env.add_roles([product_manager, architect]) - env.set_manager(Manager()) env.publish_message(Message(role="User", content="需要一个基于LLM做总结的搜索引擎", cause_by=UserRequirement)) - await env.run(k=2) logger.info(f"{env.history=}") assert len(env.history) > 10 + + +if __name__ == "__main__": + pytest.main([__file__, "-s"]) diff --git a/tests/metagpt/test_gpt.py b/tests/metagpt/test_gpt.py index 431858d4c..1884dd54b 100644 --- a/tests/metagpt/test_gpt.py +++ b/tests/metagpt/test_gpt.py @@ -5,9 +5,10 @@ @Author : alexanderwu @File : test_gpt.py """ - +import openai import pytest +from metagpt.config import CONFIG from metagpt.logs import logger @@ -18,34 +19,44 @@ class TestGPT: logger.info(answer) assert len(answer) > 0 - # def test_gptapi_ask_batch(self, llm_api): - # answer = llm_api.ask_batch(['请扮演一个Google Python专家工程师，如果理解，回复明白', '写一个hello world']) - # assert len(answer) > 0 + def test_gptapi_ask_batch(self, llm_api): + answer = llm_api.ask_batch(["请扮演一个Google Python专家工程师，如果理解，回复明白", "写一个hello world"], timeout=60) + assert len(answer) > 0 def test_llm_api_ask_code(self, llm_api): - answer = llm_api.ask_code(["请扮演一个Google Python专家工程师，如果理解，回复明白", "写一个hello world"]) - logger.info(answer) - assert len(answer) > 0 + try: + answer = llm_api.ask_code(["请扮演一个Google Python专家工程师，如果理解，回复明白", "写一个hello world"]) + logger.info(answer) + assert len(answer) > 0 + except openai.BadRequestError: + assert CONFIG.OPENAI_API_TYPE == "azure" @pytest.mark.asyncio async def test_llm_api_aask(self, llm_api): - answer = await llm_api.aask("hello chatgpt") + answer = await llm_api.aask("hello chatgpt", stream=False) + logger.info(answer) + assert len(answer) > 0 + + answer = await llm_api.aask("hello chatgpt", stream=True) logger.info(answer) assert len(answer) > 0 @pytest.mark.asyncio async def test_llm_api_aask_code(self, llm_api): - answer = await llm_api.aask_code(["请扮演一个Google Python专家工程师，如果理解，回复明白", "写一个hello world"]) - logger.info(answer) - assert len(answer) > 0 + try: + answer = await llm_api.aask_code(["请扮演一个Google Python专家工程师，如果理解，回复明白", "写一个hello world"], timeout=60) + logger.info(answer) + assert len(answer) > 0 + except openai.BadRequestError: + assert CONFIG.OPENAI_API_TYPE == "azure" @pytest.mark.asyncio async def test_llm_api_costs(self, llm_api): - await llm_api.aask("hello chatgpt") + await llm_api.aask("hello chatgpt", stream=False) costs = llm_api.get_costs() logger.info(costs) assert costs.total_cost > 0 -# if __name__ == "__main__": -# pytest.main([__file__, "-s"]) +if __name__ == "__main__": + pytest.main([__file__, "-s"]) diff --git a/tests/metagpt/test_llm.py b/tests/metagpt/test_llm.py index 408fd3162..31e6c2b24 100644 --- a/tests/metagpt/test_llm.py +++ b/tests/metagpt/test_llm.py @@ -4,11 +4,12 @@ @Time : 2023/5/11 14:45 @Author : alexanderwu @File : test_llm.py +@Modified By: mashenquan, 2023/8/20. Remove global configuration `CONFIG`, enable configuration support for business isolation. """ import pytest -from metagpt.llm import LLM +from metagpt.provider.openai_api import OpenAIGPTAPI as LLM @pytest.fixture() @@ -18,7 +19,8 @@ def llm(): @pytest.mark.asyncio async def test_llm_aask(llm): - assert len(await llm.aask("hello world")) > 0 + rsp = await llm.aask("hello world", stream=False) + assert len(rsp) > 0 @pytest.mark.asyncio @@ -29,10 +31,11 @@ async def test_llm_aask_batch(llm): @pytest.mark.asyncio async def test_llm_acompletion(llm): hello_msg = [{"role": "user", "content": "hello"}] - assert len(await llm.acompletion(hello_msg)) > 0 + rsp = await llm.acompletion(hello_msg) + assert len(rsp.choices[0].message.content) > 0 assert len(await llm.acompletion_batch([hello_msg])) > 0 assert len(await llm.acompletion_batch_text([hello_msg])) > 0 -# if __name__ == "__main__": -# pytest.main([__file__, "-s"]) +if __name__ == "__main__": + pytest.main([__file__, "-s"]) diff --git a/tests/metagpt/test_repo_parser.py b/tests/metagpt/test_repo_parser.py new file mode 100644 index 000000000..e69de29bb diff --git a/tests/metagpt/test_schema.py b/tests/metagpt/test_schema.py index 1742757e8..897d203c7 100644 --- a/tests/metagpt/test_schema.py +++ b/tests/metagpt/test_schema.py @@ -10,8 +10,6 @@ import json -import pytest - from metagpt.actions import Action from metagpt.actions.action_node import ActionNode from metagpt.actions.write_code import WriteCode @@ -19,7 +17,6 @@ from metagpt.schema import AIMessage, Message, SystemMessage, UserMessage from metagpt.utils.common import any_to_str -@pytest.mark.asyncio def test_messages(): test_content = "test_message" msgs = [ @@ -33,7 +30,6 @@ def test_messages(): assert all([i in text for i in roles]) -@pytest.mark.asyncio def test_message(): m = Message(content="a", role="v1") v = m.dump() @@ -64,7 +60,6 @@ def test_message(): assert m.content == "b" -@pytest.mark.asyncio def test_routes(): m = Message(content="a", role="b", cause_by="c", x="d", send_to="c") m.send_to = "b" diff --git a/tests/metagpt/test_startup.py b/tests/metagpt/test_startup.py index c34fd2c31..c8d4d5d29 100644 --- a/tests/metagpt/test_startup.py +++ b/tests/metagpt/test_startup.py @@ -26,3 +26,7 @@ async def test_team(): # def test_startup(): # args = ["Make a 2048 game"] # result = runner.invoke(app, args) + + +if __name__ == "__main__": + pytest.main([__file__, "-s"]) diff --git a/tests/metagpt/test_subscription.py b/tests/metagpt/test_subscription.py index 75e06411c..b902d5416 100644 --- a/tests/metagpt/test_subscription.py +++ b/tests/metagpt/test_subscription.py @@ -100,3 +100,7 @@ async def test_subscription_run_error(loguru_caplog): logs = "".join(loguru_caplog.messages) assert "run error" in logs assert "has completed" in logs + + +if __name__ == "__main__": + pytest.main([__file__, "-s"]) diff --git a/tests/metagpt/tools/test_azure_tts.py b/tests/metagpt/tools/test_azure_tts.py new file mode 100644 index 000000000..b7f94a19c --- /dev/null +++ b/tests/metagpt/tools/test_azure_tts.py @@ -0,0 +1,44 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +@Time : 2023/7/1 22:50 +@Author : alexanderwu +@File : test_azure_tts.py +@Modified By: mashenquan, 2023-8-9, add more text formatting options +@Modified By: mashenquan, 2023-8-17, move to `tools` folder. +""" +import asyncio + +from metagpt.config import CONFIG +from metagpt.tools.azure_tts import AzureTTS + + +def test_azure_tts(): + azure_tts = AzureTTS(subscription_key="", region="") + text = """ + 女儿看见父亲走了进来，问道： + + “您来的挺快的，怎么过来的？” + + 父亲放下手提包，说： + + “Writing a binary file in Python is similar to writing a regular text file, but you'll work with bytes instead of strings.” + + """ + path = CONFIG.workspace / "tts" + path.mkdir(exist_ok=True, parents=True) + filename = path / "girl.wav" + loop = asyncio.new_event_loop() + v = loop.create_task( + azure_tts.synthesize_speech(lang="zh-CN", voice="zh-CN-XiaomoNeural", text=text, output_file=str(filename)) + ) + result = loop.run_until_complete(v) + + print(result) + + # 运行需要先配置 SUBSCRIPTION_KEY + # TODO: 这里如果要检验，还要额外加上对应的asr，才能确保前后生成是接近一致的，但现在还没有 + + +if __name__ == "__main__": + test_azure_tts() diff --git a/tests/metagpt/tools/test_web_browser_engine.py b/tests/metagpt/tools/test_web_browser_engine.py index 28dd0e15c..1e4e956f2 100644 --- a/tests/metagpt/tools/test_web_browser_engine.py +++ b/tests/metagpt/tools/test_web_browser_engine.py @@ -1,5 +1,10 @@ +""" +@Modified By: mashenquan, 2023/8/20. Remove global configuration `CONFIG`, enable configuration support for business isolation. +""" + import pytest +from metagpt.config import Config from metagpt.tools import WebBrowserEngineType, web_browser_engine @@ -13,7 +18,8 @@ from metagpt.tools import WebBrowserEngineType, web_browser_engine ids=["playwright", "selenium"], ) async def test_scrape_web_page(browser_type, url, urls): - browser = web_browser_engine.WebBrowserEngine(browser_type) + conf = Config() + browser = web_browser_engine.WebBrowserEngine(options=conf.runtime_options, engine=browser_type) result = await browser.run(url) assert isinstance(result, str) assert "深度赋智" in result diff --git a/tests/metagpt/tools/test_web_browser_engine_playwright.py b/tests/metagpt/tools/test_web_browser_engine_playwright.py index e9ea80b10..cc6c09925 100644 --- a/tests/metagpt/tools/test_web_browser_engine_playwright.py +++ b/tests/metagpt/tools/test_web_browser_engine_playwright.py @@ -1,6 +1,10 @@ +""" +@Modified By: mashenquan, 2023/8/20. Remove global configuration `CONFIG`, enable configuration support for business isolation. +""" + import pytest -from metagpt.config import CONFIG +from metagpt.config import Config from metagpt.tools import web_browser_engine_playwright @@ -15,22 +19,25 @@ from metagpt.tools import web_browser_engine_playwright ids=["chromium-normal", "firefox-normal", "webkit-normal"], ) async def test_scrape_web_page(browser_type, use_proxy, kwagrs, url, urls, proxy, capfd): + conf = Config() + global_proxy = conf.global_proxy try: - global_proxy = CONFIG.global_proxy if use_proxy: - CONFIG.global_proxy = proxy - browser = web_browser_engine_playwright.PlaywrightWrapper(browser_type, **kwagrs) + conf.global_proxy = proxy + browser = web_browser_engine_playwright.PlaywrightWrapper( + options=conf.runtime_options, browser_type=browser_type, **kwagrs + ) result = await browser.run(url) result = result.inner_text assert isinstance(result, str) - assert "Deepwisdom" in result + assert "DeepWisdom" in result if urls: results = await browser.run(url, *urls) assert isinstance(results, list) assert len(results) == len(urls) + 1 - assert all(("Deepwisdom" in i) for i in results) + assert all(("DeepWisdom" in i) for i in results) if use_proxy: assert "Proxy:" in capfd.readouterr().out finally: - CONFIG.global_proxy = global_proxy + conf.global_proxy = global_proxy diff --git a/tests/metagpt/tools/test_web_browser_engine_selenium.py b/tests/metagpt/tools/test_web_browser_engine_selenium.py index ac6eafee7..77f4d8592 100644 --- a/tests/metagpt/tools/test_web_browser_engine_selenium.py +++ b/tests/metagpt/tools/test_web_browser_engine_selenium.py @@ -1,6 +1,10 @@ +""" +@Modified By: mashenquan, 2023/8/20. Remove global configuration `CONFIG`, enable configuration support for business isolation. +""" + import pytest -from metagpt.config import CONFIG +from metagpt.config import Config from metagpt.tools import web_browser_engine_selenium @@ -15,11 +19,12 @@ from metagpt.tools import web_browser_engine_selenium ids=["chrome-normal", "firefox-normal", "edge-normal"], ) async def test_scrape_web_page(browser_type, use_proxy, url, urls, proxy, capfd): + conf = Config() + global_proxy = conf.global_proxy try: - global_proxy = CONFIG.global_proxy if use_proxy: - CONFIG.global_proxy = proxy - browser = web_browser_engine_selenium.SeleniumWrapper(browser_type) + conf.global_proxy = proxy + browser = web_browser_engine_selenium.SeleniumWrapper(options=conf.runtime_options, browser_type=browser_type) result = await browser.run(url) result = result.inner_text assert isinstance(result, str) @@ -33,4 +38,4 @@ async def test_scrape_web_page(browser_type, use_proxy, url, urls, proxy, capfd) if use_proxy: assert "Proxy:" in capfd.readouterr().out finally: - CONFIG.global_proxy = global_proxy + conf.global_proxy = global_proxy diff --git a/tests/metagpt/utils/test_config.py b/tests/metagpt/utils/test_config.py index b68a535f9..bd89f0ed3 100644 --- a/tests/metagpt/utils/test_config.py +++ b/tests/metagpt/utils/test_config.py @@ -4,19 +4,15 @@ @Time : 2023/5/1 11:19 @Author : alexanderwu @File : test_config.py +@Modified By: mashenquan, 2013/8/20, Add `test_options`; remove global configuration `CONFIG`, enable configuration support for business isolation. """ +from pathlib import Path import pytest from metagpt.config import Config -def test_config_class_is_singleton(): - config_1 = Config() - config_2 = Config() - assert config_1 == config_2 - - def test_config_class_get_key_exception(): with pytest.raises(Exception) as exc_info: config = Config() @@ -28,4 +24,14 @@ def test_config_yaml_file_not_exists(): config = Config("wtf.yaml") with pytest.raises(Exception) as exc_info: config.get("OPENAI_BASE_URL") - assert str(exc_info.value) == "Key 'OPENAI_BASE_URL' not found in environment variables or in the YAML file" + assert str(exc_info.value) == "Set OPENAI_API_KEY or Anthropic_API_KEY first" + + +def test_options(): + filename = Path(__file__).resolve().parent.parent.parent.parent / "config/config.yaml" + config = Config(filename) + assert config.options + + +if __name__ == "__main__": + test_options() diff --git a/tests/metagpt/utils/test_di_graph_repository.py b/tests/metagpt/utils/test_di_graph_repository.py new file mode 100644 index 000000000..0a8011e51 --- /dev/null +++ b/tests/metagpt/utils/test_di_graph_repository.py @@ -0,0 +1,85 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +@Time : 2023/12/19 +@Author : mashenquan +@File : test_di_graph_repository.py +@Desc : Unit tests for di_graph_repository.py +""" + +from pathlib import Path + +import pytest +from pydantic import BaseModel + +from metagpt.const import DEFAULT_WORKSPACE_ROOT +from metagpt.repo_parser import RepoParser +from metagpt.utils.di_graph_repository import DiGraphRepository +from metagpt.utils.graph_repository import GraphRepository + + +@pytest.mark.asyncio +async def test_di_graph_repository(): + class Input(BaseModel): + s: str + p: str + o: str + + inputs = [ + {"s": "main.py:Game:draw", "p": "method:hasDescription", "o": "Draw image"}, + {"s": "main.py:Game:draw", "p": "method:hasDescription", "o": "Show image"}, + ] + path = Path(__file__).parent + graph = DiGraphRepository(name="test", root=path) + for i in inputs: + data = Input(**i) + await graph.insert(subject=data.s, predicate=data.p, object_=data.o) + v = graph.json() + assert v + await graph.save() + assert graph.pathname.exists() + graph.pathname.unlink() + + +@pytest.mark.asyncio +async def test_js_parser(): + class Input(BaseModel): + path: str + + inputs = [ + {"path": str(Path(__file__).parent / "../../data/code")}, + ] + path = Path(__file__).parent + graph = DiGraphRepository(name="test", root=path) + for i in inputs: + data = Input(**i) + repo_parser = RepoParser(base_directory=data.path) + symbols = repo_parser.generate_symbols() + for s in symbols: + await GraphRepository.update_graph_db(graph_db=graph, file_info=s) + data = graph.json() + assert data + + +@pytest.mark.asyncio +async def test_codes(): + path = DEFAULT_WORKSPACE_ROOT / "snake_game" + repo_parser = RepoParser(base_directory=path) + + graph = DiGraphRepository(name="test", root=path) + symbols = repo_parser.generate_symbols() + for file_info in symbols: + for code_block in file_info.page_info: + try: + val = code_block.json(ensure_ascii=False) + assert val + except TypeError as e: + assert not e + await GraphRepository.update_graph_db(graph_db=graph, file_info=file_info) + data = graph.json() + assert data + print(data) + + +if __name__ == "__main__": + pytest.main([__file__, "-s"]) diff --git a/tests/metagpt/utils/test_token_counter.py b/tests/metagpt/utils/test_token_counter.py index 479ccc22d..acb99d717 100644 --- a/tests/metagpt/utils/test_token_counter.py +++ b/tests/metagpt/utils/test_token_counter.py @@ -15,7 +15,7 @@ def test_count_message_tokens(): {"role": "user", "content": "Hello"}, {"role": "assistant", "content": "Hi there!"}, ] - assert count_message_tokens(messages) == 17 + assert count_message_tokens(messages) == 15 def test_count_message_tokens_with_name(): @@ -67,3 +67,7 @@ def test_count_string_tokens_gpt_4(): string = "Hello, world!" assert count_string_tokens(string, model_name="gpt-4-0314") == 4 + + +if __name__ == "__main__": + pytest.main([__file__, "-s"])