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

gofannon/arxiv/__init__.py

@@ -1,2 +0,0 @@
-from.search import Search
-from.get_article import GetArticle  

gofannon/base/__init__.py

@@ -1,29 +1,14 @@
 import time
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
-from typing import Dict, Any, Callable
+from typing import Any, Callable
 import json
 import logging
 from pathlib import Path
 from ..config import ToolConfig
 
-from typing import Any, Dict
-
-
-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
-
-try:
-    from langchain.tools import BaseTool as LangchainBaseTool
-    from langchain.pydantic_v1 import BaseModel, Field
-    from typing import Type, Optional
-    _HAS_LANGCHAIN = True
-except ImportError:
-    _HAS_LANGCHAIN = False
+from .smol_agents import SmolAgentsMixin
+from .langchain import LangchainMixin
 
 @dataclass
 class ToolResult:
@@ -73,7 +58,7 @@ class WorkflowContext:
         }
         self.execution_log.append(entry)
 
-class BaseTool(ABC):
+class BaseTool(SmolAgentsMixin, LangchainMixin, ABC):
     def __init__(self, **kwargs):
         self.logger = logging.getLogger(f"{self.__class__.__module__}.{self.__class__.__name__}")
         self._load_config()
@@ -125,127 +110,3 @@ class BaseTool(ABC):
                 error=str(e),
                 retryable=True
             )
-
-    def import_from_smolagents(self, smol_tool: "SmolTool"):
-        """
-        Takes a smolagents Tool instance and adapts it into this 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 #getattr(smol_tool, "description", "No description provided.")
-
-
-        def adapted_fn(*args, **kwargs):
-            return smol_tool.forward(*args, **kwargs)
-
-
-        self.fn = adapted_fn
-
-    def export_to_smolagents(self) -> "SmolTool":
-        """
-        Export this Tool as a smolagents Tool instance.
-        This sets up a smolagents-style forward method that calls self.fn.
-        """
-        if not _HAS_SMOLAGENTS:
-            raise RuntimeError(
-                "smolagents is not installed or could not be imported. "
-                "Install it or check your environment."
-            )
-
-            # Provide a standard forward function that calls self.fn
-        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"
-
-        # Construct a new smolagents Tool with the minimal fields
-        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
-
-    def import_from_langchain(self, langchain_tool: "LangchainBaseTool"):
-        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 = {}
-
-            # Store parameters to avoid modifying the definition property directly
-        self._parameters = args_schema.get("properties", {})
-        self._required = args_schema.get("required", [])
-
-        # Adapt the LangChain tool's execution method
-        def adapted_fn(*args, **kwargs):
-            return langchain_tool._run(*args, **kwargs)
-
-        self.fn = adapted_fn
-
-    def export_to_langchain(self) -> "LangchainBaseTool":
-        if not _HAS_LANGCHAIN:
-            raise RuntimeError(
-                "langchain is not installed. Install with `pip install langchain-core`"
-            )
-
-        from pydantic import create_model
-
-        # Create type mapping from JSON schema types to Python types
-        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", {})
-
-        # Dynamically create ArgsSchema using pydantic.create_model
-        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)
-
-        # Create tool subclass with our functionality
-        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)
-
-        # Instantiate and return the tool
-        tool = ExportedTool()
-        return tool

gofannon/base/langchain.py

@@ -0,0 +1,73 @@
+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: LangchainBaseTool):
+        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) -> LangchainBaseTool:
+        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,49 @@
+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: SmolTool):
+        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) -> SmolTool:
+        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/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

{gofannon-0.1.0.dist-info → gofannon-0.25.10.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: gofannon
-Version: 0.1.0
+Version: 0.25.10.1
 Summary: A collection of tools for LLMs
 License: ASFv2
 Author: Trevor Grant
@@ -10,14 +10,25 @@ Classifier: License :: Other/Proprietary License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Provides-Extra: google
+Provides-Extra: headless-browser
+Provides-Extra: langchain
+Provides-Extra: smolagents
+Provides-Extra: testing
 Requires-Dist: GitPython (>=3.1.43,<4.0.0)
-Requires-Dist: langchain (>=0.3.16,<0.4.0)
+Requires-Dist: google-api-python-client (>=2.161.0,<3.0.0) ; extra == "google"
+Requires-Dist: jsonschema (>=4.23.0,<5.0.0)
+Requires-Dist: langchain (>=0.3.16,<0.4.0) ; extra == "langchain"
 Requires-Dist: openai (>=1.60.2,<2.0.0)
-Requires-Dist: pydantic (>=2.10.6,<3.0.0)
-Requires-Dist: pytest (>=8.3.4,<9.0.0)
+Requires-Dist: pydantic (>=2.10.6,<3.0.0) ; extra == "langchain"
+Requires-Dist: pytest (>=8.3.4,<9.0.0) ; extra == "testing"
 Requires-Dist: python-dotenv (>=1.0.1,<2.0.0)
 Requires-Dist: requests (>=2.32.3,<3.0.0)
-Requires-Dist: smolagents (>=1.6.0,<2.0.0)
+Requires-Dist: requests-mock (>=1.12.1,<2.0.0) ; extra == "testing"
+Requires-Dist: selenium (>=4.10.0,<5.0.0) ; extra == "headless-browser"
+Requires-Dist: smolagents (>=1.6.0,<2.0.0) ; extra == "smolagents"
 Description-Content-Type: text/markdown
 
 ![gofannon logo](./gofannon.jpg)  
@@ -59,7 +70,7 @@ Each tool comes with its own documentation, which can be found in the `docs/` di
 To install gofannon, simply clone the repository and install the required dependencies:  
   
 ```bash  
-git clone https://github.com/your-repo/gofannon.git  
+git clone https://github.com/The-AI-Alliance/gofannon.git  
 cd gofannon  
 pip install -r requirements.txt
 ```
@@ -67,7 +78,7 @@ pip install -r requirements.txt
 or 
 
 ```
-pip install git+https://github.com/your-repo/gofannon.git
+pip install git+https://github.com/The-AI-Alliance/gofannon.git
 ```
 
 ## License  

{gofannon-0.1.0.dist-info → gofannon-0.25.10.1.dist-info}/RECORD

@@ -1,32 +1,41 @@
 gofannon/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-gofannon/arxiv/__init__.py,sha256=BoTEVP6yli8gCNTrf0IhXKc4uk5sZvvY7MV4FHtJoVI,62
+gofannon/arxiv/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 gofannon/arxiv/get_article.py,sha256=SRGTXFXdXdXTIOLZKWUTXxZEYEqZFWFJEV2nTsU5qqU,1167
 gofannon/arxiv/search.py,sha256=37Zx1y2vAX1xYIKaAxzBGXE3qPHUZdAD2XR0H1Acs-4,4225
-gofannon/base/__init__.py,sha256=xcb2cMVUcTsMX-z60dDyfJsPmw-KgMFzY4c5xF_tz4k,8401
-gofannon/basic_math/__init__.py,sha256=P-BGr3HrkFK5KmfW9jrPkUF8B0n2s7B6_CoWpM1QdkY,170
+gofannon/base/__init__.py,sha256=Bsjc0ZJkVRx_q7f6Pp6czgkiysyTRwmqCZIflX7xeqA,3396
+gofannon/base/langchain.py,sha256=JbktMQQuMr2LmmGDKU4aDPTnBJZ39_UPChXiB9m3eUM,2619
+gofannon/base/smol_agents.py,sha256=8jOK7ijpQ7JjXrk1No6baOmw7PD6FmHLgfXrNX5iJ2E,1672
+gofannon/basic_math/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 gofannon/basic_math/addition.py,sha256=zA-xtUBNnGnQVqTJkBvjZwX0gnGZ6mrUGhrlTbsH1ts,1148
 gofannon/basic_math/division.py,sha256=ZO8ZzWNL9zeFdXTEdPWDpnbDrWMXVeucSu105RbQmWU,1229
 gofannon/basic_math/exponents.py,sha256=w4qDlFZ9M1lf6X-tjG-ndpECfCOS7Qtc_VLICw0oh2w,1205
 gofannon/basic_math/multiplication.py,sha256=PJ5sKWMCVlBaTeZ_j3gwYOEQXAhN-qIXhnrNcyhWGKM,1168
 gofannon/basic_math/subtraction.py,sha256=gM1_N1mZ3qAXC6qnkzfijKXiOx27Gg93-CaB_ifMbOQ,1164
 gofannon/cli.py,sha256=-T-jjBNl_74TsGRcrjxsQnG0-wA2neYhncnaqCiEzPo,1733
-gofannon/config.py,sha256=zP_PUuSDNJ4dlZpG7m9i2-e0oqqGrK9SFoJ8GuR7VYE,1568
-gofannon/github/__init__.py,sha256=i0OtQehyyQn-1nratJD2737eMJILMJ-pobQHpM4hRcY,225
+gofannon/config.py,sha256=N1xmWTbcyDPZT3r_ZuwW1RI0VRhDcbf3qIasEZZNwyc,1718
+gofannon/github/__init__.py,sha256=VFw4sJIt4Zc0-__eYnksN8Ku9qMhbPpHJEkXMWUiD30,4
 gofannon/github/commit_file.py,sha256=jdQGQHbrZx4521XgTbx5N0Ss8fDyl7hvp9sjDW15v9U,2573
 gofannon/github/commit_files.py,sha256=0WP4nx4RYpO_Vb45Sa65afuzSMf4de-Wt6awpSOusyM,4395
 gofannon/github/create_issue.py,sha256=WXq0klzPvGZnZyZRmriGOkHl7E_Tp08vO1v2ou7TR8w,2560
 gofannon/github/get_repo_contents.py,sha256=9k6M2BqGlNsSGVjyfW7nxZpk1TFuhyPoZvURkv1PEyo,3637
 gofannon/github/read_issue.py,sha256=JrnBAlZxknhHm3aLC0uB9u0bSvoQNfK3OKmxYlr8jgQ,2308
 gofannon/github/search.py,sha256=yuX_dZ6f8ogUnskIRMUgF8wuN7JepqRtTDFrbmbwrrs,2183
+gofannon/google_search/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gofannon/google_search/google_search.py,sha256=WRaGSLoeZjy5Qtn89Sp01nNugiGI0NL1ZEdE1ebghl4,2100
+gofannon/headless_browser/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gofannon/headless_browser/base.py,sha256=bgvBvkTNCqRnhC8Ffc6oZ3yoxpOl6fkAq0doDKnQtt8,1721
+gofannon/headless_browser/headless_browser_get.py,sha256=kOnHxfoZayfCuS6OKloLdwxehiInwcd5dM0HbKAeM5U,1182
 gofannon/nhsta/__init__.py,sha256=jTV6arXumVgJagKOq6GnYhHwcX9t7Jjqq5JvsE5-zxQ,1925
+gofannon/open_notify_space/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+gofannon/open_notify_space/iss_locator.py,sha256=STLNSD5HriRR6grpRpiTRDbqVRtWMPVoGuV8SygHGNY,4734
 gofannon/orchestration/__init__.py,sha256=_p_XhWHgOIgiamFSGwFUqrnBlIYDvQMq5L5mxJvxiks,5121
 gofannon/orchestration/firebase_wrapper.py,sha256=jXqUcIoKuTC_1ZffN3v1DN9X6of-OuMKWP8ZzQ-wHOU,1394
-gofannon/reasoning/__init__.py,sha256=pk7Sbh_pvZG6xR4o4vFeM1UWUZA44MNYDUMpDD1wI-c,130
+gofannon/reasoning/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 gofannon/reasoning/base.py,sha256=D-4JHJqUlqgwMNOkKU0BHYA4GEWwNgPlLxKYHX0FVyg,1494
 gofannon/reasoning/hierarchical_cot.py,sha256=e8ZgMbyJQ0wCBEmv7QJqFv7l3XxTMwDYupGxJ7EF6t8,11516
 gofannon/reasoning/sequential_cot.py,sha256=m9c8GnyTtmI-JntCuhkoFfULAabVOxsYgTRUd3MjzfY,3166
 gofannon/reasoning/tree_of_thought.py,sha256=TRhRJQNsFVauCLw4TOvQCDcX1nGmp_wSg9H67GJn1hs,10574
-gofannon-0.1.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-gofannon-0.1.0.dist-info/METADATA,sha256=hsBifn6bjBvduAeNI61p9j4Ep_rb1feIy1bPyPlv0rI,3279
-gofannon-0.1.0.dist-info/WHEEL,sha256=Zb28QaM1gQi8f4VCBhsUklF61CTlNYfs9YAZn-TOGFk,88
-gofannon-0.1.0.dist-info/RECORD,,
+gofannon-0.25.10.1.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+gofannon-0.25.10.1.dist-info/METADATA,sha256=rP0KpQfrea01Rl4cTtYfyLCByLPjojDlleY_9lyU6QQ,3884
+gofannon-0.25.10.1.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+gofannon-0.25.10.1.dist-info/RECORD,,

{gofannon-0.1.0.dist-info → gofannon-0.25.10.1.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.6.1
+Generator: poetry-core 2.1.1
 Root-Is-Purelib: true
 Tag: py3-none-any