Is FoundationAgents/MetaGPT safe?

res = subprocess.run(adb_cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)

result = subprocess.run(command, shell=True, check=True, cwd=str(output_dir))

result = os.system(check_command)

process = await asyncio.create_subprocess_shell(
                " ".join(commands), stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE
            )

return pickle.load(f)

self.root_node = pickle.load(f)

message = pickle.loads(message_ser)

await eval("(async () => {" + programs + "\n" + code + "})()");

extracted_data[field_name] = eval(raw_value)

extracted_data[field_name] = eval(raw_value)

exec(code, namespace)

groundingdino_model = load_model(file_path, device=device).eval()

exec(code, global_namespace)

exec(test_code, globals())

thoughts = eval(thoughts)

compile(code, fname, "exec")  # USE TRACEBACK BELOW HERE

new_mapping[key] = eval(value)  # `"'(list[str], Ellipsis)"` to `(list[str], ...)`

"""A custom command to run `npm install -g @mermaid-js/mermaid-cli` via a subprocess."""

subprocess.check_call(["npm", "install", "-g", "@mermaid-js/mermaid-cli"])

except subprocess.CalledProcessError as e:

cmdclass={

process = subprocess.Popen(
            command, cwd=working_directory, stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=env
        )

return subprocess.run(cmd, check=check, cwd=cwd, env=env)

res = subprocess.run(adb_cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)

result = subprocess.run(command, shell=True, check=True, cwd=str(output_dir))

process = subprocess.Popen(cmd, cwd=self.root, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)

result = subprocess.run(command, cwd=cwd, capture_output=True, text=True, env=env, timeout=timeout, shell=shell)

self.process = await asyncio.create_subprocess_exec(
            *self.shell_command,
            stdin=PIPE,
            stdout=PIPE,
            stderr=STDOUT,
            executable=self.executable,
            env=os.environ.copy(), …

process = await asyncio.create_subprocess_exec(
            sys.executable,
            "-m",
            "playwright",
            "install",
            *browsers,
            # "--with-deps",
            stdout=asyncio.subprocess.PIPE, …

result = os.system(check_command)

from git.repo import Repo

from git.repo.fun import is_git_dir

process = await asyncio.create_subprocess_shell(
                " ".join(commands), stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE
            )

subprocess.check_call(["npm", "install", "-g", "@mermaid-js/mermaid-cli"])

const f = fs.readFileSync(file, "utf8").split("\n");

content = path.read_text()

content = data_path.read_text()

repo._set(file_path.read_text(), file_path)

with open(result_file, "r") as file:

with open(result_path, "r") as json_file:

with open(prompt_file_path, "r", encoding="utf-8") as file:

with open(graph_file_path, "r", encoding="utf-8") as file:

with open(file_path, "r") as f:

with open(file_path, "r") as file:

task_desc = self.task_desc_path.read_text()

with open(self.record_path, "r") as record_file:

doc_content = ast.literal_eval(doc_path.read_text())

doc_content = ast.literal_eval(doc_path.read_text())

doc_content = ast.literal_eval(doc_path.read_text())

with open(os.path.join(dataset_dir, task_file), encoding="utf-8") as f:

with open(f"{state['custom_dataset_dir']}/description.md", "r", encoding="utf-8") as file:

with open(dataset_info_path, "r") as file:

with open(json_dir, "r") as file:

with open(os.path.join(self.state["node_dir"], f"Node-{self.id}.pkl"), "rb") as f:

with open(os.path.join(self.root_node.state["node_dir"], "node_order.json"), "r") as f:

with open(os.path.join(self.root_node.state["node_dir"], "Node-0.pkl"), "rb") as f:

with open(file_path, "r") as stream:

with open(template_path, "r", encoding="utf-8") as f:

return json.loads(result_path.read_text())

data = json.loads(result_file.read_text(encoding="utf-8"))

shutil.rmtree(path)

self.path.write_text(self.content, encoding="utf-8")

shutil.rmtree(path)

with open(filename, "wb") as file:

os.remove(filename)

with open("tester.txt", "a") as f:

with open("tester.txt", "a") as f:

with open(result_file, "w") as file:

with open(output_path, "w", encoding="utf-8") as outfile:

with open(os.path.join(directory, "graph.py"), "w", encoding="utf-8") as file:

with open(os.path.join(directory, "prompt.py"), "w", encoding="utf-8") as file:

with open(os.path.join(directory, "__init__.py"), "w", encoding="utf-8") as file:

self.record_path.write_text("")

record_file = open(self.record_path, "w")

self.task_desc_path.write_text(task_desc)

with open(log_path, "a") as logfile:

with open(doc_path, "w") as outfile:

doc_path.write_text(str(doc_content))

with open(patch_file, "w", encoding="utf-8") as file:

with open(name, "w") as file:

with open(Path(self.dataset_dir, self.name, "dataset_info.json"), "w", encoding="utf-8") as file:

with open(fpath, "w") as file:

shutil.copy(node_nb_dir, copy_nb_dir)

with open(fpath, "w") as f:

os.remove(pred_path)

import requests

res = requests.post(f"{self.server}/stop")

res = requests.post(
                f"{self.server}/start",
                json=self.reset_options,
                timeout=self.request_timeout,
            )

res = requests.post(f"{self.server}/step", json=data, timeout=self.request_timeout)

res = requests.post(f"{self.server}/pause")

res = requests.post(f"{self.server}/pause")

import requests

response = requests.get(url, stream=True)

import aiohttp

import requests

s = requests.Session()

requests.adapters.HTTPAdapter(max_retries=MAX_CONNECTION_RETRIES),

timeout = aiohttp.ClientTimeout(
                connect=request_timeout[0],
                total=request_timeout[1],
            )

timeout = aiohttp.ClientTimeout(total=request_timeout or TIMEOUT_SECS)

data, content_type = requests.models.RequestEncodingMixin._encode_files(files, data)  # type: ignore

async with aiohttp.ClientSession() as session:

import aiohttp

import requests

import urllib

import requests

from aiohttp import ClientSession

with requests.Session() as session:

session = ClientSession()

import aiohttp

import requests