gofannon 0.1.0__py3-none-any.whl

gofannon/config.py

@@ -0,0 +1,58 @@
+import os
+from dotenv import load_dotenv
+import logging
+
+
+class ToolConfig:
+    _instance = None
+
+    def __init__(self):
+        load_dotenv()
+        self.config = {
+            'github_api_key': os.getenv('GITHUB_API_KEY'),
+            'deepinfra_api_key': os.getenv('DEEPINFRA_API_KEY'),
+            'arxiv_api_key': os.getenv('ARXIV_API_KEY')
+        }
+
+    @classmethod
+    def get(cls, key):
+        if not cls._instance:
+            cls._instance = ToolConfig()
+        return cls._instance.config.get(key)
+
+class FunctionRegistry:
+    _tools = {}
+
+    @classmethod
+    def register(cls, tool_class):
+        cls._tools[tool_class().definition['function']['name']] = tool_class
+        return tool_class
+
+    @classmethod
+    def get_tools(cls):
+        return [cls._tools[name]().definition for name in cls._tools]
+
+def setup_logging():
+    """Configure logging for the gofannon package."""
+    logger = logging.getLogger('')
+    log_level = os.getenv('GOFANNON_LOG_LEVEL', 'WARNING').upper()
+    level = getattr(logging, log_level, logging.WARNING)
+
+    # Clear existing handlers if any
+    if logger.handlers:
+        for handler in logger.handlers:
+            logger.removeHandler(handler)
+
+            # Configure new handler
+    handler = logging.StreamHandler()
+    formatter = logging.Formatter(
+        '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+    )
+    handler.setFormatter(formatter)
+    logger.addHandler(handler)
+
+    logger.setLevel(level)
+    logger.propagate = False
+
+# Initialize logging when config is imported
+setup_logging()

gofannon/github/__init__.py

@@ -0,0 +1,11 @@
+
+from.create_issue import CreateIssue
+from.get_repo_contents import GetRepoContents
+from.commit_file import CommitFile
+from.commit_files import CommitFiles
+from.search import SearchRepos
+from .read_issue import ReadIssue
+
+
+
+

gofannon/github/commit_file.py

@@ -0,0 +1,77 @@
+
+import requests
+import json
+
+from..base import BaseTool
+from ..config import FunctionRegistry
+import logging
+
+logger = logging.getLogger(__name__)
+
+@FunctionRegistry.register
+class CommitFile(BaseTool):
+    def __init__(self,
+                 api_key=None,
+                 name="commit_file",):
+        super().__init__()
+        self.api_key = api_key
+        self.name = name
+        self.API_SERVICE = 'github'
+
+    @property
+    def definition(self):
+        return {
+            "type": "function",
+            "function": {
+                "name": self.name,
+                "description": "Commit a file to a GitHub repository",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "repo_url": {
+                            "type": "string",
+                            "description": "The URL of the repository, e.g. https://github.com/The-AI-Alliance//gofannon"
+                        },
+                        "file_path": {
+                            "type": "string",
+                            "description": "The path of the file in the repository, e.g. example.txt"
+                        },
+                        "file_contents": {
+                            "type": "string",
+                            "description": "The contents of the file as a string"
+                        },
+                        "commit_message": {
+                            "type": "string",
+                            "description": "The commit message, e.g. 'Added example.txt'"
+                        }
+                    },
+                    "required": ["repo_url", "file_path", "file_contents", "commit_message"]
+                }
+            }
+        }
+
+    def fn(self, repo_url,
+           file_path,
+           file_contents,
+           commit_message)-> str:
+        logger.debug(f"Committing file {file_path} to {repo_url}")
+        # Extracting the owner and repo name from the URL
+        repo_parts = repo_url.rstrip('/').split('/')
+        owner = repo_parts[-2]
+        repo = repo_parts[-1]
+
+        api_url = f"https://api.github.com/repos/{owner}/{repo}/contents/{file_path}"
+        headers = {
+            'Authorization': f'token {self.api_key}',
+            'Content-Type': 'application/json'
+        }
+
+        data = {
+            "message": commit_message,
+            "content": file_contents
+        }
+
+        response = requests.put(api_url, headers=headers, data=json.dumps(data))
+        response.raise_for_status()
+
+        return response.json()

gofannon/github/commit_files.py

@@ -0,0 +1,116 @@
+import os
+
+import requests
+import json
+import git
+from pathlib import Path
+
+from..base import BaseTool
+from ..config import FunctionRegistry
+import logging
+
+logger = logging.getLogger(__name__)
+
+@FunctionRegistry.register
+class CommitFiles(BaseTool):
+    def __init__(self,
+                 api_key=None,
+                 name="commit_files",
+                 git_user_name=None,
+                 git_user_email=None):
+        super().__init__()
+        self.api_key = api_key
+        self.name = name
+        self.git_user_name = git_user_name
+        self.git_user_email = git_user_email
+        self.API_SERVICE = 'github'
+
+
+    @property
+    def definition(self):
+        return {
+            "type": "function",
+            "function": {
+                "name": self.name,
+                "description": "Commit multiple files to a GitHub repository",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "repo_url": {
+                            "type": "string",
+                            "description": "The URL of the repository, e.g. https://github.com/The-AI-Alliance//gofannon"
+                        },
+                        "branch": {
+                            "type": "string",
+                            "description": "The branch to commit to, e.g. 'main' or 'new-branch'"
+                        },
+                        "commit_msg": {
+                            "type": "string",
+                            "description": "The commit message, e.g. 'Added new files'"
+                        },
+                        "files_json": {
+                            "type": "string",
+                            "description": "A JSON string containing a list of files to commit, e.g. '{\"files\": [{\"path\": \"file1.py\", \"code\": \"import os\"}, {\"path\": \"file2.py\", \"code\": \"import sys\"}]}'"
+                        },
+                        "base_branch": {
+                            "type": "string",
+                            "description": "Optional. The base branch to create the new branch from. Default: 'main'"
+                        }
+                    },
+                    "required": ["repo_url", "branch", "commit_msg", "files_json"]
+                }
+            }
+        }
+
+    def fn(self, repo_url, branch, commit_msg, files_json, base_branch='main'):
+        logger.debug(f"Committing files to {repo_url}")
+        # Extracting the owner and repo name from the URL
+        repo_parts = repo_url.rstrip('/').split('/')
+        owner = repo_parts[-2]
+        repo = repo_parts[-1]
+
+        if repo_url.startswith("https://"):
+            repo_url = repo_url.replace("https://", "https://"+ self.api_key+"@")
+        elif repo_url.startswith("github.com"):
+            repo_url = f"https://{self.api_key}@{repo_url}"
+        # Clone the repository
+        repo_dir = f"/tmp/{repo}"
+
+
+        if os.path.exists(repo_dir):
+            repo = git.Repo(repo_dir)
+        else:
+            repo = git.Repo.clone_from(repo_url, repo_dir)
+        repo.config_writer().set_value("user", "name", self.git_user_name).release()
+        repo.config_writer().set_value("user", "email", self.git_user_email).release()
+
+        # Check if the branch exists
+        if branch in repo.heads:
+            # If it does, checkout the branch and pull the latest changes
+            repo.git.checkout(branch)
+            repo.git.pull()
+        else:
+            # If it does not exist, checkout the base branch and create a new branch
+            try:
+                repo.git.checkout(base_branch)
+            except git.exc.GitCommandError:
+                # If the base branch does not exist, raise an error
+                raise ValueError(f"Base branch '{base_branch}' does not exist.")
+            repo.git.checkout('-b', branch)
+
+        # Load the JSON string
+        files = json.loads(files_json)['files']
+        # Update or create the files
+        for file in files:
+            file_path = file['path']
+            code = file['code']
+            with open(f"{repo_dir}/{file_path}", 'w') as f:
+                f.write(code)
+            repo.index.add(Path(file_path))
+
+        # Commit the files
+        repo.index.commit(commit_msg)
+
+        origin = repo.remotes.origin
+        origin.push(branch)
+        return "Files committed and pushed successfully"

gofannon/github/create_issue.py

@@ -0,0 +1,78 @@
+from requests import post
+from json import dumps
+from..base import BaseTool
+from ..config import FunctionRegistry
+import logging
+
+logger = logging.getLogger(__name__)
+
+@FunctionRegistry.register
+class CreateIssue(BaseTool):
+    def __init__(self,
+                 api_key=None,
+                 name="create_issue"):
+        super().__init__()
+        self.api_key = api_key
+        self.name = name
+        self.API_SERVICE = 'github'
+
+    @property
+    def definition(self):
+        return {
+            "type": "function",
+            "function": {
+                "name": self.name,
+                "description": "Create an issue in a GitHub repository",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "repo_url": {
+                            "type": "string",
+                            "description": "The URL of the repository, e.g. https://github.com/The-AI-Alliance//gofannon"
+                        },
+                        "title": {
+                            "type": "string",
+                            "description": "The title of the issue"
+                        },
+                        "body": {
+                            "type": "string",
+                            "description": "The body of the issue"
+                        },
+                        "labels": {
+                            "type": "array",
+                            "items": {
+                                "type": "string"
+                            },
+                            "description": "An array of labels for the issue"
+                        }
+                    },
+                    "required": ["repo_url", "title", "body"]
+                }
+            }
+        }
+
+    def fn(self, repo_url, title, body, labels=None):
+        logger.debug(f"Crating issue'{title}' in repo {repo_url}")
+        # Extracting the owner and repo name from the URL
+        repo_parts = repo_url.rstrip('/').split('/')
+        owner = repo_parts[-2]
+        repo = repo_parts[-1]
+
+        api_url = f"https://api.github.com/repos/{owner}/{repo}/issues"
+        headers = {
+            'Authorization': f'token {self.api_key}',
+            'Content-Type': 'application/json'
+        }
+
+        payload = {
+            "title": title,
+            "body": body
+        }
+
+        if labels:
+            payload["labels"] = labels
+
+        response = post(api_url, headers=headers, json=payload)
+        response.raise_for_status()
+
+        return dumps(response.json())

gofannon/github/get_repo_contents.py

@@ -0,0 +1,98 @@
+import requests
+from ..base import BaseTool
+from ..config import FunctionRegistry
+import logging
+
+logger = logging.getLogger(__name__)
+
+@FunctionRegistry.register
+class GetRepoContents(BaseTool):
+
+    def __init__(self,
+                 api_key=None,
+                 name="get_repo_contents",):
+        super().__init__()
+        self.api_key = api_key
+        self.name = name
+        self.API_SERVICE = 'github'
+        self.eoi = {'js' : 'javascript',
+                    'jsx' : 'javascript',
+                    'ts' : 'typescript',
+                    'tsx' : 'typescript',
+                    'py' : 'python',
+                    'html' : 'html',
+                    'css' : 'css',
+                    'scss' : 'scss',
+                    'sass' : 'sass',
+                    'md' : 'markdown',
+                    'json' : 'json'}
+
+    @property
+    def definition(self):
+        return {
+            "type": "function",
+            "function": {
+                "name": self.name,
+                "description": "Get contents of repo on github",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "repo_url": {
+                            "type": "string",
+                            "description":
+                                "The URL of the Repo this is for reading an entire repo, not individual files., e.g. https://github.com/The-AI-Alliance//gofannon"
+                        },
+                        "directory_path": {
+                            "type": "string",
+                            "description": "Path from repository root of the directory of interest. Default '/'"
+                        },
+                        # "eoi": {
+                        #     "type": "dictionary",
+                        #     "description": "Extensions of interest. If not set, defaults to self.eoi (which contains common Python, Javascript, HTML, and Markdown extension). Example: `{'.js': 'javascript'}`",
+                        # }
+                    },
+                    "required": ["repo_url"]
+                }
+            }
+        }
+
+    def fn(self, repo_url,
+           directory_path = "/",
+           eoi = None)-> str:
+        logger.debug(f"Getting contents of repo {repo_url}")
+        if eoi is None:
+            eoi = self.eoi
+        # Extracting the owner and repo name from the URL
+        repo_parts = repo_url.rstrip('/').split('/')
+        owner = repo_parts[-2]
+        repo = repo_parts[-1]
+
+        api_url = f"https://api.github.com/repos/{owner}/{repo}/contents/{directory_path}"
+        headers = {
+            'Authorization': f'token {self.api_key}'
+        }
+
+        response = requests.get(api_url, headers=headers)
+        response.raise_for_status()
+
+        contents = response.json()
+
+        result = []
+
+        for item in contents:
+            if item['type'] == 'file':
+                file_response = requests.get(item['download_url'], headers=headers)
+                extension = item['name'].split('.')[-1]
+                if extension in eoi:
+                    language = eoi[extension]
+                else:
+                    continue
+                file_response.raise_for_status()
+                file_content = file_response.text
+                result.append(f"{item['path']}\n```{language}\n{file_content}\n```")
+            elif item['type'] == 'dir':
+                # Recursively go through subdirectories
+                subdirectory_contents = self.fn(repo_url, item['path'], eoi)
+                result.append(subdirectory_contents)
+
+        return "\n\n".join(result)

gofannon/github/read_issue.py

@@ -0,0 +1,70 @@
+
+from..base import BaseTool
+import requests
+import json
+from ..config import FunctionRegistry
+import logging
+
+logger = logging.getLogger(__name__)
+
+@FunctionRegistry.register
+class ReadIssue(BaseTool):
+    def __init__(self, api_key=None, name="read_issue"):
+        super().__init__()
+        self.api_key = api_key
+        self.name = name
+        self.API_SERVICE = 'github'
+
+    @property
+    def definition(self):
+        return {
+            "type": "function",
+            "function": {
+                "name": self.name,
+                "description": "Read an issue and its comments from a GitHub repository",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "repo_url": {
+                            "type": "string",
+                            "description": "The URL of the repository, e.g. https://github.com/The-AI-Alliance//gofannon"
+                        },
+                        "issue_number": {
+                            "type": "integer",
+                            "description": "The number of the issue to read"
+                        }
+                    },
+                    "required": ["repo_url", "issue_number"]
+                }
+            }
+        }
+
+    def fn(self, repo_url, issue_number):
+        logger.debug(f"Reading issue number {issue_number} from repo {repo_url}")
+        # Extracting the owner and repo name from the URL
+        repo_parts = repo_url.rstrip('/').split('/')
+        owner = repo_parts[-2]
+        repo = repo_parts[-1]
+
+        issue_url = f"https://api.github.com/repos/{owner}/{repo}/issues/{issue_number}"
+        comment_url = f"https://api.github.com/repos/{owner}/{repo}/issues/{issue_number}/comments"
+
+        headers = {
+            'Authorization': f'token {self.api_key}'
+        }
+
+        issue_response = requests.get(issue_url, headers=headers)
+        issue_response.raise_for_status()
+
+        comment_response = requests.get(comment_url, headers=headers)
+        comment_response.raise_for_status()
+
+        issue_data = issue_response.json()
+        comment_data = comment_response.json()
+
+        result = {
+            "issue": issue_data,
+            "comments": comment_data
+        }
+
+        return json.dumps(result, indent=4)  

gofannon/github/search.py

@@ -0,0 +1,67 @@
+from..base import BaseTool
+import requests
+from ..config import FunctionRegistry
+import logging
+
+logger = logging.getLogger(__name__)
+
+@FunctionRegistry.register
+class SearchRepos(BaseTool):
+    def __init__(self,
+                 api_key=None,
+                 name="search_repos",):
+        super().__init__()
+        self.api_key = api_key
+        self.name = name
+        self.API_SERVICE = 'github'
+
+    @property
+    def definition(self):
+        return {
+            "type": "function",
+            "function": {
+                "name": self.name,
+                "description": "Search for GitHub repositories",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "query": {
+                            "type": "string",
+                            "description": "The search query, e.g. 'machine learning'"
+                        },
+                        "page": {
+                            "type": "integer",
+                            "description": "The page number to retrieve (default: 1)"
+                        },
+                        "per_page": {
+                            "type": "integer",
+                            "description": "The number of results per page (default: 10)"
+                        }
+                    },
+                    "required": ["query"]
+                }
+            }
+        }
+
+    def fn(self, query, page=1, per_page=10) -> str:
+        logger.debug(f"Searching github.com for '{query}'")
+        api_url = f"https://api.github.com/search/repositories"
+        headers = {
+            'Authorization': f'token {self.api_key}'
+        }
+        params = {
+            "q": query,
+            "page": page,
+            "per_page": per_page
+        }
+
+        response = requests.get(api_url, headers=headers, params=params)
+        response.raise_for_status()
+
+        results = response.json()
+
+        formatted_results = []
+        for result in results['items']:
+            formatted_results.append(f"**{result['name']}** by **{result['owner']['login']}** - {result['description']}")
+
+        return "\n\n".join(formatted_results)  

gofannon/nhsta/__init__.py

@@ -0,0 +1,59 @@
+from requests import get
+from json import dumps
+
+from ..base import BaseTool
+from ..config import FunctionRegistry
+import logging
+
+logger = logging.getLogger(__name__)
+
+@FunctionRegistry.register
+class ComplaintsByVehicle(BaseTool):
+    def __init__(self,
+                 api_key=None,
+                 name="complaints_by_vehicle",):
+        super().__init__()
+        self.api_key = api_key
+        self.name = name
+        self.API_SERVICE = 'nhtsa'
+
+    @property
+    def definition(self):
+        return {
+            "type": "function",
+            "function": {
+                "name": self.name,
+                "description": "Get complaints by vehicle make, model, and year",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "make": {
+                            "type": "string",
+                            "description": "The make of the vehicle, e.g. Acura"
+                        },
+                        "model": {
+                            "type": "string",
+                            "description": "The model of the vehicle, e.g. ILX"
+                        },
+                        "modelYear": {
+                            "type": "string",
+                            "description": "The year of the vehicle, e.g. 2022"
+                        }
+                    },
+                    "required": ["make", "model", "modelYear"]
+                }
+            }
+        }
+
+    def fn(self, make,
+                 model,
+                 modelYear)-> str:
+        logger.debug(f"Searching for complaints related to {modelYear} {make} {model}")
+        base_url = "https://api.nhtsa.gov/complaints/complaintsByVehicle"
+        payload = {
+            "make": make,
+            "model": model,
+            "modelYear": modelYear
+        }
+        r = get(base_url, params=payload)
+        return dumps(r.json())