swarms 7.8.4__py3-none-any.whl → 7.8.7__py3-none-any.whl

swarms/agents/ape_agent.py

@@ -1,27 +1,17 @@
-from typing import Any
+from typing import Callable
 
-from tenacity import retry, stop_after_attempt, wait_exponential
 
-from swarms.prompts.prompt_generator import (
-    prompt_generator_sys_prompt as second_sys_prompt,
-)
 from swarms.prompts.prompt_generator_optimizer import (
-    prompt_generator_sys_prompt,
+    OPENAI_PROMPT_GENERATOR_SYS_PROMPT,
 )
 from swarms.utils.loguru_logger import initialize_logger
 
 logger = initialize_logger(log_folder="ape_agent")
 
 
-@retry(
-    stop=stop_after_attempt(3),
-    wait=wait_exponential(multiplier=1, min=4, max=10),
-)
 def auto_generate_prompt(
     task: str = None,
-    model: Any = None,
-    max_tokens: int = 4000,
-    use_second_sys_prompt: bool = True,
+    model: Callable = None,
     *args,
     **kwargs,
 ):
@@ -38,16 +28,9 @@ def auto_generate_prompt(
     str: The generated prompt.
     """
     try:
-        system_prompt = (
-            second_sys_prompt.get_prompt()
-            if use_second_sys_prompt
-            else prompt_generator_sys_prompt.get_prompt()
-        )
-        output = model.run(
-            system_prompt + task, max_tokens=max_tokens
+        return model.run(
+            task=f"{OPENAI_PROMPT_GENERATOR_SYS_PROMPT} \n\n Task: {task}"
         )
-        print(output)
-        return output
     except Exception as e:
         logger.error(f"Error generating prompt: {str(e)}")
         raise

swarms/agents/consistency_agent.py

@@ -7,7 +7,7 @@ from loguru import logger
 from swarms.structs.agent import Agent
 from swarms.structs.conversation import Conversation
 from swarms.structs.malt import majority_voting_prompt
-from swarms.structs.output_types import OutputType
+from swarms.utils.output_types import OutputType
 from swarms.utils.any_to_str import any_to_str
 from swarms.utils.history_output_formatter import (
     history_output_formatter,

swarms/agents/i_agent.py

@@ -22,7 +22,7 @@ from typing import List, Tuple
 from loguru import logger
 from swarms.structs.agent import Agent
 from swarms.structs.conversation import Conversation
-from swarms.structs.output_types import OutputType
+from swarms.utils.output_types import OutputType
 from swarms.utils.history_output_formatter import (
     history_output_formatter,
 )

swarms/agents/reasoning_agents.py

@@ -1,4 +1,4 @@
-from typing import List, Literal
+from typing import List, Literal, Dict, Callable, Any
 
 from swarms.agents.consistency_agent import SelfConsistencyAgent
 from swarms.agents.flexion_agent import ReflexionAgent
@@ -7,7 +7,7 @@ from swarms.agents.i_agent import (
     IterativeReflectiveExpansion as IREAgent,
 )
 from swarms.agents.reasoning_duo import ReasoningDuo
-from swarms.structs.output_types import OutputType
+from swarms.utils.output_types import OutputType
 from swarms.agents.agent_judge import AgentJudge
 
 agent_types = Literal[
@@ -62,13 +62,100 @@ class ReasoningAgentRouter:
         self.num_knowledge_items = num_knowledge_items
         self.memory_capacity = memory_capacity
 
+        # Added: Initialize the factory mapping dictionary
+        self._initialize_agent_factories()
+
+    # Added: Factory method initialization function
+    def _initialize_agent_factories(self) -> None:
+        """
+        Initialize the agent factory mapping dictionary, mapping various agent types to their respective creation functions.
+        This method replaces the original if-elif chain, making the code easier to maintain and extend.
+        """
+        self.agent_factories: Dict[str, Callable[[], Any]] = {
+            # ReasoningDuo factory methods
+            "reasoning-duo": self._create_reasoning_duo,
+            "reasoning-agent": self._create_reasoning_duo,
+            # SelfConsistencyAgent factory methods
+            "self-consistency": self._create_consistency_agent,
+            "consistency-agent": self._create_consistency_agent,
+            # IREAgent factory methods
+            "ire": self._create_ire_agent,
+            "ire-agent": self._create_ire_agent,
+            # Other agent type factory methods
+            "AgentJudge": self._create_agent_judge,
+            "ReflexionAgent": self._create_reflexion_agent,
+            "GKPAgent": self._create_gkp_agent,
+        }
+
+    # Added: Concrete factory methods for various agent types
+    def _create_reasoning_duo(self):
+        """Creates an agent instance for ReasoningDuo type"""
+        return ReasoningDuo(
+            agent_name=self.agent_name,
+            agent_description=self.description,
+            model_name=[self.model_name, self.model_name],
+            system_prompt=self.system_prompt,
+            output_type=self.output_type,
+        )
+
+    def _create_consistency_agent(self):
+        """Creates an agent instance for SelfConsistencyAgent type"""
+        return SelfConsistencyAgent(
+            agent_name=self.agent_name,
+            description=self.description,
+            model_name=self.model_name,
+            system_prompt=self.system_prompt,
+            max_loops=self.max_loops,
+            num_samples=self.num_samples,
+            output_type=self.output_type,
+        )
+
+    def _create_ire_agent(self):
+        """Creates an agent instance for IREAgent type"""
+        return IREAgent(
+            agent_name=self.agent_name,
+            description=self.description,
+            model_name=self.model_name,
+            system_prompt=self.system_prompt,
+            max_loops=self.max_loops,
+            max_iterations=self.num_samples,
+            output_type=self.output_type,
+        )
+
+    def _create_agent_judge(self):
+        """Creates an agent instance for AgentJudge type"""
+        return AgentJudge(
+            agent_name=self.agent_name,
+            model_name=self.model_name,
+            system_prompt=self.system_prompt,
+            max_loops=self.max_loops,
+        )
+
+    def _create_reflexion_agent(self):
+        """Creates an agent instance for ReflexionAgent type"""
+        return ReflexionAgent(
+            agent_name=self.agent_name,
+            system_prompt=self.system_prompt,
+            model_name=self.model_name,
+            max_loops=self.max_loops,
+        )
+
+    def _create_gkp_agent(self):
+        """Creates an agent instance for GKPAgent type"""
+        return GKPAgent(
+            agent_name=self.agent_name,
+            model_name=self.model_name,
+            num_knowledge_items=self.num_knowledge_items,
+        )
+
     def select_swarm(self):
         """
         Selects and initializes the appropriate reasoning swarm based on the specified swarm type.
-
         Returns:
             An instance of the selected reasoning swarm.
         """
+        # Commented out original if-elif chain implementation
+        """
         if (
             self.swarm_type == "reasoning-duo"
             or self.swarm_type == "reasoning-agent"
@@ -132,6 +219,15 @@ class ReasoningAgentRouter:
             )
         else:
             raise ValueError(f"Invalid swarm type: {self.swarm_type}")
+        """
+
+        # Added: Implementation using factory pattern and dictionary mapping
+        try:
+            # Get the corresponding creation function from the factory dictionary and call it
+            return self.agent_factories[self.swarm_type]()
+        except KeyError:
+            # Maintain the same error handling as the original code
+            raise ValueError(f"Invalid swarm type: {self.swarm_type}")
 
     def run(self, task: str, *args, **kwargs):
         """

swarms/agents/reasoning_duo.py

@@ -4,7 +4,7 @@ from loguru import logger
 
 from swarms.prompts.reasoning_prompt import REASONING_PROMPT
 from swarms.structs.agent import Agent
-from swarms.structs.output_types import OutputType
+from swarms.utils.output_types import OutputType
 from swarms.structs.conversation import Conversation
 from swarms.utils.history_output_formatter import (
     history_output_formatter,

swarms/cli/main.py

@@ -67,7 +67,7 @@ def show_ascii_art():
         Text(ASCII_ART, style=f"bold {COLORS['primary']}"),
         border_style=COLORS["secondary"],
         title="[bold]Welcome to Swarms[/bold]",
-        subtitle="[dim]Power to the Swarms[/dim]",
+        subtitle="[dim]swarms.ai[/dim]",
     )
     console.print(panel)
 

swarms/communication/__init__.py

@@ -0,0 +1 @@
+

swarms/communication/duckdb_wrap.py

@@ -7,7 +7,6 @@ from contextlib import contextmanager
 from pathlib import Path
 from typing import Any, Callable, Dict, List, Optional, Union
 
-import duckdb
 import yaml
 
 from swarms.communication.base_communication import (
@@ -76,6 +75,37 @@ class DuckDBConversation(BaseCommunication):
         *args,
         **kwargs,
     ):
+        # Lazy load duckdb with auto-installation
+        try:
+            import duckdb
+
+            self.duckdb = duckdb
+            self.duckdb_available = True
+        except ImportError:
+            # Auto-install duckdb if not available
+            print("📦 DuckDB not found. Installing automatically...")
+            try:
+                import subprocess
+                import sys
+
+                # Install duckdb
+                subprocess.check_call(
+                    [sys.executable, "-m", "pip", "install", "duckdb"]
+                )
+                print("✅ DuckDB installed successfully!")
+
+                # Try importing again
+                import duckdb
+
+                self.duckdb = duckdb
+                self.duckdb_available = True
+                print("✅ DuckDB loaded successfully!")
+
+            except Exception as e:
+                raise ImportError(
+                    f"Failed to auto-install DuckDB. Please install manually with 'pip install duckdb': {e}"
+                )
+
         super().__init__(
             system_prompt=system_prompt,
             time_enabled=time_enabled,
@@ -171,7 +201,7 @@ class DuckDBConversation(BaseCommunication):
         conn = None
         for attempt in range(self.max_retries):
             try:
-                conn = duckdb.connect(str(self.db_path))
+                conn = self.duckdb.connect(str(self.db_path))
                 yield conn
                 break
             except Exception as e:

swarms/communication/pulsar_struct.py

@@ -12,20 +12,6 @@ from swarms.communication.base_communication import (
 )
 
 
-# Check if Pulsar is available
-try:
-    import pulsar
-
-    PULSAR_AVAILABLE = True
-    logger.info("Apache Pulsar client library is available")
-except ImportError as e:
-    PULSAR_AVAILABLE = False
-    logger.error(
-        f"Apache Pulsar client library is not installed: {e}"
-    )
-    logger.error("Please install it using: pip install pulsar-client")
-
-
 class PulsarConnectionError(Exception):
     """Exception raised for Pulsar connection errors."""
 
@@ -77,11 +63,48 @@ class PulsarConversation(BaseCommunication):
         **kwargs,
     ):
         """Initialize the Pulsar conversation interface."""
-        if not PULSAR_AVAILABLE:
-            raise ImportError(
-                "Apache Pulsar client library is not installed. "
-                "Please install it using: pip install pulsar-client"
+        # Lazy load Pulsar with auto-installation
+        try:
+            import pulsar
+
+            self.pulsar = pulsar
+            self.pulsar_available = True
+        except ImportError:
+            # Auto-install pulsar-client if not available
+            print(
+                "📦 Pulsar client not found. Installing automatically..."
             )
+            try:
+                import subprocess
+                import sys
+
+                # Install pulsar-client
+                subprocess.check_call(
+                    [
+                        sys.executable,
+                        "-m",
+                        "pip",
+                        "install",
+                        "pulsar-client",
+                    ]
+                )
+                print("✅ Pulsar client installed successfully!")
+
+                # Try importing again
+                import pulsar
+
+                self.pulsar = pulsar
+                self.pulsar_available = True
+                print("✅ Pulsar loaded successfully!")
+
+            except Exception as e:
+                self.pulsar_available = False
+                logger.error(
+                    f"Failed to auto-install Pulsar client. Please install manually with 'pip install pulsar-client': {e}"
+                )
+                raise ImportError(
+                    f"Failed to auto-install Pulsar client. Please install manually with 'pip install pulsar-client': {e}"
+                )
 
         logger.info(
             f"Initializing PulsarConversation with host: {pulsar_host}"
@@ -631,7 +654,10 @@ class PulsarConversation(BaseCommunication):
         Returns:
             bool: True if Pulsar is available and accessible, False otherwise
         """
-        if not PULSAR_AVAILABLE:
+        try:
+            import pulsar
+
+        except ImportError:
             logger.error("Pulsar client library is not installed")
             return False
 

swarms/communication/redis_wrap.py

@@ -11,6 +11,17 @@ from typing import Any, Dict, List, Optional, Union
 
 import yaml
 
+from loguru import logger
+
+from swarms.structs.base_structure import BaseStructure
+from swarms.utils.any_to_str import any_to_str
+from swarms.utils.formatter import formatter
+from swarms.utils.litellm_tokenizer import count_tokens
+
+# Module-level variable to track Redis availability
+REDIS_AVAILABLE = False
+
+# Try to import Redis and set availability flag
 try:
     import redis
     from redis.exceptions import (
@@ -23,14 +34,36 @@ try:
 
     REDIS_AVAILABLE = True
 except ImportError:
-    REDIS_AVAILABLE = False
+    # Auto-install Redis at import time
+    print("📦 Redis not found. Installing automatically...")
+    try:
+        import subprocess
+        import sys
+
+        # Install redis
+        subprocess.check_call(
+            [sys.executable, "-m", "pip", "install", "redis"]
+        )
+        print("✅ Redis installed successfully!")
+
+        # Try importing again
+        import redis
+        from redis.exceptions import (
+            AuthenticationError,
+            BusyLoadingError,
+            ConnectionError,
+            RedisError,
+            TimeoutError,
+        )
 
-from loguru import logger
+        REDIS_AVAILABLE = True
+        print("✅ Redis loaded successfully!")
 
-from swarms.structs.base_structure import BaseStructure
-from swarms.utils.any_to_str import any_to_str
-from swarms.utils.formatter import formatter
-from swarms.utils.litellm_tokenizer import count_tokens
+    except Exception as e:
+        REDIS_AVAILABLE = False
+        print(
+            f"❌ Failed to auto-install Redis. Please install manually with 'pip install redis': {e}"
+        )
 
 
 class RedisConnectionError(Exception):
@@ -96,6 +129,11 @@ rdbchecksum yes
             bool: True if server started successfully, False otherwise
         """
         try:
+            # Check if Redis is available
+            if not REDIS_AVAILABLE:
+                logger.error("Redis package is not installed")
+                return False
+
             # Use data directory if persistence is enabled and auto_persist is True
             if not (self.persist and self.auto_persist):
                 self.data_dir = tempfile.mkdtemp()
@@ -152,7 +190,11 @@ rdbchecksum yes
         try:
             if self.process:
                 # Send SAVE and BGSAVE commands before stopping if persistence is enabled
-                if self.persist and self.auto_persist:
+                if (
+                    self.persist
+                    and self.auto_persist
+                    and REDIS_AVAILABLE
+                ):
                     try:
                         r = redis.Redis(
                             host="localhost", port=self.port
@@ -293,14 +335,17 @@ class RedisConversation(BaseStructure):
             RedisConnectionError: If connection to Redis fails.
             RedisOperationError: If Redis operations fail.
         """
+        global REDIS_AVAILABLE
+
+        # Check if Redis is available (should be True after module import auto-installation)
         if not REDIS_AVAILABLE:
-            logger.error(
-                "Redis package is not installed. Please install it with 'pip install redis'"
-            )
             raise ImportError(
-                "Redis package is not installed. Please install it with 'pip install redis'"
+                "Redis is not available. Module-level auto-installation failed. "
+                "Please install manually with 'pip install redis'"
             )
 
+        self.redis_available = True
+
         super().__init__()
         self.system_prompt = system_prompt
         self.time_enabled = time_enabled