130 lines
5.6 KiB
Python
130 lines
5.6 KiB
Python
# methodDiscovery.py
|
|
# Method discovery and management for workflow execution
|
|
|
|
import json
|
|
import logging
|
|
import importlib
|
|
import pkgutil
|
|
import inspect
|
|
from typing import Any, Dict, List
|
|
from modules.datamodels.datamodelWorkflow import TaskContext, ReviewContext, DocumentExchange
|
|
from modules.workflows.methods.methodBase import MethodBase
|
|
|
|
# Set up logger
|
|
logger = logging.getLogger(__name__)
|
|
|
|
# Global methods catalog - moved from serviceCenter
|
|
methods = {}
|
|
|
|
def discoverMethods(serviceCenter):
|
|
"""Dynamically discover all method classes and their actions in modules methods package"""
|
|
try:
|
|
# Import the methods package
|
|
methodsPackage = importlib.import_module('modules.workflows.methods')
|
|
|
|
# Discover all modules in the package
|
|
for _, name, isPkg in pkgutil.iter_modules(methodsPackage.__path__):
|
|
if not isPkg and name.startswith('method'):
|
|
try:
|
|
# Import the module
|
|
module = importlib.import_module(f'modules.workflows.methods.{name}')
|
|
|
|
# Find all classes in the module that inherit from MethodBase
|
|
for itemName, item in inspect.getmembers(module):
|
|
if (inspect.isclass(item) and
|
|
issubclass(item, MethodBase) and
|
|
item != MethodBase):
|
|
# Instantiate the method
|
|
methodInstance = item(serviceCenter)
|
|
|
|
# Use the actions property from MethodBase which handles @action decorator
|
|
actions = methodInstance.actions
|
|
|
|
# Create method info
|
|
methodInfo = {
|
|
'instance': methodInstance,
|
|
'actions': actions,
|
|
'description': item.__doc__ or f"Method {itemName}"
|
|
}
|
|
|
|
# Store the method with full class name
|
|
methods[itemName] = methodInfo
|
|
|
|
# Also store with short name for action executor access
|
|
shortName = itemName.replace('Method', '').lower()
|
|
methods[shortName] = methodInfo
|
|
|
|
logger.info(f"Discovered method {itemName} (short: {shortName}) with {len(actions)} actions")
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error discovering method {name}: {str(e)}")
|
|
continue
|
|
|
|
logger.info(f"Discovered {len(methods)} method entries total")
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error discovering methods: {str(e)}")
|
|
|
|
def getMethodsList(serviceCenter):
|
|
"""Get a list of available methods with their signatures"""
|
|
if not methods:
|
|
discoverMethods(serviceCenter)
|
|
|
|
methodsList = []
|
|
for methodName, methodInfo in methods.items():
|
|
methodDescription = methodInfo['description']
|
|
actionsList = []
|
|
|
|
for actionName, actionInfo in methodInfo['actions'].items():
|
|
actionDescription = actionInfo['description']
|
|
parameters = actionInfo['parameters']
|
|
|
|
# Build parameter signature
|
|
paramSig = []
|
|
for paramName, paramInfo in parameters.items():
|
|
paramType = paramInfo['type']
|
|
paramRequired = paramInfo['required']
|
|
paramDefault = paramInfo['default']
|
|
|
|
if paramRequired:
|
|
paramSig.append(f"{paramName}: {paramType}")
|
|
else:
|
|
defaultStr = f" = {paramDefault}" if paramDefault is not None else " = None"
|
|
paramSig.append(f"{paramName}: {paramType}{defaultStr}")
|
|
|
|
paramSignature = f"({', '.join(paramSig)})" if paramSig else "()"
|
|
actionsList.append(f"- {actionName}{paramSignature}: {actionDescription}")
|
|
|
|
actionsStr = "\n".join(actionsList)
|
|
methodsList.append(f"**{methodName}**: {methodDescription}\n{actionsStr}")
|
|
|
|
return "\n\n".join(methodsList)
|
|
|
|
def getActionParameterSignature(methodName: str, actionName: str, methods: Dict[str, Any]) -> str:
|
|
"""Get action parameter signature from method docstring for AI parameter generation"""
|
|
try:
|
|
if not methods or methodName not in methods:
|
|
return ""
|
|
|
|
methodInstance = methods[methodName]['instance']
|
|
if actionName not in methodInstance.actions:
|
|
return ""
|
|
|
|
action_info = methodInstance.actions[actionName]
|
|
# Extract parameter descriptions from docstring
|
|
docstring = action_info.get('description', '')
|
|
paramDescriptions, paramTypes = methodInstance._extractParameterDetails(docstring)
|
|
|
|
param_list = []
|
|
for paramName, paramDesc in paramDescriptions.items():
|
|
paramType = paramTypes.get(paramName, 'Any')
|
|
if paramDesc:
|
|
param_list.append(f"- {paramName} ({paramType}): {paramDesc}")
|
|
else:
|
|
param_list.append(f"- {paramName} ({paramType})")
|
|
|
|
return "Required parameters:\n" + "\n".join(param_list)
|
|
except Exception as e:
|
|
logger.error(f"Error getting action parameter signature for {methodName}.{actionName}: {str(e)}")
|
|
return ""
|
|
|