From 9a1e938f3cf5859d42f5a4f9442cceb4ec7d6d43 Mon Sep 17 00:00:00 2001 From: Josh XT <102809327+Josh-XT@users.noreply.github.com> Date: Sun, 21 Apr 2024 18:41:28 -0400 Subject: [PATCH] Add command documentation (#1171) * Add command documentation * Update extension readme --- agixt/extensions/README.md | 114 ++++++++---- agixt/extensions/agixt_actions.py | 242 +++++++++++++++++++++++++- agixt/extensions/discord.py | 66 ++++++- agixt/extensions/file_system.py | 94 ++++++++++ agixt/extensions/github.py | 168 ++++++++++++++++++ agixt/extensions/google.py | 126 ++++++++++++++ agixt/extensions/microsoft365.py | 113 ++++++++++++ agixt/extensions/mysql_database.py | 15 ++ agixt/extensions/postgres_database.py | 16 ++ agixt/extensions/searxng.py | 9 + agixt/extensions/sendgrid_email.py | 17 +- agixt/extensions/sqlite_database.py | 16 ++ agixt/extensions/times.py | 6 + agixt/extensions/web_playwright.py | 28 +++ 14 files changed, 991 insertions(+), 39 deletions(-) diff --git a/agixt/extensions/README.md b/agixt/extensions/README.md index 537dca9e7188..07891112e62b 100644 --- a/agixt/extensions/README.md +++ b/agixt/extensions/README.md @@ -1,27 +1,32 @@ -## AGiXT Extensions +# AGiXT Extensions Extensions are the way to extend the functionality of AGiXT with other software APIs or Python modules. Extensions are Python files that are placed in the `extensions` folder. AGiXT will automatically load all extensions and commands associated when it starts. -### Creating an Extension +## Creating an Extension -To create an extension, create a new Python file in the `extensions` folder. The file name will be the name of the extension. We will use the `GitHub` extension as an example. +To create an extension, create a new Python file in the `extensions` folder. The file name will be the name of the extension. We will make a smaller version of our `GitHub` extension as an example. + +The example `GitHub` extension will have two commands: -The `GitHub` extension will have two commands: - `Clone GitHub Repository` - `Create GitHub Repository` The `GibHub` extension will require two keys: + - `GITHUB_USERNAME` - The username of the GitHub account to use - `GITHUB_API_KEY` - The API key of the GitHub account to use All extensions will inherit from the `Extensions` class. This class will provide the following: + - `self.commands` - A dictionary of commands that the extension provides. The key is the name of the command and the value is the function that will be called when the command is run. -- `WORKING_DIRECTORY` - The directory that AGiXT Agent is allowed to work in. - Any API Keys for your extension. In this case, `GITHUB_USERNAME` and `GITHUB_API_KEY`. Add these to `__init__` as shown below. -- Any imports that are required for your extension. In this case, `os`, `git`, and `Github`. Add try/excepts to install the modules if they are not already installed. +- Any imports that are required for your extension that are not built into Python. In this case, `GitPython`, and `PyGithub`. Add try/excepts to install the modules if they are not already installed. ```python import os +import time +import datetime +from Extensions import Extensions try: import git @@ -29,18 +34,17 @@ except ImportError: import sys import subprocess - subprocess.check_call([sys.executable, "-m", "pip", "install", "GitPython==3.1.31"]) + subprocess.check_call([sys.executable, "-m", "pip", "install", "GitPython"]) import git try: - from github import Github + from github import Github, RateLimitExceededException except ImportError: import sys import subprocess - subprocess.check_call([sys.executable, "-m", "pip", "install", "PyGithub==1.58.2"]) - from github import Github -from Extensions import Extensions + subprocess.check_call([sys.executable, "-m", "pip", "install", "PyGithub"]) + from github import Github, RateLimitExceededException class github(Extensions): @@ -48,17 +52,36 @@ class github(Extensions): self, GITHUB_USERNAME: str = "", GITHUB_API_KEY: str = "", - WORKING_DIRECTORY: str = "./WORKSPACE", **kwargs, ): self.GITHUB_USERNAME = GITHUB_USERNAME self.GITHUB_API_KEY = GITHUB_API_KEY - self.WORKING_DIRECTORY = WORKING_DIRECTORY - self.commands = {"Clone Github Repository": self.clone_repo} if self.GITHUB_USERNAME and self.GITHUB_API_KEY: - self.commands["Create Github Repository"] = self.create_repo + self.commands = { + "Clone Github Repository": self.clone_repo, + "Create Github Repository": self.create_repo, + } + try: + self.gh = Github(self.GITHUB_API_KEY) + except Exception as e: + self.gh = None + self.commands = {} + print(f"GitHub Error: {str(e)}") + else: + self.commands = {} + self.gh = None + self.failures = 0 async def clone_repo(self, repo_url: str) -> str: + """ + Clone a GitHub repository to the local workspace + + Args: + repo_url (str): The URL of the GitHub repository to clone + + Returns: + str: The result of the cloning operation + """ split_url = repo_url.split("//") if self.GITHUB_USERNAME is not None and self.GITHUB_API_KEY is not None: auth_repo_url = f"//{self.GITHUB_USERNAME}:{self.GITHUB_API_KEY}@".join( @@ -68,29 +91,58 @@ class github(Extensions): auth_repo_url = "//".join(split_url) try: repo_name = repo_url.split("/")[-1] - repo_dir = os.path.join(self.WORKING_DIRECTORY, repo_name) + repo_dir = os.path.join("./WORKSPACE", repo_name) if os.path.exists(repo_dir): - return f"""{repo_dir} already exists""" + # Pull the latest changes + repo = git.Repo(repo_dir) + repo.remotes.origin.pull() + self.failures = 0 + return f"Pulled latest changes for {repo_url} to {repo_dir}" git.Repo.clone_from( url=auth_repo_url, to_path=repo_dir, ) + self.failures = 0 return f"Cloned {repo_url} to {repo_dir}" except Exception as e: + if self.failures < 3: + self.failures += 1 + time.sleep(5) + return await self.clone_repo(repo_url) return f"Error: {str(e)}" async def create_repo(self, repo_name: str, content_of_readme: str) -> str: - g = Github(self.GITHUB_API_KEY) - user = g.get_user(self.GITHUB_USERNAME) - repo = user.create_repo(repo_name, private=True) - repo_url = repo.clone_url - repo_dir = f"./{repo_name}" - repo = git.Repo.init(repo_dir) - with open(f"{repo_dir}/README.md", "w") as f: - f.write(content_of_readme) - repo.git.add(A=True) - repo.git.commit(m="Added README") - repo.create_remote("origin", repo_url) - repo.git.push("origin", "HEAD:main") - return repo_url -``` \ No newline at end of file + """ + Create a new private GitHub repository + + Args: + repo_name (str): The name of the repository to create + content_of_readme (str): The content of the README.md file + + Returns: + str: The URL of the newly created repository + """ + try: + try: + user = self.gh.get_organization(self.GITHUB_USERNAME) + except: + user = self.gh.get_user(self.GITHUB_USERNAME) + repo = user.create_repo(repo_name, private=True) + repo_url = repo.clone_url + repo_dir = f"./{repo_name}" + repo = git.Repo.init(repo_dir) + with open(f"{repo_dir}/README.md", "w") as f: + f.write(content_of_readme) + repo.git.add(A=True) + repo.git.commit(m="Added README") + repo.create_remote("origin", repo_url) + repo.git.push("origin", "HEAD:main") + self.failures = 0 + return repo_url + except Exception as e: + if self.failures < 3: + self.failures += 1 + time.sleep(5) + return await self.create_repo(repo_name, content_of_readme) + return f"Error: {str(e)}" +``` diff --git a/agixt/extensions/agixt_actions.py b/agixt/extensions/agixt_actions.py index 77ac269f3892..650b19dafb6a 100644 --- a/agixt/extensions/agixt_actions.py +++ b/agixt/extensions/agixt_actions.py @@ -182,6 +182,15 @@ def __init__(self, **kwargs): self.failures = 0 async def read_file_content(self, file_path: str): + """ + Read the content of a file and store it in long term memory + + Args: + file_path (str): The path to the file + + Returns: + str: Success message + """ with open(file_path, "r") as f: file_content = f.read() filename = os.path.basename(file_path) @@ -193,6 +202,15 @@ async def read_file_content(self, file_path: str): ) async def write_website_to_memory(self, url: str): + """ + Read the content of a website and store it in long term memory + + Args: + url (str): The URL of the website + + Returns: + str: Success message + """ return self.ApiClient.learn_url( agent_name=self.agent_name, url=url, @@ -202,6 +220,16 @@ async def write_website_to_memory(self, url: str): async def store_long_term_memory( self, input: str, data_to_correlate_with_input: str ): + """ + Store information in long term memory + + Args: + input (str): The user input + data_to_correlate_with_input (str): The data to correlate with the user input in long term memory, useful for feedback or remembering important information for later + + Returns: + str: Success message + """ return self.ApiClient.learn_text( agent_name=self.agent_name, user_input=input, @@ -209,6 +237,16 @@ async def store_long_term_memory( ) async def search_arxiv(self, query: str, max_articles: int = 5): + """ + Search for articles on arXiv, read into long term memory + + Args: + query (str): The search query + max_articles (int): The maximum number of articles to read + + Returns: + str: Success message + """ return self.ApiClient.learn_arxiv( query=query, article_ids=None, @@ -217,6 +255,15 @@ async def search_arxiv(self, query: str, max_articles: int = 5): ) async def read_github_repository(self, repository_url: str): + """ + Read the content of a GitHub repository and store it in long term memory + + Args: + repository_url (str): The URL of the GitHub repository + + Returns: + str: Success message + """ return self.ApiClient.learn_github_repo( agent_name=self.agent_name, github_repo=repository_url, @@ -233,6 +280,20 @@ async def create_task_chain( smart_chain: bool = False, researching: bool = False, ): + """ + Create a task chain from a numbered list of tasks + + Args: + agent (str): The agent to create the task chain for + primary_objective (str): The primary objective to keep in mind while working on the task + numbered_list_of_tasks (str): The numbered list of tasks to complete + short_chain_description (str): A short description of the chain + smart_chain (bool): Whether to create a smart chain + researching (bool): Whether to include web research in the chain + + Returns: + str: The name of the created chain + """ now = datetime.datetime.now() timestamp = now.strftime("%Y-%m-%d_%H-%M-%S") task_list = numbered_list_of_tasks.split("\n") @@ -309,6 +370,15 @@ async def create_task_chain( return chain_name async def run_chain(self, input_for_task: str = ""): + """ + Run a chain + + Args: + input_for_task (str): The input for the task + + Returns: + str: The response from the chain + """ response = await self.ApiClient.run_chain( chain_name=self.command_name, user_input=input_for_task, @@ -322,6 +392,15 @@ async def run_chain(self, input_for_task: str = ""): return response def parse_openapi(self, data): + """ + Parse OpenAPI data to extract endpoints + + Args: + data (dict): The OpenAPI data + + Returns: + list: The list of endpoints + """ endpoints = [] schemas = data.get("components", {}).get( "schemas", {} @@ -382,6 +461,15 @@ def resolve_schema(ref): return endpoints def get_auth_type(self, openapi_data): + """ + Get the authentication type from the OpenAPI data + + Args: + openapi_data (dict): The OpenAPI data + + Returns: + str: The authentication type + """ # The "components" section contains the security schemes if ( "components" in openapi_data @@ -399,6 +487,16 @@ def get_auth_type(self, openapi_data): return "basic" async def generate_openapi_chain(self, extension_name: str, openapi_json_url: str): + """ + Generate an AGiXT extension from an OpenAPI JSON URL + + Args: + extension_name (str): The name of the extension + openapi_json_url (str): The URL of the OpenAPI JSON file + + Returns: + str: The name of the created chain + """ # Experimental currently. openapi_str = requests.get(openapi_json_url).text openapi_data = json.loads(openapi_str) @@ -499,6 +597,17 @@ async def generate_openapi_chain(self, extension_name: str, openapi_json_url: st return chain_name async def generate_helper_chain(self, user_agent, helper_agent, task_in_question): + """ + Generate a helper chain for an agent + + Args: + user_agent (str): The user agent + helper_agent (str): The helper agent + task_in_question (str): The task in question + + Returns: + str: The name of the created chain + """ chain_name = f"Help Chain - {user_agent} to {helper_agent}" self.ApiClient.add_chain(chain_name=chain_name) i = 1 @@ -528,6 +637,16 @@ async def generate_helper_chain(self, user_agent, helper_agent, task_in_question return chain_name async def ask_for_help(self, your_agent_name, your_task): + """ + Ask for help from a helper agent + + Args: + your_agent_name (str): Your agent name + your_task (str): Your task + + Returns: + str: The response from the helper agent + """ return self.ApiClient.run_chain( chain_name="Ask Helper Agent for Help", user_input=your_task, @@ -542,6 +661,16 @@ async def ask_for_help(self, your_agent_name, your_task): async def create_command( self, function_description: str, agent: str = "AGiXT" ) -> List[str]: + """ + Create a new command + + Args: + function_description (str): The description of the function + agent (str): The agent to create the command for + + Returns: + str: The response from the chain + """ try: return self.ApiClient.run_chain( chain_name="Create New Command", @@ -557,6 +686,15 @@ async def create_command( return f"Unable to create command: {e}" async def ask(self, user_input: str) -> str: + """ + Ask a question + + Args: + user_input (str): The user input + + Returns: + str: The response to the question + """ response = self.ApiClient.prompt_agent( agent_name=self.agent_name, prompt_name="Chat", @@ -570,6 +708,15 @@ async def ask(self, user_input: str) -> str: return response async def instruct(self, user_input: str) -> str: + """ + Instruct the agent + + Args: + user_input (str): The user input + + Returns: + str: The response to the instruction + """ response = self.ApiClient.prompt_agent( agent_name=self.agent_name, prompt_name="instruct", @@ -583,11 +730,30 @@ async def instruct(self, user_input: str) -> str: return response async def get_python_code_from_response(self, response: str): + """ + Get the Python code from the response + + Args: + response (str): The response + + Returns: + str: The Python code + """ if "```python" in response: response = response.split("```python")[1].split("```")[0] return response async def execute_python_code_internal(self, code: str, text: str = "") -> str: + """ + Execute Python code + + Args: + code (str): The Python code + text (str): The text + + Returns: + str: The result of the Python code + """ working_dir = os.environ.get("WORKING_DIRECTORY", self.WORKING_DIRECTORY) if text: csv_content_header = text.split("\n")[0] @@ -602,6 +768,15 @@ async def execute_python_code_internal(self, code: str, text: str = "") -> str: return execute_python_code(code=code, working_directory=working_dir) async def get_mindmap(self, task: str): + """ + Get a mindmap for a task + + Args: + task (str): The task + + Returns: + dict: The mindmap + """ mindmap = self.ApiClient.prompt_agent( agent_name=self.agent_name, prompt_name="Mindmap", @@ -613,10 +788,27 @@ async def get_mindmap(self, task: str): return parse_mindmap(mindmap=mindmap) async def make_csv_code_block(self, data: str) -> str: + """ + Make a CSV code block + + Args: + data (str): The data + + Returns: + str: The CSV code block + """ return f"```csv\n{data}\n```" async def get_csv_preview(self, filename: str): - # Get first 2 lines of the file + """ + Get a preview of a CSV file + + Args: + filename (str): The filename + + Returns: + str: The preview of the CSV file consisting of the first 2 lines + """ filepath = self.safe_join(base=self.WORKING_DIRECTORY, paths=filename) with open(filepath, "r") as f: lines = f.readlines() @@ -625,17 +817,42 @@ async def get_csv_preview(self, filename: str): return lines_string async def get_csv_preview_text(self, text: str): - # Get first 2 lines of the text + """ + Get a preview of a CSV text + + Args: + text (str): The text + + Returns: + str: The preview of the CSV text consisting of the first 2 lines + """ lines = text.split("\n") lines = lines[:2] lines_string = "\n".join(lines) return lines_string async def get_csv_from_response(self, response: str) -> str: + """ + Get the CSV data from the response + + Args: + response (str): The response + + Returns: + str: The CSV data + """ return response.split("```csv")[1].split("```")[0] - # Convert LLM response of a list of either numbers like a numbered list, *'s, -'s to a list from the string response async def convert_llm_response_to_list(self, response): + """ + Convert an LLM response to a list + + Args: + response (str): The response + + Returns: + list: The list + """ response = response.split("\n") response = [item.lstrip("0123456789.*- ") for item in response if item.lstrip()] response = [item for item in response if item] @@ -643,6 +860,15 @@ async def convert_llm_response_to_list(self, response): return response async def convert_questions_to_dataset(self, response): + """ + Convert questions to a dataset + + Args: + response (str): The response + + Returns: + str: The dataset + """ questions = await self.convert_llm_response_to_list(response) tasks = [] i = 0 @@ -667,6 +893,16 @@ async def convert_questions_to_dataset(self, response): async def convert_string_to_pydantic_model( self, input_string: str, output_model: Type[BaseModel] ): + """ + Convert a string to a Pydantic model + + Args: + input_string (str): The input string + output_model (Type[BaseModel]): The output model + + Returns: + Type[BaseModel]: The Pydantic model + """ fields = output_model.model_fields field_descriptions = [f"{field}: {fields[field]}" for field in fields] schema = "\n".join(field_descriptions) diff --git a/agixt/extensions/discord.py b/agixt/extensions/discord.py index db48f3ffe653..7a677f40e6e2 100644 --- a/agixt/extensions/discord.py +++ b/agixt/extensions/discord.py @@ -53,28 +53,90 @@ async def on_command_error(ctx, error): pass async def send_message(self, channel_id: int, content: str): + """ + Send a message to a Discord channel + + Args: + channel_id (int): The ID of the Discord channel + content (str): The content of the message + + Returns: + str: The result of sending the message + """ channel = self.bot.get_channel(channel_id) await channel.send(content) + return f"Message sent to channel {channel_id} successfully!" async def get_messages(self, channel_id: int, limit: int = 100): + """ + Get messages from a Discord channel + + Args: + channel_id (int): The ID of the Discord channel + limit (int): The number of messages to retrieve + + Returns: + str: The messages from the channel + """ channel = self.bot.get_channel(channel_id) messages = await channel.history(limit=limit).flatten() - return [(message.author, message.content) for message in messages] + str_messages = "" + for message in messages: + str_messages += f"{message.author}: {message.content}\n" + return str_messages async def delete_message(self, channel_id: int, message_id: int): + """ + Delete a message from a Discord channel + + Args: + channel_id (int): The ID of the Discord channel + message_id (int): The ID of the message to delete + + Returns: + str: The result of deleting the message + """ channel = self.bot.get_channel(channel_id) message = await channel.fetch_message(message_id) await message.delete() + return f"Message {message_id} deleted successfully!" async def create_invite(self, channel_id: int, max_age: int = 0, max_uses: int = 0): + """ + Create an invite to a Discord channel + + Args: + channel_id (int): The ID of the Discord channel + max_age (int): The maximum age of the invite in seconds + max_uses (int): The maximum number of uses for the invite + + Returns: + str: The invite URL + """ channel = self.bot.get_channel(channel_id) invite = await channel.create_invite(max_age=max_age, max_uses=max_uses) return invite.url async def get_servers(self): - return [guild.name for guild in self.bot.guilds] + """ + Get the list of servers the bot is connected to + + Returns: + str: The list of servers + """ + servers = [guild.name for guild in self.bot.guilds] + return ", ".join(servers) async def get_server_info(self, server_id: int): + """ + Get information about a Discord server + + Args: + server_id (int): The ID of the Discord server + + Returns: + dict: The information about the server + """ server = self.bot.get_guild(server_id) return { "name": server.name, diff --git a/agixt/extensions/file_system.py b/agixt/extensions/file_system.py index 4d1241a5162e..71811945345d 100644 --- a/agixt/extensions/file_system.py +++ b/agixt/extensions/file_system.py @@ -32,6 +32,15 @@ def __init__( self.WORKING_DIRECTORY = WORKING_DIRECTORY async def execute_python_file(self, file: str): + """ + Execute a Python file in the workspace + + Args: + file (str): The name of the Python file to execute + + Returns: + str: The output of the Python file + """ logging.info(f"Executing file '{file}' in workspace '{self.WORKING_DIRECTORY}'") if not file.endswith(".py"): @@ -55,6 +64,15 @@ async def execute_python_file(self, file: str): return execute_python_code(code=code, working_directory=self.WORKING_DIRECTORY) async def execute_shell(self, command_line: str) -> str: + """ + Execute a shell command + + Args: + command_line (str): The shell command to execute + + Returns: + str: The output of the shell command + """ current_dir = os.getcwd() os.chdir(current_dir) logging.info( @@ -72,6 +90,16 @@ def we_are_running_in_a_docker_container() -> bool: return os.path.exists("/.dockerenv") def safe_join(self, base: str, paths) -> str: + """ + Safely join paths together + + Args: + base (str): The base path + paths (str): The paths to join + + Returns: + str: The joined path + """ if "/path/to/" in paths: paths = paths.replace("/path/to/", "") if str(self.WORKING_DIRECTORY_RESTRICTED).lower() == "true": @@ -86,6 +114,15 @@ def safe_join(self, base: str, paths) -> str: return new_path async def read_file(self, filename: str) -> str: + """ + Read a file in the workspace + + Args: + filename (str): The name of the file to read + + Returns: + str: The content of the file + """ try: filepath = self.safe_join(base=self.WORKING_DIRECTORY, paths=filename) with open(filepath, "r", encoding="utf-8") as f: @@ -95,6 +132,16 @@ async def read_file(self, filename: str) -> str: return f"Error: {str(e)}" async def write_to_file(self, filename: str, text: str) -> str: + """ + Write text to a file in the workspace + + Args: + filename (str): The name of the file to write to + text (str): The text to write to the file + + Returns: + str: The status of the write operation + """ try: filepath = self.safe_join(base=self.WORKING_DIRECTORY, paths=filename) directory = os.path.dirname(filepath) @@ -107,6 +154,16 @@ async def write_to_file(self, filename: str, text: str) -> str: return f"Error: {str(e)}" async def append_to_file(self, filename: str, text: str) -> str: + """ + Append text to a file in the workspace + + Args: + filename (str): The name of the file to append to + text (str): The text to append to the file + + Returns: + str: The status of the append operation + """ try: filepath = self.safe_join(base=self.WORKING_DIRECTORY, paths=filename) if not os.path.exists(filepath): @@ -120,6 +177,15 @@ async def append_to_file(self, filename: str, text: str) -> str: return f"Error: {str(e)}" async def delete_file(self, filename: str) -> str: + """ + Delete a file in the workspace + + Args: + filename (str): The name of the file to delete + + Returns: + str: The status of the delete operation + """ try: filepath = self.safe_join(base=self.WORKING_DIRECTORY, paths=filename) os.remove(filepath) @@ -128,6 +194,15 @@ async def delete_file(self, filename: str) -> str: return f"Error: {str(e)}" async def search_files(self, directory: str) -> List[str]: + """ + Search for files in the workspace + + Args: + directory (str): The directory to search in + + Returns: + List[str]: The list of files found + """ found_files = [] if directory in {"", "/"}: @@ -149,6 +224,16 @@ async def search_files(self, directory: str) -> List[str]: return found_files async def indent_string(self, string: str, indents: int = 1): + """ + Indent a string for Python code + + Args: + string (str): The string to indent + indents (int): The number of indents to add + + Returns: + str: The indented string + """ if indents == 1: indent = " " else: @@ -159,6 +244,15 @@ async def indent_string(self, string: str, indents: int = 1): return indented_string async def generate_commands_dict(self, python_file_content): + """ + Generate a dictionary of commands from a Python file + + Args: + python_file_content (str): The content of the Python file + + Returns: + str: The dictionary of commands + """ function_names = re.findall(r"async def (.*?)\(", python_file_content) commands_dict = { f_name.replace("_", " "): f"self.{f_name}" for f_name in function_names diff --git a/agixt/extensions/github.py b/agixt/extensions/github.py index 5be37990932f..cd7f7280b793 100644 --- a/agixt/extensions/github.py +++ b/agixt/extensions/github.py @@ -62,6 +62,15 @@ def __init__( self.failures = 0 async def clone_repo(self, repo_url: str) -> str: + """ + Clone a GitHub repository to the local workspace + + Args: + repo_url (str): The URL of the GitHub repository to clone + + Returns: + str: The result of the cloning operation + """ split_url = repo_url.split("//") if self.GITHUB_USERNAME is not None and self.GITHUB_API_KEY is not None: auth_repo_url = f"//{self.GITHUB_USERNAME}:{self.GITHUB_API_KEY}@".join( @@ -92,6 +101,16 @@ async def clone_repo(self, repo_url: str) -> str: return f"Error: {str(e)}" async def create_repo(self, repo_name: str, content_of_readme: str) -> str: + """ + Create a new private GitHub repository + + Args: + repo_name (str): The name of the repository to create + content_of_readme (str): The content of the README.md file + + Returns: + str: The URL of the newly created repository + """ try: try: user = self.gh.get_organization(self.GITHUB_USERNAME) @@ -117,6 +136,15 @@ async def create_repo(self, repo_name: str, content_of_readme: str) -> str: return f"Error: {str(e)}" async def get_repo_code_contents(self, repo_url: str) -> str: + """ + Get the code contents of a GitHub repository + + Args: + repo_url (str): The URL of the GitHub repository + + Returns: + str: The code contents of the repository in markdown format + """ repo_name = repo_url.split("/")[-1] await self.clone_repo(repo_url) python_files = [] @@ -177,6 +205,15 @@ async def get_repo_code_contents(self, repo_url: str) -> str: return content async def get_repo_issues(self, repo_url: str) -> str: + """ + Get the open issues for a GitHub repository + + Args: + repo_url (str): The URL of the GitHub repository + + Returns: + str: The open issues for the repository + """ try: repo = self.gh.get_repo(repo_url.split("github.com/")[-1]) issues = repo.get_issues(state="open") @@ -197,6 +234,16 @@ async def get_repo_issues(self, repo_url: str) -> str: return f"Error: {str(e)}" async def get_repo_issue(self, repo_url: str, issue_number: int) -> str: + """ + Get the details of a specific issue in a GitHub repository + + Args: + repo_url (str): The URL of the GitHub repository + issue_number (int): The issue number to retrieve + + Returns: + str: The details of the issue + """ try: repo = self.gh.get_repo(repo_url.split("github.com/")[-1]) issue = repo.get_issue(issue_number) @@ -214,6 +261,18 @@ async def get_repo_issue(self, repo_url: str, issue_number: int) -> str: async def create_repo_issue( self, repo_url: str, title: str, body: str, assignee: str = None ) -> str: + """ + Create a new issue in a GitHub repository + + Args: + repo_url (str): The URL of the GitHub repository + title (str): The title of the issue + body (str): The body of the issue + assignee (str): The assignee for the issue + + Returns: + str: The result of the issue creation operation + """ try: repo = self.gh.get_repo(repo_url.split("github.com/")[-1]) issue = repo.create_issue(title=title, body=body, assignee=assignee) @@ -238,6 +297,19 @@ async def update_repo_issue( body: str, assignee: str = None, ) -> str: + """ + Update an existing issue in a GitHub repository + + Args: + repo_url (str): The URL of the GitHub repository + issue_number (int): The issue number to update + title (str): The new title of the issue + body (str): The new body of the issue + assignee (str): The new assignee for the issue + + Returns: + str: The result of the issue update operation + """ try: repo = self.gh.get_repo(repo_url.split("github.com/")[-1]) issue = repo.get_issue(issue_number) @@ -254,6 +326,15 @@ async def update_repo_issue( return f"Error: {str(e)}" async def get_repo_pull_requests(self, repo_url: str) -> str: + """ + Get the open pull requests for a GitHub repository + + Args: + repo_url (str): The URL of the GitHub repository + + Returns: + str: The open pull requests for the repository + """ try: repo = self.gh.get_repo(repo_url.split("github.com/")[-1]) pull_requests = repo.get_pulls(state="open") @@ -277,6 +358,16 @@ async def get_repo_pull_requests(self, repo_url: str) -> str: async def get_repo_pull_request( self, repo_url: str, pull_request_number: int ) -> str: + """ + Get the details of a specific pull request in a GitHub repository + + Args: + repo_url (str): The URL of the GitHub repository + pull_request_number (int): The pull request number to retrieve + + Returns: + str: The details of the pull request + """ try: repo = self.gh.get_repo(repo_url.split("github.com/")[-1]) pull_request = repo.get_pull(pull_request_number) @@ -294,6 +385,19 @@ async def get_repo_pull_request( async def create_repo_pull_request( self, repo_url: str, title: str, body: str, head: str, base: str ) -> str: + """ + Create a new pull request in a GitHub repository + + Args: + repo_url (str): The URL of the GitHub repository + title (str): The title of the pull request + body (str): The body of the pull request + head (str): The branch to merge from + base (str): The branch to merge to + + Returns: + str: The result of the pull request creation operation + """ try: repo = self.gh.get_repo(repo_url.split("github.com/")[-1]) pull_request = repo.create_pull( @@ -315,6 +419,18 @@ async def create_repo_pull_request( async def update_repo_pull_request( self, repo_url: str, pull_request_number: int, title: str, body: str ) -> str: + """ + Update an existing pull request in a GitHub repository + + Args: + repo_url (str): The URL of the GitHub repository + pull_request_number (int): The pull request number to update + title (str): The new title of the pull request + body (str): The new body of the pull request + + Returns: + str: The result of the pull request update operation + """ try: repo = self.gh.get_repo(repo_url.split("github.com/")[-1]) pull_request = repo.get_pull(pull_request_number) @@ -333,6 +449,16 @@ async def update_repo_pull_request( return f"Error: {str(e)}" async def get_repo_commits(self, repo_url: str, days: int = 7) -> str: + """ + Get the commits for a GitHub repository + + Args: + repo_url (str): The URL of the GitHub repository + days (int): The number of days to retrieve commits for (default is 7 days) + + Returns: + str: The commits for the repository + """ try: repo = self.gh.get_repo(repo_url.split("github.com/")[-1]) if days == 0: @@ -358,6 +484,16 @@ async def get_repo_commits(self, repo_url: str, days: int = 7) -> str: return f"Error: {str(e)}" async def get_repo_commit(self, repo_url: str, commit_sha: str) -> str: + """ + Get the details of a specific commit in a GitHub repository + + Args: + repo_url (str): The URL of the GitHub repository + commit_sha (str): The commit SHA to retrieve + + Returns: + str: The details of the commit + """ try: repo = self.gh.get_repo(repo_url.split("github.com/")[-1]) commit = repo.get_commit(commit_sha) @@ -371,6 +507,17 @@ async def get_repo_commit(self, repo_url: str, commit_sha: str) -> str: async def add_comment_to_repo_issue( self, repo_url: str, issue_number: int, comment_body: str ) -> str: + """ + Add a comment to an issue in a GitHub repository + + Args: + repo_url (str): The URL of the GitHub repository + issue_number (int): The issue number to add a comment to + comment_body (str): The body of the comment + + Returns: + str: The result of the comment addition operation + """ try: repo = self.gh.get_repo(repo_url.split("github.com/")[-1]) issue = repo.get_issue(issue_number) @@ -391,6 +538,17 @@ async def add_comment_to_repo_issue( async def add_comment_to_repo_pull_request( self, repo_url: str, pull_request_number: int, comment_body: str ) -> str: + """ + Add a comment to a pull request in a GitHub repository + + Args: + repo_url (str): The URL of the GitHub repository + pull_request_number (int): The pull request number to add a comment to + comment_body (str): The body of the comment + + Returns: + str: The result of the comment addition operation + """ try: repo = self.gh.get_repo(repo_url.split("github.com/")[-1]) pull_request = repo.get_pull(pull_request_number) @@ -409,6 +567,16 @@ async def add_comment_to_repo_pull_request( return f"Error: {str(e)}" async def close_issue(self, repo_url, issue_number): + """ + Close an issue in a GitHub repository + + Args: + repo_url (str): The URL of the GitHub repository + issue_number (int): The issue number to close + + Returns: + str: The result of the issue closure operation + """ try: repo = self.gh.get_repo(repo_url.split("github.com/")[-1]) issue = repo.get_issue(issue_number) diff --git a/agixt/extensions/google.py b/agixt/extensions/google.py index 855e1d808f07..6b74c8784164 100644 --- a/agixt/extensions/google.py +++ b/agixt/extensions/google.py @@ -86,6 +86,16 @@ def authenticate(self): return None async def get_emails(self, query=None, max_emails=10): + """ + Get emails from the user's Gmail account + + Args: + query (str): The search query to filter emails + max_emails (int): The maximum number of emails to retrieve + + Returns: + List[Dict]: A list of email data + """ try: service = build("gmail", "v1", credentials=self.creds) result = ( @@ -126,6 +136,18 @@ async def get_emails(self, query=None, max_emails=10): return [] async def send_email(self, recipient, subject, body, attachments=None): + """ + Send an email using the user's Gmail account + + Args: + recipient (str): The email address of the recipient + subject (str): The subject of the email + body (str): The body of the email + attachments (List[str]): A list of file paths to attach to the email + + Returns: + str: The result of sending the email + """ try: service = build("gmail", "v1", credentials=self.creds) @@ -164,6 +186,16 @@ async def send_email(self, recipient, subject, body, attachments=None): return "Failed to send email." async def move_email_to_folder(self, message_id, folder_name): + """ + Move an email to a specific folder in the user's Gmail account + + Args: + message_id (str): The ID of the email message + folder_name (str): The name of the folder to move the email to + + Returns: + str: The result of moving the email + """ try: service = build("gmail", "v1", credentials=self.creds) @@ -197,6 +229,18 @@ async def move_email_to_folder(self, message_id, folder_name): return "Failed to move email." async def create_draft_email(self, recipient, subject, body, attachments=None): + """ + Create a draft email in the user's Gmail account + + Args: + recipient (str): The email address of the recipient + subject (str): The subject of the email + body (str): The body of the email + attachments (List[str]): A list of file paths to attach to the email + + Returns: + str: The result of creating the draft email + """ try: service = build("gmail", "v1", credentials=self.creds) @@ -235,6 +279,15 @@ async def create_draft_email(self, recipient, subject, body, attachments=None): return "Failed to create draft email." async def delete_email(self, message_id): + """ + Delete an email from the user's Gmail account + + Args: + message_id (str): The ID of the email message + + Returns: + str: The result of deleting the email + """ try: service = build("gmail", "v1", credentials=self.creds) service.users().messages().delete(userId="me", id=message_id).execute() @@ -244,6 +297,16 @@ async def delete_email(self, message_id): return "Failed to delete email." async def search_emails(self, query, max_emails=10): + """ + Search emails in the user's Gmail account + + Args: + query (str): The search query to filter emails + max_emails (int): The maximum number of emails to retrieve + + Returns: + List[Dict]: A list of email data + """ try: service = build("gmail", "v1", credentials=self.creds) result = ( @@ -284,6 +347,17 @@ async def search_emails(self, query, max_emails=10): return [] async def reply_to_email(self, message_id, body, attachments=None): + """ + Reply to an email in the user's Gmail account + + Args: + message_id (str): The ID of the email message + body (str): The body of the reply email + attachments (List[str]): A list of file paths to attach to the reply email + + Returns: + str: The result of sending the reply + """ try: service = build("gmail", "v1", credentials=self.creds) message = ( @@ -332,6 +406,15 @@ async def reply_to_email(self, message_id, body, attachments=None): return "Failed to send reply." async def process_attachments(self, message_id): + """ + Process attachments from an email in the user's Gmail account + + Args: + message_id (str): The ID of the email message + + Returns: + List[str]: A list of file paths to the saved attachments + """ try: service = build("gmail", "v1", credentials=self.creds) message = ( @@ -364,6 +447,17 @@ async def process_attachments(self, message_id): return [] async def get_calendar_items(self, start_date=None, end_date=None, max_items=10): + """ + Get calendar items from the user's Google Calendar + + Args: + start_date (datetime): The start date to filter calendar items + end_date (datetime): The end date to filter calendar items + max_items (int): The maximum number of calendar items to retrieve + + Returns: + List[Dict]: A list of calendar item data + """ try: service = build("calendar", "v3", credentials=self.creds) @@ -411,6 +505,19 @@ async def get_calendar_items(self, start_date=None, end_date=None, max_items=10) async def add_calendar_item( self, subject, start_time, end_time, location, attendees=None ): + """ + Add a calendar item to the user's Google Calendar + + Args: + subject (str): The subject of the calendar item + start_time (str): The start time of the calendar item + end_time (str): The end time of the calendar item + location (str): The location of the calendar item + attendees (List[str]): A list of email addresses of attendees + + Returns: + str: The result of adding the calendar item + """ try: service = build("calendar", "v3", credentials=self.creds) @@ -438,6 +545,15 @@ async def add_calendar_item( return "Failed to add calendar item." async def remove_calendar_item(self, item_id): + """ + Remove a calendar item from the user's Google Calendar + + Args: + item_id (str): The ID of the calendar item to remove + + Returns: + str: The result of removing the calendar item + """ try: service = build("calendar", "v3", credentials=self.creds) service.events().delete(calendarId="primary", eventId=item_id).execute() @@ -449,6 +565,16 @@ async def remove_calendar_item(self, item_id): async def google_official_search( self, query: str, num_results: int = 8 ) -> Union[str, List[str]]: + """ + Perform a Google search using the official Google API + + Args: + query (str): The search query + num_results (int): The number of search results to retrieve + + Returns: + Union[str, List[str]]: The search results + """ try: service = build("customsearch", "v1", developerKey=self.GOOGLE_API_KEY) result = ( diff --git a/agixt/extensions/microsoft365.py b/agixt/extensions/microsoft365.py index b96d4a355564..d7e8514ba847 100644 --- a/agixt/extensions/microsoft365.py +++ b/agixt/extensions/microsoft365.py @@ -62,6 +62,17 @@ def authenticate(self): return None async def get_emails(self, folder_name="Inbox", max_emails=10, page_size=10): + """ + Get emails from the specified folder in the Microsoft 365 email account + + Args: + folder_name (str): The name of the folder to retrieve emails from + max_emails (int): The maximum number of emails to retrieve + page_size (int): The number of emails to retrieve per page + + Returns: + list: A list of dictionaries containing email date + """ try: mailbox = self.account.mailbox() folder = mailbox.get_folder(folder_name=folder_name) @@ -90,6 +101,19 @@ async def get_emails(self, folder_name="Inbox", max_emails=10, page_size=10): async def send_email( self, recipient, subject, body, attachments=None, priority=None ): + """ + Send an email using the Microsoft 365 email account + + Args: + recipient (str): The email address of the recipient + subject (str): The subject of the email + body (str): The body of the email + attachments (list): A list of file paths to attach to the email + priority (str): The priority of the email (e.g. "normal", "high", "low") + + Returns: + str: The result of sending the email + """ try: mailbox = self.account.mailbox() message = mailbox.new_message() @@ -120,6 +144,19 @@ async def move_email_to_folder(self, message_id, destination_folder): async def create_draft_email( self, recipient, subject, body, attachments=None, priority=None ): + """ + Create a draft email in the Microsoft 365 email account + + Args: + recipient (str): The email address of the recipient + subject (str): The subject of the email + body (str): The body of the email + attachments (list): A list of file paths to attach to the email + priority (str): The priority of the email (e.g. "normal", "high", "low") + + Returns: + str: The result of creating the draft email + """ try: mailbox = self.account.mailbox() draft = mailbox.new_message() @@ -138,6 +175,15 @@ async def create_draft_email( return "Failed to create draft email." async def delete_email(self, message_id): + """ + Delete an email from the Microsoft 365 email account + + Args: + message_id (str): The ID of the email message to delete + + Returns: + str: The result of deleting the email + """ try: mailbox = self.account.mailbox() message = mailbox.get_message(object_id=message_id) @@ -150,6 +196,18 @@ async def delete_email(self, message_id): async def search_emails( self, query, folder_name="Inbox", max_emails=10, date_range=None ): + """ + Search for emails in the Microsoft 365 email account + + Args: + query (str): The search query to use + folder_name (str): The name of the folder to search in + max_emails (int): The maximum number of emails to retrieve + date_range (tuple): A tuple containing the start and end dates for the search + + Returns: + list: A list of dictionaries containing email data + """ try: mailbox = self.account.mailbox() folder = mailbox.get_folder(folder_name=folder_name) @@ -178,6 +236,17 @@ async def search_emails( return [] async def reply_to_email(self, message_id, body, attachments=None): + """ + Reply to an email in the Microsoft 365 email account + + Args: + message_id (str): The ID of the email message to reply to + body (str): The body of the reply email + attachments (list): A list of file paths to attach to the reply email + + Returns: + str: The result of sending the reply email + """ try: mailbox = self.account.mailbox() message = mailbox.get_message(object_id=message_id) @@ -193,6 +262,15 @@ async def reply_to_email(self, message_id, body, attachments=None): return "Failed to send reply." async def process_attachments(self, message_id): + """ + Process attachments from an email in the Microsoft 365 email account + + Args: + message_id (str): The ID of the email message to process attachments from + + Returns: + list: A list of file paths to the saved attachments + """ try: mailbox = self.account.mailbox() message = mailbox.get_message(object_id=message_id) @@ -209,6 +287,18 @@ async def process_attachments(self, message_id): return [] async def get_calendar_items(self, start_date=None, end_date=None, max_items=10): + """ + Get calendar items from the Microsoft 365 calendar account + + Args: + start_date (datetime): The start date for the calendar items + end_date (datetime): The end date for the calendar items + max_items (int): The maximum number of items to retrieve + + Returns: + list: A list of dictionaries containing calendar item data + """ + try: schedule = self.account.schedule() calendar = schedule.get_default_calendar() @@ -243,6 +333,20 @@ async def get_calendar_items(self, start_date=None, end_date=None, max_items=10) async def add_calendar_item( self, subject, start_time, end_time, location, attendees=None, body=None ): + """ + Add a calendar item to the Microsoft 365 calendar account + + Args: + subject (str): The subject of the calendar item + start_time (datetime): The start time of the calendar item + end_time (datetime): The end time of the calendar item + location (str): The location of the calendar item + attendees (list): A list of email addresses of attendees + body (str): The body of the calendar item + + Returns: + str: The result of adding the calendar item + """ try: schedule = self.account.schedule() calendar = schedule.get_default_calendar() @@ -268,6 +372,15 @@ async def add_calendar_item( return "Failed to add calendar item." async def remove_calendar_item(self, item_id): + """ + Remove a calendar item from the Microsoft 365 calendar account + + Args: + item_id (str): The ID of the calendar item to remove + + Returns: + str: The result of removing the calendar item + """ try: schedule = self.account.schedule() calendar = schedule.get_default_calendar() diff --git a/agixt/extensions/mysql_database.py b/agixt/extensions/mysql_database.py index 57982e4ddfc1..50d9fbba069a 100644 --- a/agixt/extensions/mysql_database.py +++ b/agixt/extensions/mysql_database.py @@ -40,6 +40,15 @@ def get_connection(self): return None async def execute_sql(self, query: str): + """ + Execute a custom SQL query in the MySQL database + + Args: + query (str): The SQL query to execute + + Returns: + str: The result of the SQL query + """ if "```sql" in query: query = query.split("```sql")[1].split("```")[0] logging.info(f"Executing SQL Query: {query}") @@ -88,6 +97,12 @@ async def execute_sql(self, query: str): return await self.execute_sql(query=new_query) async def get_schema(self): + """ + Get the schema of the MySQL database + + Returns: + str: The schema of the MySQL database + """ logging.info(f"Getting schema for database '{self.MYSQL_DATABASE_NAME}'") connection = self.get_connection() cursor = connection.cursor() diff --git a/agixt/extensions/postgres_database.py b/agixt/extensions/postgres_database.py index 0a4abdd69d14..4c4ec687fa8d 100644 --- a/agixt/extensions/postgres_database.py +++ b/agixt/extensions/postgres_database.py @@ -51,6 +51,15 @@ def get_connection(self): return None async def execute_sql(self, query: str): + """ + Execute a custom SQL query in the Postgres database + + Args: + query (str): The SQL query to execute + + Returns: + str: The result of the SQL query + """ if "```sql" in query: query = query.split("```sql")[1].split("```")[0] query = query.replace("\n", " ") @@ -101,6 +110,13 @@ async def execute_sql(self, query: str): return await self.execute_sql(query=new_query) async def get_schema(self): + """ + Get the schema of the Postgres database + + Returns: + str: The schema of the Postgres database + """ + logging.info(f"Getting schema for database '{self.POSTGRES_DATABASE_NAME}'") connection = self.get_connection() cursor = connection.cursor(cursor_factory=psycopg2.extras.DictCursor) diff --git a/agixt/extensions/searxng.py b/agixt/extensions/searxng.py index b7f9fa04c7a1..d80a2fe68603 100644 --- a/agixt/extensions/searxng.py +++ b/agixt/extensions/searxng.py @@ -26,6 +26,15 @@ def get_server(self): return endpoint async def search(self, query: str) -> List[str]: + """ + Search using the SearXNG search engine + + Args: + query (str): The query to search for + + Returns: + List[str]: A list of search results + """ try: response = requests.get( self.SEARXNG_ENDPOINT, diff --git a/agixt/extensions/sendgrid_email.py b/agixt/extensions/sendgrid_email.py index f9e1b387efa0..d3d76826d0fd 100644 --- a/agixt/extensions/sendgrid_email.py +++ b/agixt/extensions/sendgrid_email.py @@ -19,7 +19,18 @@ def __init__(self, SENDGRID_API_KEY: str = "", SENDGRID_EMAIL: str = "", **kwarg if self.SENDGRID_API_KEY: self.commands = {"Send Email with Sendgrid": self.send_email} - async def send_email(self, to_email: str, subject: str, content: str) -> List[str]: + async def send_email(self, to_email: str, subject: str, content: str): + """ + Send an email using SendGrid + + Args: + to_email (str): The email address to send the email to + subject (str): The subject of the email + content (str): The content of the email + + Returns: + str: The result of sending the email + """ message = Mail( from_email=self.SENDGRID_EMAIL, to_emails=to_email, @@ -30,6 +41,6 @@ async def send_email(self, to_email: str, subject: str, content: str) -> List[st try: sg = SendGridAPIClient(self.SENDGRID_API_KEY) response = sg.send(message) - return [f"Email sent successfully. Status code: {response.status_code}"] + return f"Email to {to_email} sent successfully!\n\nThe subject of the email was: {subject}. The content of the email was:\n\n{content}" except Exception as e: - return [f"Error sending email: {e}"] + return f"Error sending email: {e}" diff --git a/agixt/extensions/sqlite_database.py b/agixt/extensions/sqlite_database.py index 264c4ef9573e..b28b8f2a145e 100644 --- a/agixt/extensions/sqlite_database.py +++ b/agixt/extensions/sqlite_database.py @@ -34,6 +34,15 @@ def get_connection(self): return None async def execute_sql(self, query: str): + """ + Execute a custom SQL query in the SQLite database + + Args: + query (str): The SQL query to execute + + Returns: + str: The result of the SQL query + """ if "```sql" in query: query = query.split("```sql")[1].split("```")[0] query = query.replace("\n", " ") @@ -83,6 +92,13 @@ async def execute_sql(self, query: str): return await self.execute_sql(query=new_query) async def get_schema(self): + """ + Get the schema of the SQLite database + + Returns: + str: The schema of the SQLite database + """ + logging.info(f"Getting schema for database '{self.SQLITE_DATABASE_PATH}'") connection = self.get_connection() cursor = connection.cursor() diff --git a/agixt/extensions/times.py b/agixt/extensions/times.py index e808a1bc2130..da4ad86c1622 100644 --- a/agixt/extensions/times.py +++ b/agixt/extensions/times.py @@ -7,4 +7,10 @@ def __init__(self, **kwargs): self.commands = {"Get Datetime": self.get_datetime} async def get_datetime(self) -> str: + """ + Get the current date and time + + Returns: + str: The current date and time in the format "YYYY-MM-DD HH:MM:SS" + """ return "Current date and time: " + datetime.now().strftime("%Y-%m-%d %H:%M:%S") diff --git a/agixt/extensions/web_playwright.py b/agixt/extensions/web_playwright.py index 778fd09b1045..3df0011e532b 100644 --- a/agixt/extensions/web_playwright.py +++ b/agixt/extensions/web_playwright.py @@ -34,6 +34,15 @@ def __init__(self, **kwargs): } async def scrape_text_with_playwright(self, url: str) -> str: + """ + Scrape the text content of a webpage using Playwright + + Args: + url (str): The URL of the webpage to scrape + + Returns: + str: The text content of the webpage + """ try: async with async_playwright() as p: browser = await p.chromium.launch() @@ -57,6 +66,15 @@ async def scrape_text_with_playwright(self, url: str) -> str: return text async def scrape_links_with_playwright(self, url: str) -> Union[str, List[str]]: + """ + Scrape the hyperlinks of a webpage using Playwright + + Args: + url (str): The URL of the webpage to scrape + + Returns: + Union[str, List[str]]: The hyperlinks of the webpage + """ try: async with async_playwright() as p: browser = await p.chromium.launch() @@ -81,6 +99,16 @@ async def scrape_links_with_playwright(self, url: str) -> Union[str, List[str]]: return formatted_links async def take_screenshot_with_playwright(self, url: str, path: str): + """ + Take a screenshot of a webpage using Playwright + + Args: + url (str): The URL of the webpage to take a screenshot of + path (str): The path to save the screenshot + + Returns: + str: The result of taking the screenshot + """ try: async with async_playwright() as p: browser = await p.chromium.launch()