gofannon 0.1.0__py3-none-any.whl

gofannon/arxiv/__init__.py

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

gofannon/arxiv/get_article.py

@@ -0,0 +1,41 @@
+from..base import BaseTool
+import requests
+from ..config import FunctionRegistry
+import logging
+
+logger = logging.getLogger(__name__)
+
+@FunctionRegistry.register
+class GetArticle(BaseTool):
+    def __init__(self, name="get_article"):
+        super().__init__()
+        self.name = name
+
+    @property
+    def definition(self):
+        return {
+            "type": "function",
+            "function": {
+                "name": self.name,
+                "description": "Get a specific article from arXiv",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "id": {
+                            "type": "string",
+                            "description": "The ID of the article"
+                        }
+                    },
+                    "required": ["id"]
+                }
+            }
+        }
+
+    def fn(self, id):
+        logger.debug("Fetching Article '%s' from ArXiv", id)
+        base_url = "http://export.arxiv.org/api/query"
+        params = {
+            "id_list": id
+        }
+        response = requests.get(base_url, params=params)
+        return response.text  

gofannon/arxiv/search.py

@@ -0,0 +1,115 @@
+
+from..base import BaseTool
+import requests
+from ..config import FunctionRegistry
+import logging
+
+logger = logging.getLogger(__name__)
+
+@FunctionRegistry.register
+class Search(BaseTool):
+    def __init__(self, name="search"):
+        super().__init__()
+        self.name = name
+
+    @property
+    def definition(self):
+        return {
+            "type": "function",
+            "function": {
+                "name": self.name,
+                "description": "Search for articles on arXiv",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "query": {
+                            "type": "string",
+                            "description": "The search query"
+                        },
+                        "start": {
+                            "type": "integer",
+                            "description": "The start index of the search results"
+                        },
+                        "max_results": {
+                            "type": "integer",
+                            "description": "The maximum number of search results to return"
+                        },
+                        "submittedDateFrom": {
+                            "type": "string",
+                            "description": "The start submission date in the format YYYYMMDD"
+                        },
+                        "submittedDateTo": {
+                            "type": "string",
+                            "description": "The end submission date in the format YYYYMMDD"
+                        },
+                        "ti": {
+                            "type": "string",
+                            "description": "Search in title"
+                        },
+                        "au": {
+                            "type": "string",
+                            "description": "Search in author"
+                        },
+                        "abs": {
+                            "type": "string",
+                            "description": "Search in abstract"
+                        },
+                        "co": {
+                            "type": "string",
+                            "description": "Search in comment"
+                        },
+                        "jr": {
+                            "type": "string",
+                            "description": "Search in journal reference"
+                        },
+                        "cat": {
+                            "type": "string",
+                            "description": "Search in subject category"
+                        }
+                    },
+                    "required": ["query"]
+                }
+            }
+        }
+
+    def _format_date(self, date):
+        if len(date) == 8:
+            return f"{date}0000"
+        return date
+
+    def fn(self, query, start=0, max_results=10, submittedDateFrom=None, submittedDateTo=None, ti=None, au=None, abs=None, co=None, jr=None, cat=None):
+        logger.debug("Querying ArXiv for '%s'", query)
+        base_url = "http://export.arxiv.org/api/query"
+        params = {
+            "search_query": query,
+            "start": start,
+            "max_results": max_results
+        }
+
+        if submittedDateFrom and submittedDateTo:
+            params["search_query"] += f" AND submittedDate:[{self._format_date(submittedDateFrom)}0000 TO {self._format_date(submittedDateTo)}0000]"
+        elif submittedDateFrom:
+            params["search_query"] += f" AND submittedDate:[{self._format_date(submittedDateFrom)}0000 TO *]"
+        elif submittedDateTo:
+            params["search_query"] += f" AND submittedDate:[* TO {self._format_date(submittedDateTo)}0000]"
+
+        if ti:
+            params["search_query"] += f" AND ti:{ti}"
+
+        if au:
+            params["search_query"] += f" AND au:{au}"
+
+        if abs:
+            params["search_query"] += f" AND abs:{abs}"
+
+        if co:
+            params["search_query"] += f" AND co:{co}"
+
+        if jr:
+            params["search_query"] += f" AND jr:{jr}"
+
+        if cat:
+            params["search_query"] += f" AND cat:{cat}"
+
+        response = requests.get(base_url, params=params)
+        return response.text

gofannon/base/__init__.py

@@ -0,0 +1,251 @@
+import time
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import Dict, 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
+
+@dataclass
+class ToolResult:
+    success: bool
+    output: Any
+    error: str = None
+    retryable: bool = False
+
+class WorkflowContext:
+    def __init__(self, firebase_config=None):
+        self.data = {}
+        self.execution_log = []
+        self.firebase_config = firebase_config
+        self.local_storage = Path.home() / ".llama" / "checkpoints"
+        self.local_storage.mkdir(parents=True, exist_ok=True)
+
+    def save_checkpoint(self, name="checkpoint"):
+        if self.firebase_config:
+            self._save_to_firebase(name)
+        else:
+            self._save_local(name)
+
+    def _save_local(self, name):
+        path = self.local_storage / f"{name}.json"
+        with open(path, 'w') as f:
+            json.dump({
+                'data': self.data,
+                'execution_log': self.execution_log
+            }, f)
+
+    def _save_to_firebase(self, name):
+        from firebase_admin import firestore
+        db = firestore.client()
+        doc_ref = db.collection('checkpoints').document(name)
+        doc_ref.set({
+            'data': self.data,
+            'execution_log': self.execution_log,
+            'timestamp': firestore.SERVER_TIMESTAMP
+        })
+
+    def log_execution(self, tool_name, duration, input_data, output_data):
+        entry = {
+            'tool': tool_name,
+            'duration': duration,
+            'input': input_data,
+            'output': output_data
+        }
+        self.execution_log.append(entry)
+
+class BaseTool(ABC):
+    def __init__(self, **kwargs):
+        self.logger = logging.getLogger(f"{self.__class__.__module__}.{self.__class__.__name__}")
+        self._load_config()
+        self._configure(**kwargs)
+        self.logger.debug("Initialized %s tool", self.__class__.__name__)
+
+    def _configure(self, **kwargs):
+        """Set instance-specific configurations"""
+        for key, value in kwargs.items():
+            if hasattr(self, key):
+                setattr(self, key, value)
+
+    def _load_config(self):
+        """Auto-load config based on tool type"""
+        if hasattr(self, 'API_SERVICE'):
+            self.api_key = ToolConfig.get(f"{self.API_SERVICE}_api_key")
+
+    @property
+    @abstractmethod
+    def definition(self):
+        pass
+
+    @property
+    def output_schema(self):
+        return self.definition.get('function', {}).get('parameters', {})
+
+    @abstractmethod
+    def fn(self, *args, **kwargs):
+        pass
+
+    def execute(self, context: WorkflowContext, **kwargs) -> ToolResult:
+        try:
+            start_time = time.time()
+            result = self.fn(**kwargs)
+            duration = time.time() - start_time
+
+            context.log_execution(
+                tool_name=self.__class__.__name__,
+                duration=duration,
+                input_data=kwargs,
+                output_data=result
+            )
+
+            return ToolResult(success=True, output=result)
+        except Exception as e:
+            return ToolResult(
+                success=False,
+                output=None,
+                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/basic_math/__init__.py

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

gofannon/basic_math/addition.py

@@ -0,0 +1,39 @@
+from..base import BaseTool
+from ..config import FunctionRegistry
+import logging
+
+logger = logging.getLogger(__name__)
+
+@FunctionRegistry.register
+class Addition(BaseTool):
+    def __init__(self, name="addition"):
+        super().__init__()
+        self.name = name
+
+    @property
+    def definition(self):
+        return {
+            "type": "function",
+            "function": {
+                "name": self.name,
+                "description": "Calculate the sum of two numbers",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "num1": {
+                            "type": "number",
+                            "description": "The first number"
+                        },
+                        "num2": {
+                            "type": "number",
+                            "description": "The second number"
+                        }
+                    },
+                    "required": ["num1", "num2"]
+                }
+            }
+        }
+
+    def fn(self, num1, num2):
+        logger.debug(f"Adding {num1} and {num2}")
+        return num1 + num2

gofannon/basic_math/division.py

@@ -0,0 +1,41 @@
+from..base import BaseTool
+from ..config import FunctionRegistry
+import logging
+
+logger = logging.getLogger(__name__)
+
+@FunctionRegistry.register
+class Division(BaseTool):
+    def __init__(self, name="division"):
+        super().__init__()
+        self.name = name
+
+    @property
+    def definition(self):
+        return {
+            "type": "function",
+            "function": {
+                "name": self.name,
+                "description": "Calculate the quotient of two numbers",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "num1": {
+                            "type": "number",
+                            "description": "The dividend"
+                        },
+                        "num2": {
+                            "type": "number",
+                            "description": "The divisor"
+                        }
+                    },
+                    "required": ["num1", "num2"]
+                }
+            }
+        }
+
+    def fn(self, num1, num2):
+        logger.debug(f"Dividing {num1} by {num2}")
+        if num2 == 0:
+            raise ZeroDivisionError("Cannot divide by zero")
+        return num1 / num2  

gofannon/basic_math/exponents.py

@@ -0,0 +1,39 @@
+from..base import BaseTool
+from ..config import FunctionRegistry
+import logging
+
+logger = logging.getLogger(__name__)
+
+@FunctionRegistry.register
+class Exponents(BaseTool):
+    def __init__(self, name="exponents"):
+        super().__init__()
+        self.name = name
+
+    @property
+    def definition(self):
+        return {
+            "type": "function",
+            "function": {
+                "name": self.name,
+                "description": "Calculate the result of a number raised to a power",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "base": {
+                            "type": "number",
+                            "description": "The base number"
+                        },
+                        "power": {
+                            "type": "number",
+                            "description": "The power to which the base is raised"
+                        }
+                    },
+                    "required": ["base", "power"]
+                }
+            }
+        }
+
+    def fn(self, base, power):
+        logger.debug(f"Raising {base} to the {power}th power")
+        return base ** power

gofannon/basic_math/multiplication.py

@@ -0,0 +1,39 @@
+from..base import BaseTool
+from ..config import FunctionRegistry
+import logging
+
+logger = logging.getLogger(__name__)
+
+@FunctionRegistry.register
+class Multiplication(BaseTool):
+    def __init__(self, name="multiplication"):
+        super().__init__()
+        self.name = name
+
+    @property
+    def definition(self):
+        return {
+            "type": "function",
+            "function": {
+                "name": self.name,
+                "description": "Calculate the product of two numbers",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "num1": {
+                            "type": "number",
+                            "description": "The first number"
+                        },
+                        "num2": {
+                            "type": "number",
+                            "description": "The second number"
+                        }
+                    },
+                    "required": ["num1", "num2"]
+                }
+            }
+        }
+
+    def fn(self, num1, num2):
+        logger.debug(f"Multiplying {num1} by {num2}")
+        return num1 * num2

gofannon/basic_math/subtraction.py

@@ -0,0 +1,39 @@
+from..base import BaseTool
+from ..config import FunctionRegistry
+import logging
+
+logger = logging.getLogger(__name__)
+
+@FunctionRegistry.register
+class Subtraction(BaseTool):
+    def __init__(self, name="subtraction"):
+        super().__init__()
+        self.name = name
+
+    @property
+    def definition(self):
+        return {
+            "type": "function",
+            "function": {
+                "name": self.name,
+                "description": "Calculate the difference between two numbers",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "num1": {
+                            "type": "number",
+                            "description": "The minuend"
+                        },
+                        "num2": {
+                            "type": "number",
+                            "description": "The subtrahend"
+                        }
+                    },
+                    "required": ["num1", "num2"]
+                }
+            }
+        }
+
+    def fn(self, num1, num2):
+        logger.debug(f"Subtracting {num2} from {num1}")
+        return num1 - num2

gofannon/cli.py

@@ -0,0 +1,53 @@
+import argparse
+from .orchestration import ToolChain
+from .base import WorkflowContext
+from orchestration.firebase_wrapper import FirebaseWrapper
+import json
+
+def main():
+    parser = argparse.ArgumentParser(description="Gofannon CLI")
+    parser.add_argument('--local', action='store_true', help='Run locally')
+    parser.add_argument('--firebase', help='Firebase config path')
+    parser.add_argument('--workflow', required=True, help='Workflow config JSON')
+    parser.add_argument('--output', help='Output file path')
+
+    args = parser.parse_args()
+
+    # Initialize context
+    if args.firebase:
+        FirebaseWrapper.initialize(args.firebase)
+        context = FirebaseWrapper.get_context('current_workflow')
+    else:
+        context = WorkflowContext()
+
+        # Load workflow config
+    with open(args.workflow) as f:
+        workflow_config = json.load(f)
+
+        # Import and instantiate tools
+    tools = []
+    for tool_config in workflow_config['tools']:
+        module = __import__(f".{tool_config['module']}", fromlist=[tool_config['class']])
+        tool_class = getattr(module, tool_config['class'])
+        tool = tool_class(**tool_config.get('params', {}))
+        tools.append(tool)
+
+        # Execute workflow
+    chain = ToolChain(tools, context)
+    result = chain.execute(workflow_config.get('initial_input', {}))
+
+    # Handle output
+    if args.output:
+        with open(args.output, 'w') as f:
+            json.dump(result.output, f)
+    else:
+        print(json.dumps(result.output, indent=2))
+
+        # Save final state
+    if args.firebase:
+        FirebaseWrapper.save_context('current_workflow', context)
+    else:
+        context.save_checkpoint('final')
+
+if __name__ == '__main__':
+    main()