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

gofannon/base/__init__.py

@@ -9,6 +9,8 @@ from ..config import ToolConfig
 
 from .smol_agents import SmolAgentsMixin
 from .langchain import LangchainMixin
+from .bedrock import BedrockMixin
+
 
 @dataclass
 class ToolResult:
@@ -17,6 +19,7 @@ class ToolResult:
     error: str = None
     retryable: bool = False
 
+
 class WorkflowContext:
     def __init__(self, firebase_config=None):
         self.data = {}
@@ -33,34 +36,37 @@ class WorkflowContext:
 
     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)
+        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
-        })
+        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
+            "tool": tool_name,
+            "duration": duration,
+            "input": input_data,
+            "output": output_data,
         }
         self.execution_log.append(entry)
 
-class BaseTool(SmolAgentsMixin, LangchainMixin, ABC):
+
+class BaseTool(SmolAgentsMixin, LangchainMixin, BedrockMixin, ABC):
     def __init__(self, **kwargs):
-        self.logger = logging.getLogger(f"{self.__class__.__module__}.{self.__class__.__name__}")
+        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__)
@@ -73,7 +79,7 @@ class BaseTool(SmolAgentsMixin, LangchainMixin, ABC):
 
     def _load_config(self):
         """Auto-load config based on tool type"""
-        if hasattr(self, 'API_SERVICE'):
+        if hasattr(self, "API_SERVICE"):
             self.api_key = ToolConfig.get(f"{self.API_SERVICE}_api_key")
 
     @property
@@ -83,7 +89,7 @@ class BaseTool(SmolAgentsMixin, LangchainMixin, ABC):
 
     @property
     def output_schema(self):
-        return self.definition.get('function', {}).get('parameters', {})
+        return self.definition.get("function", {}).get("parameters", {})
 
     @abstractmethod
     def fn(self, *args, **kwargs):
@@ -99,14 +105,9 @@ class BaseTool(SmolAgentsMixin, LangchainMixin, ABC):
                 tool_name=self.__class__.__name__,
                 duration=duration,
                 input_data=kwargs,
-                output_data=result
+                output_data=result,
             )
 
             return ToolResult(success=True, output=result)
         except Exception as e:
-            return ToolResult(
-                success=False,
-                output=None,
-                error=str(e),
-                retryable=True
-            )
+            return ToolResult(success=False, output=None, error=str(e), retryable=True)

gofannon/base/bedrock.py

@@ -0,0 +1,666 @@
+from typing import Type, Callable
+import subprocess
+import shutil
+import zipfile
+import json
+import time
+
+try:
+    import boto3
+    from botocore.exceptions import ClientError
+    from botocore.client import BaseClient
+
+    _HAS_BOTO3 = True
+except ImportError:
+    _HAS_BOTO3 = False
+
+try:
+    from jsonschema import validate
+    import jsonschema.exceptions
+
+    _HAS_JSONSCHEMA = True
+except ImportError:
+    _HAS_JSONSCHEMA = False
+
+
+class BedrockMixin:
+
+    def export_to_bedrock(self, agent_app_config: dict = None) -> dict:
+        """
+        Export tool as Bedrock Agent tool configuration
+        """
+        if not _HAS_BOTO3:
+            error = "boto3 not installed. Install with `pip install boto3`"
+            self.logger.error(error)
+            raise RuntimeError(error)
+
+        if not _HAS_JSONSCHEMA:
+            error = "jasonschema not installed. Install with `pip install jsonschema`"
+            self.logger.error(error)
+            raise RuntimeError(error)
+
+        valid_agent_app_config_schema = {
+            "type": "object",
+            "properties": {
+                "app_id": {"type": "string"},
+                "agent_session_timeout": {"type": "integer"},
+                "instruction": {"type": "string"},
+                "agent_description": {"type": "string"},
+                "target_model": {"type": "string"},
+                "python_runtime_version": {"type": "string"},
+                "temp_build_root": {"type": "string"},
+            },
+            "required": [
+                "app_id",
+                "agent_session_timeout",
+                "instruction",
+                "agent_description",
+                "target_model",
+                "python_runtime_version",
+                "temp_build_root",
+            ],
+        }
+        try:
+            validate(agent_app_config, valid_agent_app_config_schema)
+        except jsonschema.exceptions.ValidationError as err:
+            error = f"JSON validation failure on input parameters: {err}"
+            self.logger.error(error)
+            raise RuntimeError(error)
+
+        self.bedrock_agent_client = boto3.client("bedrock-agent")
+        self.app_id = agent_app_config["app_id"]
+        self.agent_name = agent_app_config["agent_name"]
+        self.agent_session_timeout = agent_app_config["agent_session_timeout"]
+        self.agent_instruction = agent_app_config["instruction"]
+        self.agent_description = agent_app_config["agent_description"]
+        self.agent_target_model = agent_app_config["target_model"]
+        self.python_runtime_version = agent_app_config["python_runtime_version"]
+        self.temp_build_root = agent_app_config["temp_build_root"]
+        try:
+            self.aws_account_id = (
+                boto3.client("sts").get_caller_identity().get("Account")
+            )
+        except ClientError as e:
+            error = f"Error getting AWS account number. Client error: {e}"
+            self.logger.error(error)
+            raise RuntimeError(error)
+        except Exception as e:
+            error = f"Error getting AWS account number. Unexpected error: {e}"
+            self.logger.error(error)
+            raise RuntimeError(error)
+
+        self.openapi_schema_dict = self._generate_openapi_schema()
+
+        self.logger.info(
+            f"Starting build of app {self.app_id}...", self.__class__.__name__
+        )
+        # Creates:
+        # the lambda - a .zip archive that contains all the dependencies and the lambda source.
+        #              This lambda will have a resource-based policy attached giving it
+        #              permission to be invoked by the agent attached.
+        # an IAM role - the lambda execution role with managed attached policy
+        #               AWSLambdaBasicExecutionRole allowing the lambda to use CloudWatch
+
+        self.logger.info("\tCreating lambda...", self.__class__.__name__)
+
+        self.lambda_arn = self._create_bedrock_lambda()
+
+        # Creates:
+        # the Bedrock agent - The bedrock agent itself
+        # an IAM role - The agent execution role
+        # An IAM policy - a policy to attach to the role allowing the agent to invoke the
+        #               - foundational model
+        self.logger.info("\tCreating agent...", self.__class__.__name__)
+        self.agent_id = self._create_bedrock_agent()
+
+        # Creates:
+        # the Bedrock agent action group - Defined with an API schema
+        self.logger.info("\tCreating agent action group...", self.__class__.__name__)
+        action_group = self._create_agent_action_group()
+
+        # Finally, prepare the agent
+        self.logger.info("\tPreparing agent...", self.__class__.__name__)
+        try:
+            response = self.bedrock_agent_client.prepare_agent(agentId=self.agent_id)
+        except ClientError as e:
+            error = f"Error preparing agent. Client error: {e}"
+            self.logger.error(error)
+            raise RuntimeError(error)
+        except Exception as e:
+            error = f"Error preparing agent. Unexpected error: {e}"
+            self.logger.error(error)
+            raise RuntimeError(error)
+
+        output_manifest = {
+            "lambdaARN": self.lambda_arn,
+            "lambdaRoleName": self.lambda_role_name,
+            "agentId": self.agent_id,
+            "agentRoleName": self.agent_role_name,
+            "agentPolicyARN": self.agent_role_policy_arn,
+            "agentActionGroup": self.agent_action_group_id,
+        }
+        self.logger.info("Done!", self.__class__.__name__)
+        return output_manifest
+
+    def _generate_openapi_schema(self) -> dict:
+        """Convert Gofannon definition to OpenAPI schema"""
+        params = self.definition["function"]["parameters"]
+        if not "properties" in params:
+            params["properties"] = {}
+        openapi_schema = {
+            "openapi": "3.0.0",
+            "info": {"title": self.name, "version": "1.0.0"},
+            "paths": {
+                f"/{self.name}": {
+                    "get": {
+                        "description": self.definition["function"]["description"],
+                        "requestBody": {
+                            "content": {
+                                "application/json": {
+                                    "schema": {
+                                        "type": "object",
+                                        "properties": {
+                                            param: {
+                                                "type": props["type"],
+                                                "description": props["description"],
+                                            }
+                                            for param, props in params[
+                                                "properties"
+                                            ].items()
+                                        },
+                                        "required": params.get("required", []),
+                                    }
+                                }
+                            }
+                        },
+                        "responses": {
+                            "200": {
+                                "description": "Successful operation",
+                                "content": {
+                                    "application/json": {
+                                        "schema": {
+                                            "type": "object",
+                                            "properties": {
+                                                "result": {"type": "string"}
+                                            },
+                                        }
+                                    }
+                                },
+                            }
+                        },
+                    }
+                }
+            },
+        }
+
+        return openapi_schema
+
+    def _create_bedrock_lambda(self) -> str:
+        """Create Lambda function for Bedrock integration"""
+
+        lambda_client = boto3.client("lambda")
+        self.lambda_role_arn = self._create_bedrock_lambda_role()
+
+        # Build the lambda .zip deployment package here. Package consits of:
+        # 1. All the Python dependencies, including Gofannon itself
+        # 2. The lambda source code.
+        # bash code as comments at the bottom of this file.
+        # See: https://docs.aws.amazon.com/lambda/latest/dg/python-package.html
+
+        # TODO: verify the path here
+        command = f"""../../scripts/build_lambda.sh {self.temp_build_root} {self.python_runtime_version.replace("python","")} {self.app_id}"""
+        try:
+            process = subprocess.Popen(
+                command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE
+            )
+            stdout, stderr = process.communicate()
+
+            if process.returncode == 0:
+                self.built_archive = stdout.decode("utf-8").replace("\n", "")
+            else:
+                raise RuntimeError(stderr.decode("utf-8"))
+
+        except Exception as e:
+            error = f"Error creating .zip archive. {e}"
+            self.logger.error(error)
+            raise RuntimeError(error)
+
+        # TODO: Skeleton code in the function directory or here?
+        lambda_src_string = self._get_lambda_source(
+            module_name=self.__class__.__module__, class_name=self.__class__.__name__
+        )
+
+        try:
+            with open(f"{self.temp_build_root}/lambda_function.py", "w") as text_file:
+                text_file.write(lambda_src_string)
+        except Exception as e:
+            error = f"Error writing lambda Python source file: {e}"
+            self.logger.error(error)
+            raise RuntimeError(error)
+
+        try:
+            with zipfile.ZipFile(
+                self.built_archive,
+                "a",
+                compression=zipfile.ZIP_DEFLATED,
+            ) as zipf:
+                zipf.write(
+                    f"{self.temp_build_root}/lambda_function.py", "lambda_function.py"
+                )
+        except Exception as e:
+            error = f"Error inserting lambda Python source file into zip: {e}"
+            self.logger.error(error)
+            raise RuntimeError(error)
+
+        with open(self.built_archive, "rb") as f:
+            zipped_code = f.read()
+
+        try:
+            response = lambda_client.create_function(
+                FunctionName=f"{self.app_id}_{self.name}",
+                Runtime=self.python_runtime_version,
+                Role=self.lambda_role_arn,
+                Handler="lambda_function.lambda_handler",
+                Code={"ZipFile": zipped_code},
+                Description=f"{self.app_id} tool: {self.name}",
+                Timeout=30,
+                MemorySize=256,
+            )
+        except ClientError as e:
+            error = f"Error creating lambda. Client error: {e}"
+            self.logger.error(error)
+            raise RuntimeError(error)
+
+        except Exception as e:
+            error = f"Error creating lambda. Unexpected error: {e}"
+            self.logger.error(error)
+            raise RuntimeError(error)
+
+        # Clean up the .zip archive build
+        try:
+            shutil.rmtree(self.temp_build_root)
+        except OSError as e:
+            error = (
+                f"Error deleting temporary build directory {self.temp_build_root}: {e}"
+            )
+            self.logger.error(error)
+            pass
+
+        # Add the resourced-base policy allowing the lambda to be invoked
+        # by the agent.
+        try:
+            add_permission_response = lambda_client.add_permission(
+                StatementId=f"{self.app_id}-bedrock-invoke",
+                FunctionName=response["FunctionArn"],
+                Action="lambda:InvokeFunction",
+                Principal="bedrock.amazonaws.com",
+                # TODO: fix this. Remove wildcard
+                SourceArn=f"arn:aws:bedrock:us-east-1:{self.aws_account_id}:agent/*",
+            )
+        except ClientError as e:
+            error = f"Error attaching resource policy to lambda execution role. Client error: {e}"
+            self.logger.error(error)
+            raise RuntimeError(error)
+        except Exception as e:
+            error = f"Error attaching resource policy to lambda execution role. Unexpected error: {e}"
+            self.logger.error(error)
+            raise RuntimeError(error)
+
+        return response["FunctionArn"]
+
+    def _create_bedrock_lambda_role(self) -> str:
+        """Get or create IAM role for Bedrock integration"""
+        iam = boto3.client("iam")
+
+        self.lambda_role_name = f"{self.app_id}_bedrock_lambda_execution_role"
+        self.assume_role = self._get_assumed_role(service="lambda.amazonaws.com")
+
+        try:
+            iam.create_role(
+                RoleName=self.lambda_role_name,
+                AssumeRolePolicyDocument=json.dumps(self.assume_role),
+            )
+        except ClientError as e:
+            error = f"Error creating lambda execution role. Client error: {e}"
+            self.logger.error(error)
+            raise RuntimeError(error)
+        except Exception as e:
+            error = f"Error creating lambda execution role. Unexpected error: {e}"
+            self.logger.error(error)
+            raise RuntimeError(error)
+
+        try:
+            iam.attach_role_policy(
+                RoleName=self.lambda_role_name,
+                PolicyArn="arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole",
+            )
+        except ClientError as e:
+            error = f"Error attaching managed policy to lambda execution role. Client error: {e}"
+            self.logger.error(error)
+            raise RuntimeError(error)
+
+        except Exception as e:
+            error = f"Error attaching managed policy to lambda execution role. Unexpected error: {e}"
+            self.logger.error(error)
+            raise RuntimeError(error)
+
+        return iam.get_role(RoleName=self.lambda_role_name)["Role"]["Arn"]
+
+    def _create_bedrock_agent(self) -> str:
+        """Create Bedrock agent"""
+
+        self.agent_role_arn = self._create_agent_role()
+
+        args = {
+            "agentName": f"{self.app_id}_{self.agent_name}Agent",
+            "agentResourceRoleArn": self.agent_role_arn,
+            "foundationModel": self.agent_target_model,
+            "idleSessionTTLInSeconds": self.agent_session_timeout,
+            "instruction": self.agent_instruction,
+            "description": self.agent_description,
+        }
+
+        try:
+            response = self.bedrock_agent_client.create_agent(**args)
+        except ClientError as e:
+            error = f"Error creating agent. Client error: {e}"
+            self.logger.error(error)
+            raise RuntimeError(error)
+
+        except Exception as e:
+            error = f"Error creating agent. Unexpected error: {e}"
+            self.logger.error(error)
+            raise RuntimeError(error)
+
+        return response["agent"]["agentId"]
+
+    def _create_agent_action_group(self):
+        """Create Bedrock action group and attach to Bedrock agent"""
+
+        args = {
+            "agentId": self.agent_id,
+            "actionGroupExecutor": {
+                "lambda": self.lambda_arn,
+            },
+            "actionGroupName": f"{self.app_id}_{self.agent_name}_ag",
+            "agentVersion": "DRAFT",
+            "apiSchema": {"payload": json.dumps(self.openapi_schema_dict)},
+            "description": self.agent_description,
+        }
+
+        # Wait until agent status transitions to CREATING before creating the action group.
+        counter = 0
+        agent_details = self.bedrock_agent_client.get_agent(agentId=self.agent_id)
+        agent_status = agent_details["agent"]["agentStatus"]
+        while (agent_status == "CREATING") and (counter <= 9):
+            counter = counter + 1
+            time.sleep(1)
+            agent_details = self.bedrock_agent_client.get_agent(agentId=self.agent_id)
+            agent_status = agent_details["agent"]["agentStatus"]
+
+        if counter == 10:
+            error = f"Error creating agent timeout. Agent created, but status never transitioned out of CREATING"
+            self.logger.error(error)
+            raise RuntimeError(error)
+
+        try:
+            agent_action_group = self.bedrock_agent_client.create_agent_action_group(
+                **args
+            )
+            self.agent_action_group_id = agent_action_group["agentActionGroup"][
+                "actionGroupId"
+            ]
+        except ClientError as e:
+            error = f"Error creating agent action group. Client error: {e}"
+            self.logger.error(error)
+            raise RuntimeError(error)
+        except Exception as e:
+            error = f"Error creating agent action group. Unexpected error: {e}"
+            self.logger.error(error)
+            raise RuntimeError(error)
+
+        return agent_action_group
+
+    def _create_agent_role(self) -> str:
+        """Create IAM agent role for Bedrock integration"""
+
+        iam = boto3.client("iam")
+
+        self.agent_role_name = f"{self.app_id}_bedrock_agent_execution_role"
+        self.agent_policy_name = f"{self.app_id}_bedrock_agent_allow_model"
+
+        assume_role = self._get_assumed_role(service="bedrock.amazonaws.com")
+
+        try:
+            iam.create_role(
+                RoleName=self.agent_role_name,
+                AssumeRolePolicyDocument=json.dumps(assume_role),
+            )
+        except ClientError as e:
+            error = f"Error creating agent role. Client error: {e}"
+            self.logger.error(error)
+            raise RuntimeError(error)
+        except Exception as e:
+            error = f"Error creating agent role. Unexpected error: {e}"
+            self.logger.error(error)
+            raise RuntimeError(error)
+
+        managed_policy_txt = self._get_managed_policy(
+            resource=f"foundation-model/{self.agent_target_model}"
+        )
+
+        try:
+            managed_policy = iam.create_policy(
+                PolicyName=self.agent_policy_name,
+                PolicyDocument=json.dumps(managed_policy_txt),
+            )
+        except ClientError as e:
+            error = f"Error creating agent policy. Client error: {e}"
+            self.logger.error(error)
+            raise RuntimeError(error)
+        except Exception as e:
+            error = f"Error creating agent policy. Unexpected error: {e}"
+            self.logger.error(error)
+            raise RuntimeError(error)
+
+        self.agent_role_policy_arn = (
+            f"arn:aws:iam::{self.aws_account_id}:policy/{self.agent_policy_name}"
+        )
+        try:
+            iam.attach_role_policy(
+                RoleName=self.agent_role_name,
+                PolicyArn=self.agent_role_policy_arn,
+            )
+        except ClientError as e:
+            error = f"Error creating attaching policy to agent role. Client error: {e}"
+            self.logger.error(error)
+            raise RuntimeError(error)
+        except Exception as e:
+            error = (
+                f"Error creating attaching policy to agent role. Unexpected error: {e}"
+            )
+            self.logger.error(error)
+            raise RuntimeError(error)
+
+        return iam.get_role(RoleName=self.agent_role_name)["Role"]["Arn"]
+
+    def _get_assumed_role(self, service: str = None) -> str:
+        """Skeleton code for creating a role"""
+        role = {
+            "Version": "2012-10-17",
+            "Statement": [
+                {
+                    "Effect": "Allow",
+                    "Principal": {"Service": f"{service}"},
+                    "Action": "sts:AssumeRole",
+                }
+            ],
+        }
+        return role
+
+    def _get_managed_policy(self, resource: str = None) -> str:
+        """Skeleton code for creating a policy"""
+        managed_policy_txt = {
+            "Version": "2012-10-17",
+            "Statement": [
+                {
+                    "Action": "bedrock:InvokeModel",
+                    "Resource": f"arn:aws:bedrock:us-east-1::{resource}",
+                    "Effect": "Allow",
+                }
+            ],
+        }
+
+        return managed_policy_txt
+
+    def _get_lambda_source(
+        self, module_name: str = None, class_name: str = None
+    ) -> str:
+        """Bedrock wrapped lambda used by the agent"""
+
+        # funky spacing below is required...
+        lambda_src = f"""
+import json
+from {module_name} import {class_name}
+
+
+def lambda_handler(event, context):
+    tool = {class_name}()
+    result = tool.fn()
+    action_response = {{
+        "actionGroup": event["actionGroup"],
+        "apiPath": event["apiPath"],
+        "httpMethod": event["httpMethod"],
+        "httpStatusCode": 200,
+        "responseBody": {{"application/json": {{"body": json.dumps(result)}}}},
+    }}
+    api_response = {{"messageVersion": "1.0", "response": action_response}}
+
+    return api_response"""
+        return lambda_src
+
+    def delete_app(self, bedrock_config: dict = None) -> bool:
+        """Tear down the boto3 stack created by .export_to_bedrock()"""
+
+        valid_bedrock_config_schema = {
+            "type": "object",
+            "properties": {
+                "lambdaARN": {"type": "string"},
+                "lambdaRoleName": {"type": "string"},
+                "agentId": {"type": "string"},
+                "agentRoleName": {"type": "string"},
+                "agentPolicyARN": {"type": "string"},
+                "agentActionGroup": {"type": "string"},
+            },
+            "required": [
+                "lambdaARN",
+                "lambdaRoleName",
+                "agentId",
+                "agentRoleName",
+                "agentPolicyARN",
+                "agentActionGroup",
+            ],
+        }
+        try:
+            validate(bedrock_config, valid_bedrock_config_schema)
+        except jsonschema.exceptions.ValidationError as err:
+            error = f"JSON validation failure on input bedrock_config: {err}"
+            self.logger.error(error)
+            raise RuntimeError(error)
+
+        self.lambda_client = boto3.client("lambda")
+        self.iam_client = boto3.client("iam")
+        self.bedrock_agent_client = boto3.client("bedrock-agent")
+
+        # Order is important here...
+        try:
+            detach_agent_policy = self.iam_client.detach_role_policy(
+                RoleName=bedrock_config["agentRoleName"],
+                PolicyArn=bedrock_config["agentPolicyARN"],
+            )
+        except ClientError as e:
+            error = f"Error detaching agent policy. Client error: {e}"
+            self.logger.error(error)
+            pass
+        except Exception as e:
+            error = f"Error detaching agent policy. Unexpected error: {e}"
+            self.logger.error(error)
+            pass
+        try:
+            delete_agent_role = self.iam_client.delete_role(
+                RoleName=bedrock_config["agentRoleName"]
+            )
+        except ClientError as e:
+            error = f"Error deleting agent role. Client error: {e}"
+            self.logger.error(error)
+            pass
+        except Exception as e:
+            error = f"Error deleting agent role. Unexpected error: {e}"
+            self.logger.error(error)
+            pass
+
+        try:
+            delete_agent_policy = self.iam_client.delete_policy(
+                PolicyArn=bedrock_config["agentPolicyARN"]
+            )
+        except ClientError as e:
+            error = f"Error deleting agent policy. Client error: {e}"
+            self.logger.error(error)
+            pass
+        except Exception as e:
+            error = f"Error deleting agent policy. Unexpected error: {e}"
+            self.logger.error(error)
+            pass
+
+        try:
+            delete_agent = self.bedrock_agent_client.delete_agent(
+                agentId=bedrock_config["agentId"], skipResourceInUseCheck=True
+            )
+        except ClientError as e:
+            error = f"Error deleting agent. Client error: {e}"
+            self.logger.error(error)
+            pass
+        except Exception as e:
+            error = f"Error deleting agent. Unexpected error: {e}"
+            self.logger.error(error)
+            pass
+
+        try:
+            detach_lambda_policy = self.iam_client.detach_role_policy(
+                RoleName=bedrock_config["lambdaRoleName"],
+                PolicyArn="arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole",
+            )
+        except ClientError as e:
+            error = f"Error detaching lambda policy. Client error: {e}"
+            self.logger.error(error)
+            pass
+        except Exception as e:
+            error = f"Error detaching lambda policy. Unexpected error: {e}"
+            self.logger.error(error)
+            pass
+
+        try:
+            delete_lambda_role = self.iam_client.delete_role(
+                RoleName=bedrock_config["lambdaRoleName"]
+            )
+        except ClientError as e:
+            error = f"Error deleting lambda role. Client error: {e}"
+            self.logger.error(error)
+            pass
+        except Exception as e:
+            error = f"Error deleting lambda role. Unexpected error: {e}"
+            self.logger.error(error)
+            pass
+
+        try:
+            delete_lambda = self.lambda_client.delete_function(
+                FunctionName=bedrock_config["lambdaARN"]
+            )
+        except ClientError as e:
+            error = f"Error deleting lambda. Client error: {e}"
+            self.logger.error(error)
+            pass
+        except Exception as e:
+            error = f"Error deleting lambda. Unexpected error: {e}"
+            self.logger.error(error)
+            pass

gofannon/base/langchain.py

@@ -3,20 +3,30 @@ 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):
+    def import_from_langchain(self, langchain_tool):
         if not _HAS_LANGCHAIN:
-            raise RuntimeError("langchain is not installed. Install with `pip install langchain-core`")
+            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.")
+        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):
+        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 = {}
@@ -29,7 +39,7 @@ class LangchainMixin:
 
         self.fn = adapted_fn
 
-    def export_to_langchain(self) -> LangchainBaseTool:
+    def export_to_langchain(self):
         if not _HAS_LANGCHAIN:
             raise RuntimeError(
                 "langchain is not installed. Install with `pip install langchain-core`"
@@ -43,7 +53,7 @@ class LangchainMixin:
             "integer": int,
             "boolean": bool,
             "object": dict,
-            "array": list
+            "array": list,
         }
 
         parameters = self.definition.get("function", {}).get("parameters", {})
@@ -55,14 +65,16 @@ class LangchainMixin:
             description = param_def.get("description", "")
             fields[param_name] = (
                 type_map.get(param_type, str),
-                Field(..., description=description)
+                Field(..., description=description),
             )
 
-        ArgsSchema = create_model('ArgsSchema', **fields)
+        ArgsSchema = create_model("ArgsSchema", **fields)
 
         class ExportedTool(LangchainBaseTool):
             name: str = self.definition.get("function", {}).get("name", "")
-            description: str = self.definition.get("function", {}).get("description", "")
+            description: str = self.definition.get("function", {}).get(
+                "description", ""
+            )
             args_schema: Type[BaseModel] = ArgsSchema
             fn: Callable = self.fn
 
@@ -70,4 +82,4 @@ class LangchainMixin:
                 return self.fn(*args, **kwargs)
 
         tool = ExportedTool()
-        return tool
+        return tool

gofannon/base/smol_agents.py

@@ -1,12 +1,14 @@
 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):
+    def import_from_smolagents(self, smol_tool):
         if not _HAS_SMOLAGENTS:
             raise RuntimeError(
                 "smolagents is not installed or could not be imported. "
@@ -20,7 +22,7 @@ class SmolAgentsMixin:
 
         self.fn = adapted_fn
 
-    def export_to_smolagents(self) -> SmolTool:
+    def export_to_smolagents(self):
         if not _HAS_SMOLAGENTS:
             raise RuntimeError(
                 "smolagents is not installed or could not be imported. "
@@ -33,7 +35,7 @@ class SmolAgentsMixin:
         inputs_definition = {
             "example_arg": {
                 "type": "string",
-                "description": "Example argument recognized by this tool"
+                "description": "Example argument recognized by this tool",
             }
         }
         output_type = "string"
@@ -46,4 +48,4 @@ class SmolAgentsMixin:
         exported_tool.forward = smol_forward
         exported_tool.is_initialized = True
 
-        return exported_tool
+        return exported_tool

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-0.25.10.1.dist-info → gofannon-0.25.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: gofannon
-Version: 0.25.10.1
+Version: 0.25.12
 Summary: A collection of tools for LLMs
 License: ASFv2
 Author: Trevor Grant
@@ -12,17 +12,20 @@ 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: aws
 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: boto3 (>=1.34.97,<2.0.0) ; extra == "aws"
 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) ; extra == "langchain"
+Requires-Dist: pygithub (>=2.6.1,<3.0.0)
 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)
@@ -31,7 +34,12 @@ 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)  
+![gofannon logo](https://github.com/The-AI-Alliance/gofannon/blob/main/gofannon.jpg)  
+<!-- ![CI](https://github.com/The-AI-Alliance/gofannon/actions/workflows/main.yml/badge.svg) -->
+![PyPI](https://img.shields.io/pypi/v/gofannon)
+![License](https://img.shields.io/github/license/The-AI-Alliance/gofannon)
+![Issues](https://img.shields.io/github/issues/The-AI-Alliance/gofannon)
+![GitHub stars](https://img.shields.io/github/stars/The-AI-Alliance/gofannon?style=social)
   
 # gofannon  
   
@@ -39,7 +47,30 @@ Description-Content-Type: text/markdown
 
 ## Why the name `gofanon` ?
 
-See [`why_the_name_gofannon.md`](./why_the_name_gofannon.md) for the rich story on why we chose to honor this Celtic Diety
+See [`why_the_name_gofannon.md`](https://the-ai-alliance.github.io/gofannon/about/the_name_gofannon/) for the rich story on why we chose to honor this Celtic Diety
+
+## Our Mission
+
+We aim to achieve:
+
+### Cross-Framework Compatibility
+We solve the "vendor lock-in" problem in AI tooling through:
+- Standardized interface definitions
+- Automatic schema translation
+- Bidirectional conversion tools
+
+### Open Source Education
+We make AI development accessible by:
+- Curated contribution pathways
+- Interactive documentation
+- Pair programming sessions
+- Weekly office hours
+
+### Encouraging First-Time Contributors
+We actively support new contributors through:
+- Beginner-friendly issues
+- Clear documentation and guides
+- Supportuve community engagement
 
 ## Features  
   
@@ -51,20 +82,12 @@ See [`why_the_name_gofannon.md`](./why_the_name_gofannon.md) for the rich story
   
 ## Roadmap  
   
-For a detailed overview of planned features and their current status, please refer to the [ROADMAP](./ROADMAP.md).  
+For a detailed overview of planned features and their current status, please refer to the [ROADMAP](https://github.com/The-AI-Alliance/gofannon/blob/main/ROADMAP.md).   
 
 ## Documentation
 
-Documentation can be found [here](./docs).
+Documentation can be found [here](https://github.com/The-AI-Alliance/gofannon/tree/main/docs).Each tool comes with its own documentation, which can be found in the docs/ directory. The documentation provides detailed information on how to use each tool, including required parameters and example usage.
 
-## Contributing  
-  
-We welcome contributions from the community! If you'd like to add a new tool or improve an existing one, please check out our [CONTRIBUTING](./CONTRIBUTING.md) guide for detailed instructions on how to get started.  
-  
-## Documentation  
-  
-Each tool comes with its own documentation, which can be found in the `docs/` directory. The documentation provides detailed information on how to use each tool, including required parameters and example usage.  
-  
 ## Installation  
   
 To install gofannon, simply clone the repository and install the required dependencies:  
@@ -79,11 +102,41 @@ or
 
 ```
 pip install git+https://github.com/The-AI-Alliance/gofannon.git
+# OR
+pip install gofannon
+```
+
+## Communication Channels
+- **Discord** [Join our Discord server](https://discord.gg/2MMCVs76Sr)for eal-time collaboration and support
+- **GitHub Discussions**: Explore our [GitHub organization](https://github.com/The-AI-Alliance/agents-wg/discussions/) for all related projects
+- **Community Calls**: [Join our bi-weekly video meetings](https://calendar.app.google/c4eKW4zrNiXaue926)
+
+## Usage Example
+```bash
+from gofannon.base import BaseTool  
+  
+class NewTool(BaseTool):  
+    def __init__(self):  
+        super().__init__()  
+  
+    @property  
+    def definition(self):  
+        return {  
+            # Define your tool metadata and configuration  
+        }  
+  
+    def fn(self, *args, **kwargs):  
+        # Define your tool functionality  
+        pass  
 ```
 
 ## License  
   
-This project is licensed under the ASFv2 License. See the [LICENSE](./LICENSE) file for more details.  
+This project is licensed under the ASFv2 License. See the [LICENSE](https://github.com/The-AI-Alliance/gofannon/blob/main/LICENSE) file for more details.
+
+## Contributing  
+  
+We welcome contributions from the community! If you'd like to add a new tool or improve an existing one, please check out our [CONTRIBUTING](https://github.com/The-AI-Alliance/gofannon/blob/main/CONTRIBUTING.md) guide for detailed instructions on how to get started.  
   
 ## Support  
   

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

@@ -2,9 +2,10 @@ 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=Bsjc0ZJkVRx_q7f6Pp6czgkiysyTRwmqCZIflX7xeqA,3396
-gofannon/base/langchain.py,sha256=JbktMQQuMr2LmmGDKU4aDPTnBJZ39_UPChXiB9m3eUM,2619
-gofannon/base/smol_agents.py,sha256=8jOK7ijpQ7JjXrk1No6baOmw7PD6FmHLgfXrNX5iJ2E,1672
+gofannon/base/__init__.py,sha256=8-uJsYAbLD-2e4clX73QZ8eip9S2PJlQ9JMRNWFHxSI,3387
+gofannon/base/bedrock.py,sha256=Z2c36R8jaIusgpmegbYVz2eR7lDBc0IhTtwiqUGOcT4,25646
+gofannon/base/langchain.py,sha256=gAmDT_khB28-p8KMf4lT4Buy2w4zrdP1jG4hOituQ54,2714
+gofannon/base/smol_agents.py,sha256=rrdsXiOF-LZ1eY08PCN3r8bg0YEaN1b4vPlSaxii4LI,1654
 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
@@ -18,6 +19,7 @@ gofannon/github/commit_file.py,sha256=jdQGQHbrZx4521XgTbx5N0Ss8fDyl7hvp9sjDW15v9
 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/pr_review_tool.py,sha256=srBbfgqBWy-J4wdAM0kLJfQr8LJ6uaA4vkDErqhyMxI,4336
 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
@@ -35,7 +37,7 @@ gofannon/reasoning/base.py,sha256=D-4JHJqUlqgwMNOkKU0BHYA4GEWwNgPlLxKYHX0FVyg,14
 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.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.25.12.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+gofannon-0.25.12.dist-info/METADATA,sha256=KqFu7dMGSTz5Xg9ESdM20VRNZS3jdWwfRWj9NkV2gvA,6041
+gofannon-0.25.12.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+gofannon-0.25.12.dist-info/RECORD,,