From 98ac5fbce3d744d4c3a91403d73cf2e0bbe7cf8b Mon Sep 17 00:00:00 2001 From: seehi <6580@pm.me> Date: Fri, 9 Aug 2024 10:31:03 +0800 Subject: [PATCH 1/9] serialize mgxenv --- metagpt/environment/mgx/mgx_env.py | 66 ++++++++++++++++++++++-- metagpt/roles/di/role_zero.py | 9 ++-- metagpt/roles/di/swe_agent.py | 3 +- metagpt/strategy/experience_retriever.py | 2 +- metagpt/tools/libs/browser.py | 24 +++++---- metagpt/tools/libs/editor.py | 11 ++-- metagpt/tools/tool_recommend.py | 4 ++ metagpt/utils/common.py | 22 +++++++- metagpt/utils/serialize.py | 38 +++++++++++++- tests/metagpt/utils/test_serialize.py | 36 +++++++++++++ 10 files changed, 185 insertions(+), 30 deletions(-) diff --git a/metagpt/environment/mgx/mgx_env.py b/metagpt/environment/mgx/mgx_env.py index 873358252..156b08267 100644 --- a/metagpt/environment/mgx/mgx_env.py +++ b/metagpt/environment/mgx/mgx_env.py @@ -1,3 +1,5 @@ +from typing import ClassVar + from metagpt.actions import ( UserRequirement, WriteDesign, @@ -6,12 +8,14 @@ from metagpt.actions import ( WriteTest, ) from metagpt.actions.summarize_code import SummarizeCode -from metagpt.const import AGENT +from metagpt.const import AGENT, SERDESER_PATH from metagpt.environment.base_env import Environment -from metagpt.logs import get_human_input +from metagpt.logs import get_human_input, logger from metagpt.roles import Architect, ProductManager, ProjectManager, Role from metagpt.schema import Message from metagpt.utils.common import any_to_str, any_to_str_set +from metagpt.utils.exceptions import handle_exception +from metagpt.utils.serialize import deserialize_model, serialize_model class MGXEnv(Environment): @@ -22,6 +26,11 @@ class MGXEnv(Environment): direct_chat_roles: set[str] = set() # record direct chat: @role_name + default_serialization_path: ClassVar[str] = str(SERDESER_PATH / "mgxenv" / "mgxenv.json") + + def __repr__(self): + return "MGXEnv()" + def _publish_message(self, message: Message, peekable: bool = True) -> bool: return super().publish_message(message, peekable) @@ -121,5 +130,54 @@ class MGXEnv(Environment): converted_msg.content = f"from {sent_from} to {converted_msg.send_to}: {converted_msg.content}" return converted_msg - def __repr__(self): - return "MGXEnv()" + @handle_exception + def serialize(self, file_path: str = None) -> str: + """Serializes the current instance to a JSON file. + + If an exception occurs, `handle_exception` will catch it and return `None`. + + Args: + file_path (str, optional): The path to the JSON file where the instance will be saved. Defaults to None. + + Returns: + str: The path to the JSON file where the instance was saved. + """ + + file_path = file_path or self.default_serialization_path + + serialize_model(self, file_path, remove_unserializable=self.remove_unserializable) + logger.info(f"MGXEnv serialization successful. File saved at: {file_path}") + + return file_path + + @classmethod + @handle_exception + def deserialize(cls, file_path: str = None) -> "MGXEnv": + """Deserializes a JSON file to an instance of MGXEnv. + + If an exception occurs, `handle_exception` will catch it and return `None`. + + Args: + file_path (str, optional): The path to the JSON file to read from. Defaults to None. + + Returns: + MGXEnv: An instance of MGXEnv. + """ + + file_path = file_path or cls.default_serialization_path + + model = deserialize_model(cls, file_path) + logger.info(f"MGXEnv deserialization successful. Instance created from file: {file_path}") + + return model + + def remove_unserializable(self, data: dict): + """Removes unserializable content from the data dictionary. + + Args: + data (dict): The data dictionary to clean, obtained from Pydantic's model_dump method. + """ + roles = data.get("roles", {}) + + for role in roles.values(): + [role.pop(key, None) for key in role.get("unserializable_fields", [])] diff --git a/metagpt/roles/di/role_zero.py b/metagpt/roles/di/role_zero.py index 4e932649c..b1b524d21 100644 --- a/metagpt/roles/di/role_zero.py +++ b/metagpt/roles/di/role_zero.py @@ -4,7 +4,7 @@ import inspect import json import re import traceback -from typing import Callable, Dict, List, Literal, Tuple +from typing import Callable, Dict, List, Literal, Optional, Tuple from pydantic import model_validator @@ -46,11 +46,11 @@ class RoleZero(Role): name: str = "Zero" profile: str = "RoleZero" goal: str = "" - system_msg: list[str] = None # Use None to conform to the default value at llm.aask + system_msg: Optional[list[str]] = None # Use None to conform to the default value at llm.aask cmd_prompt: str = CMD_PROMPT thought_guidance: str = THOUGHT_GUIDANCE instruction: str = ROLE_INSTRUCTION - task_type_desc: str = None + task_type_desc: Optional[str] = None # React Mode react_mode: Literal["react"] = "react" @@ -58,7 +58,7 @@ class RoleZero(Role): # Tools tools: list[str] = [] # Use special symbol [""] to indicate use of all registered tools - tool_recommender: ToolRecommender = None + tool_recommender: Optional[ToolRecommender] = None tool_execution_map: dict[str, Callable] = {} special_tool_commands: list[str] = ["Plan.finish_current_task", "end", "Bash.run"] # Equipped with three basic tools by default for optional use @@ -74,6 +74,7 @@ class RoleZero(Role): memory_k: int = 20 # number of memories (messages) to use as historical context use_fixed_sop: bool = False requirements_constraints: str = "" # the constraints in user requirements + unserializable_fields: list[str] = ["tool_execution_map", "experience_retriever"] @model_validator(mode="after") def set_plan_and_tool(self) -> "RoleZero": diff --git a/metagpt/roles/di/swe_agent.py b/metagpt/roles/di/swe_agent.py index 2384ac147..d85a3863b 100644 --- a/metagpt/roles/di/swe_agent.py +++ b/metagpt/roles/di/swe_agent.py @@ -1,4 +1,5 @@ import json +from typing import Optional from pydantic import Field @@ -17,7 +18,7 @@ class SWEAgent(RoleZero): name: str = "Swen" profile: str = "Issue Solver" goal: str = "Resolve GitHub issue or bug in any existing codebase" - system_msg: str = [SWE_AGENT_SYSTEM_TEMPLATE] + system_msg: Optional[list[str]] = [SWE_AGENT_SYSTEM_TEMPLATE] _instruction: str = NEXT_STEP_TEMPLATE tools: list[str] = [ "Bash", diff --git a/metagpt/strategy/experience_retriever.py b/metagpt/strategy/experience_retriever.py index 9587ef9f8..46d0fd862 100644 --- a/metagpt/strategy/experience_retriever.py +++ b/metagpt/strategy/experience_retriever.py @@ -6,7 +6,7 @@ from pydantic import BaseModel class ExpRetriever(BaseModel): """interface for experience retriever""" - def retrieve(self, context: str) -> str: + def retrieve(self, context: str = "") -> str: raise NotImplementedError diff --git a/metagpt/tools/libs/browser.py b/metagpt/tools/libs/browser.py index a458109e6..3efddd2e8 100644 --- a/metagpt/tools/libs/browser.py +++ b/metagpt/tools/libs/browser.py @@ -12,6 +12,7 @@ from playwright.async_api import ( Request, async_playwright, ) +from pydantic import BaseModel, ConfigDict, Field from metagpt.tools.tool_registry import register_tool from metagpt.utils.a11y_tree import ( @@ -43,7 +44,7 @@ from metagpt.utils.report import BrowserReporter "type", ], ) -class Browser: +class Browser(BaseModel): """A tool for browsing the web. Don't initialize a new instance of this class if one already exists. Note: If you plan to use the browser to assist you in completing tasks, then using the browser should be a standalone @@ -66,16 +67,17 @@ class Browser: >>> await browser.close_tab() """ - def __init__(self): - self.playwright: Optional[Playwright] = None - self.browser_instance: Optional[Browser_] = None - self.browser_ctx: Optional[BrowserContext] = None - self.page: Optional[Page] = None - self.accessibility_tree: list = [] - self.headless: bool = True - self.proxy = get_proxy_from_env() - self.is_empty_page = True - self.reporter = BrowserReporter() + model_config = ConfigDict(arbitrary_types_allowed=True) + + playwright: Optional[Playwright] = None + browser_instance: Optional[Browser_] = None + browser_ctx: Optional[BrowserContext] = None + page: Optional[Page] = None + accessibility_tree: list = Field(default_factory=list) + headless: bool = True + proxy: Optional[str] = Field(default_factory=get_proxy_from_env) + is_empty_page: bool = True + reporter: BrowserReporter = Field(default_factory=BrowserReporter) async def start(self) -> None: """Starts Playwright and launches a browser""" diff --git a/metagpt/tools/libs/editor.py b/metagpt/tools/libs/editor.py index b964a2741..149482ab2 100644 --- a/metagpt/tools/libs/editor.py +++ b/metagpt/tools/libs/editor.py @@ -2,9 +2,8 @@ import os import shutil import subprocess -from pydantic import BaseModel +from pydantic import BaseModel, ConfigDict -from metagpt.const import DEFAULT_WORKSPACE_ROOT from metagpt.tools.tool_registry import register_tool from metagpt.utils.report import EditorReporter @@ -17,12 +16,12 @@ class FileBlock(BaseModel): @register_tool() -class Editor: +class Editor(BaseModel): """A tool for reading, understanding, writing, and editing files""" - def __init__(self) -> None: - print(f"Editor initialized with root path at: {DEFAULT_WORKSPACE_ROOT}") - self.resource = EditorReporter() + model_config = ConfigDict(arbitrary_types_allowed=True) + + resource: EditorReporter = EditorReporter() def write(self, path: str, content: str): """Write the whole content to a file. When used, make sure content arg contains the full content of the file.""" diff --git a/metagpt/tools/tool_recommend.py b/metagpt/tools/tool_recommend.py index cca5cb3ae..25f403c77 100644 --- a/metagpt/tools/tool_recommend.py +++ b/metagpt/tools/tool_recommend.py @@ -64,6 +64,10 @@ class ToolRecommender(BaseModel): @field_validator("tools", mode="before") @classmethod def validate_tools(cls, v: list[str]) -> dict[str, Tool]: + # If `v` is already a dictionary (e.g., during deserialization), return it as is. + if isinstance(v, dict): + return v + # One can use special symbol [""] to indicate use of all registered tools if v == [""]: return TOOL_REGISTRY.get_all_tools() diff --git a/metagpt/utils/common.py b/metagpt/utils/common.py index 3eead9ed4..2f7867104 100644 --- a/metagpt/utils/common.py +++ b/metagpt/utils/common.py @@ -28,6 +28,7 @@ import time import traceback from asyncio import iscoroutinefunction from datetime import datetime +from functools import partial from io import BytesIO from pathlib import Path from typing import Any, Callable, Dict, List, Literal, Optional, Tuple, Union @@ -577,13 +578,30 @@ def read_json_file(json_file: str, encoding="utf-8") -> list[Any]: return data -def write_json_file(json_file: str, data: list, encoding: str = None, indent: int = 4): +def write_json_file(json_file: str, data: Any, encoding: str = None, indent: int = 4, use_fallback: bool = False): folder_path = Path(json_file).parent if not folder_path.exists(): folder_path.mkdir(parents=True, exist_ok=True) + # For debug, if use_fallback, unknown values will be logged instead of raising an exception. + def fallback(x: Any) -> str: + tip = f"PydanticSerializationError occurred while processing file '{json_file}'" + + if inspect.ismethod(x): + logger.error(f"{tip}, Method: {x.__self__.__class__.__name__}.{x.__func__.__name__}") + elif inspect.isfunction(x): + logger.error(f"{tip}, Function: {x.__name__}") + elif hasattr(x, "__class__"): + logger.error(f"{tip}, Instance of: {x.__class__.__name__}") + elif hasattr(x, "__name__"): + logger.error(f"{tip}, Class or module: {x.__name__}") + else: + logger.error(f"{tip}, Unknown type: {type(x)}") + + custom_default = partial(to_jsonable_python, fallback=fallback if use_fallback else None) + with open(json_file, "w", encoding=encoding) as fout: - json.dump(data, fout, ensure_ascii=False, indent=indent, default=to_jsonable_python) + json.dump(data, fout, ensure_ascii=False, indent=indent, default=custom_default) def read_csv_to_list(curr_file: str, header=False, strip_trail=True): diff --git a/metagpt/utils/serialize.py b/metagpt/utils/serialize.py index c6bd8ad75..814621377 100644 --- a/metagpt/utils/serialize.py +++ b/metagpt/utils/serialize.py @@ -4,8 +4,11 @@ import copy import pickle +from typing import Callable, Optional, Type -from metagpt.utils.common import import_class +from pydantic import BaseModel + +from metagpt.utils.common import import_class, read_json_file, write_json_file def actionoutout_schema_to_mapping(schema: dict) -> dict: @@ -81,3 +84,36 @@ def deserialize_message(message_ser: str) -> "Message": message.instruct_content = ic_new return message + + +def serialize_model(model: BaseModel, file_path: str, remove_unserializable: Optional[Callable[[dict], None]] = None): + """Serializes a Pydantic model to a JSON file. + + Args: + model (BaseModel): The Pydantic model to serialize. + file_path (str): The path to the JSON file where the model will be saved. + remove_unserializable (Optional[Callable[[dict], None]]): Optional function to remove unserializable content from the serialized data. + """ + + serialized_data = model.model_dump() + + if remove_unserializable: + remove_unserializable(serialized_data) + + write_json_file(file_path, serialized_data) + + +def deserialize_model(cls: Type[BaseModel], file_path: str) -> BaseModel: + """Deserializes a JSON file to a Pydantic model. + + Args: + cls (Type[BaseModel]): The Pydantic model class to deserialize into. + file_path (str): The path to the JSON file to read from. + + Returns: + BaseModel: An instance of the Pydantic model. + """ + + data: dict = read_json_file(file_path) + + return cls(**data) diff --git a/tests/metagpt/utils/test_serialize.py b/tests/metagpt/utils/test_serialize.py index 0ba3a8d41..3b20f3fa0 100644 --- a/tests/metagpt/utils/test_serialize.py +++ b/tests/metagpt/utils/test_serialize.py @@ -6,13 +6,17 @@ from typing import List +from pydantic import BaseModel + from metagpt.actions import WritePRD from metagpt.actions.action_node import ActionNode from metagpt.schema import Message from metagpt.utils.serialize import ( actionoutout_schema_to_mapping, deserialize_message, + deserialize_model, serialize_message, + serialize_model, ) @@ -66,3 +70,35 @@ def test_serialize_and_deserialize_message(): assert new_message.content == message.content assert new_message.cause_by == message.cause_by assert new_message.instruct_content.field1 == out_data["field1"] + + +class TestUserModel(BaseModel): + name: str + value: int + + +def test_serialize_model(mocker): + model = TestUserModel(name="test", value=42) + file_path = "test.json" + mock_write_json_file = mocker.patch("metagpt.utils.serialize.write_json_file") + + # Test without remove_unserializable + serialize_model(model, file_path) + mock_write_json_file.assert_called_once_with(file_path, model.model_dump()) + + # Test with remove_unserializable + def remove_unserializable(data: dict): + data.pop("value", None) + + serialize_model(model, file_path, remove_unserializable) + mock_write_json_file.assert_called_with(file_path, {"name": "test"}) + + +def test_deserialize_model(mocker): + file_path = "test.json" + data = {"name": "test", "value": 42} + mock_read_json_file = mocker.patch("metagpt.utils.serialize.read_json_file", return_value=data) + + model = deserialize_model(TestUserModel, file_path) + mock_read_json_file.assert_called_once_with(file_path) + assert model == TestUserModel(**data) From d98d36fec5b367c1fcf29cbfc50e0bc7739fb62d Mon Sep 17 00:00:00 2001 From: seehi <6580@pm.me> Date: Fri, 9 Aug 2024 10:34:20 +0800 Subject: [PATCH 2/9] serialize mgxenv --- metagpt/environment/mgx/mgx_env.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/metagpt/environment/mgx/mgx_env.py b/metagpt/environment/mgx/mgx_env.py index 156b08267..517e185d9 100644 --- a/metagpt/environment/mgx/mgx_env.py +++ b/metagpt/environment/mgx/mgx_env.py @@ -28,9 +28,6 @@ class MGXEnv(Environment): default_serialization_path: ClassVar[str] = str(SERDESER_PATH / "mgxenv" / "mgxenv.json") - def __repr__(self): - return "MGXEnv()" - def _publish_message(self, message: Message, peekable: bool = True) -> bool: return super().publish_message(message, peekable) @@ -130,6 +127,9 @@ class MGXEnv(Environment): converted_msg.content = f"from {sent_from} to {converted_msg.send_to}: {converted_msg.content}" return converted_msg + def __repr__(self): + return "MGXEnv()" + @handle_exception def serialize(self, file_path: str = None) -> str: """Serializes the current instance to a JSON file. From 887f180e58f338025eb8bedcd16c662215a58b30 Mon Sep 17 00:00:00 2001 From: seehi <6580@pm.me> Date: Fri, 9 Aug 2024 16:38:38 +0800 Subject: [PATCH 3/9] create new func `handle_unknown_serialization` --- metagpt/utils/common.py | 34 ++++++++++++++++++---------------- 1 file changed, 18 insertions(+), 16 deletions(-) diff --git a/metagpt/utils/common.py b/metagpt/utils/common.py index 7b3cb5224..cf938cb3d 100644 --- a/metagpt/utils/common.py +++ b/metagpt/utils/common.py @@ -579,27 +579,29 @@ def read_json_file(json_file: str, encoding="utf-8") -> list[Any]: return data +def handle_unknown_serialization(x: Any) -> str: + """For `to_jsonable_python` debug, unknown values will be logged instead of raising an exception.""" + + if inspect.ismethod(x): + logger.error(f"Method: {x.__self__.__class__.__name__}.{x.__func__.__name__}") + elif inspect.isfunction(x): + logger.error(f"Function: {x.__name__}") + elif hasattr(x, "__class__"): + logger.error(f"Instance of: {x.__class__.__name__}") + elif hasattr(x, "__name__"): + logger.error(f"Class or module: {x.__name__}") + else: + logger.error(f"Unknown type: {type(x)}") + + return f"" + + def write_json_file(json_file: str, data: Any, encoding: str = None, indent: int = 4, use_fallback: bool = False): folder_path = Path(json_file).parent if not folder_path.exists(): folder_path.mkdir(parents=True, exist_ok=True) - # For debug, if use_fallback, unknown values will be logged instead of raising an exception. - def fallback(x: Any) -> str: - tip = f"PydanticSerializationError occurred while processing file '{json_file}'" - - if inspect.ismethod(x): - logger.error(f"{tip}, Method: {x.__self__.__class__.__name__}.{x.__func__.__name__}") - elif inspect.isfunction(x): - logger.error(f"{tip}, Function: {x.__name__}") - elif hasattr(x, "__class__"): - logger.error(f"{tip}, Instance of: {x.__class__.__name__}") - elif hasattr(x, "__name__"): - logger.error(f"{tip}, Class or module: {x.__name__}") - else: - logger.error(f"{tip}, Unknown type: {type(x)}") - - custom_default = partial(to_jsonable_python, fallback=fallback if use_fallback else None) + custom_default = partial(to_jsonable_python, fallback=handle_unknown_serialization if use_fallback else None) with open(json_file, "w", encoding=encoding) as fout: json.dump(data, fout, ensure_ascii=False, indent=indent, default=custom_default) From 587dd0cc81d06aa039ff942e2f23162498d77642 Mon Sep 17 00:00:00 2001 From: seehi <6580@pm.me> Date: Mon, 12 Aug 2024 14:37:00 +0800 Subject: [PATCH 4/9] use serialize in SerializationMixin --- metagpt/environment/mgx/mgx_env.py | 56 ++------------------ metagpt/schema.py | 74 +++++++++++++++++++++++++++ metagpt/utils/serialize.py | 38 +------------- tests/metagpt/test_schema.py | 71 ++++++++++++++++++++++++- tests/metagpt/utils/test_serialize.py | 36 ------------- 5 files changed, 150 insertions(+), 125 deletions(-) diff --git a/metagpt/environment/mgx/mgx_env.py b/metagpt/environment/mgx/mgx_env.py index 43ef9c4b5..99f94052a 100644 --- a/metagpt/environment/mgx/mgx_env.py +++ b/metagpt/environment/mgx/mgx_env.py @@ -1,5 +1,3 @@ -from typing import ClassVar - from metagpt.actions import ( UserRequirement, WriteDesign, @@ -8,17 +6,15 @@ from metagpt.actions import ( WriteTest, ) from metagpt.actions.summarize_code import SummarizeCode -from metagpt.const import AGENT, SERDESER_PATH +from metagpt.const import AGENT from metagpt.environment.base_env import Environment -from metagpt.logs import get_human_input, logger +from metagpt.logs import get_human_input from metagpt.roles import Architect, ProductManager, ProjectManager, Role -from metagpt.schema import Message +from metagpt.schema import Message, SerializationMixin from metagpt.utils.common import any_to_str, any_to_str_set -from metagpt.utils.exceptions import handle_exception -from metagpt.utils.serialize import deserialize_model, serialize_model -class MGXEnv(Environment): +class MGXEnv(Environment, SerializationMixin): """MGX Environment""" # If True, fixed software sop bypassing TL is allowed, otherwise, TL will fully take over the routing @@ -26,8 +22,6 @@ class MGXEnv(Environment): direct_chat_roles: set[str] = set() # record direct chat: @role_name - default_serialization_path: ClassVar[str] = str(SERDESER_PATH / "mgxenv" / "mgxenv.json") - def _publish_message(self, message: Message, peekable: bool = True) -> bool: return super().publish_message(message, peekable) @@ -132,53 +126,13 @@ class MGXEnv(Environment): def __repr__(self): return "MGXEnv()" - @handle_exception - def serialize(self, file_path: str = None) -> str: - """Serializes the current instance to a JSON file. - - If an exception occurs, `handle_exception` will catch it and return `None`. - - Args: - file_path (str, optional): The path to the JSON file where the instance will be saved. Defaults to None. - - Returns: - str: The path to the JSON file where the instance was saved. - """ - - file_path = file_path or self.default_serialization_path - - serialize_model(self, file_path, remove_unserializable=self.remove_unserializable) - logger.info(f"MGXEnv serialization successful. File saved at: {file_path}") - - return file_path - - @classmethod - @handle_exception - def deserialize(cls, file_path: str = None) -> "MGXEnv": - """Deserializes a JSON file to an instance of MGXEnv. - - If an exception occurs, `handle_exception` will catch it and return `None`. - - Args: - file_path (str, optional): The path to the JSON file to read from. Defaults to None. - - Returns: - MGXEnv: An instance of MGXEnv. - """ - - file_path = file_path or cls.default_serialization_path - - model = deserialize_model(cls, file_path) - logger.info(f"MGXEnv deserialization successful. Instance created from file: {file_path}") - - return model - def remove_unserializable(self, data: dict): """Removes unserializable content from the data dictionary. Args: data (dict): The data dictionary to clean, obtained from Pydantic's model_dump method. """ + roles = data.get("roles", {}) for role in roles.values(): diff --git a/metagpt/schema.py b/metagpt/schema.py index 648e2bd73..2431304db 100644 --- a/metagpt/schema.py +++ b/metagpt/schema.py @@ -44,6 +44,7 @@ from metagpt.const import ( MESSAGE_ROUTE_FROM, MESSAGE_ROUTE_TO, MESSAGE_ROUTE_TO_ALL, + SERDESER_PATH, SYSTEM_DESIGN_FILE_REPO, TASK_FILE_REPO, ) @@ -56,6 +57,8 @@ from metagpt.utils.common import ( any_to_str_set, aread, import_class, + read_json_file, + write_json_file, ) from metagpt.utils.exceptions import handle_exception from metagpt.utils.report import TaskReporter @@ -127,6 +130,77 @@ class SerializationMixin(BaseModel, extra="forbid"): cls.__subclasses_map__[f"{cls.__module__}.{cls.__qualname__}"] = cls super().__init_subclass__(**kwargs) + @handle_exception + def serialize(self, file_path: str = None) -> str: + """Serializes the current instance to a JSON file. + + If an exception occurs, `handle_exception` will catch it and return `None`. + + Args: + file_path (str, optional): The path to the JSON file where the instance will be saved. Defaults to None. + + Returns: + str: The path to the JSON file where the instance was saved. + """ + + file_path = file_path or self.get_serialization_path() + + serialized_data = self.model_dump() + self.remove_unserializable(serialized_data) + + write_json_file(file_path, serialized_data) + logger.info(f"{self.__class__.__qualname__} serialization successful. File saved at: {file_path}") + + return file_path + + @classmethod + @handle_exception + def deserialize(cls, file_path: str = None) -> BaseModel: + """Deserializes a JSON file to an instance of cls. + + If an exception occurs, `handle_exception` will catch it and return `None`. + + Args: + file_path (str, optional): The path to the JSON file to read from. Defaults to None. + + Returns: + An instance of the cls. + """ + + file_path = file_path or cls.get_serialization_path() + + data: dict = read_json_file(file_path) + + model = cls(**data) + logger.info(f"{cls.__qualname__} deserialization successful. Instance created from file: {file_path}") + + return model + + @classmethod + def get_serialization_path(cls) -> str: + """Get the serialization path for the class. + + This method constructs a file path for serialization based on the class name. + The default path is constructed as './workspace/storage/ClassName.json', where 'ClassName' + is the name of the class. + + Returns: + str: The path to the serialization file. + """ + + return str(SERDESER_PATH / f"{cls.__qualname__}.json") + + def remove_unserializable(self, data: dict): + """Removes unserializable content from the data dictionary. + + This method removes keys specified in the "unserializable_fields" list from the provided data dictionary. + It is intended to clean the dictionary obtained from Pydantic's `model_dump` method by removing fields + that cannot be serialized. + """ + + for key in data.get("unserializable_fields", []): + data.pop(key, None) + class SimpleMessage(BaseModel): content: str diff --git a/metagpt/utils/serialize.py b/metagpt/utils/serialize.py index 814621377..c6bd8ad75 100644 --- a/metagpt/utils/serialize.py +++ b/metagpt/utils/serialize.py @@ -4,11 +4,8 @@ import copy import pickle -from typing import Callable, Optional, Type -from pydantic import BaseModel - -from metagpt.utils.common import import_class, read_json_file, write_json_file +from metagpt.utils.common import import_class def actionoutout_schema_to_mapping(schema: dict) -> dict: @@ -84,36 +81,3 @@ def deserialize_message(message_ser: str) -> "Message": message.instruct_content = ic_new return message - - -def serialize_model(model: BaseModel, file_path: str, remove_unserializable: Optional[Callable[[dict], None]] = None): - """Serializes a Pydantic model to a JSON file. - - Args: - model (BaseModel): The Pydantic model to serialize. - file_path (str): The path to the JSON file where the model will be saved. - remove_unserializable (Optional[Callable[[dict], None]]): Optional function to remove unserializable content from the serialized data. - """ - - serialized_data = model.model_dump() - - if remove_unserializable: - remove_unserializable(serialized_data) - - write_json_file(file_path, serialized_data) - - -def deserialize_model(cls: Type[BaseModel], file_path: str) -> BaseModel: - """Deserializes a JSON file to a Pydantic model. - - Args: - cls (Type[BaseModel]): The Pydantic model class to deserialize into. - file_path (str): The path to the JSON file to read from. - - Returns: - BaseModel: An instance of the Pydantic model. - """ - - data: dict = read_json_file(file_path) - - return cls(**data) diff --git a/tests/metagpt/test_schema.py b/tests/metagpt/test_schema.py index 48f13f4a2..12e0c7aab 100644 --- a/tests/metagpt/test_schema.py +++ b/tests/metagpt/test_schema.py @@ -11,11 +11,12 @@ import json import pytest +from pydantic import BaseModel from metagpt.actions import Action from metagpt.actions.action_node import ActionNode from metagpt.actions.write_code import WriteCode -from metagpt.const import SYSTEM_DESIGN_FILE_REPO, TASK_FILE_REPO +from metagpt.const import SERDESER_PATH, SYSTEM_DESIGN_FILE_REPO, TASK_FILE_REPO from metagpt.schema import ( AIMessage, CodeSummarizeContext, @@ -23,6 +24,7 @@ from metagpt.schema import ( Message, MessageQueue, Plan, + SerializationMixin, SystemMessage, Task, UMLClassAttribute, @@ -398,5 +400,72 @@ def test_create_instruct_value(name, value): assert obj.model_dump() == value +class TestUserModel(SerializationMixin, BaseModel): + name: str + value: int + + +class TestUserModelWithRemove(TestUserModel): + def remove_unserializable(self, data: dict): + for key in ["value", "__module_class_name"]: + data.pop(key, None) + + +class TestSerializationMixin: + @pytest.fixture + def mock_write_json_file(self, mocker): + return mocker.patch("metagpt.schema.write_json_file") + + @pytest.fixture + def mock_read_json_file(self, mocker): + return mocker.patch("metagpt.schema.read_json_file") + + @pytest.fixture + def mock_user_model(self): + return TestUserModel(name="test", value=42) + + def test_serialize(self, mock_write_json_file, mock_user_model): + file_path = "test.json" + + mock_user_model.serialize(file_path) + + mock_write_json_file.assert_called_once_with(file_path, mock_user_model.model_dump()) + + def test_deserialize(self, mock_read_json_file): + file_path = "test.json" + data = {"name": "test", "value": 42} + mock_read_json_file.return_value = data + + model = TestUserModel.deserialize(file_path) + + mock_read_json_file.assert_called_once_with(file_path) + assert model == TestUserModel(**data) + + def test_serialize_with_remove_unserializable(self, mock_write_json_file): + model = TestUserModelWithRemove(name="test", value=42) + file_path = "test.json" + + model.serialize(file_path) + + mock_write_json_file.assert_called_once_with(file_path, {"name": "test"}) + + def test_get_serialization_path(self): + expected_path = str(SERDESER_PATH / "TestUserModel.json") + + assert TestUserModel.get_serialization_path() == expected_path + + def test_remove_unserializable(self, mock_user_model): + data = { + "name": "example", + "unserializable_fields": ["temp_data", "debug_info"], + "temp_data": "some temporary data", + "debug_info": "some debug information", + } + mock_user_model.remove_unserializable(data) + + expected_data = {"name": "example", "unserializable_fields": ["temp_data", "debug_info"]} + assert data == expected_data + + if __name__ == "__main__": pytest.main([__file__, "-s"]) diff --git a/tests/metagpt/utils/test_serialize.py b/tests/metagpt/utils/test_serialize.py index 3b20f3fa0..0ba3a8d41 100644 --- a/tests/metagpt/utils/test_serialize.py +++ b/tests/metagpt/utils/test_serialize.py @@ -6,17 +6,13 @@ from typing import List -from pydantic import BaseModel - from metagpt.actions import WritePRD from metagpt.actions.action_node import ActionNode from metagpt.schema import Message from metagpt.utils.serialize import ( actionoutout_schema_to_mapping, deserialize_message, - deserialize_model, serialize_message, - serialize_model, ) @@ -70,35 +66,3 @@ def test_serialize_and_deserialize_message(): assert new_message.content == message.content assert new_message.cause_by == message.cause_by assert new_message.instruct_content.field1 == out_data["field1"] - - -class TestUserModel(BaseModel): - name: str - value: int - - -def test_serialize_model(mocker): - model = TestUserModel(name="test", value=42) - file_path = "test.json" - mock_write_json_file = mocker.patch("metagpt.utils.serialize.write_json_file") - - # Test without remove_unserializable - serialize_model(model, file_path) - mock_write_json_file.assert_called_once_with(file_path, model.model_dump()) - - # Test with remove_unserializable - def remove_unserializable(data: dict): - data.pop("value", None) - - serialize_model(model, file_path, remove_unserializable) - mock_write_json_file.assert_called_with(file_path, {"name": "test"}) - - -def test_deserialize_model(mocker): - file_path = "test.json" - data = {"name": "test", "value": 42} - mock_read_json_file = mocker.patch("metagpt.utils.serialize.read_json_file", return_value=data) - - model = deserialize_model(TestUserModel, file_path) - mock_read_json_file.assert_called_once_with(file_path) - assert model == TestUserModel(**data) From 31764add8a6065316b02df6fdbc0c55f6938d1a0 Mon Sep 17 00:00:00 2001 From: seehi <6580@pm.me> Date: Mon, 12 Aug 2024 14:56:15 +0800 Subject: [PATCH 5/9] add an example --- examples/serialize_model.py | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) create mode 100644 examples/serialize_model.py diff --git a/examples/serialize_model.py b/examples/serialize_model.py new file mode 100644 index 000000000..b81afc743 --- /dev/null +++ b/examples/serialize_model.py @@ -0,0 +1,24 @@ +from metagpt.logs import logger +from metagpt.roles.product_manager import ProductManager + + +def main(): + """Demonstrates serialization and deserialization using SerializationMixin. + + This example creates an instance of ProductManager, serializes it to a file, + and then deserializes it back to an instance. + + If executed correctly, the following log messages will be output: + ProductManager serialization successful. File saved at: /data/hjt/gitlab_metagpt/workspace/storage/ProductManager.json + ProductManager deserialization successful. Instance created from file: /data/hjt/gitlab_metagpt/workspace/storage/ProductManager.json + The role is Product Manager + """ + role = ProductManager() + role.serialize() + + role: ProductManager = ProductManager.deserialize() + logger.info(f"The role is {role.profile}") + + +if __name__ == "__main__": + main() From 9d40d96535e8325a416c086aa619901b112d8168 Mon Sep 17 00:00:00 2001 From: seehi <6580@pm.me> Date: Mon, 12 Aug 2024 15:04:56 +0800 Subject: [PATCH 6/9] add an example --- examples/serialize_model.py | 19 ++++++++++--------- 1 file changed, 10 insertions(+), 9 deletions(-) diff --git a/examples/serialize_model.py b/examples/serialize_model.py index b81afc743..2e4431ed2 100644 --- a/examples/serialize_model.py +++ b/examples/serialize_model.py @@ -1,23 +1,24 @@ +from metagpt.environment.mgx.mgx_env import MGXEnv from metagpt.logs import logger -from metagpt.roles.product_manager import ProductManager def main(): """Demonstrates serialization and deserialization using SerializationMixin. - This example creates an instance of ProductManager, serializes it to a file, + This example creates an instance of MGXEnv, serializes it to a file, and then deserializes it back to an instance. If executed correctly, the following log messages will be output: - ProductManager serialization successful. File saved at: /data/hjt/gitlab_metagpt/workspace/storage/ProductManager.json - ProductManager deserialization successful. Instance created from file: /data/hjt/gitlab_metagpt/workspace/storage/ProductManager.json - The role is Product Manager + MGXEnv serialization successful. File saved at: /.../workspace/storage/MGXEnv.json + MGXEnv deserialization successful. Instance created from file: /.../workspace/storage/MGXEnv.json + The object is MGXEnv() """ - role = ProductManager() - role.serialize() - role: ProductManager = ProductManager.deserialize() - logger.info(f"The role is {role.profile}") + env = MGXEnv() + env.serialize() + + env: MGXEnv = MGXEnv.deserialize() + logger.info(f"The object is {repr(env)}") if __name__ == "__main__": From 11894d12f3f056053c6c7743c0e6b15ccb643650 Mon Sep 17 00:00:00 2001 From: seehi <6580@pm.me> Date: Mon, 12 Aug 2024 15:19:36 +0800 Subject: [PATCH 7/9] add an example --- examples/serialize_model.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/examples/serialize_model.py b/examples/serialize_model.py index 2e4431ed2..2423efef8 100644 --- a/examples/serialize_model.py +++ b/examples/serialize_model.py @@ -11,14 +11,14 @@ def main(): If executed correctly, the following log messages will be output: MGXEnv serialization successful. File saved at: /.../workspace/storage/MGXEnv.json MGXEnv deserialization successful. Instance created from file: /.../workspace/storage/MGXEnv.json - The object is MGXEnv() + The instance is MGXEnv() """ env = MGXEnv() env.serialize() env: MGXEnv = MGXEnv.deserialize() - logger.info(f"The object is {repr(env)}") + logger.info(f"The instance is {repr(env)}") if __name__ == "__main__": From b4207cec923bd15b5d74ffbbf0e442a937af4aa3 Mon Sep 17 00:00:00 2001 From: seehi <6580@pm.me> Date: Mon, 12 Aug 2024 17:16:28 +0800 Subject: [PATCH 8/9] use pydantic's exclude --- metagpt/environment/mgx/mgx_env.py | 12 ----------- metagpt/roles/di/role_zero.py | 9 ++++---- metagpt/schema.py | 12 ----------- tests/metagpt/test_schema.py | 33 ++++++++++++------------------ 4 files changed, 17 insertions(+), 49 deletions(-) diff --git a/metagpt/environment/mgx/mgx_env.py b/metagpt/environment/mgx/mgx_env.py index 99f94052a..fae386952 100644 --- a/metagpt/environment/mgx/mgx_env.py +++ b/metagpt/environment/mgx/mgx_env.py @@ -125,15 +125,3 @@ class MGXEnv(Environment, SerializationMixin): def __repr__(self): return "MGXEnv()" - - def remove_unserializable(self, data: dict): - """Removes unserializable content from the data dictionary. - - Args: - data (dict): The data dictionary to clean, obtained from Pydantic's model_dump method. - """ - - roles = data.get("roles", {}) - - for role in roles.values(): - [role.pop(key, None) for key in role.get("unserializable_fields", [])] diff --git a/metagpt/roles/di/role_zero.py b/metagpt/roles/di/role_zero.py index 119fdf5a3..6802fdb00 100644 --- a/metagpt/roles/di/role_zero.py +++ b/metagpt/roles/di/role_zero.py @@ -4,9 +4,9 @@ import inspect import json import re import traceback -from typing import Callable, Dict, List, Literal, Optional, Tuple +from typing import Annotated, Callable, Dict, List, Literal, Optional, Tuple -from pydantic import model_validator +from pydantic import Field, model_validator from metagpt.actions import Action, UserRequirement from metagpt.actions.analyze_requirements import AnalyzeRequirementsRestrictions @@ -59,14 +59,14 @@ class RoleZero(Role): # Tools tools: list[str] = [] # Use special symbol [""] to indicate use of all registered tools tool_recommender: Optional[ToolRecommender] = None - tool_execution_map: dict[str, Callable] = {} + tool_execution_map: Annotated[dict[str, Callable], Field(exclude=True)] = {} special_tool_commands: list[str] = ["Plan.finish_current_task", "end", "Bash.run"] # Equipped with three basic tools by default for optional use editor: Editor = Editor() browser: Browser = Browser() # Experience - experience_retriever: ExpRetriever = DummyExpRetriever() + experience_retriever: Annotated[ExpRetriever, Field(exclude=True)] = DummyExpRetriever() # Others command_rsp: str = "" # the raw string containing the commands @@ -74,7 +74,6 @@ class RoleZero(Role): memory_k: int = 20 # number of memories (messages) to use as historical context use_fixed_sop: bool = False requirements_constraints: str = "" # the constraints in user requirements - unserializable_fields: list[str] = ["tool_execution_map", "experience_retriever"] @model_validator(mode="after") def set_plan_and_tool(self) -> "RoleZero": diff --git a/metagpt/schema.py b/metagpt/schema.py index 2431304db..ad8c8f1d7 100644 --- a/metagpt/schema.py +++ b/metagpt/schema.py @@ -146,7 +146,6 @@ class SerializationMixin(BaseModel, extra="forbid"): file_path = file_path or self.get_serialization_path() serialized_data = self.model_dump() - self.remove_unserializable(serialized_data) write_json_file(file_path, serialized_data) logger.info(f"{self.__class__.__qualname__} serialization successful. File saved at: {file_path}") @@ -190,17 +189,6 @@ class SerializationMixin(BaseModel, extra="forbid"): return str(SERDESER_PATH / f"{cls.__qualname__}.json") - def remove_unserializable(self, data: dict): - """Removes unserializable content from the data dictionary. - - This method removes keys specified in the "unserializable_fields" list from the provided data dictionary. - It is intended to clean the dictionary obtained from Pydantic's `model_dump` method by removing fields - that cannot be serialized. - """ - - for key in data.get("unserializable_fields", []): - data.pop(key, None) - class SimpleMessage(BaseModel): content: str diff --git a/tests/metagpt/test_schema.py b/tests/metagpt/test_schema.py index 12e0c7aab..bc2bdd02a 100644 --- a/tests/metagpt/test_schema.py +++ b/tests/metagpt/test_schema.py @@ -9,9 +9,10 @@ """ import json +from typing import Annotated import pytest -from pydantic import BaseModel +from pydantic import BaseModel, Field from metagpt.actions import Action from metagpt.actions.action_node import ActionNode @@ -405,10 +406,8 @@ class TestUserModel(SerializationMixin, BaseModel): value: int -class TestUserModelWithRemove(TestUserModel): - def remove_unserializable(self, data: dict): - for key in ["value", "__module_class_name"]: - data.pop(key, None) +class TestUserModelWithExclude(TestUserModel): + age: Annotated[int, Field(exclude=True)] class TestSerializationMixin: @@ -441,31 +440,25 @@ class TestSerializationMixin: mock_read_json_file.assert_called_once_with(file_path) assert model == TestUserModel(**data) - def test_serialize_with_remove_unserializable(self, mock_write_json_file): - model = TestUserModelWithRemove(name="test", value=42) + def test_serialize_with_exclude(self, mock_write_json_file): + model = TestUserModelWithExclude(name="test", value=42, age=10) file_path = "test.json" model.serialize(file_path) - mock_write_json_file.assert_called_once_with(file_path, {"name": "test"}) + expected_data = { + "name": "test", + "value": 42, + "__module_class_name": "tests.metagpt.test_schema.TestUserModelWithExclude", + } + + mock_write_json_file.assert_called_once_with(file_path, expected_data) def test_get_serialization_path(self): expected_path = str(SERDESER_PATH / "TestUserModel.json") assert TestUserModel.get_serialization_path() == expected_path - def test_remove_unserializable(self, mock_user_model): - data = { - "name": "example", - "unserializable_fields": ["temp_data", "debug_info"], - "temp_data": "some temporary data", - "debug_info": "some debug information", - } - mock_user_model.remove_unserializable(data) - - expected_data = {"name": "example", "unserializable_fields": ["temp_data", "debug_info"]} - assert data == expected_data - if __name__ == "__main__": pytest.main([__file__, "-s"]) From 2222cf33793577f222e1316b14803d5433cfce22 Mon Sep 17 00:00:00 2001 From: seehi <6580@pm.me> Date: Mon, 12 Aug 2024 18:24:10 +0800 Subject: [PATCH 9/9] use exclude --- metagpt/roles/di/data_analyst.py | 4 +++- metagpt/roles/di/team_leader.py | 6 +++++- 2 files changed, 8 insertions(+), 2 deletions(-) diff --git a/metagpt/roles/di/data_analyst.py b/metagpt/roles/di/data_analyst.py index 3a43f72e0..f65042217 100644 --- a/metagpt/roles/di/data_analyst.py +++ b/metagpt/roles/di/data_analyst.py @@ -1,5 +1,7 @@ from __future__ import annotations +from typing import Annotated + from pydantic import Field, model_validator from metagpt.actions.di.execute_nb_code import ExecuteNbCode @@ -31,7 +33,7 @@ class DataAnalyst(RoleZero): tools: list[str] = ["Plan", "DataAnalyst", "RoleZero", "Browser"] custom_tools: list[str] = ["web scraping", "Terminal"] custom_tool_recommender: ToolRecommender = None - experience_retriever: ExpRetriever = KeywordExpRetriever() + experience_retriever: Annotated[ExpRetriever, Field(exclude=True)] = KeywordExpRetriever() use_reflection: bool = True write_code: WriteAnalysisCode = Field(default_factory=WriteAnalysisCode, exclude=True) diff --git a/metagpt/roles/di/team_leader.py b/metagpt/roles/di/team_leader.py index 12b4b3a18..353e00620 100644 --- a/metagpt/roles/di/team_leader.py +++ b/metagpt/roles/di/team_leader.py @@ -1,5 +1,9 @@ from __future__ import annotations +from typing import Annotated + +from pydantic import Field + from metagpt.actions.di.run_command import RunCommand from metagpt.prompts.di.team_leader import ( FINISH_CURRENT_TASK_CMD, @@ -24,7 +28,7 @@ class TeamLeader(RoleZero): tools: list[str] = ["Plan", "RoleZero", "TeamLeader"] - experience_retriever: ExpRetriever = SimpleExpRetriever() + experience_retriever: Annotated[ExpRetriever, Field(exclude=True)] = SimpleExpRetriever() def _update_tool_execution(self): self.tool_execution_map.update(