mirror of
https://github.com/FoundationAgents/MetaGPT.git
synced 2026-04-25 16:56:26 +02:00
110 lines
3.4 KiB
Python
110 lines
3.4 KiB
Python
#!/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, Optional
|
|
|
|
from pydantic import BaseModel, ConfigDict
|
|
|
|
from metagpt.config2 import Config
|
|
from metagpt.configs.llm_config import LLMConfig, LLMType
|
|
from metagpt.provider.base_llm import BaseLLM
|
|
from metagpt.provider.llm_provider_registry import create_llm_instance
|
|
from metagpt.utils.cost_manager import (
|
|
CostManager,
|
|
FireworksCostManager,
|
|
TokenCostManager,
|
|
)
|
|
from metagpt.utils.git_repository import GitRepository
|
|
from metagpt.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"""
|
|
|
|
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 use_llm(self, name: Optional[str] = None, provider: LLMType = LLMType.OPENAI) -> BaseLLM:
|
|
# """Use a LLM instance"""
|
|
# self._llm_config = self.config.get_llm_config(name, provider)
|
|
# self._llm = None
|
|
# return self._llm
|
|
|
|
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
|