gofannon 0.1.0__py3-none-any.whl → 0.25.11__py3-none-any.whl

gofannon/base/langchain.py

@@ -0,0 +1,85 @@
+from typing import Type, Callable
+
+try:
+    from langchain.tools import BaseTool as LangchainBaseTool
+    from langchain.pydantic_v1 import BaseModel, Field
+
+    _HAS_LANGCHAIN = True
+except ImportError:
+    _HAS_LANGCHAIN = False
+
+
+class LangchainMixin:
+    def import_from_langchain(self, langchain_tool):
+        if not _HAS_LANGCHAIN:
+            raise RuntimeError(
+                "langchain is not installed. Install with `pip install langchain-core`"
+            )
+
+        self.name = getattr(langchain_tool, "name", "exported_langchain_tool")
+        self.description = getattr(
+            langchain_tool, "description", "No description provided."
+        )
+
+        maybe_args_schema = getattr(langchain_tool, "args_schema", None)
+        if (
+            maybe_args_schema
+            and hasattr(maybe_args_schema, "schema")
+            and callable(maybe_args_schema.schema)
+        ):
+            args_schema = maybe_args_schema.schema()
+        else:
+            args_schema = {}
+
+        self._parameters = args_schema.get("properties", {})
+        self._required = args_schema.get("required", [])
+
+        def adapted_fn(*args, **kwargs):
+            return langchain_tool._run(*args, **kwargs)
+
+        self.fn = adapted_fn
+
+    def export_to_langchain(self):
+        if not _HAS_LANGCHAIN:
+            raise RuntimeError(
+                "langchain is not installed. Install with `pip install langchain-core`"
+            )
+
+        from pydantic import create_model
+
+        type_map = {
+            "number": float,
+            "string": str,
+            "integer": int,
+            "boolean": bool,
+            "object": dict,
+            "array": list,
+        }
+
+        parameters = self.definition.get("function", {}).get("parameters", {})
+        param_properties = parameters.get("properties", {})
+
+        fields = {}
+        for param_name, param_def in param_properties.items():
+            param_type = param_def.get("type", "string")
+            description = param_def.get("description", "")
+            fields[param_name] = (
+                type_map.get(param_type, str),
+                Field(..., description=description),
+            )
+
+        ArgsSchema = create_model("ArgsSchema", **fields)
+
+        class ExportedTool(LangchainBaseTool):
+            name: str = self.definition.get("function", {}).get("name", "")
+            description: str = self.definition.get("function", {}).get(
+                "description", ""
+            )
+            args_schema: Type[BaseModel] = ArgsSchema
+            fn: Callable = self.fn
+
+            def _run(self, *args, **kwargs):
+                return self.fn(*args, **kwargs)
+
+        tool = ExportedTool()
+        return tool

gofannon/base/smol_agents.py

@@ -0,0 +1,51 @@
+try:
+    from smolagents.tools import Tool as SmolTool
+    from smolagents.tools import tool as smol_tool_decorator
+
+    _HAS_SMOLAGENTS = True
+except ImportError:
+    _HAS_SMOLAGENTS = False
+
+
+class SmolAgentsMixin:
+    def import_from_smolagents(self, smol_tool):
+        if not _HAS_SMOLAGENTS:
+            raise RuntimeError(
+                "smolagents is not installed or could not be imported. "
+                "Install it or check your environment."
+            )
+        self.name = smol_tool.name[0]
+        self.description = smol_tool.description
+
+        def adapted_fn(*args, **kwargs):
+            return smol_tool.forward(*args, **kwargs)
+
+        self.fn = adapted_fn
+
+    def export_to_smolagents(self):
+        if not _HAS_SMOLAGENTS:
+            raise RuntimeError(
+                "smolagents is not installed or could not be imported. "
+                "Install it or check your environment."
+            )
+
+        def smol_forward(*args, **kwargs):
+            return self.fn(*args, **kwargs)
+
+        inputs_definition = {
+            "example_arg": {
+                "type": "string",
+                "description": "Example argument recognized by this tool",
+            }
+        }
+        output_type = "string"
+
+        exported_tool = SmolTool()
+        exported_tool.name = getattr(self, "name", "exported_base_tool")
+        exported_tool.description = getattr(self, "description", "Exported from Tool")
+        exported_tool.inputs = inputs_definition
+        exported_tool.output_type = output_type
+        exported_tool.forward = smol_forward
+        exported_tool.is_initialized = True
+
+        return exported_tool

gofannon/basic_math/__init__.py

@@ -1,5 +1 @@
-from.exponents import Exponents
-from.multiplication import Multiplication
-from.division import Division
-from.addition import Addition
-from.subtraction import Subtraction
+

gofannon/config.py

@@ -11,7 +11,9 @@ class ToolConfig:
         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')
+            'arxiv_api_key': os.getenv('ARXIV_API_KEY'),
+            'google_search_api_key': os.getenv('GOOGLE_SEARCH_API_KEY'),
+            'google_search_engine_id': os.getenv('GOOGLE_SEARCH_ENGINE_ID')
         }
 
     @classmethod

gofannon/github/__init__.py

@@ -1,11 +1,4 @@
 
-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/pr_review_tool.py

@@ -0,0 +1,104 @@
+import os
+import json
+import logging
+import importlib.util
+from github import Github
+from openai import OpenAI
+from gofannon.config import FunctionRegistry
+from gofannon.base import BaseTool
+
+logger = logging.getLogger(__name__)
+
+def load_review_checks():
+    """
+    Dynamically load the review checks module from a configurable file.
+    The path is specified via the environment variable PR_REVIEW_CHECKS_PATH.
+    If not defined, it defaults to ".github/scripts/pr_review_checks.py".
+    Returns a list of check classes (having names ending with 'Check').
+    """
+    checks_path = os.getenv("PR_REVIEW_CHECKS_PATH", ".github/scripts/pr_review_checks.py")
+    spec = importlib.util.spec_from_file_location("pr_review_checks", checks_path)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    # Collect all classes in the module with names ending in 'Check'
+    checks = [cls for name, cls in module.__dict__.items() if name.endswith("Check") and isinstance(cls, type)]
+    return checks
+
+@FunctionRegistry.register
+class PRReviewTool(BaseTool):
+    def __init__(self, name="pr_review_tool"):
+        super().__init__()
+        self.name = name
+        self.api_key = os.getenv("OPENAI_API_KEY")
+        self.base_url = os.getenv("OPENAI_BASE_URL")
+        self.model_name = os.getenv("OPENAI_MODEL_NAME")
+        self.client = OpenAI(api_key=self.api_key, base_url=self.base_url)
+
+    @property
+    def definition(self):
+        return {
+            "type": "function",
+            "function": {
+                "name": self.name,
+                "description": "Perform an automated pull request review using gofannon tools. "
+                               "It aggregates configurable checks (e.g. code quality and schema validation).",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "pr_number": {
+                            "type": "integer",
+                            "description": "The pull request number."
+                        },
+                        "repo_name": {
+                            "type": "string",
+                            "description": "The repository name in the format owner/repo."
+                        }
+                    },
+                    "required": ["pr_number", "repo_name"]
+                }
+            }
+        }
+
+    def fn(self, pr_number, repo_name):
+        # Connect to GitHub and get pull request details.
+        g = Github(os.getenv("GITHUB_TOKEN"))
+        repo = g.get_repo(repo_name)
+        pr = repo.get_pull(pr_number)
+        all_comments = []
+        check_results = {}
+
+        # Load review check classes dynamically.
+        check_classes = load_review_checks()
+        checks = [check_class(self.client, self.model_name) for check_class in check_classes]
+
+        for check in checks:
+            check_name = check.__class__.__name__
+            check_results[check_name] = []
+            if hasattr(check, 'process_pr_file'):
+                for file in pr.get_files():
+                    file_comments, analyzed = check.process_pr_file(file, repo, pr)
+                    if analyzed:
+                        for comment in file_comments:
+                            comment['check_name'] = check_name
+                            all_comments.append(comment)
+                            check_results[check_name].append(comment)
+            if hasattr(check, 'process_pr'):
+                pr_comments, _ = check.process_pr(pr)
+                for comment in pr_comments:
+                    comment['check_name'] = check_name
+                    all_comments.append(comment)
+                    check_results[check_name].append(comment)
+
+        summary = "## 🤖 Automated PR Review Summary 🤖\n\n"
+        for check_name, comments in check_results.items():
+            summary += f"### 🤖 {check_name} 🤖\n\n"
+            for comment in comments:
+                body = comment.get("body", "")
+                file_path = comment.get("path", "")
+                if file_path and file_path != "GENERAL":
+                    body = f"**File:** `{file_path}`\n{body}"
+                summary += f"{body}\n\n"
+        if not all_comments:
+            summary += "\nNo issues found. Code looks good!"
+
+        return summary

gofannon/google_search/google_search.py

@@ -0,0 +1,55 @@
+from ..base import BaseTool
+from googleapiclient.discovery import build
+from ..config import ToolConfig, FunctionRegistry
+import logging
+
+logger = logging.getLogger(__name__)
+
+@FunctionRegistry.register
+class GoogleSearch(BaseTool):
+    def __init__(self, api_key=None, engine_id=None, name="google_search"):
+        super().__init__()
+        self.api_key = api_key or ToolConfig.get("google_search_api_key")
+        self.engine_id = engine_id or ToolConfig.get("google_search_engine_id")
+        self.name = name
+        self.API_SERVICE = 'google_search'
+
+    @property
+    def definition(self):
+        return {
+            "type": "function",
+            "function": {
+                "name": self.name,
+                "description": "Searches Google for the given query and returns snippets from the results.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "query": {
+                            "type": "string",
+                            "description": "The search query."
+                        },
+                        "num_results": {
+                            "type": "integer",
+                            "description": "The maximum number of results to return (default: 5)."
+                        }
+                    },
+                    "required": ["query"]
+                }
+            }
+        }
+
+    def fn(self, query, num_results=5):
+        logger.debug(f"Searching Google for: {query}")
+        try:
+            service = build("customsearch", "v1", developerKey=self.api_key)
+            cse = service.cse()
+            result = cse.list(q=query, cx=self.engine_id, num=num_results).execute()
+
+            search_results = []
+            for item in result['items']:
+                search_results.append(f"Title: {item['title']}\nSnippet: {item['snippet']}\nLink: {item['link']}")
+            return "\n\n".join(search_results)
+
+        except Exception as e:
+            logger.error(f"Error during Google Search: {e}")
+            return f"Error during Google Search: {e}"

gofannon/headless_browser/base.py

@@ -0,0 +1,42 @@
+from selenium import webdriver
+from selenium.webdriver.chrome.options import Options
+from ..base import BaseTool
+import logging
+
+logger = logging.getLogger(__name__)
+
+class HeadlessBrowserBase(BaseTool):
+    """
+    Base class for headless browser tools.
+    On initialization, the provider parameter may be one of:
+    "selenium-chrome", "selenium-firefox", "lightpanda", or "remote".
+    Currently, only "selenium-chrome" is supported.
+    """
+    def __init__(self, provider="selenium-chrome", **kwargs):
+        super().__init__(**kwargs)
+        self.provider = provider.lower()
+        supported = ["selenium-chrome", "selenium-firefox", "lightpanda", "remote"]
+        if self.provider not in supported:
+            raise ValueError(f"Unsupported provider: {self.provider}. Supported providers: {supported}")
+
+    def _get_driver(self):
+        if self.provider == "selenium-chrome":
+            chrome_options = Options()
+            chrome_options.add_argument("--headless")
+            chrome_options.add_argument("--disable-gpu")
+            chrome_options.add_argument("--no-sandbox")
+            # Adjust the executable_path if needed or ensure the chromedriver is in PATH.
+            driver = webdriver.Chrome(options=chrome_options)
+            return driver
+        else:
+            raise NotImplementedError(f"Provider {self.provider} is not supported in the current implementation.")
+
+    def get_page_source(self, url):
+        driver = self._get_driver()
+        try:
+            driver.get(url)
+            # Optionally, add waits here if needed so that JavaScript can fully execute.
+            page_source = driver.page_source
+        finally:
+            driver.quit()
+        return page_source

gofannon/headless_browser/headless_browser_get.py

@@ -0,0 +1,35 @@
+from .base import HeadlessBrowserBase
+from ..config import FunctionRegistry
+import logging
+
+logger = logging.getLogger(__name__)
+
+@FunctionRegistry.register
+class HeadlessBrowserGet(HeadlessBrowserBase):
+    def __init__(self, provider="selenium-chrome", name="headless_browser_get"):
+        super().__init__(provider=provider)
+        self.name = name
+
+    @property
+    def definition(self):
+        return {
+            "type": "function",
+            "function": {
+                "name": self.name,
+                "description": "Retrieve the contents of a web page with JavaScript rendered using a headless browser.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "url": {
+                            "type": "string",
+                            "description": "The URL of the web page to fetch"
+                        }
+                    },
+                    "required": ["url"]
+                }
+            }
+        }
+
+    def fn(self, url):
+        logger.debug(f"Fetching URL with headless browser using provider {self.provider}: {url}")
+        return self.get_page_source(url)

gofannon/open_notify_space/__init__.py

@@ -0,0 +1 @@
+

gofannon/open_notify_space/iss_locator.py

@@ -0,0 +1,126 @@
+import jsonschema
+import jsonschema.exceptions
+from ..base import BaseTool
+from ..config import FunctionRegistry
+
+import logging
+import json
+
+import requests
+from jsonschema import validate
+
+logger = logging.getLogger(__name__)
+
+valid_iss_schema = {
+    "type": "object",
+    "properties": {
+        "message": {"type": "string", "enum": ["success"]},
+        "timestamp": {"type": "integer"},
+        "iss_position": {
+            "type": "object",
+            "properties": {
+                "longitude": {"type": "string"},
+                "latitude": {"type": "string"},
+            },
+            "required": ["longitude", "latitude"],
+        },
+    },
+    "required": ["message", "timestamp", "iss_position"],
+}
+
+error_response_string = "Error: The ISS endpoint returned an error. No location for the ISS can be determined"
+error_response_json = {
+    "message": "failure",
+    "error": "Error: The ISS endpoint returned an error. No location for the ISS can be determined",
+}
+
+
+@FunctionRegistry.register
+class IssLocator(BaseTool):
+    def __init__(self, name="iss_locator", format_json=True):
+        super().__init__()
+        self.name = name
+        self.format_json = format_json
+
+    @property
+    def definition(self):
+        return {
+            "type": "function",
+            "function": {
+                "name": self.name,
+                "description": "Returns the latitude / longitude of the current location of the International Space Station (ISS)",
+                "parameters": {},
+                "required": [],
+            },
+        }
+
+    # Function returns one of two messages, depending on the requested format:
+    #
+    # With format_json=False, Returns one of two strings:
+    #   "According to OpenNotify.org, the International Space Station can be found at (lat, long) (x,y)"
+    #   or
+    #   "The ISS endpoint returned an error. No location for the ISS can be determined"
+    #
+    # With format_json=True (default), the following strings:
+    #   "{
+    #        "message": "success",
+    #       "timestamp": 1739999640,
+    #       "iss_position": {"longitude": "-11.6885", "latitude": "-50.0654"},
+    #   }"
+    #   or
+    #   "{
+    #       "message": "failure",
+    #       "error": "Error: The ISS endpoint returned an error. No location for the ISS can be determined",
+    #   }"
+
+    def fn(self):
+        base_url = "http://api.open-notify.org/iss-now.json"
+        logger.debug(f"Fetching ISS pos from OpenNotify.org at {base_url}")
+        if self.format_json:
+            response = json.dumps(error_response_json)
+        else:
+            response = error_response_string
+
+        try:
+            http_response = requests.get(base_url)
+            response_json = http_response.json()
+            # Validate the returned schema is valid.
+            validate(response_json, valid_iss_schema)
+            # Does not seem to be a way to evaluate strings as floats in a range in jsonschema,
+            # other than using a REALLY ugly regex.
+            lat = float(response_json["iss_position"]["latitude"])
+            long = float(response_json["iss_position"]["longitude"])
+            if (lat > -90 and lat < 90) and (long > -180 and long < 180):
+                if self.format_json:
+                    response = json.dumps(response_json)
+                else:
+                    response = f"According to OpenNotify.org, the International Space Station can be found at (lat, long) ({lat}, {long})"
+            else:
+                raise ValueError(f"(latitude, longitude) out of range: ({lat},{long})")
+        except requests.exceptions.HTTPError as errh:
+            logger.debug(f"HTTP exception: GET at {base_url} returns {errh}")
+            pass
+        except requests.exceptions.ConnectionError as errc:
+            logger.debug(f"HTTP connection exception: GET at {base_url} returns {errc}")
+            pass
+        except requests.exceptions.Timeout as errt:
+            logger.debug(f"HTTP timeout exception: GET at {base_url} returns {errt}")
+            pass
+        except requests.exceptions.RequestException as err:
+            logger.debug(f"Requests exception: GET at {base_url} returns {err}")
+            pass
+        except jsonschema.exceptions.ValidationError as errj:
+            logger.debug(
+                f"JSON validation failure GET at {base_url} malformed response: {errj}"
+            )
+            pass
+        except ValueError as errv:
+            logger.debug(
+                f"Value Exception GET at {base_url} malformed response: {errv}"
+            )
+            pass
+        except Exception as erre:
+            logger.debug(f"General exception GET at {base_url} Error: {erre}")
+            pass
+
+        return response

gofannon/reasoning/__init__.py

@@ -1,3 +0,0 @@
-from .sequential_cot import SequentialCoT
-from .hierarchical_cot import HierarchicalCoT
-from .tree_of_thought import TreeOfThought