feat: merge send18:dev

metagpt/tools/__init__.py

@@ -22,3 +22,8 @@ class WebBrowserEngineType(Enum):
     PLAYWRIGHT = "playwright"
     SELENIUM = "selenium"
     CUSTOM = "custom"
+
+    @classmethod
+    def _missing_(cls, key):
+        """缺省类型转换"""
+        return cls.CUSTOM

metagpt/tools/azure_tts.py

@@ -0,0 +1,113 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+@Time    : 2023/8/17
+@Author  : mashenquan
+@File    : azure_tts.py
+@Desc    : 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, Config
+from metagpt.logs import logger
+
+
+class AzureTTS:
+    """Azure Text-to-Speech"""
+
+    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)
+
+        # More detail: https://learn.microsoft.com/en-us/azure/ai-services/speech-service/speech-synthesis-markup-voice
+        ssml_string = (
+            "<speak version='1.0' xmlns='http://www.w3.org/2001/10/synthesis' "
+            f"xml:lang='{lang}' xmlns:mstts='http://www.w3.org/2001/mstts'>"
+            f"<voice name='{voice}'>{text}</voice></speak>"
+        )
+
+        return synthesizer.speak_ssml_async(ssml_string).get()
+
+    @staticmethod
+    def role_style_text(role, style, text):
+        return f'<mstts:express-as role="{role}" style="{style}">{text}</mstts:express-as>'
+
+    @staticmethod
+    def role_text(role, text):
+        return f'<mstts:express-as role="{role}">{text}</mstts:express-as>'
+
+    @staticmethod
+    def style_text(style, text):
+        return f'<mstts:express-as style="{style}">{text}</mstts:express-as>'
+
+
+# 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__":
+    Config()
+    loop = asyncio.new_event_loop()
+    v = loop.create_task(oas3_azsure_tts("测试，test"))
+    loop.run_until_complete(v)
+    print(v)

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)

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",
+        )
+    )

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()

metagpt/tools/metagpt_text_to_image.py

@@ -0,0 +1,117 @@
+#!/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
+import os
+import sys
+from pathlib import Path
+from typing import List, Dict
+
+import aiohttp
+import requests
+from pydantic import BaseModel
+
+from metagpt.config import CONFIG, Config
+
+sys.path.append(str(Path(__file__).resolve().parent.parent.parent))  # fix-bug: No module named 'metagpt'
+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)

metagpt/tools/openai_text_to_embedding.py

@@ -0,0 +1,96 @@
+#!/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
+import os
+from pathlib import Path
+from typing import List
+
+import aiohttp
+import requests
+from pydantic import BaseModel
+import sys
+
+from metagpt.config import CONFIG, Config
+
+sys.path.append(str(Path(__file__).resolve().parent.parent.parent))  # fix-bug: No module named 'metagpt'
+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)

metagpt/tools/openai_text_to_image.py

@@ -0,0 +1,93 @@
+#!/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 openai
+import requests
+
+from metagpt.config import CONFIG, Config
+from metagpt.logs import logger
+
+
+class OpenAIText2Image:
+    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_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 openai.Image.acreate(
+                api_key=CONFIG.OPENAI_API_KEY,
+                api_base=CONFIG.OPENAI_API_BASE,
+                api_type=None,
+                api_version=None,
+                organization=None,
+                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", openai_api_key=""):
+    """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: One of ['256x256', '512x512', '1024x1024']
+    :return: The image data is returned in Base64 encoding.
+    """
+    if not text:
+        return ""
+    if not openai_api_key:
+        openai_api_key = CONFIG.OPENAI_API_KEY
+    return await OpenAIText2Image(openai_api_key).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)

metagpt/tools/sd_engine.py

@@ -13,7 +13,12 @@ from typing import List
 from aiohttp import ClientSession
 from PIL import Image, PngImagePlugin
 
+<<<<<<< HEAD
 from metagpt.config import CONFIG
+=======
+from metagpt.config import Config
+from metagpt.logs import logger
+>>>>>>> send18/dev
 
 # from metagpt.const import WORKSPACE_ROOT
 from metagpt.logs import logger
@@ -79,7 +84,11 @@ class SDEngine:
         return self.payload
 
     def _save(self, imgs, save_name=""):
+<<<<<<< HEAD
         save_dir = CONFIG.workspace_path / "resources" / "SD_Output"
+=======
+        save_dir = CONFIG.get_workspace() / "resources" / "SD_Output"
+>>>>>>> send18/dev
         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)

metagpt/tools/web_browser_engine.py

@@ -1,9 +1,12 @@
 #!/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 importlib
-from typing import Any, Callable, Coroutine, Literal, overload
+from typing import Any, Callable, Coroutine, Dict, Literal, overload
 
 from metagpt.config import CONFIG
 from metagpt.tools import WebBrowserEngineType
@@ -13,18 +16,21 @@ from metagpt.utils.parse_html import WebPage
 class WebBrowserEngine:
     def __init__(
         self,
+        options: Dict,
         engine: WebBrowserEngineType | None = None,
         run_func: Callable[..., Coroutine[Any, Any, WebPage | list[WebPage]]] | None = None,
     ):
-        engine = engine or CONFIG.web_browser_engine
+        engine = engine or options.get("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:
+            run_func = importlib.import_module(module).PlaywrightWrapper(options=options).run
+        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:
+            run_func = importlib.import_module(module).SeleniumWrapper(options=options).run
+        elif WebBrowserEngineType(engine) is WebBrowserEngineType.CUSTOM:
             run_func = run_func
         else:
             raise NotImplementedError
@@ -47,6 +53,8 @@ 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(options=CONFIG.options, engine=WebBrowserEngineType(engine_type), **kwargs).run(
+            url, *urls
+        )
 
     fire.Fire(main)

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)

metagpt/tools/web_browser_engine_selenium.py

@@ -1,17 +1,21 @@
 #!/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 Literal, Dict
 
 from selenium.webdriver.common.by import By
 from selenium.webdriver.support import expected_conditions as EC
 from selenium.webdriver.support.wait import WebDriverWait
 
-from metagpt.config import CONFIG
+from metagpt.config import Config
 from metagpt.utils.parse_html import WebPage
 
 
@@ -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,
         *,
@@ -36,11 +41,11 @@ class SeleniumWrapper:
         executor: futures.Executor | None = None,
     ) -> None:
         if browser_type is None:
-            browser_type = CONFIG.selenium_browser_type
+            browser_type = options.get("selenium_browser_type")
         self.browser_type = browser_type
         launch_kwargs = launch_kwargs or {}
-        if CONFIG.global_proxy and "proxy-server" not in launch_kwargs:
-            launch_kwargs["proxy-server"] = CONFIG.global_proxy
+        if options.get("global_proxy") and "proxy-server" not in launch_kwargs:
+            launch_kwargs["proxy-server"] = options.get("global_proxy")
 
         self.executable_path = launch_kwargs.pop("executable_path", None)
         self.launch_args = [f"--{k}={v}" for k, v in launch_kwargs.items()]
@@ -118,6 +123,8 @@ 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(options=Config().runtime_options,
+                                     browser_type=browser_type,
+                                     **kwargs).run(url, *urls)
 
     fire.Fire(main)