gofannon 0.25.17__py3-none-any.whl → 0.25.18__py3-none-any.whl

gofannon/base/__init__.py

@@ -15,6 +15,7 @@ from .langchain import LangchainMixin
 from .bedrock import BedrockMixin
 from .langflow import LangflowMixin
 from .mcp import MCPMixin
+from .llamastack import LlamaStackMixin
 
 
 @dataclass
@@ -72,6 +73,7 @@ class BaseTool(SmolAgentsMixin,
                BedrockMixin,
                LangflowMixin,
                MCPMixin,
+               LlamaStackMixin,
                ABC):
     def __init__(self, **kwargs):
         self.logger = logging.getLogger(

gofannon/base/llamastack.py

@@ -0,0 +1,266 @@
+# gofannon/base/llamastack.py
+
+import inspect
+import re
+from textwrap import dedent
+from typing import Callable, Any
+
+# Type mapping from Gofannon definition to Python types (primarily for potential future use,
+# as Llama Stack example doesn't heavily rely on type hints in the generated function)
+GOFANNON_TO_PYTHON_TYPE_MAP = {
+    "string": str,
+    "number": float,
+    "integer": int,
+    "boolean": bool,
+    "object": dict,
+    "array": list,
+}
+
+# Type mapping from Python types/common hints to Gofannon definition types
+PYTHON_TO_GOFANNON_TYPE_MAP = {
+    str: "string",
+    float: "number",
+    int: "integer",
+    bool: "boolean",
+    dict: "object",
+    list: "array",
+    Any: "string", # Default fallback
+    type(None): "string" # Default fallback for untyped
+}
+
+
+class LlamaStackMixin:
+    """
+    Mixin for converting Gofannon tools to and from the Llama Stack custom tool format.
+
+    Llama Stack expects custom tools as Python functions with specific docstrings.
+    See: https://github.com/meta-llama/llama-stack/blob/main/docs/tools.md#adding-custom-tools
+    """
+
+    def _parse_llamastack_docstring(self, docstring: str) -> tuple[str, dict[str, str], list[str]]:
+        """
+        Parses a Llama Stack style docstring to extract description and parameters.
+
+        Args:
+            docstring: The docstring content.
+
+        Returns:
+            A tuple containing:
+            - description (str): The main tool description.
+            - params (dict): A dictionary mapping parameter names to their descriptions.
+            - required (list): A list of required parameter names (inferred if not explicitly optional).
+              NOTE: Llama Stack's doc example doesn't show optional syntax, so we assume all
+              documented params are required unless function signature has defaults.
+        """
+        if not docstring:
+            return "No description provided.", {}, []
+
+        lines = docstring.strip().split('\n')
+        description_lines = []
+        params = {}
+        param_section_started = False
+
+        # Simple regex to find ':param <name>:' or ':param <name> (<type>):'
+        param_regex = re.compile(r":param\s+([\w_]+)(?:\s*\([^)]+\))?:\s*(.*)")
+
+        for line in lines:
+            line = line.strip()
+            if not line: # Skip empty lines between description and params
+                if description_lines and not param_section_started:
+                    param_section_started = True # Assume blank line separates desc from params
+                continue
+
+            match = param_regex.match(line)
+            if match:
+                param_section_started = True
+                param_name = match.group(1)
+                param_desc = match.group(2).strip()
+                params[param_name] = param_desc
+            elif not param_section_started:
+                description_lines.append(line)
+
+        description = " ".join(description_lines).strip()
+        # Llama Stack example doesn't specify required/optional in docstring.
+        # We'll infer from function signature later.
+        # For now, return an empty required list based purely on docstring parsing.
+        required = list(params.keys()) # Assume all documented params are required initially
+
+        return description, params, required
+
+    def import_from_llamastack(self, llamastack_tool_func: Callable):
+        """
+        Adapts a Llama Stack custom tool function to a Gofannon tool.
+
+        Args:
+            llamastack_tool_func: The Python function representing the Llama Stack tool.
+        """
+        if not callable(llamastack_tool_func):
+            raise ValueError("Input must be a callable function.")
+
+        self.name = llamastack_tool_func.__name__
+        docstring = inspect.getdoc(llamastack_tool_func) or ""
+
+        # Parse docstring for description and param descriptions
+        description, param_descriptions, _ = self._parse_llamastack_docstring(docstring)
+        self.description = description # Set top-level description
+
+        # Use inspect.signature to get parameter names, types, and defaults
+        try:
+            sig = inspect.signature(llamastack_tool_func)
+            parameters_properties = {}
+            required_params = []
+
+            for name, param in sig.parameters.items():
+                param_type_hint = param.annotation
+                gofannon_type = PYTHON_TO_GOFANNON_TYPE_MAP.get(param_type_hint, "string") # Default to string if unknown
+
+                parameters_properties[name] = {
+                    "type": gofannon_type,
+                    "description": param_descriptions.get(name, f"Parameter '{name}'") # Use parsed desc or default
+                }
+
+                # If the parameter has no default value, it's required
+                if param.default is inspect.Parameter.empty:
+                    required_params.append(name)
+
+            self.definition = {
+                "function": {
+                    "name": self.name,
+                    "description": self.description,
+                    "parameters": {
+                        "type": "object",
+                        "properties": parameters_properties,
+                        "required": required_params,
+                    }
+                }
+            }
+
+        except Exception as e:
+            # Fallback if signature inspection fails (e.g., built-in function)
+            # Create a basic definition based only on name/docstring
+            self.logger.warning(f"Could not inspect signature for {self.name}: {e}. Creating basic definition.")
+            self.definition = {
+                "function": {
+                    "name": self.name,
+                    "description": self.description,
+                    "parameters": { # Assume no parameters if signature fails
+                        "type": "object",
+                        "properties": {},
+                        "required": []
+                    }
+                }
+            }
+
+
+            # The core function is the Llama Stack function itself
+        self.fn = llamastack_tool_func
+
+        self.logger.info(f"Imported Llama Stack tool: {self.name}")
+
+
+    def export_to_llamastack(self) -> Callable:
+        """
+        Convert the Gofannon tool to a Llama Stack compatible function.
+
+        Returns:
+            A callable function with a Llama Stack-style docstring.
+        """
+        gofannon_def = self.definition.get("function", {})
+        tool_name = gofannon_def.get("name", getattr(self, "name", "gofannon_exported_tool"))
+        tool_description = gofannon_def.get("description", getattr(self, "description", "No description provided."))
+        parameters = gofannon_def.get("parameters", {})
+        param_properties = parameters.get("properties", {})
+        required_params = parameters.get("required", [])
+
+        # Construct the docstring
+        docstring_lines = [tool_description, ""]
+        param_lines = []
+        arg_names = []
+
+        for param_name, param_def in param_properties.items():
+            param_desc = param_def.get("description", "")
+            # Llama Stack example doesn't show type in docstring, just param name and description
+            # param_type = param_def.get("type", "string") # Could potentially add :type if needed
+            docstring_line = f":param {param_name}: {param_desc}"
+            # NOTE: Llama Stack example doesn't explicitly mark required/optional in docstring
+            # We could add (required) or (optional) if desired, but sticking to example format.
+            # if param_name in required_params:
+            #     docstring_line += " (required)"
+            param_lines.append(docstring_line)
+            arg_names.append(param_name)
+
+        if param_lines:
+            docstring_lines.extend(param_lines)
+            docstring_lines.append("") # Add blank line after params if any
+
+        # Add a basic return description (Gofannon definition doesn't store this explicitly)
+        docstring_lines.append(":return: The result of executing the tool.")
+
+        final_docstring = "\n".join(docstring_lines)
+
+        # Create the wrapper function dynamically
+        original_fn = self.fn
+        args_string = ", ".join(arg_names)
+
+        # We need to define the function in a scope where original_fn is accessible
+        # Using exec can be risky, but is one way to dynamically create a function
+        # with a specific signature and docstring. A safer alternative might involve
+        # function factories or functools.wraps if the signature complexity allows.
+
+        # Let's try a closure approach which is generally safer:
+        def make_wrapper(original_func, doc, name, signature_args):
+            # Construct the function signature string dynamically
+            sig_str = f"({', '.join(signature_args)})"
+            # Use eval to create the function with the correct signature
+            # This is still somewhat risky, ensure signature_args are sanitized if needed.
+            # Define the wrapper within this factory function's scope
+            def wrapper(*args, **kwargs):
+                # Map positional args to keywords if necessary, or rely on kwargs
+                call_kwargs = {}
+                if args:
+                    for i, arg_val in enumerate(args):
+                        if i < len(signature_args):
+                            call_kwargs[signature_args[i]] = arg_val
+                        else:
+                            # Handle extra positional args if necessary, maybe raise error?
+                            pass
+                call_kwargs.update(kwargs)
+                return original_func(**call_kwargs)
+
+            wrapper.__doc__ = doc
+            wrapper.__name__ = name
+            # Try to mimic signature for inspection tools (might not be perfect)
+            try:
+                # Build parameter list for inspect.Signature
+                params = [inspect.Parameter(arg, inspect.Parameter.POSITIONAL_OR_KEYWORD) for arg in signature_args]
+                wrapper.__signature__ = inspect.Signature(parameters=params)
+            except Exception as e:
+                self.logger.warning(f"Could not set __signature__ for {name}: {e}")
+
+            return wrapper
+
+            # Generate the arguments list for the signature
+        signature_args_list = list(param_properties.keys())
+        exported_function = make_wrapper(original_fn, final_docstring, tool_name, signature_args_list)
+
+
+        # Alternative using exec (use with caution):
+        # func_code = f"""
+        # def {tool_name}({args_string}):
+        #     '''{final_docstring}'''
+        #     # Prepare kwargs for the original function
+        #     kwargs_for_original = {{}}
+        # """
+        # for arg_name in arg_names:
+        #     func_code += f"    kwargs_for_original['{arg_name}'] = {arg_name}\n"
+        #
+        # func_code += f"""
+        #     return original_fn(**kwargs_for_original)
+        # """
+        # local_scope = {'original_fn': original_fn}
+        # exec(dedent(func_code), local_scope)
+        # exported_function = local_scope[tool_name]
+
+        self.logger.info(f"Exported Gofannon tool '{self.name}' to Llama Stack format as function '{tool_name}'")
+        return exported_function
+  

gofannon/file/list_directory.py

@@ -0,0 +1,82 @@
+import os
+
+from..base import BaseTool
+from ..config import FunctionRegistry
+import logging
+
+logger = logging.getLogger(__name__)
+
+@FunctionRegistry.register
+class ListDirectory(BaseTool):
+    def __init__(self, name="list_directory"):
+        super().__init__()
+        self.name = name
+
+    @property
+    def definition(self):
+        return {
+            "type": "function",
+            "function": {
+                "name": self.name,
+                "description": "List the contents of a directory recursively in a tree-like format",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "directory_path": {
+                            "type": "string",
+                            "description": "The path of the directory to list"
+                        },
+                        "max_depth": {
+                            "type": "integer",
+                            "description": "Maximum depth to recurse into (default: 5)",
+                            "default": 5
+                        }
+                    },
+                    "required": ["directory_path"]
+                }
+            }
+        }
+
+    def _build_tree(self, path, prefix="", depth=0, max_depth=5):
+        if depth > max_depth:
+            return ""
+
+        try:
+            entries = os.listdir(path)
+        except PermissionError:
+            return f"{prefix}[Permission Denied]\n"
+        except FileNotFoundError:
+            return f"{prefix}[Directory Not Found]\n"
+
+        tree = ""
+        entries.sort()
+        length = len(entries)
+
+        for i, entry in enumerate(entries):
+            full_path = os.path.join(path, entry)
+            is_last = i == length - 1
+
+            if os.path.isdir(full_path):
+                tree += f"{prefix}{'└── ' if is_last else '├── '}{entry}/\n"
+                tree += self._build_tree(
+                    full_path,
+                    prefix + ("    " if is_last else "│   "),
+                    depth + 1,
+                    max_depth
+                )
+            else:
+                tree += f"{prefix}{'└── ' if is_last else '├── '}{entry}\n"
+
+        return tree
+
+    def fn(self, directory_path, max_depth=5):
+        logger.debug(f"Listing directory: {directory_path}")
+
+        if not os.path.exists(directory_path):
+            return f"Error: Directory '{directory_path}' does not exist"
+
+        if not os.path.isdir(directory_path):
+            return f"Error: '{directory_path}' is not a directory"
+
+        tree = self._build_tree(directory_path, max_depth=max_depth)
+        return f"{directory_path}/\n{tree}"

gofannon/file/read_file.py

@@ -0,0 +1,56 @@
+import os
+
+from..base import BaseTool
+from ..config import FunctionRegistry
+import logging
+
+logger = logging.getLogger(__name__)
+
+@FunctionRegistry.register
+class ReadFile(BaseTool):
+    """
+    A tool for reading the contents of a file from the local filesystem.
+
+    This class provides a function that takes a file path as input and returns
+    the contents of that file as a string.
+
+    Attributes:
+        file_path (str): The path to the file that should be read.
+    """
+    def __init__(self, name="read_file"):
+        super().__init__()
+        self.name = name
+
+    @property
+    def definition(self):
+        return {
+            "type": "function",
+            "function": {
+                "name": self.name,
+                "description": "Read the contents of a specified file.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "file_path": {
+                            "type": "string",
+                            "description": "The path to the file to be read."
+                        }
+                    },
+                    "required": ["file_path"]
+                }
+            }
+        }
+
+    def fn(self, file_path):
+        logger.debug(f"Reading file: {file_path}")
+        try:
+            if not os.path.exists(file_path):
+                raise FileNotFoundError(f"The file '{file_path}' does not exist.")
+
+            with open(file_path, 'r') as file:
+                content = file.read()
+
+            return content
+        except Exception as e:
+            logger.error(f"Error reading file: {e}")
+            return f"Error reading file: {e}"

gofannon/file/write_file.py

@@ -0,0 +1,46 @@
+from..base import BaseTool
+from ..config import FunctionRegistry
+import logging
+
+logger = logging.getLogger(__name__)
+
+@FunctionRegistry.register
+class WriteFile(BaseTool):
+    def __init__(self, name="write_file"):
+        super().__init__()
+        self.name = name
+
+    @property
+    def definition(self):
+        return {
+            "type": "function",
+            "function": {
+                "name": self.name,
+                "description": "Write the contents of a sting to a specified file.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "file_path": {
+                            "type": "string",
+                            "description": "The path to the file to be written."
+                        },
+                        "content": {
+                            "type": "string",
+                            "description": "The content to be written to the file."
+                        }
+                    },
+                    "required": ["file_path", "content"]
+                }
+            }
+        }
+
+    def fn(self, file_path, content):
+        logger.debug(f"Writing file: {file_path}")
+        try:
+            with open(file_path, 'w') as file:
+                file.write(content)
+
+            return f"File {file_path} written successfully."
+        except Exception as e:
+            logger.error(f"Error writing file: {e}")
+            return f"Error writing file: {e}"

gofannon/github/list_issues.py

@@ -0,0 +1,110 @@
+from..base import BaseTool
+from requests import get
+import json
+from ..config import FunctionRegistry
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+@FunctionRegistry.register
+class ListIssues(BaseTool):
+    def __init__(self, api_key=None, name="list_issues"):
+        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": "List all issues 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"
+                        },
+                        "state": {
+                            "type": "string",
+                            "enum": ["open", "closed", "all"],
+                            "description": "Filter issues by state (default: open)",
+                            "default": "open"
+                        },
+                        "labels": {
+                            "type": "string",
+                            "description": "Comma-separated list of label names to filter by"
+                        },
+                        "sort": {
+                            "type": "string",
+                            "enum": ["created", "updated", "comments"],
+                            "description": "What to sort results by (default: created)",
+                            "default": "created"
+                        },
+                        "direction": {
+                            "type": "string",
+                            "enum": ["asc", "desc"],
+                            "description": "Sort direction (default: desc)",
+                            "default": "desc"
+                        },
+                        "since": {
+                            "type": "string",
+                            "description": "Only show issues updated after this date (ISO 8601 format)"
+                        }
+                    },
+                    "required": ["repo_url"]
+                }
+            }
+        }
+
+    def fn(self, repo_url, state="open", labels=None, sort="created", direction="desc", since=None):
+        logger.debug(f"Listing issues for repo {repo_url} with state={state}")
+        # 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}',
+            'Accept': 'application/vnd.github.v3+json'
+        }
+        params = {
+            'state': state,
+            'sort': sort,
+            'direction': direction
+        }
+
+        if labels:
+            params['labels'] = labels
+        if since:
+            params['since'] = since
+
+        response = get(api_url, headers=headers, params=params)
+        response.raise_for_status()
+
+        issues = response.json()
+
+        # Format the response
+        formatted_issues = []
+        for issue in issues:
+            # Skip pull requests (GitHub API returns PRs as issues too)
+            if 'pull_request' in issue:
+                continue
+
+            formatted_issues.append({
+                "number": issue['number'],
+                "title": issue['title'],
+                "state": issue['state'],
+                "created_at": issue['created_at'],
+                "updated_at": issue['updated_at'],
+                "html_url": issue['html_url'],
+                "labels": [label['name'] for label in issue['labels']],
+                "user": issue['user']['login']
+            })
+
+        return formatted_issues

{gofannon-0.25.17.dist-info → gofannon-0.25.18.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: gofannon
-Version: 0.25.17
+Version: 0.25.18
 Summary: A collection of tools for LLMs
 License: ASFv2
 Author: Trevor Grant

{gofannon-0.25.17.dist-info → gofannon-0.25.18.dist-info}/RECORD

@@ -2,10 +2,11 @@ gofannon/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 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=gFBxYPxhyy1yLyXIEgbVPqQSgnr6PzXnEb1S054IYQM,3685
+gofannon/base/__init__.py,sha256=wnTkASBszxkZiWugQOgvSdAghFFBUwxzRzz7wTMxg3c,3757
 gofannon/base/bedrock.py,sha256=Z2c36R8jaIusgpmegbYVz2eR7lDBc0IhTtwiqUGOcT4,25646
 gofannon/base/langchain.py,sha256=25z9opy7E7qWP-DSn6oYAqKDg8i21az-kAKrsYLfyiQ,2704
 gofannon/base/langflow.py,sha256=0WfNJ9MnndyLJ-yUAStIuXZpCzOPItsGKgtxdNifmLM,3833
+gofannon/base/llamastack.py,sha256=M1820wdKgNBDca12fjO5PMWyhHu7Inj0qSioKqmFj8o,11251
 gofannon/base/mcp.py,sha256=2e7f1FiD_M7wk4gOd7YNt4zLBgdLQTnWWYL0Kf5CzTY,253
 gofannon/base/smol_agents.py,sha256=p2YU5BrscavGk5X9R7HSJmtVR5OpOsQwCd9hwC9eBMk,2229
 gofannon/basic_math/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
@@ -15,12 +16,17 @@ gofannon/basic_math/exponents.py,sha256=w4qDlFZ9M1lf6X-tjG-ndpECfCOS7Qtc_VLICw0o
 gofannon/basic_math/multiplication.py,sha256=PJ5sKWMCVlBaTeZ_j3gwYOEQXAhN-qIXhnrNcyhWGKM,1168
 gofannon/basic_math/subtraction.py,sha256=gM1_N1mZ3qAXC6qnkzfijKXiOx27Gg93-CaB_ifMbOQ,1164
 gofannon/config.py,sha256=KPVtjBnpwfM39EQg-_xiqL1UFxcuQehrQIUS6HHBP6k,1784
+gofannon/file/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gofannon/file/list_directory.py,sha256=Jw0F50_hdtyDSFBmcy9e8F4KajtsPyT8Gsm_eyjMUuQ,2679
+gofannon/file/read_file.py,sha256=kYf-4aGCHLj-D-XQs0YBEnbB1MbIccgcWbiLnVXidp4,1669
+gofannon/file/write_file.py,sha256=fQ5P4cqZKdoq8Bk7nys2Esau0Q5WvbeY8srGvfx36NQ,1495
 gofannon/github/__init__.py,sha256=VFw4sJIt4Zc0-__eYnksN8Ku9qMhbPpHJEkXMWUiD30,4
 gofannon/github/clone_repo.py,sha256=UNXh1JaZkzK94REJUfQrBAhF66ncFWkzcZj34Si34cI,2287
 gofannon/github/commit_file.py,sha256=jdQGQHbrZx4521XgTbx5N0Ss8fDyl7hvp9sjDW15v9U,2573
 gofannon/github/commit_files.py,sha256=OZclhhSejRB1CYmd7IGYvdJZEWBzpaRRKK5S8NQxALU,4554
 gofannon/github/create_issue.py,sha256=oS4Q-3urpd-qTJ9K4cCCrwMl_QumlVFsM5q-M1_pc_I,2475
 gofannon/github/get_repo_contents.py,sha256=9k6M2BqGlNsSGVjyfW7nxZpk1TFuhyPoZvURkv1PEyo,3637
+gofannon/github/list_issues.py,sha256=F1YkRrmtequaGAPo-dIanyi75SQ-Gq5UWMf6cmhOLcY,4018
 gofannon/github/pr_review_tool.py,sha256=srBbfgqBWy-J4wdAM0kLJfQr8LJ6uaA4vkDErqhyMxI,4336
 gofannon/github/read_issue.py,sha256=JrnBAlZxknhHm3aLC0uB9u0bSvoQNfK3OKmxYlr8jgQ,2308
 gofannon/github/search.py,sha256=yuX_dZ6f8ogUnskIRMUgF8wuN7JepqRtTDFrbmbwrrs,2183
@@ -43,7 +49,7 @@ gofannon/reasoning/sequential_cot.py,sha256=m9c8GnyTtmI-JntCuhkoFfULAabVOxsYgTRU
 gofannon/reasoning/tree_of_thought.py,sha256=TRhRJQNsFVauCLw4TOvQCDcX1nGmp_wSg9H67GJn1hs,10574
 gofannon/wikipedia/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 gofannon/wikipedia/wikipedia_lookup.py,sha256=J6wKPbSivCF7cccaiRaJW1o0VqNhQAGfrh5U1ULLesg,2869
-gofannon-0.25.17.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-gofannon-0.25.17.dist-info/METADATA,sha256=CHzEBQQRiROqssrVgBKj2e3Qk-sZaV-NcGZfK6aXNh4,5415
-gofannon-0.25.17.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
-gofannon-0.25.17.dist-info/RECORD,,
+gofannon-0.25.18.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+gofannon-0.25.18.dist-info/METADATA,sha256=fEPx-nCBs3eCopXGFC-fo7UODM7aHKBSt5KE2X2i5Qk,5415
+gofannon-0.25.18.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
+gofannon-0.25.18.dist-info/RECORD,,