Upload 699 files

notebook_dir/GeoAgent-20250427.ipynb

@@ -0,0 +1,124 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "24b811ea-7714-4c2d-947d-1fb1b2ec980d",
+   "metadata": {
+   "collapsed": false,
+    "deletable": false,
+    "editable": false,
+    "jupyter": {
+     "outputs_hidden": false
+    }},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2025-04-27 16:56:51.233 | INFO     | metagpt_yusin.const:get_metagpt_yusin_package_root:29 - Package root set to /data\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "382ee0ae87fd4555959704f7f29aa79b",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "HBox(children=(VBox(children=(VBox(children=(Label(value='Select data sources and LLM models (or Submit defaul…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from metagpt_yusin.geoagent import GeoAgent; GeoAgent().default()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bf9d8a3f-ee15-490b-8ecf-ba58836d2bc2",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "62f50c92-c051-4650-988b-c84b9f22a130",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "161e81a7-680a-431b-af6c-772fe827afd3",
+   "metadata": {},
+   "source": [
+    "# Decomposing the overall task into tasks!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c3a17761-7ddd-47b8-91b5-40d4e382a816",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "[\n",
+    "    {\n",
+    "        \"task_id\": \"1\",\n",
+    "        \"dependent_task_ids\": [],\n",
+    "        \"instruction\": \"Design ASCII rabbit art\",\n",
+    "        \"task_type\": \"other\"\n",
+    "    },\n",
+    "    {\n",
+    "        \"task_id\": \"2\",\n",
+    "        \"dependent_task_ids\": [\"1\"],\n",
+    "        \"instruction\": \"Create function to plot ASCII rabbit\",\n",
+    "        \"task_type\": \"other\"\n",
+    "    },\n",
+    "    {\n",
+    "        \"task_id\": \"3\",\n",
+    "        \"dependent_task_ids\": [\"2\"],\n",
+    "        \"instruction\": \"Test the plotting function\",\n",
+    "        \"task_type\": \"other\"\n",
+    "    }\n",
+    "]\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "538d829b-61d1-42a2-8c9a-553c5ff45dfa",
+   "metadata": {},
+   "source": [
+    "# Here is the code part!"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

notebook_dir/metagpt_yusin/.ipynb_checkpoints/__init__-checkpoint.py

@@ -0,0 +1,7 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# @Time    : 2023/4/24 22:26
+# @Author  : alexanderwu
+# @File    : __init__.py
+
+from metagpt_yusin import _compat as _  # noqa: F401

notebook_dir/metagpt_yusin/.ipynb_checkpoints/_compat-checkpoint.py

@@ -0,0 +1,23 @@
+import platform
+import sys
+import warnings
+
+if sys.implementation.name == "cpython" and platform.system() == "Windows":
+    import asyncio
+
+    if sys.version_info[:2] == (3, 9):
+        from asyncio.proactor_events import _ProactorBasePipeTransport
+
+        # https://github.com/python/cpython/pull/92842
+        def pacth_del(self, _warn=warnings.warn):
+            if self._sock is not None:
+                _warn(f"unclosed transport {self!r}", ResourceWarning, source=self)
+                self._sock.close()
+
+        _ProactorBasePipeTransport.__del__ = pacth_del
+
+    if sys.version_info >= (3, 9, 0):
+        from semantic_kernel.orchestration import sk_function as _  # noqa: F401
+
+        # caused by https://github.com/microsoft/semantic-kernel/pull/1416
+        asyncio.set_event_loop_policy(asyncio.WindowsProactorEventLoopPolicy())

notebook_dir/metagpt_yusin/.ipynb_checkpoints/config2-checkpoint.py

@@ -0,0 +1,195 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+@Time    : 2024/1/4 01:25
+@Author  : alexanderwu
+@File    : config2.py
+"""
+import os
+from pathlib import Path
+from typing import Dict, Iterable, List, Literal, Optional
+
+from pydantic import BaseModel, model_validator
+
+from metagpt_yusin.logs import logger
+from metagpt_yusin.configs.browser_config import BrowserConfig
+from metagpt_yusin.configs.llm_config import LLMConfig, LLMType
+from metagpt_yusin.configs.mermaid_config import MermaidConfig
+from metagpt_yusin.configs.redis_config import RedisConfig
+from metagpt_yusin.configs.s3_config import S3Config
+from metagpt_yusin.configs.search_config import SearchConfig
+from metagpt_yusin.configs.workspace_config import WorkspaceConfig
+from metagpt_yusin.const import CONFIG_ROOT, metagpt_yusin_ROOT
+from metagpt_yusin.utils.yaml_model import YamlModel
+
+# list all varibles in LLMType
+#LLMType_dict = LLMType.__dict__
+
+class CLIParams(BaseModel):
+    """CLI parameters"""
+
+    project_path: str = ""
+    project_name: str = ""
+    inc: bool = False
+    reqa_file: str = ""
+    max_auto_summarize_code: int = 0
+    git_reinit: bool = False
+
+    @model_validator(mode="after")
+    def check_project_path(self):
+        """Check project_path and project_name"""
+        if self.project_path:
+            self.inc = True
+            self.project_name = self.project_name or Path(self.project_path).name
+        return self
+
+
+class Config(CLIParams, YamlModel):
+    """Configurations for metagpt_yusin"""
+
+    # Key Parameters
+    llm: LLMConfig
+
+    # Global Proxy. Will be used if llm.proxy is not set
+    proxy: str = ""
+
+    # Tool Parameters
+    search: SearchConfig = SearchConfig()
+    browser: BrowserConfig = BrowserConfig()
+    mermaid: MermaidConfig = MermaidConfig()
+
+    # Storage Parameters
+    s3: Optional[S3Config] = None
+    redis: Optional[RedisConfig] = None
+
+    # Misc Parameters
+    repair_llm_output: bool = False
+    prompt_schema: Literal["json", "markdown", "raw"] = "json"
+    workspace: WorkspaceConfig = WorkspaceConfig()
+    enable_longterm_memory: bool = False
+    code_review_k_times: int = 2
+
+    # Will be removed in the future
+    metagpt_yusin_tti_url: str = ""
+    language: str = "English"
+    redis_key: str = "placeholder"
+    iflytek_app_id: str = ""
+    iflytek_api_secret: str = ""
+    iflytek_api_key: str = ""
+    azure_tts_subscription_key: str = ""
+    azure_tts_region: str = ""
+    _extra: dict = dict()  # extra config dict
+
+    @classmethod
+    def from_home(cls, path):
+        """Load config from ~/.metagpt_yusin/config2.yaml"""
+        pathname = CONFIG_ROOT / path
+        if not pathname.exists():
+            return None
+        return Config.from_yaml_file(pathname)
+
+    @classmethod
+    def default(cls):
+        """Load default config
+        - Priority: env < default_config_paths
+        - Inside default_config_paths, the latter one overwrites the former one
+        """
+        
+        #default_config_paths: List[Path] = [
+        #    metagpt_yusin_ROOT / "config/config2.yaml",
+        #    CONFIG_ROOT / "config2.yaml",
+        #]
+        
+        default_config_paths: List[Path] = [
+            CONFIG_ROOT / "config2.yaml",
+        ]
+        	
+        dicts = [dict(os.environ)]
+        dicts += [Config.read_yaml(path) for path in default_config_paths]
+        final = merge_dict(dicts)
+        config_init = Config(**final)
+        
+        
+        # appended new
+        if 'api_type' in os.environ:
+            if os.environ.get('api_type') == 'openai':
+            	config_init.llm.api_type = LLMType.OPENAI
+            elif os.environ.get('api_type') == 'groq':
+                config_init.llm.api_type = LLMType.OPENAI
+                config_init.llm.base_url = 'https://api.groq.com/openai/v1'
+            elif os.environ.get('api_type') == 'openrouter':
+                config_init.llm.api_type = LLMType.OPENROUTER
+                config_init.llm.base_url = 'https://openrouter.ai/api/v1'
+            else:
+            	logger.debug('The API Type is not supported!!')
+        else:
+            logger.debug('Provide your api type!!')
+        if 'model' in os.environ:
+            config_init.llm.model = os.environ.get('model')
+        else:
+            logger.debug('Provide your model!!')
+        if 'api_key' in os.environ:
+            config_init.llm.api_key = os.environ.get('api_key')
+        else:
+            logger.debug('Provide your api key!!')
+         
+        
+        return config_init
+
+    @classmethod
+    def from_llm_config(cls, llm_config: dict):
+        """user config llm
+        example:
+        llm_config = {"api_type": "xxx", "api_key": "xxx", "model": "xxx"}
+        gpt4 = Config.from_llm_config(llm_config)
+        A = Role(name="A", profile="Democratic candidate", goal="Win the election", actions=[a1], watch=[a2], config=gpt4)
+        """
+        llm_config = LLMConfig.model_validate(llm_config)
+        dicts = [dict(os.environ)]
+        dicts += [{"llm": llm_config}]
+        final = merge_dict(dicts)
+        return Config(**final)
+
+    def update_via_cli(self, project_path, project_name, inc, reqa_file, max_auto_summarize_code):
+        """update config via cli"""
+
+        # Use in the PrepareDocuments action according to Section 2.2.3.5.1 of RFC 135.
+        if project_path:
+            inc = True
+            project_name = project_name or Path(project_path).name
+        self.project_path = project_path
+        self.project_name = project_name
+        self.inc = inc
+        self.reqa_file = reqa_file
+        self.max_auto_summarize_code = max_auto_summarize_code
+
+    @property
+    def extra(self):
+        return self._extra
+
+    @extra.setter
+    def extra(self, value: dict):
+        self._extra = value
+
+    def get_openai_llm(self) -> Optional[LLMConfig]:
+        """Get OpenAI LLMConfig by name. If no OpenAI, raise Exception"""
+        if self.llm.api_type == LLMType.OPENAI:
+            return self.llm
+        return None
+
+    def get_azure_llm(self) -> Optional[LLMConfig]:
+        """Get Azure LLMConfig by name. If no Azure, raise Exception"""
+        if self.llm.api_type == LLMType.AZURE:
+            return self.llm
+        return None
+
+
+def merge_dict(dicts: Iterable[Dict]) -> Dict:
+    """Merge multiple dicts into one, with the latter dict overwriting the former"""
+    result = {}
+    for dictionary in dicts:
+        result.update(dictionary)
+    return result
+
+
+config = Config.default()

notebook_dir/metagpt_yusin/.ipynb_checkpoints/const-checkpoint.py

@@ -0,0 +1,138 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+@Time    : 2023/5/1 11:59
+@Author  : alexanderwu
+@File    : const.py
+@Modified By: mashenquan, 2023-11-1. According to Section 2.2.1 and 2.2.2 of RFC 116, added key definitions for
+        common properties in the Message.
+@Modified By: mashenquan, 2023-11-27. Defines file repository paths according to Section 2.2.3.4 of RFC 135.
+@Modified By: mashenquan, 2023/12/5. Add directories for code summarization..
+"""
+import os
+from pathlib import Path
+
+from loguru import logger
+
+import metagpt_yusin
+
+
+def get_metagpt_yusin_package_root():
+    """Get the root directory of the installed package."""
+    package_root = Path(metagpt_yusin.__file__).parent.parent
+    for i in (".git", ".project_root", ".gitignore"):
+        if (package_root / i).exists():
+            break
+    else:
+        package_root = Path.cwd()
+
+    logger.info(f"Package root set to {str(package_root)}")
+    return package_root
+
+
+def get_metagpt_yusin_root():
+    """Get the project root directory."""
+    # Check if a project root is specified in the environment variable
+    project_root_env = os.getenv("metagpt_yusin_PROJECT_ROOT")
+    if project_root_env:
+        project_root = Path(project_root_env)
+        logger.info(f"PROJECT_ROOT set from environment variable to {str(project_root)}")
+    else:
+        # Fallback to package root if no environment variable is set
+        project_root = get_metagpt_yusin_package_root()
+    return project_root
+
+
+# metagpt_yusin PROJECT ROOT AND VARS
+#CONFIG_ROOT = Path.home() / ".metagpt_yusin"
+metagpt_yusin_ROOT = get_metagpt_yusin_root()  # Dependent on metagpt_yusin_PROJECT_ROOT
+DEFAULT_WORKSPACE_ROOT = metagpt_yusin_ROOT / "workspace"
+CONFIG_ROOT = metagpt_yusin_ROOT / "metagpt_yusin/configs"
+
+EXAMPLE_PATH = metagpt_yusin_ROOT / "examples"
+EXAMPLE_DATA_PATH = EXAMPLE_PATH / "data"
+DATA_PATH = metagpt_yusin_ROOT / "data"
+TEST_DATA_PATH = metagpt_yusin_ROOT / "tests/data"
+RESEARCH_PATH = DATA_PATH / "research"
+TUTORIAL_PATH = DATA_PATH / "tutorial_docx"
+INVOICE_OCR_TABLE_PATH = DATA_PATH / "invoice_table"
+
+UT_PATH = DATA_PATH / "ut"
+SWAGGER_PATH = UT_PATH / "files/api/"
+UT_PY_PATH = UT_PATH / "files/ut/"
+API_QUESTIONS_PATH = UT_PATH / "files/question/"
+
+SERDESER_PATH = DEFAULT_WORKSPACE_ROOT / "storage"  # TODO to store `storage` under the individual generated project
+
+TMP = metagpt_yusin_ROOT / "tmp"
+
+SOURCE_ROOT = metagpt_yusin_ROOT / "metagpt_yusin"
+PROMPT_PATH = SOURCE_ROOT / "prompts"
+SKILL_DIRECTORY = SOURCE_ROOT / "skills"
+TOOL_SCHEMA_PATH = metagpt_yusin_ROOT / "metagpt_yusin/tools/schemas"
+TOOL_LIBS_PATH = metagpt_yusin_ROOT / "metagpt_yusin/tools/libs"
+
+# REAL CONSTS
+
+MEM_TTL = 24 * 30 * 3600
+
+MESSAGE_ROUTE_FROM = "sent_from"
+MESSAGE_ROUTE_TO = "send_to"
+MESSAGE_ROUTE_CAUSE_BY = "cause_by"
+MESSAGE_META_ROLE = "role"
+MESSAGE_ROUTE_TO_ALL = "<all>"
+MESSAGE_ROUTE_TO_NONE = "<none>"
+
+REQUIREMENT_FILENAME = "requirement.txt"
+BUGFIX_FILENAME = "bugfix.txt"
+PACKAGE_REQUIREMENTS_FILENAME = "requirements.txt"
+
+DOCS_FILE_REPO = "docs"
+PRDS_FILE_REPO = "docs/prd"
+SYSTEM_DESIGN_FILE_REPO = "docs/system_design"
+TASK_FILE_REPO = "docs/task"
+CODE_PLAN_AND_CHANGE_FILE_REPO = "docs/code_plan_and_change"
+COMPETITIVE_ANALYSIS_FILE_REPO = "resources/competitive_analysis"
+DATA_API_DESIGN_FILE_REPO = "resources/data_api_design"
+SEQ_FLOW_FILE_REPO = "resources/seq_flow"
+SYSTEM_DESIGN_PDF_FILE_REPO = "resources/system_design"
+PRD_PDF_FILE_REPO = "resources/prd"
+TASK_PDF_FILE_REPO = "resources/api_spec_and_task"
+CODE_PLAN_AND_CHANGE_PDF_FILE_REPO = "resources/code_plan_and_change"
+TEST_CODES_FILE_REPO = "tests"
+TEST_OUTPUTS_FILE_REPO = "test_outputs"
+CODE_SUMMARIES_FILE_REPO = "docs/code_summary"
+CODE_SUMMARIES_PDF_FILE_REPO = "resources/code_summary"
+RESOURCES_FILE_REPO = "resources"
+SD_OUTPUT_FILE_REPO = "resources/sd_output"
+GRAPH_REPO_FILE_REPO = "docs/graph_repo"
+VISUAL_GRAPH_REPO_FILE_REPO = "resources/graph_db"
+CLASS_VIEW_FILE_REPO = "docs/class_view"
+
+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"
+
+# Message id
+IGNORED_MESSAGE_ID = "0"
+
+# Class Relationship
+GENERALIZATION = "Generalize"
+COMPOSITION = "Composite"
+AGGREGATION = "Aggregate"
+
+# Timeout
+USE_CONFIG_TIMEOUT = 0  # Using llm.timeout configuration.
+LLM_API_TIMEOUT = 300

notebook_dir/metagpt_yusin/.ipynb_checkpoints/context-checkpoint.py

@@ -0,0 +1,139 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+@Time    : 2024/1/4 16:32
+@Author  : alexanderwu
+@File    : context.py
+"""
+import os
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+from pydantic import BaseModel, ConfigDict
+
+from metagpt_yusin.config2 import Config
+from metagpt_yusin.configs.llm_config import LLMConfig, LLMType
+from metagpt_yusin.provider.base_llm import BaseLLM
+from metagpt_yusin.provider.llm_provider_registry import create_llm_instance
+from metagpt_yusin.utils.cost_manager import (
+    CostManager,
+    FireworksCostManager,
+    TokenCostManager,
+)
+from metagpt_yusin.utils.git_repository import GitRepository
+from metagpt_yusin.utils.project_repo import ProjectRepo
+
+
+class AttrDict(BaseModel):
+    """A dict-like object that allows access to keys as attributes, compatible with Pydantic."""
+
+    model_config = ConfigDict(extra="allow")
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.__dict__.update(kwargs)
+
+    def __getattr__(self, key):
+        return self.__dict__.get(key, None)
+
+    def __setattr__(self, key, value):
+        self.__dict__[key] = value
+
+    def __delattr__(self, key):
+        if key in self.__dict__:
+            del self.__dict__[key]
+        else:
+            raise AttributeError(f"No such attribute: {key}")
+
+    def set(self, key, val: Any):
+        self.__dict__[key] = val
+
+    def get(self, key, default: Any = None):
+        return self.__dict__.get(key, default)
+
+    def remove(self, key):
+        if key in self.__dict__:
+            self.__delattr__(key)
+
+
+class Context(BaseModel):
+    """Env context for metagpt_yusin"""
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    kwargs: AttrDict = AttrDict()
+    config: Config = Config.default()
+
+    repo: Optional[ProjectRepo] = None
+    git_repo: Optional[GitRepository] = None
+    src_workspace: Optional[Path] = None
+    cost_manager: CostManager = CostManager()
+
+    _llm: Optional[BaseLLM] = None
+
+    def new_environ(self):
+        """Return a new os.environ object"""
+        env = os.environ.copy()
+        # i = self.options
+        # env.update({k: v for k, v in i.items() if isinstance(v, str)})
+        return env
+
+    def _select_costmanager(self, llm_config: LLMConfig) -> CostManager:
+        """Return a CostManager instance"""
+        if llm_config.api_type == LLMType.FIREWORKS:
+            return FireworksCostManager()
+        elif llm_config.api_type == LLMType.OPEN_LLM:
+            return TokenCostManager()
+        else:
+            return self.cost_manager
+
+    def llm(self) -> BaseLLM:
+        """Return a LLM instance, fixme: support cache"""
+        # if self._llm is None:
+        self._llm = create_llm_instance(self.config.llm)
+        if self._llm.cost_manager is None:
+            self._llm.cost_manager = self._select_costmanager(self.config.llm)
+        return self._llm
+
+    def llm_with_cost_manager_from_llm_config(self, llm_config: LLMConfig) -> BaseLLM:
+        """Return a LLM instance, fixme: support cache"""
+        # if self._llm is None:
+        llm = create_llm_instance(llm_config)
+        if llm.cost_manager is None:
+            llm.cost_manager = self._select_costmanager(llm_config)
+        return llm
+
+    def serialize(self) -> Dict[str, Any]:
+        """Serialize the object's attributes into a dictionary.
+
+        Returns:
+            Dict[str, Any]: A dictionary containing serialized data.
+        """
+        return {
+            "workdir": str(self.repo.workdir) if self.repo else "",
+            "kwargs": {k: v for k, v in self.kwargs.__dict__.items()},
+            "cost_manager": self.cost_manager.model_dump_json(),
+        }
+
+    def deserialize(self, serialized_data: Dict[str, Any]):
+        """Deserialize the given serialized data and update the object's attributes accordingly.
+
+        Args:
+            serialized_data (Dict[str, Any]): A dictionary containing serialized data.
+        """
+        if not serialized_data:
+            return
+        workdir = serialized_data.get("workdir")
+        if workdir:
+            self.git_repo = GitRepository(local_path=workdir, auto_init=True)
+            self.repo = ProjectRepo(self.git_repo)
+            src_workspace = self.git_repo.workdir / self.git_repo.workdir.name
+            if src_workspace.exists():
+                self.src_workspace = src_workspace
+        kwargs = serialized_data.get("kwargs")
+        if kwargs:
+            for k, v in kwargs.items():
+                self.kwargs.set(k, v)
+        cost_manager = serialized_data.get("cost_manager")
+        if cost_manager:
+            self.cost_manager.model_validate_json(cost_manager)

notebook_dir/metagpt_yusin/.ipynb_checkpoints/context_mixin-checkpoint.py

@@ -0,0 +1,101 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+@Time    : 2024/1/11 17:25
+@Author  : alexanderwu
+@File    : context_mixin.py
+"""
+from typing import Optional
+
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+
+from metagpt_yusin.config2 import Config
+from metagpt_yusin.context import Context
+from metagpt_yusin.provider.base_llm import BaseLLM
+
+
+class ContextMixin(BaseModel):
+    """Mixin class for context and config"""
+
+    model_config = ConfigDict(arbitrary_types_allowed=True, extra="allow")
+
+    # Pydantic has bug on _private_attr when using inheritance, so we use private_* instead
+    # - https://github.com/pydantic/pydantic/issues/7142
+    # - https://github.com/pydantic/pydantic/issues/7083
+    # - https://github.com/pydantic/pydantic/issues/7091
+
+    # Env/Role/Action will use this context as private context, or use self.context as public context
+    private_context: Optional[Context] = Field(default=None, exclude=True)
+    # Env/Role/Action will use this config as private config, or use self.context.config as public config
+    private_config: Optional[Config] = Field(default=None, exclude=True)
+
+    # Env/Role/Action will use this llm as private llm, or use self.context._llm instance
+    private_llm: Optional[BaseLLM] = Field(default=None, exclude=True)
+
+    @model_validator(mode="after")
+    def validate_context_mixin_extra(self):
+        self._process_context_mixin_extra()
+        return self
+
+    def _process_context_mixin_extra(self):
+        """Process the extra field"""
+        kwargs = self.model_extra or {}
+        self.set_context(kwargs.pop("context", None))
+        self.set_config(kwargs.pop("config", None))
+        self.set_llm(kwargs.pop("llm", None))
+
+    def set(self, k, v, override=False):
+        """Set attribute"""
+        if override or not self.__dict__.get(k):
+            self.__dict__[k] = v
+
+    def set_context(self, context: Context, override=True):
+        """Set context"""
+        self.set("private_context", context, override)
+
+    def set_config(self, config: Config, override=False):
+        """Set config"""
+        self.set("private_config", config, override)
+        if config is not None:
+            _ = self.llm  # init llm
+
+    def set_llm(self, llm: BaseLLM, override=False):
+        """Set llm"""
+        self.set("private_llm", llm, override)
+
+    @property
+    def config(self) -> Config:
+        """Role config: role config > context config"""
+        if self.private_config:
+            return self.private_config
+        return self.context.config
+
+    @config.setter
+    def config(self, config: Config) -> None:
+        """Set config"""
+        self.set_config(config)
+
+    @property
+    def context(self) -> Context:
+        """Role context: role context > context"""
+        if self.private_context:
+            return self.private_context
+        return Context()
+
+    @context.setter
+    def context(self, context: Context) -> None:
+        """Set context"""
+        self.set_context(context)
+
+    @property
+    def llm(self) -> BaseLLM:
+        """Role llm: if not existed, init from role.config"""
+        # print(f"class:{self.__class__.__name__}({self.name}), llm: {self._llm}, llm_config: {self._llm_config}")
+        if not self.private_llm:
+            self.private_llm = self.context.llm_with_cost_manager_from_llm_config(self.config.llm)
+        return self.private_llm
+
+    @llm.setter
+    def llm(self, llm: BaseLLM) -> None:
+        """Set llm"""
+        self.private_llm = llm

notebook_dir/metagpt_yusin/.ipynb_checkpoints/geoagent-checkpoint.py

@@ -0,0 +1,76 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+@Time    : 2024/1/4 01:25
+@Author  : yusin
+@File    : geoagent.py
+"""
+
+import leafmap
+from ipywidgets import DatePicker, Text, Button, Textarea, Tab, Box, VBox, HBox, Layout, Label, Password, Dropdown, FloatText
+from IPython.display import display
+
+from metagpt_yusin.tasks import RunLLM
+from metagpt_yusin.set_envs import SetLlmEnv
+
+class GeoAgent(SetLlmEnv, RunLLM):
+
+    def default(self):
+        # 数据集输入面板
+        data_set = VBox([GeoAgent.data_source,
+            HBox([GeoAgent.gee_key,GeoAgent.button_set2])
+        ])
+        
+        # LLM设置面板
+        llm_set = VBox([
+            HBox([GeoAgent.api_type, GeoAgent.model]), 
+            HBox([GeoAgent.api_key, GeoAgent.button_set1])
+        ])
+
+        #设置时间以及空间
+        st_set =  VBox([
+            HBox([GeoAgent.start_date, GeoAgent.end_date]),  # 时间选择框在一行
+            HBox([GeoAgent.get_bounds_button, GeoAgent.bounds_label])  # 获取边界按钮和标签在一行
+        ])
+
+        # Tab布局
+        tab_nest = Tab()
+        tab_nest.children = [data_set, llm_set, st_set]
+        tab_nest.titles = ('Data Sources', 'LLM Models', 'Space & Time')
+
+
+        # 左侧的控件布局
+        left_panel = VBox([
+            Label(value="Select data sources and LLM models (or Submit default) and Space Time:"),
+            tab_nest,
+            Label(value="Start with your task which can be refined and built upon previous tasks:"),
+            VBox([GeoAgent.notice_text, GeoAgent.box_llm])
+        ])
+
+        # 右侧的地图布局
+        right_panel = VBox([self.m])
+
+        # 使用 HBox 来调整左侧面板和右侧地图的宽度比例
+        layout_all = HBox([
+            left_panel,
+            right_panel
+        ], layout=Layout(
+            width='100%',  # 整个 HBox 占满屏幕宽度
+            height='330px',  # 设置高度为 900px 或其他你想要的值
+            justify_content='space-between'
+        ))
+
+        # 设置左侧面板宽度为 50%，右侧面板宽度为 50%
+        left_panel.layout = Layout(width='50%', height='100%')  # 高度与父容器相同
+        right_panel.layout = Layout(width='50%', height='100%')  # 高度与父容器相同
+
+        # 显示最终布局
+        display(layout_all)
+
+        # 设置按钮事件
+        GeoAgent.button_set1.on_click(self.set_env)
+        GeoAgent.button_set2.on_click(self.set_env2)
+        GeoAgent.button_submit.on_click(self._check_id, self.clean)
+        GeoAgent.button_cl.on_click(self.clean)
+        GeoAgent.button_abort.on_click(self.abort)
+        GeoAgent.get_bounds_button.on_click(self.get_bounds)

notebook_dir/metagpt_yusin/.ipynb_checkpoints/llm-checkpoint.py

@@ -0,0 +1,20 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+@Time    : 2023/5/11 14:45
+@Author  : alexanderwu
+@File    : llm.py
+"""
+from typing import Optional
+
+from metagpt_yusin.configs.llm_config import LLMConfig
+from metagpt_yusin.context import Context
+from metagpt_yusin.provider.base_llm import BaseLLM
+
+
+def LLM(llm_config: Optional[LLMConfig] = None, context: Context = None) -> BaseLLM:
+    """get the default llm provider if name is None"""
+    ctx = context or Context()
+    if llm_config is not None:
+        return ctx.llm_with_cost_manager_from_llm_config(llm_config)
+    return ctx.llm()

notebook_dir/metagpt_yusin/.ipynb_checkpoints/logs-checkpoint.py

@@ -0,0 +1,48 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+@Time    : 2023/6/1 12:41
+@Author  : alexanderwu
+@File    : logs.py
+"""
+
+import sys
+from datetime import datetime
+
+from loguru import logger as _logger
+
+from metagpt_yusin.const import metagpt_yusin_ROOT
+
+_print_level = "INFO"
+
+
+def define_log_level(print_level="INFO", logfile_level="DEBUG", name: str = None):
+    """Adjust the log level to above level"""
+    global _print_level
+    _print_level = print_level
+
+    current_date = datetime.now()
+    formatted_date = current_date.strftime("%Y%m%d")
+    log_name = f"{name}_{formatted_date}" if name else formatted_date  # name a log with prefix name
+
+    _logger.remove()
+    _logger.add(sys.stderr, level=print_level)
+    _logger.add(metagpt_yusin_ROOT / f"logs/{log_name}.txt", level=logfile_level)
+    return _logger
+
+
+logger = define_log_level()
+
+
+def log_llm_stream(msg):
+    _llm_stream_log(msg)
+
+
+def set_llm_stream_logfunc(func):
+    global _llm_stream_log
+    _llm_stream_log = func
+
+
+def _llm_stream_log(msg):
+    if _print_level in ["INFO"]:
+        print(msg, end="")

notebook_dir/metagpt_yusin/.ipynb_checkpoints/schema-checkpoint.py

@@ -0,0 +1,787 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+@Time    : 2023/5/8 22:12
+@Author  : alexanderwu
+@File    : schema.py
+@Modified By: mashenquan, 2023-10-31. According to Chapter 2.2.1 of RFC 116:
+        Replanned the distribution of responsibilities and functional positioning of `Message` class attributes.
+@Modified By: mashenquan, 2023/11/22.
+        1. Add `Document` and `Documents` for `FileRepository` in Section 2.2.3.4 of RFC 135.
+        2. Encapsulate the common key-values set to pydantic structures to standardize and unify parameter passing
+        between actions.
+        3. Add `id` to `Message` according to Section 2.2.3.1.1 of RFC 135.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import os.path
+import uuid
+from abc import ABC
+from asyncio import Queue, QueueEmpty, wait_for
+from json import JSONDecodeError
+from pathlib import Path
+from typing import Any, Dict, Iterable, List, Optional, Type, TypeVar, Union
+
+from pydantic import (
+    BaseModel,
+    ConfigDict,
+    Field,
+    PrivateAttr,
+    field_serializer,
+    field_validator,
+    model_serializer,
+    model_validator,
+)
+
+from metagpt_yusin.const import (
+    MESSAGE_ROUTE_CAUSE_BY,
+    MESSAGE_ROUTE_FROM,
+    MESSAGE_ROUTE_TO,
+    MESSAGE_ROUTE_TO_ALL,
+    PRDS_FILE_REPO,
+    SYSTEM_DESIGN_FILE_REPO,
+    TASK_FILE_REPO,
+)
+from metagpt_yusin.logs import logger
+from metagpt_yusin.repo_parser import DotClassInfo
+from metagpt_yusin.utils.common import any_to_str, any_to_str_set, import_class
+from metagpt_yusin.utils.exceptions import handle_exception
+from metagpt_yusin.utils.serialize import (
+    actionoutout_schema_to_mapping,
+    actionoutput_mapping_to_str,
+    actionoutput_str_to_mapping,
+)
+
+
+class SerializationMixin(BaseModel, extra="forbid"):
+    """
+    PolyMorphic subclasses Serialization / Deserialization Mixin
+    - First of all, we need to know that pydantic is not designed for polymorphism.
+    - If Engineer is subclass of Role, it would be serialized as Role. If we want to serialize it as Engineer, we need
+        to add `class name` to Engineer. So we need Engineer inherit SerializationMixin.
+
+    More details:
+    - https://docs.pydantic.dev/latest/concepts/serialization/
+    - https://github.com/pydantic/pydantic/discussions/7008 discuss about avoid `__get_pydantic_core_schema__`
+    """
+
+    __is_polymorphic_base = False
+    __subclasses_map__ = {}
+
+    @model_serializer(mode="wrap")
+    def __serialize_with_class_type__(self, default_serializer) -> Any:
+        # default serializer, then append the `__module_class_name` field and return
+        ret = default_serializer(self)
+        ret["__module_class_name"] = f"{self.__class__.__module__}.{self.__class__.__qualname__}"
+        return ret
+
+    @model_validator(mode="wrap")
+    @classmethod
+    def __convert_to_real_type__(cls, value: Any, handler):
+        if isinstance(value, dict) is False:
+            return handler(value)
+
+        # it is a dict so make sure to remove the __module_class_name
+        # because we don't allow extra keywords but want to ensure
+        # e.g Cat.model_validate(cat.model_dump()) works
+        class_full_name = value.pop("__module_class_name", None)
+
+        # if it's not the polymorphic base we construct via default handler
+        if not cls.__is_polymorphic_base:
+            if class_full_name is None:
+                return handler(value)
+            elif str(cls) == f"<class '{class_full_name}'>":
+                return handler(value)
+            else:
+                # f"Trying to instantiate {class_full_name} but this is not the polymorphic base class")
+                pass
+
+        # otherwise we lookup the correct polymorphic type and construct that
+        # instead
+        if class_full_name is None:
+            raise ValueError("Missing __module_class_name field")
+
+        class_type = cls.__subclasses_map__.get(class_full_name, None)
+
+        if class_type is None:
+            # TODO could try dynamic import
+            raise TypeError("Trying to instantiate {class_full_name}, which has not yet been defined!")
+
+        return class_type(**value)
+
+    def __init_subclass__(cls, is_polymorphic_base: bool = False, **kwargs):
+        cls.__is_polymorphic_base = is_polymorphic_base
+        cls.__subclasses_map__[f"{cls.__module__}.{cls.__qualname__}"] = cls
+        super().__init_subclass__(**kwargs)
+
+
+class SimpleMessage(BaseModel):
+    content: str
+    role: str
+
+
+class Document(BaseModel):
+    """
+    Represents a document.
+    """
+
+    root_path: str = ""
+    filename: str = ""
+    content: str = ""
+
+    def get_meta(self) -> Document:
+        """Get metadata of the document.
+
+        :return: A new Document instance with the same root path and filename.
+        """
+
+        return Document(root_path=self.root_path, filename=self.filename)
+
+    @property
+    def root_relative_path(self):
+        """Get relative path from root of git repository.
+
+        :return: relative path from root of git repository.
+        """
+        return os.path.join(self.root_path, self.filename)
+
+    def __str__(self):
+        return self.content
+
+    def __repr__(self):
+        return self.content
+
+
+class Documents(BaseModel):
+    """A class representing a collection of documents.
+
+    Attributes:
+        docs (Dict[str, Document]): A dictionary mapping document names to Document instances.
+    """
+
+    docs: Dict[str, Document] = Field(default_factory=dict)
+
+    @classmethod
+    def from_iterable(cls, documents: Iterable[Document]) -> Documents:
+        """Create a Documents instance from a list of Document instances.
+
+        :param documents: A list of Document instances.
+        :return: A Documents instance.
+        """
+
+        docs = {doc.filename: doc for doc in documents}
+        return Documents(docs=docs)
+
+    def to_action_output(self) -> "ActionOutput":
+        """Convert to action output string.
+
+        :return: A string representing action output.
+        """
+        from metagpt_yusin.actions.action_output import ActionOutput
+
+        return ActionOutput(content=self.model_dump_json(), instruct_content=self)
+
+
+class Message(BaseModel):
+    """list[<role>: <content>]"""
+
+    id: str = Field(default="", validate_default=True)  # According to Section 2.2.3.1.1 of RFC 135
+    content: str
+    instruct_content: Optional[BaseModel] = Field(default=None, validate_default=True)
+    role: str = "user"  # system / user / assistant
+    cause_by: str = Field(default="", validate_default=True)
+    sent_from: str = Field(default="", validate_default=True)
+    send_to: set[str] = Field(default={MESSAGE_ROUTE_TO_ALL}, validate_default=True)
+
+    @field_validator("id", mode="before")
+    @classmethod
+    def check_id(cls, id: str) -> str:
+        return id if id else uuid.uuid4().hex
+
+    @field_validator("instruct_content", mode="before")
+    @classmethod
+    def check_instruct_content(cls, ic: Any) -> BaseModel:
+        if ic and isinstance(ic, dict) and "class" in ic:
+            if "mapping" in ic:
+                # compatible with custom-defined ActionOutput
+                mapping = actionoutput_str_to_mapping(ic["mapping"])
+                actionnode_class = import_class("ActionNode", "metagpt_yusin.actions.action_node")  # avoid circular import
+                ic_obj = actionnode_class.create_model_class(class_name=ic["class"], mapping=mapping)
+            elif "module" in ic:
+                # subclasses of BaseModel
+                ic_obj = import_class(ic["class"], ic["module"])
+            else:
+                raise KeyError("missing required key to init Message.instruct_content from dict")
+            ic = ic_obj(**ic["value"])
+        return ic
+
+    @field_validator("cause_by", mode="before")
+    @classmethod
+    def check_cause_by(cls, cause_by: Any) -> str:
+        return any_to_str(cause_by if cause_by else import_class("UserRequirement", "metagpt_yusin.actions.add_requirement"))
+
+    @field_validator("sent_from", mode="before")
+    @classmethod
+    def check_sent_from(cls, sent_from: Any) -> str:
+        return any_to_str(sent_from if sent_from else "")
+
+    @field_validator("send_to", mode="before")
+    @classmethod
+    def check_send_to(cls, send_to: Any) -> set:
+        return any_to_str_set(send_to if send_to else {MESSAGE_ROUTE_TO_ALL})
+
+    @field_serializer("send_to", mode="plain")
+    def ser_send_to(self, send_to: set) -> list:
+        return list(send_to)
+
+    @field_serializer("instruct_content", mode="plain")
+    def ser_instruct_content(self, ic: BaseModel) -> Union[dict, None]:
+        ic_dict = None
+        if ic:
+            # compatible with custom-defined ActionOutput
+            schema = ic.model_json_schema()
+            ic_type = str(type(ic))
+            if "<class 'metagpt_yusin.actions.action_node" in ic_type:
+                # instruct_content from AutoNode.create_model_class, for now, it's single level structure.
+                mapping = actionoutout_schema_to_mapping(schema)
+                mapping = actionoutput_mapping_to_str(mapping)
+
+                ic_dict = {"class": schema["title"], "mapping": mapping, "value": ic.model_dump()}
+            else:
+                # due to instruct_content can be assigned by subclasses of BaseModel
+                ic_dict = {"class": schema["title"], "module": ic.__module__, "value": ic.model_dump()}
+        return ic_dict
+
+    def __init__(self, content: str = "", **data: Any):
+        data["content"] = data.get("content", content)
+        super().__init__(**data)
+
+    def __setattr__(self, key, val):
+        """Override `@property.setter`, convert non-string parameters into string parameters."""
+        if key == MESSAGE_ROUTE_CAUSE_BY:
+            new_val = any_to_str(val)
+        elif key == MESSAGE_ROUTE_FROM:
+            new_val = any_to_str(val)
+        elif key == MESSAGE_ROUTE_TO:
+            new_val = any_to_str_set(val)
+        else:
+            new_val = val
+        super().__setattr__(key, new_val)
+
+    def __str__(self):
+        # prefix = '-'.join([self.role, str(self.cause_by)])
+        if self.instruct_content:
+            return f"{self.role}: {self.instruct_content.model_dump()}"
+        return f"{self.role}: {self.content}"
+
+    def __repr__(self):
+        return self.__str__()
+
+    def rag_key(self) -> str:
+        """For search"""
+        return self.content
+
+    def to_dict(self) -> dict:
+        """Return a dict containing `role` and `content` for the LLM call.l"""
+        return {"role": self.role, "content": self.content}
+
+    def dump(self) -> str:
+        """Convert the object to json string"""
+        return self.model_dump_json(exclude_none=True, warnings=False)
+
+    @staticmethod
+    @handle_exception(exception_type=JSONDecodeError, default_return=None)
+    def load(val):
+        """Convert the json string to object."""
+
+        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):
+    """便于支持OpenAI的消息
+    Facilitate support for OpenAI messages
+    """
+
+    def __init__(self, content: str):
+        super().__init__(content=content, role="user")
+
+
+class SystemMessage(Message):
+    """便于支持OpenAI的消息
+    Facilitate support for OpenAI messages
+    """
+
+    def __init__(self, content: str):
+        super().__init__(content=content, role="system")
+
+
+class AIMessage(Message):
+    """便于支持OpenAI的消息
+    Facilitate support for OpenAI messages
+    """
+
+    def __init__(self, content: str):
+        super().__init__(content=content, role="assistant")
+
+
+class Task(BaseModel):
+    task_id: str = ""
+    dependent_task_ids: list[str] = []  # Tasks prerequisite to this Task
+    instruction: str = ""
+    task_type: str = ""
+    code: str = ""
+    result: str = ""
+    is_success: bool = False
+    is_finished: bool = False
+
+    def reset(self):
+        self.code = ""
+        self.result = ""
+        self.is_success = False
+        self.is_finished = False
+
+    def update_task_result(self, task_result: TaskResult):
+        self.code = task_result.code
+        self.result = task_result.result
+        self.is_success = task_result.is_success
+
+
+class TaskResult(BaseModel):
+    """Result of taking a task, with result and is_success required to be filled"""
+
+    code: str = ""
+    result: str
+    is_success: bool
+
+
+class Plan(BaseModel):
+    goal: str
+    context: str = ""
+    tasks: list[Task] = []
+    task_map: dict[str, Task] = {}
+    current_task_id: str = ""
+
+    def _topological_sort(self, tasks: list[Task]):
+        task_map = {task.task_id: task for task in tasks}
+        dependencies = {task.task_id: set(task.dependent_task_ids) for task in tasks}
+        sorted_tasks = []
+        visited = set()
+
+        def visit(task_id):
+            if task_id in visited:
+                return
+            visited.add(task_id)
+            for dependent_id in dependencies.get(task_id, []):
+                visit(dependent_id)
+            sorted_tasks.append(task_map[task_id])
+
+        for task in tasks:
+            visit(task.task_id)
+
+        return sorted_tasks
+
+    def add_tasks(self, tasks: list[Task]):
+        """
+        Integrates new tasks into the existing plan, ensuring dependency order is maintained.
+
+        This method performs two primary functions based on the current state of the task list:
+        1. If there are no existing tasks, it topologically sorts the provided tasks to ensure
+        correct execution order based on dependencies, and sets these as the current tasks.
+        2. If there are existing tasks, it merges the new tasks with the existing ones. It maintains
+        any common prefix of tasks (based on task_id and instruction) and appends the remainder
+        of the new tasks. The current task is updated to the first unfinished task in this merged list.
+
+        Args:
+            tasks (list[Task]): A list of tasks (may be unordered) to add to the plan.
+
+        Returns:
+            None: The method updates the internal state of the plan but does not return anything.
+        """
+        if not tasks:
+            return
+
+        # Topologically sort the new tasks to ensure correct dependency order
+        new_tasks = self._topological_sort(tasks)
+
+        if not self.tasks:
+            # If there are no existing tasks, set the new tasks as the current tasks
+            self.tasks = new_tasks
+
+        else:
+            # Find the length of the common prefix between existing and new tasks
+            prefix_length = 0
+            for old_task, new_task in zip(self.tasks, new_tasks):
+                if old_task.task_id != new_task.task_id or old_task.instruction != new_task.instruction:
+                    break
+                prefix_length += 1
+
+            # Combine the common prefix with the remainder of the new tasks
+            final_tasks = self.tasks[:prefix_length] + new_tasks[prefix_length:]
+            self.tasks = final_tasks
+
+        # Update current_task_id to the first unfinished task in the merged list
+        self._update_current_task()
+
+        # Update the task map for quick access to tasks by ID
+        self.task_map = {task.task_id: task for task in self.tasks}
+
+    def reset_task(self, task_id: str):
+        """
+        Clear code and result of the task based on task_id, and set the task as unfinished.
+
+        Args:
+            task_id (str): The ID of the task to be reset.
+
+        Returns:
+            None
+        """
+        if task_id in self.task_map:
+            task = self.task_map[task_id]
+            task.reset()
+
+    def replace_task(self, new_task: Task):
+        """
+        Replace an existing task with the new input task based on task_id, and reset all tasks depending on it.
+
+        Args:
+            new_task (Task): The new task that will replace an existing one.
+
+        Returns:
+            None
+        """
+        assert new_task.task_id in self.task_map
+        # Replace the task in the task map and the task list
+        self.task_map[new_task.task_id] = new_task
+        for i, task in enumerate(self.tasks):
+            if task.task_id == new_task.task_id:
+                self.tasks[i] = new_task
+                break
+
+        # Reset dependent tasks
+        for task in self.tasks:
+            if new_task.task_id in task.dependent_task_ids:
+                self.reset_task(task.task_id)
+
+    def append_task(self, new_task: Task):
+        """
+        Append a new task to the end of existing task sequences
+
+        Args:
+            new_task (Task): The new task to be appended to the existing task sequence
+
+        Returns:
+            None
+        """
+        assert not self.has_task_id(new_task.task_id), "Task already in current plan, use replace_task instead"
+
+        assert all(
+            [self.has_task_id(dep_id) for dep_id in new_task.dependent_task_ids]
+        ), "New task has unknown dependencies"
+
+        # Existing tasks do not depend on the new task, it's fine to put it to the end of the sorted task sequence
+        self.tasks.append(new_task)
+        self.task_map[new_task.task_id] = new_task
+        self._update_current_task()
+
+    def has_task_id(self, task_id: str) -> bool:
+        return task_id in self.task_map
+
+    def _update_current_task(self):
+        current_task_id = ""
+        for task in self.tasks:
+            if not task.is_finished:
+                current_task_id = task.task_id
+                break
+        self.current_task_id = current_task_id  # all tasks finished
+
+    @property
+    def current_task(self) -> Task:
+        """Find current task to execute
+
+        Returns:
+            Task: the current task to be executed
+        """
+        return self.task_map.get(self.current_task_id, None)
+
+    def finish_current_task(self):
+        """Finish current task, set Task.is_finished=True, set current task to next task"""
+        if self.current_task_id:
+            self.current_task.is_finished = True
+            self._update_current_task()  # set to next task
+
+    def get_finished_tasks(self) -> list[Task]:
+        """return all finished tasks in correct linearized order
+
+        Returns:
+            list[Task]: list of finished tasks
+        """
+        return [task for task in self.tasks if task.is_finished]
+
+
+class MessageQueue(BaseModel):
+    """Message queue which supports asynchronous updates."""
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    _queue: Queue = PrivateAttr(default_factory=Queue)
+
+    def pop(self) -> Message | None:
+        """Pop one message from the queue."""
+        try:
+            item = self._queue.get_nowait()
+            if item:
+                self._queue.task_done()
+            return item
+        except QueueEmpty:
+            return None
+
+    def pop_all(self) -> List[Message]:
+        """Pop all messages from the queue."""
+        ret = []
+        while True:
+            msg = self.pop()
+            if not msg:
+                break
+            ret.append(msg)
+        return ret
+
+    def push(self, msg: Message):
+        """Push a message into the queue."""
+        self._queue.put_nowait(msg)
+
+    def empty(self):
+        """Return true if the queue is empty."""
+        return self._queue.empty()
+
+    async def dump(self) -> str:
+        """Convert the `MessageQueue` object to a json string."""
+        if self.empty():
+            return "[]"
+
+        lst = []
+        msgs = []
+        try:
+            while True:
+                item = await wait_for(self._queue.get(), timeout=1.0)
+                if item is None:
+                    break
+                msgs.append(item)
+                lst.append(item.dump())
+                self._queue.task_done()
+        except asyncio.TimeoutError:
+            logger.debug("Queue is empty, exiting...")
+        finally:
+            for m in msgs:
+                self._queue.put_nowait(m)
+        return json.dumps(lst, ensure_ascii=False)
+
+    @staticmethod
+    def load(data) -> "MessageQueue":
+        """Convert the json string to the `MessageQueue` object."""
+        queue = MessageQueue()
+        try:
+            lst = json.loads(data)
+            for i in lst:
+                msg = Message.load(i)
+                queue.push(msg)
+        except JSONDecodeError as e:
+            logger.warning(f"JSON load failed: {data}, error:{e}")
+
+        return queue
+
+
+# 定义一个泛型类型变量
+T = TypeVar("T", bound="BaseModel")
+
+
+class BaseContext(BaseModel, ABC):
+    @classmethod
+    @handle_exception
+    def loads(cls: Type[T], val: str) -> Optional[T]:
+        i = json.loads(val)
+        return cls(**i)
+
+
+class CodingContext(BaseContext):
+    filename: str
+    design_doc: Optional[Document] = None
+    task_doc: Optional[Document] = None
+    code_doc: Optional[Document] = None
+    code_plan_and_change_doc: Optional[Document] = None
+
+
+class TestingContext(BaseContext):
+    filename: str
+    code_doc: Document
+    test_doc: Optional[Document] = None
+
+
+class RunCodeContext(BaseContext):
+    mode: str = "script"
+    code: Optional[str] = None
+    code_filename: str = ""
+    test_code: Optional[str] = None
+    test_filename: str = ""
+    command: List[str] = Field(default_factory=list)
+    working_directory: str = ""
+    additional_python_paths: List[str] = Field(default_factory=list)
+    output_filename: Optional[str] = None
+    output: Optional[str] = None
+
+
+class RunCodeResult(BaseContext):
+    summary: str
+    stdout: str
+    stderr: str
+
+
+class CodeSummarizeContext(BaseModel):
+    design_filename: str = ""
+    task_filename: str = ""
+    codes_filenames: List[str] = Field(default_factory=list)
+    reason: str = ""
+
+    @staticmethod
+    def loads(filenames: List) -> CodeSummarizeContext:
+        ctx = CodeSummarizeContext()
+        for filename in filenames:
+            if Path(filename).is_relative_to(SYSTEM_DESIGN_FILE_REPO):
+                ctx.design_filename = str(filename)
+                continue
+            if Path(filename).is_relative_to(TASK_FILE_REPO):
+                ctx.task_filename = str(filename)
+                continue
+        return ctx
+
+    def __hash__(self):
+        return hash((self.design_filename, self.task_filename))
+
+
+class BugFixContext(BaseContext):
+    filename: str = ""
+
+
+class CodePlanAndChangeContext(BaseModel):
+    requirement: str = ""
+    issue: str = ""
+    prd_filename: str = ""
+    design_filename: str = ""
+    task_filename: str = ""
+
+    @staticmethod
+    def loads(filenames: List, **kwargs) -> CodePlanAndChangeContext:
+        ctx = CodePlanAndChangeContext(requirement=kwargs.get("requirement", ""), issue=kwargs.get("issue", ""))
+        for filename in filenames:
+            filename = Path(filename)
+            if filename.is_relative_to(PRDS_FILE_REPO):
+                ctx.prd_filename = filename.name
+                continue
+            if filename.is_relative_to(SYSTEM_DESIGN_FILE_REPO):
+                ctx.design_filename = filename.name
+                continue
+            if filename.is_relative_to(TASK_FILE_REPO):
+                ctx.task_filename = filename.name
+                continue
+        return ctx
+
+
+# mermaid class view
+class UMLClassMeta(BaseModel):
+    name: str = ""
+    visibility: str = ""
+
+    @staticmethod
+    def name_to_visibility(name: str) -> str:
+        if name == "__init__":
+            return "+"
+        if name.startswith("__"):
+            return "-"
+        elif name.startswith("_"):
+            return "#"
+        return "+"
+
+
+class UMLClassAttribute(UMLClassMeta):
+    value_type: str = ""
+    default_value: str = ""
+
+    def get_mermaid(self, align=1) -> str:
+        content = "".join(["\t" for i in range(align)]) + self.visibility
+        if self.value_type:
+            content += self.value_type.replace(" ", "") + " "
+        name = self.name.split(":", 1)[1] if ":" in self.name else self.name
+        content += name
+        if self.default_value:
+            content += "="
+            if self.value_type not in ["str", "string", "String"]:
+                content += self.default_value
+            else:
+                content += '"' + self.default_value.replace('"', "") + '"'
+        # if self.abstraction:
+        #     content += "*"
+        # if self.static:
+        #     content += "$"
+        return content
+
+
+class UMLClassMethod(UMLClassMeta):
+    args: List[UMLClassAttribute] = Field(default_factory=list)
+    return_type: str = ""
+
+    def get_mermaid(self, align=1) -> str:
+        content = "".join(["\t" for i in range(align)]) + self.visibility
+        name = self.name.split(":", 1)[1] if ":" in self.name else self.name
+        content += name + "(" + ",".join([v.get_mermaid(align=0) for v in self.args]) + ")"
+        if self.return_type:
+            content += " " + self.return_type.replace(" ", "")
+        # if self.abstraction:
+        #     content += "*"
+        # if self.static:
+        #     content += "$"
+        return content
+
+
+class UMLClassView(UMLClassMeta):
+    attributes: List[UMLClassAttribute] = Field(default_factory=list)
+    methods: List[UMLClassMethod] = Field(default_factory=list)
+
+    def get_mermaid(self, align=1) -> str:
+        content = "".join(["\t" for i in range(align)]) + "class " + self.name + "{\n"
+        for v in self.attributes:
+            content += v.get_mermaid(align=align + 1) + "\n"
+        for v in self.methods:
+            content += v.get_mermaid(align=align + 1) + "\n"
+        content += "".join(["\t" for i in range(align)]) + "}\n"
+        return content
+
+    @classmethod
+    def load_dot_class_info(cls, dot_class_info: DotClassInfo) -> UMLClassView:
+        visibility = UMLClassView.name_to_visibility(dot_class_info.name)
+        class_view = cls(name=dot_class_info.name, visibility=visibility)
+        for i in dot_class_info.attributes.values():
+            visibility = UMLClassAttribute.name_to_visibility(i.name)
+            attr = UMLClassAttribute(name=i.name, visibility=visibility, value_type=i.type_, default_value=i.default_)
+            class_view.attributes.append(attr)
+        for i in dot_class_info.methods.values():
+            visibility = UMLClassMethod.name_to_visibility(i.name)
+            method = UMLClassMethod(name=i.name, visibility=visibility, return_type=i.return_args.type_)
+            for j in i.args:
+                arg = UMLClassAttribute(name=j.name, value_type=j.type_, default_value=j.default_)
+                method.args.append(arg)
+            method.return_type = i.return_args.type_
+            class_view.methods.append(method)
+        return class_view

notebook_dir/metagpt_yusin/.ipynb_checkpoints/set_envs-checkpoint.py

@@ -0,0 +1,87 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+@Time    : 2024/1/4 01:25
+@Author  : alexanderwu
+@File    : config2.py
+"""
+
+import os
+from metagpt_yusin.config2 import Config
+from ipywidgets import Tab, Label, Button, Textarea, VBox, HBox, Layout, Password, Dropdown
+from IPython.display import display
+from ipylab import JupyterFrontEnd
+app = JupyterFrontEnd()
+
+def restart():
+    # restart kernel
+    app.commands.execute('kernelmenu:restart-and-clear')
+
+class SetLlmEnv:
+
+    api_type = Dropdown(
+    options=['openai', 'gemini', 'llama3', 'groq', 'openrouter'],
+    value='openrouter', #'groq', #'openai',
+    description='API Type:',
+    disabled=False,
+    layout=Layout(width='500px', height='30px'))
+
+    model = Dropdown(
+    options=['gpt-3.5-turbo-1106','deepseek-r1-distill-llama-70b', 'tngtech/deepseek-r1t-chimera:free'],
+    value='tngtech/deepseek-r1t-chimera:free', #'deepseek-r1-distill-llama-70b', #'gpt-3.5-turbo-1106',
+    description='Model:',
+    disabled=False,
+    layout=Layout(width='500px', height='30px'))
+
+    api_key = Password(
+    value='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',#'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', #'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',
+    placeholder='Enter API Key',
+    description='API Key :',
+    disabled=False,
+    layout=Layout(width='800px', height='30px'))
+
+
+    gee_key = Password(
+    value='sk-.....................................................................',
+    placeholder='Provide your GEE key here',
+    description='Data    Key:',
+    disabled=False,
+    layout=Layout(width='800px', height='30px'))
+
+    pc_key = Password(
+    value='sk-',
+    placeholder='Provide your Planetary Computer key here',
+    description='PC Key :',
+    disabled=False,
+    layout=Layout(width='800px', height='30px'))
+
+    button_set1 = Button(description='Submit', layout=Layout(height='30px', width='200px'))
+    button_set2 = Button(description='Submit', layout=Layout(height='30px', width='200px'))
+
+
+    @staticmethod
+    def set_env(event):
+        os.environ['api_type'] = SetLlmEnv.api_type.value
+        os.environ['model'] = SetLlmEnv.model.value
+        os.environ['api_key'] = SetLlmEnv.api_key.value
+        app.commands.execute('notebook:move-cursor-down')
+
+    @staticmethod
+    def set_env2(event):
+        os.environ['EARTHENGINE_TOKEN'] = SetLlmEnv.gee_key.value
+        os.environ['PC_SDK_SUBSCRIPTION_KEY'] = SetLlmEnv.pc_key.value
+        #os.environ['MLHub API Key'] = SetLlmEnv.mkhub_key.value
+
+    @classmethod
+    def default(cls):
+        data_set = HBox([VBox([Label(value="Provide GEE key here:"), SetLlmEnv.gee_key]),
+                         VBox([Label(value="Provide Planetary Computer key here:"), SetLlmEnv.pc_key]),
+                         VBox([Label(value=" "), SetLlmEnv.button_set2])])
+        llm_set = VBox([HBox([SetLlmEnv.api_type, SetLlmEnv.model]), HBox([SetLlmEnv.api_key, SetLlmEnv.button_set1])])
+        tab_nest = Tab()
+        tab_nest.children = [data_set, llm_set]
+        tab_nest.titles = ('Data Sources', 'LLM Models')
+
+        display(VBox([Label(value="Specify your preferred:"), tab_nest]))
+        SetLlmEnv.button_set1.on_click(cls.set_env)
+        SetLlmEnv.button_set2.on_click(cls.set_env2)

notebook_dir/metagpt_yusin/.ipynb_checkpoints/tasks-checkpoint.py

@@ -0,0 +1,246 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+@Time    : 2024/1/4 01:25
+@Author  : alexanderwu
+@File    : config2.py
+"""
+import leafmap
+import asyncio
+import nest_asyncio
+import nbformat
+from nbclient import NotebookClient
+from ipylab import JupyterFrontEnd
+from metagpt_yusin.logs import log_llm_stream, logger
+from ipywidgets import DatePicker, Text, Button, Textarea, Tab, Box, VBox, HBox, Layout, Label, Password, Dropdown, FloatText
+from traitlets import observe, link, Unicode, Bool, Any
+from IPython.display import display
+nest_asyncio.apply()
+app = JupyterFrontEnd()
+
+
+class ConfirmationButton(VBox):
+    button_style = Any(default_value='')
+    description = Unicode()
+    disabled = Bool()
+    icon = Unicode()
+    layout = Any()
+    style = Any()
+    tooltip = Unicode()
+
+    def  __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self._button = Button(**kwargs)
+        self._confirm_btn = Button(description='confirm', icon='check', button_style='success', layout=dict(height='45%', width='90%'))
+        self._cancel_btn = Button(description='cancel', icon='times',  button_style='warning', layout=dict(height='45%', width='90%'), disabled=True)
+        self._button.on_click(self._on_btn_click)
+        self._cancel_btn.on_click(self._on_btn_click)
+        self._confirm_btn.on_click(self._on_btn_click)
+        self.children = [self._button]
+
+    def on_click(self, *args, **kwargs):
+        self._confirm_btn.on_click(args[0], **kwargs)
+        self._cancel_btn.on_click(args[1], **kwargs)
+
+    def _on_btn_click(self, b):
+        if b==self._button:
+            self.children = [self._confirm_btn, self._cancel_btn]
+        else:
+            self.children = [self._button]
+
+
+class RunLLM:
+    # context
+    context = None
+    # overall tasks
+    tasks = []
+    # widget
+    input_text = Textarea(
+    #description='Give your task description:',
+    placeholder='Give your task description, such as: run data analysis on sklearn Iris dataset, include a plot',
+    disabled=False,
+    layout=Layout(height='90px', width='400px')
+    )
+    #button_submit = Button(description='Submit', layout=Layout(height='100px', width='100px'))
+    button_submit = ConfirmationButton(description='Submit', layout=Layout(height='30px', width='80px'))
+    button_cl = Button(description='Clean', disabled=False, layout=Layout(height='30px', width='80px'))
+    button_abort = Button(description='Abort', disabled=True, layout=Layout(height='30px', width='80px'))
+    box_llm = HBox([
+            input_text, 
+            VBox([button_submit, button_cl, button_abort])
+        ])
+    #Box(layout=Layout(width='500px', height='150px'))
+    #box_llm.children += (input_text, VBox([button_submit, button_cl, button_abort], layout=Layout(height='110px', width='80px')))
+    # popup button
+    notice_text = Text(placeholder='Make sure whether you want to include the following cells as a context for your text, such as the refined task description and code of previous steps',
+    disabled=False,
+    layout=Layout(height='30px', width='500px'))
+    context = None
+
+    # 创建地图，设置中心和缩放级别
+    m = leafmap.Map(center=[37.6412, -122.1353], zoom=15, height="800px")
+    m.add_basemap("SATELLITE")
+
+    # 时间数据选择框
+    start_date = DatePicker(description='Start Date', layout=Layout(height='30px', width='50%'))
+    end_date = DatePicker(description='End Date', layout=Layout(height='30px', width='50%'))
+    data_source = Dropdown(
+    options=['Online Tile', 'GEE', 'NASA Earth Data', 'OSM', 'AWS', 'CDSE', 'MAXAR', 'Planetary Computer'],
+    value='Online Tile', #'groq', #'openai',
+    description='Data Source:',
+    disabled=False,
+    layout=Layout(height='30px', width='78%'))
+
+    # 用户区域选择事件
+    bounds_label = Label(value="", layout=Layout(height='30px', width='65%', border='1px solid gray', padding='5px',
+                                                display='flex', align_items='center', justify_content='center'))
+    get_bounds_button = Button(description="Get Selected Bounds", layout=Layout(height='30px', width='35%'))
+
+    @staticmethod
+    def get_bounds(event):
+        # 每次点击按钮时都重新获取地图选区
+        if RunLLM.m.user_roi is not None:
+            bbox = RunLLM.m.user_roi_bounds()  # 获取当前选择的区域的边界框
+            RunLLM.bounds_label.value = f"{bbox}"
+        else:
+            RunLLM.bounds_label.value = None
+
+    @staticmethod
+    def clean(event):
+        RunLLM.notice_text.value = 'excluding and cleaning the following cells.'
+        #print('clean cells!')
+        app.commands.execute('notebook:move-cursor-down')
+        app.commands.execute('notebook:insert-cell-above')
+        for i in range(100):
+            #if app.commands.execute('notebook:merge-cell-below'):
+            #    app.commands.execute('notebook:delete-cell')
+            app.commands.execute('notebook:merge-cell-below')
+            app.commands.execute('notebook:delete-cell')
+        # clean last cell
+        app.commands.execute('notebook:delete-cell')
+        # trun off clean after clean
+        RunLLM.button_cl.disabled = True
+        RunLLM.button_submit._cancel_btn.disabled = True
+
+    @staticmethod
+    def abort(event):
+        RunLLM.button_cl.disabled = False
+        RunLLM.button_submit._cancel_btn.disabled = False
+        #print('abort!')
+        for task in RunLLM.tasks:
+            task.cancel()
+        RunLLM.tasks.clear()
+        # after abort trun off it
+        RunLLM.button_abort.disabled = True
+
+    def _check_id(self, b):
+        RunLLM.notice_text.value = 'keep the following cells as the context of current step.'
+        RunLLM.button_abort.disabled = True 
+        '''
+        # get context -------------------------------
+        app.commands.execute('docmanager:save')
+        app.commands.execute('notebook:insert-cell-below')
+        app.commands.execute('notebook:replace-selection', {'text': "from ipylab import JupyterFrontEnd\napp = JupyterFrontEnd()\nnb_path = app.sessions.sessions[0]['path']"})
+        app.commands.execute('notebook:run-cell')
+        #app.commands.execute('notebook:delete-cell')
+        print(app)
+        # -------------------------------------------
+        '''
+        nb_path = app.sessions.sessions[0]['path']
+        # Load the notebook
+        with open(nb_path, 'r') as notebook_file:
+            notebook_content = notebook_file.read()
+        # Parse the notebook
+        notebook = nbformat.reads(notebook_content, as_version=4)
+        content = []
+        for i_cell in notebook['cells']:
+            #if i_cell['cell_type'] == 'code':
+            content.append(i_cell['source'])
+        #print(content)
+        # get the first place of the given strings
+        try:
+            index_code = content.index('# Here is the code part!')
+            code = content[index_code+1:]
+        except:
+            code = None   
+        try:
+            index_task = content.index('# Decomposing the overall task into tasks!')
+            task = content[index_task+1:index_code]
+        except:
+            task = None
+        # give context
+        if code is None or task is None:
+            index_context = content.index('from metagpt_yusin.geoagent import GeoAgent\nGeoAgent().default()')
+            RunLLM.context = '\nThis is the initial subtasks and codes:\n' + '\n'.join(content[index_context+1:]) + '\nNow please further improve these initial subtasks and codes.'
+        else:
+            RunLLM.context = '\nThis is the initial subtasks:\n' + '\n'.join(task) + '\nAnd the initial generated codes:\n' + '\n'.join(code) + '\nNow please further improve these initial subtasks and codes.'
+        #print(context)
+
+        # 检查时间范围
+        if not RunLLM.start_date.value or not RunLLM.end_date.value:
+            RunLLM.notice_text.value = "!!Please select a valid start and end date before submitting."
+            raise ValueError("Please select a valid start and end date before submitting.")
+        RunLLM.context += f"\nTime Range: {RunLLM.start_date.value} to {RunLLM.end_date.value}"
+
+        # 检查区域范围
+        if not RunLLM.bounds_label.value:
+            RunLLM.notice_text.value = "!!Please select a valid bounding box (area) before submitting."
+            raise ValueError("Please select a valid bounding box (area) before submitting.")
+        RunLLM.context += f"\nBounds: {RunLLM.bounds_label.value}"
+        
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        try:
+            loop.run_until_complete(self.start_job())
+            RunLLM.tasks.clear()
+        except KeyboardInterrupt:
+            print("User termination detected")
+        finally:
+            loop.close()
+
+    async def async_run_task(self, ):
+        from metagpt_yusin.logs import logger
+        from metagpt_yusin.roles.di.data_interpreter import DataInterpreter
+        from metagpt_yusin.utils.recovery_util import save_history
+        RunLLM.button_submit._confirm_btn.on_click(self._check_id, remove=True)
+        #print('running job')
+        #goal = 'This is the overall task: ' + goal + context
+        #print(input_text.value)
+        output = await DataInterpreter.jynb_run(RunLLM.input_text.value, RunLLM.context)
+        tasks, tasks_results, di = output[0], output[1], output[2]
+        logger.info('-----------------------------------')
+        logger.info(tasks)
+        logger.info(tasks_results)
+        save_history(role=di)
+        #print('job complete!')
+
+    async def run_task(self, ):
+        # trun off clean during runing
+        RunLLM.button_cl.disabled = True
+        RunLLM.button_submit._cancel_btn.disabled = True
+        # trun on abort during runing
+        RunLLM.button_abort.disabled = False
+        await self.async_run_task()
+        # trun on clean afetr one iter runing
+        RunLLM.button_cl.disabled = False
+        RunLLM.button_submit._cancel_btn.disabled = False
+        # trun off abort during runing
+        RunLLM.button_abort.disabled = True
+
+    def run_job(self, event):
+        task = asyncio.create_task(self.run_task())
+        RunLLM.tasks.append(task)
+
+    async def start_job(self,):
+        try:
+            RunLLM.button_submit.description='Submit'
+            RunLLM.button_submit._confirm_btn.on_click(self.run_job)
+        except KeyboardInterrupt:
+            # Handle keyboard interrupt (user termination)
+            print("User termination detected")
+
+    def default(self,):
+        display(VBox([RunLLM.box_llm, RunLLM.notice_text]))
+        RunLLM.button_submit.on_click(self._check_id, self.clean)
+        RunLLM.button_cl.on_click(self.clean)
+        RunLLM.button_abort.on_click(self.abort)

notebook_dir/metagpt_yusin/__init__.py

@@ -0,0 +1,7 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# @Time    : 2023/4/24 22:26
+# @Author  : alexanderwu
+# @File    : __init__.py
+
+from metagpt_yusin import _compat as _  # noqa: F401

notebook_dir/metagpt_yusin/_compat.py

@@ -0,0 +1,23 @@
+import platform
+import sys
+import warnings
+
+if sys.implementation.name == "cpython" and platform.system() == "Windows":
+    import asyncio
+
+    if sys.version_info[:2] == (3, 9):
+        from asyncio.proactor_events import _ProactorBasePipeTransport
+
+        # https://github.com/python/cpython/pull/92842
+        def pacth_del(self, _warn=warnings.warn):
+            if self._sock is not None:
+                _warn(f"unclosed transport {self!r}", ResourceWarning, source=self)
+                self._sock.close()
+
+        _ProactorBasePipeTransport.__del__ = pacth_del
+
+    if sys.version_info >= (3, 9, 0):
+        from semantic_kernel.orchestration import sk_function as _  # noqa: F401
+
+        # caused by https://github.com/microsoft/semantic-kernel/pull/1416
+        asyncio.set_event_loop_policy(asyncio.WindowsProactorEventLoopPolicy())

notebook_dir/metagpt_yusin/actions/.ipynb_checkpoints/__init__-checkpoint.py

@@ -0,0 +1,57 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+@Time    : 2023/5/11 17:44
+@Author  : alexanderwu
+@File    : __init__.py
+"""
+from enum import Enum
+
+from metagpt_yusin.actions.action import Action
+from metagpt_yusin.actions.action_output import ActionOutput
+from metagpt_yusin.actions.add_requirement import UserRequirement
+from metagpt_yusin.actions.debug_error import DebugError
+from metagpt_yusin.actions.design_api import WriteDesign
+from metagpt_yusin.actions.design_api_review import DesignReview
+from metagpt_yusin.actions.project_management import WriteTasks
+from metagpt_yusin.actions.research import CollectLinks, WebBrowseAndSummarize, ConductResearch
+from metagpt_yusin.actions.run_code import RunCode
+from metagpt_yusin.actions.search_and_summarize import SearchAndSummarize
+from metagpt_yusin.actions.write_code import WriteCode
+from metagpt_yusin.actions.write_code_review import WriteCodeReview
+from metagpt_yusin.actions.write_prd import WritePRD
+from metagpt_yusin.actions.write_prd_review import WritePRDReview
+from metagpt_yusin.actions.write_test import WriteTest
+from metagpt_yusin.actions.di.execute_nb_code import ExecuteNbCode
+from metagpt_yusin.actions.di.write_analysis_code import WriteAnalysisCode
+from metagpt_yusin.actions.di.write_plan import WritePlan
+
+
+class ActionType(Enum):
+    """All types of Actions, used for indexing."""
+
+    ADD_REQUIREMENT = UserRequirement
+    WRITE_PRD = WritePRD
+    WRITE_PRD_REVIEW = WritePRDReview
+    WRITE_DESIGN = WriteDesign
+    DESIGN_REVIEW = DesignReview
+    WRTIE_CODE = WriteCode
+    WRITE_CODE_REVIEW = WriteCodeReview
+    WRITE_TEST = WriteTest
+    RUN_CODE = RunCode
+    DEBUG_ERROR = DebugError
+    WRITE_TASKS = WriteTasks
+    SEARCH_AND_SUMMARIZE = SearchAndSummarize
+    COLLECT_LINKS = CollectLinks
+    WEB_BROWSE_AND_SUMMARIZE = WebBrowseAndSummarize
+    CONDUCT_RESEARCH = ConductResearch
+    EXECUTE_NB_CODE = ExecuteNbCode
+    WRITE_ANALYSIS_CODE = WriteAnalysisCode
+    WRITE_PLAN = WritePlan
+
+
+__all__ = [
+    "ActionType",
+    "Action",
+    "ActionOutput",
+]

notebook_dir/metagpt_yusin/actions/.ipynb_checkpoints/action-checkpoint.py

@@ -0,0 +1,106 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+@Time    : 2023/5/11 14:43
+@Author  : alexanderwu
+@File    : action.py
+"""
+
+from __future__ import annotations
+
+from typing import Optional, Union
+
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+
+from metagpt_yusin.actions.action_node import ActionNode
+from metagpt_yusin.context_mixin import ContextMixin
+from metagpt_yusin.schema import (
+    CodePlanAndChangeContext,
+    CodeSummarizeContext,
+    CodingContext,
+    RunCodeContext,
+    SerializationMixin,
+    TestingContext,
+)
+from metagpt_yusin.utils.project_repo import ProjectRepo
+
+
+class Action(SerializationMixin, ContextMixin, BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    name: str = ""
+    i_context: Union[
+        dict, CodingContext, CodeSummarizeContext, TestingContext, RunCodeContext, CodePlanAndChangeContext, str, None
+    ] = ""
+    prefix: str = ""  # aask*时会加上prefix，作为system_message
+    desc: str = ""  # for skill manager
+    node: ActionNode = Field(default=None, exclude=True)
+
+    @property
+    def repo(self) -> ProjectRepo:
+        if not self.context.repo:
+            self.context.repo = ProjectRepo(self.context.git_repo)
+        return self.context.repo
+
+    @property
+    def prompt_schema(self):
+        return self.config.prompt_schema
+
+    @property
+    def project_name(self):
+        return self.config.project_name
+
+    @project_name.setter
+    def project_name(self, value):
+        self.config.project_name = value
+
+    @property
+    def project_path(self):
+        return self.config.project_path
+
+    @model_validator(mode="before")
+    @classmethod
+    def set_name_if_empty(cls, values):
+        if "name" not in values or not values["name"]:
+            values["name"] = cls.__name__
+        return values
+
+    @model_validator(mode="before")
+    @classmethod
+    def _init_with_instruction(cls, values):
+        if "instruction" in values:
+            name = values["name"]
+            i = values.pop("instruction")
+            values["node"] = ActionNode(key=name, expected_type=str, instruction=i, example="", schema="raw")
+        return values
+
+    def set_prefix(self, prefix):
+        """Set prefix for later usage"""
+        self.prefix = prefix
+        self.llm.system_prompt = prefix
+        if self.node:
+            self.node.llm = self.llm
+        return self
+
+    def __str__(self):
+        return self.__class__.__name__
+
+    def __repr__(self):
+        return self.__str__()
+
+    async def _aask(self, prompt: str, system_msgs: Optional[list[str]] = None) -> str:
+        """Append default prefix"""
+        return await self.llm.aask(prompt, system_msgs)
+
+    async def _run_action_node(self, *args, **kwargs):
+        """Run action node"""
+        msgs = args[0]
+        context = "## History Messages\n"
+        context += "\n".join([f"{idx}: {i}" for idx, i in enumerate(reversed(msgs))])
+        return await self.node.fill(context=context, llm=self.llm)
+
+    async def run(self, *args, **kwargs):
+        """Run action"""
+        if self.node:
+            return await self._run_action_node(*args, **kwargs)
+        raise NotImplementedError("The run method should be implemented in a subclass.")

notebook_dir/metagpt_yusin/actions/.ipynb_checkpoints/execute_task-checkpoint.py

@@ -0,0 +1,19 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+@Time    : 2023/9/13 12:26
+@Author  : femto Zheng
+@File    : execute_task.py
+"""
+
+
+from metagpt_yusin.actions import Action
+from metagpt_yusin.schema import Message
+
+
+class ExecuteTask(Action):
+    name: str = "ExecuteTask"
+    i_context: list[Message] = []
+
+    async def run(self, *args, **kwargs):
+        pass

notebook_dir/metagpt_yusin/actions/.ipynb_checkpoints/generate_questions-checkpoint.py

@@ -0,0 +1,25 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+@File    : generate_questions.py
+"""
+from metagpt_yusin.actions import Action
+from metagpt_yusin.actions.action_node import ActionNode
+
+QUESTIONS = ActionNode(
+    key="Questions",
+    expected_type=list[str],
+    instruction="Task: Refer to the context to further inquire about the details that interest you, within a word limit"
+    " of 150 words. Please provide the specific details you would like to inquire about here",
+    example=["1. What ...", "2. How ...", "3. ..."],
+)
+
+
+class GenerateQuestions(Action):
+    """This class allows LLM to further mine noteworthy details based on specific "##TOPIC"(discussion topic) and
+    "##RECORD" (discussion records), thereby deepening the discussion."""
+
+    name: str = "GenerateQuestions"
+
+    async def run(self, context) -> ActionNode:
+        return await QUESTIONS.fill(context=context, llm=self.llm)

notebook_dir/metagpt_yusin/actions/.ipynb_checkpoints/talk_action-checkpoint.py

@@ -0,0 +1,169 @@
+#!/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_yusin.actions import Action
+from metagpt_yusin.config2 import config
+from metagpt_yusin.logs import logger
+from metagpt_yusin.schema import Message
+
+
+class TalkAction(Action):
+    i_context: str
+    history_summary: str = ""
+    knowledge: str = ""
+    rsp: Optional[Message] = None
+
+    @property
+    def agent_description(self):
+        return self.context.kwargs.agent_description
+
+    @property
+    def language(self):
+        return self.context.kwargs.language or config.language
+
+    @property
+    def prompt(self):
+        prompt = ""
+        if self.agent_description:
+            prompt = (
+                f"You are {self.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 = self.language
+        prompt += (
+            f"Answer the following questions strictly in {language}, and the answers must follow the Markdown format.\n "
+            f"{self.i_context}"
+        )
+        logger.debug(f"PROMPT: {prompt}")
+        return prompt
+
+    @property
+    def prompt_gpt4(self):
+        kvs = {
+            "{role}": self.agent_description or "",
+            "{history}": self.history_summary or "",
+            "{knowledge}": self.knowledge or "",
+            "{language}": self.language,
+            "{ask}": self.i_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 = self.language
+        system_msgs = [
+            f"You are {self.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.i_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, stream=False)
+        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}
+"""

notebook_dir/metagpt_yusin/actions/__init__.py

@@ -0,0 +1,57 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+@Time    : 2023/5/11 17:44
+@Author  : alexanderwu
+@File    : __init__.py
+"""
+from enum import Enum
+
+from metagpt_yusin.actions.action import Action
+from metagpt_yusin.actions.action_output import ActionOutput
+from metagpt_yusin.actions.add_requirement import UserRequirement
+from metagpt_yusin.actions.debug_error import DebugError
+from metagpt_yusin.actions.design_api import WriteDesign
+from metagpt_yusin.actions.design_api_review import DesignReview
+from metagpt_yusin.actions.project_management import WriteTasks
+from metagpt_yusin.actions.research import CollectLinks, WebBrowseAndSummarize, ConductResearch
+from metagpt_yusin.actions.run_code import RunCode
+from metagpt_yusin.actions.search_and_summarize import SearchAndSummarize
+from metagpt_yusin.actions.write_code import WriteCode
+from metagpt_yusin.actions.write_code_review import WriteCodeReview
+from metagpt_yusin.actions.write_prd import WritePRD
+from metagpt_yusin.actions.write_prd_review import WritePRDReview
+from metagpt_yusin.actions.write_test import WriteTest
+from metagpt_yusin.actions.di.execute_nb_code import ExecuteNbCode
+from metagpt_yusin.actions.di.write_analysis_code import WriteAnalysisCode
+from metagpt_yusin.actions.di.write_plan import WritePlan
+
+
+class ActionType(Enum):
+    """All types of Actions, used for indexing."""
+
+    ADD_REQUIREMENT = UserRequirement
+    WRITE_PRD = WritePRD
+    WRITE_PRD_REVIEW = WritePRDReview
+    WRITE_DESIGN = WriteDesign
+    DESIGN_REVIEW = DesignReview
+    WRTIE_CODE = WriteCode
+    WRITE_CODE_REVIEW = WriteCodeReview
+    WRITE_TEST = WriteTest
+    RUN_CODE = RunCode
+    DEBUG_ERROR = DebugError
+    WRITE_TASKS = WriteTasks
+    SEARCH_AND_SUMMARIZE = SearchAndSummarize
+    COLLECT_LINKS = CollectLinks
+    WEB_BROWSE_AND_SUMMARIZE = WebBrowseAndSummarize
+    CONDUCT_RESEARCH = ConductResearch
+    EXECUTE_NB_CODE = ExecuteNbCode
+    WRITE_ANALYSIS_CODE = WriteAnalysisCode
+    WRITE_PLAN = WritePlan
+
+
+__all__ = [
+    "ActionType",
+    "Action",
+    "ActionOutput",
+]