solana-agent 20.1.2__py3-none-any.whl → 31.4.0__py3-none-any.whl

solana_agent/plugins/manager.py

@@ -4,14 +4,21 @@ Plugin manager for the Solana Agent system.
 This module implements the concrete PluginManager that discovers,
 loads, and manages plugins.
 """
+
 import importlib
+import logging
 from typing import Dict, List, Any, Optional
 import importlib.metadata
 
-from solana_agent.interfaces.plugins.plugins import PluginManager as PluginManagerInterface
+from solana_agent.interfaces.plugins.plugins import (
+    PluginManager as PluginManagerInterface,
+)
 from solana_agent.interfaces.plugins.plugins import Plugin
 from solana_agent.plugins.registry import ToolRegistry
 
+# Setup logger for this module
+logger = logging.getLogger(__name__)
+
 
 class PluginManager(PluginManagerInterface):
     """Manager for discovering and loading plugins."""
@@ -19,7 +26,11 @@ class PluginManager(PluginManagerInterface):
     # Class variable to track loaded entry points
     _loaded_entry_points = set()
 
-    def __init__(self, config: Optional[Dict[str, Any]] = None, tool_registry: Optional[ToolRegistry] = None):
+    def __init__(
+        self,
+        config: Optional[Dict[str, Any]] = None,
+        tool_registry: Optional[ToolRegistry] = None,
+    ):
         """Initialize with optional configuration and tool registry."""
         self.config = config or {}
         self.tool_registry = tool_registry or ToolRegistry()
@@ -43,11 +54,15 @@ class PluginManager(PluginManagerInterface):
 
             # Only store plugin if both initialize and configure succeed
             self._plugins[plugin.name] = plugin
-            print(f"Successfully registered plugin {plugin.name}")
+            logger.info(
+                f"Successfully registered plugin {plugin.name}"
+            )  # Use logger.info
             return True
 
         except Exception as e:
-            print(f"Error registering plugin {plugin.name}: {e}")
+            logger.error(
+                f"Error registering plugin {plugin.name}: {e}"
+            )  # Use logger.error
             # Remove plugin from registry if it was added
             self._plugins.pop(plugin.name, None)
             return False
@@ -61,16 +76,21 @@ class PluginManager(PluginManagerInterface):
         loaded_plugins = []
 
         # Discover plugins through entry points
-        for entry_point in importlib.metadata.entry_points(group='solana_agent.plugins'):
+        for entry_point in importlib.metadata.entry_points(
+            group="solana_agent.plugins"
+        ):
             # Skip if this entry point has already been loaded
             entry_point_id = f"{entry_point.name}:{entry_point.value}"
             if entry_point_id in PluginManager._loaded_entry_points:
-                print(
-                    f"Skipping already loaded plugin: {entry_point.name}")
+                logger.info(
+                    f"Skipping already loaded plugin: {entry_point.name}"
+                )  # Use logger.info
                 continue
 
             try:
-                print(f"Found plugin entry point: {entry_point.name}")
+                logger.info(
+                    f"Found plugin entry point: {entry_point.name}"
+                )  # Use logger.info
                 PluginManager._loaded_entry_points.add(entry_point_id)
                 plugin_factory = entry_point.load()
                 plugin = plugin_factory()
@@ -81,7 +101,9 @@ class PluginManager(PluginManagerInterface):
                     loaded_plugins.append(entry_point.name)
 
             except Exception as e:
-                print(f"Error loading plugin {entry_point.name}: {e}")
+                logger.error(
+                    f"Error loading plugin {entry_point.name}: {e}"
+                )  # Use logger.error
 
         return loaded_plugins
 
@@ -103,10 +125,7 @@ class PluginManager(PluginManagerInterface):
             List of plugin details dictionaries
         """
         return [
-            {
-                "name": plugin.name,
-                "description": plugin.description
-            }
+            {"name": plugin.name, "description": plugin.description}
             for plugin in self._plugins.values()
         ]
 
@@ -137,10 +156,12 @@ class PluginManager(PluginManagerInterface):
         """
         self.config.update(config)
         self.tool_registry.configure_all_tools(config)
-        print("Configuring all plugins with updated config")
+        logger.info("Configuring all plugins with updated config")  # Use logger.info
         for name, plugin in self._plugins.items():
             try:
-                print(f"Configuring plugin: {name}")
+                logger.info(f"Configuring plugin: {name}")  # Use logger.info
                 plugin.configure(self.config)
             except Exception as e:
-                print(f"Error configuring plugin {name}: {e}")
+                logger.error(
+                    f"Error configuring plugin {name}: {e}"
+                )  # Use logger.error

solana_agent/plugins/registry.py

@@ -1,14 +1,21 @@
 """
 Tool registry for the Solana Agent system.
 
-This module implements the concrete ToolRegistry that manages tools 
+This module implements the concrete ToolRegistry that manages tools
 and their access permissions.
 """
+
+import logging  # Import logging
 from typing import Dict, List, Any, Optional
 
-from solana_agent.interfaces.plugins.plugins import ToolRegistry as ToolRegistryInterface
+from solana_agent.interfaces.plugins.plugins import (
+    ToolRegistry as ToolRegistryInterface,
+)
 from solana_agent.interfaces.plugins.plugins import Tool
 
+# Setup logger for this module
+logger = logging.getLogger(__name__)
+
 
 class ToolRegistry(ToolRegistryInterface):
     """Instance-based registry that manages tools and their access permissions."""
@@ -25,10 +32,12 @@ class ToolRegistry(ToolRegistryInterface):
             tool.configure(self._config)
 
             self._tools[tool.name] = tool
-            print(f"Successfully registered and configured tool: {tool.name}")
+            logger.info(
+                f"Successfully registered and configured tool: {tool.name}"
+            )  # Use logger.info
             return True
         except Exception as e:
-            print(f"Error registering tool: {str(e)}")
+            logger.error(f"Error registering tool: {str(e)}")  # Use logger.error
             return False
 
     def get_tool(self, tool_name: str) -> Optional[Tool]:
@@ -38,8 +47,9 @@ class ToolRegistry(ToolRegistryInterface):
     def assign_tool_to_agent(self, agent_name: str, tool_name: str) -> bool:
         """Give an agent access to a specific tool."""
         if tool_name not in self._tools:
-            print(
-                f"Error: Tool {tool_name} is not registered. Available tools: {list(self._tools.keys())}")
+            logger.error(  # Use logger.error
+                f"Error: Tool {tool_name} is not registered. Available tools: {list(self._tools.keys())}"
+            )
             return False
 
         # Initialize agent's tool list if not exists
@@ -47,12 +57,14 @@ class ToolRegistry(ToolRegistryInterface):
             self._agent_tools[agent_name] = [tool_name]
         elif tool_name not in self._agent_tools[agent_name]:
             # Add new tool to existing list
-            self._agent_tools[agent_name] = [
-                *self._agent_tools[agent_name], tool_name]
+            self._agent_tools[agent_name] = [*self._agent_tools[agent_name], tool_name]
 
-        print(f"Successfully assigned tool {tool_name} to agent {agent_name}")
-        print(
-            f"Agent {agent_name} now has access to: {self._agent_tools[agent_name]}")
+        logger.info(
+            f"Successfully assigned tool {tool_name} to agent {agent_name}"
+        )  # Use logger.info
+        logger.info(
+            f"Agent {agent_name} now has access to: {self._agent_tools[agent_name]}"
+        )  # Use logger.info
 
         return True
 
@@ -63,12 +75,15 @@ class ToolRegistry(ToolRegistryInterface):
             {
                 "name": name,
                 "description": self._tools[name].description,
-                "parameters": self._tools[name].get_schema()
+                "parameters": self._tools[name].get_schema(),
             }
-            for name in tool_names if name in self._tools
+            for name in tool_names
+            if name in self._tools
         ]
-        print(
-            f"Tools available to agent {agent_name}: {[t['name'] for t in tools]}")
+        # Changed to debug level as this might be verbose during normal operation
+        logger.debug(
+            f"Tools available to agent {agent_name}: {[t['name'] for t in tools]}"
+        )  # Use logger.debug
         return tools
 
     def list_all_tools(self) -> List[str]:
@@ -86,13 +101,13 @@ class ToolRegistry(ToolRegistryInterface):
 
         for name, tool in self._tools.items():
             try:
-                print(f"Configuring tool: {name}")
+                logger.info(f"Configuring tool: {name}")  # Use logger.info
                 tool.configure(self._config)
             except Exception as e:
-                print(f"Error configuring tool {name}: {e}")
+                logger.error(f"Error configuring tool {name}: {e}")  # Use logger.error
                 configure_errors.append((name, str(e)))
 
         if configure_errors:
-            print("The following tools failed to configure:")
+            logger.error("The following tools failed to configure:")  # Use logger.error
             for name, error in configure_errors:
-                print(f"- {name}: {error}")
+                logger.error(f"- {name}: {error}")  # Use logger.error

solana_agent/plugins/tools/__init__.py

@@ -3,8 +3,3 @@ Tools for the Solana Agent system.
 
 This package contains the base AutoTool class and built-in tool implementations.
 """
-
-from solana_agent.plugins.tools.auto_tool import *
-
-# Version of the domain model
-__version__ = '14.0.0'

solana_agent/plugins/tools/auto_tool.py

@@ -4,6 +4,7 @@ AutoTool implementation for the Solana Agent system.
 This module provides the base AutoTool class that implements the Tool interface
 and can be extended to create custom tools.
 """
+
 from typing import Dict, Any
 
 from solana_agent.interfaces.plugins.plugins import Tool