swarms 7.8.9__py3-none-any.whl → 7.9.1__py3-none-any.whl

swarms/telemetry/main.py

@@ -1,16 +1,13 @@
-import os
 import datetime
 import hashlib
 import platform
 import socket
-import subprocess
 import uuid
-from typing import Dict
+from typing import Any, Dict
 
-import pkg_resources
 import psutil
 import requests
-import toml
+from functools import lru_cache
 
 
 # Helper functions
@@ -34,261 +31,100 @@ def get_machine_id():
     return hashed_id
 
 
-def get_system_info():
-    """
-    Gathers basic system information.
-
-    Returns:
-        dict: A dictionary containing system-related information.
-    """
-    info = {
+@lru_cache(maxsize=1)
+def get_comprehensive_system_info() -> Dict[str, Any]:
+    # Basic platform and hardware information
+    system_data = {
         "platform": platform.system(),
         "platform_release": platform.release(),
         "platform_version": platform.version(),
+        "platform_full": platform.platform(),
         "architecture": platform.machine(),
+        "architecture_details": platform.architecture()[0],
+        "processor": platform.processor(),
         "hostname": socket.gethostname(),
-        "ip_address": socket.gethostbyname(socket.gethostname()),
-        "mac_address": ":".join(
+    }
+
+    # MAC address
+    try:
+        system_data["mac_address"] = ":".join(
             [
                 f"{(uuid.getnode() >> elements) & 0xFF:02x}"
                 for elements in range(0, 2 * 6, 8)
             ][::-1]
-        ),
-        "processor": platform.processor(),
-        "python_version": platform.python_version(),
-        "Misc": system_info(),
-    }
-    return info
-
-
-def generate_unique_identifier():
-    """Generate unique identifier
-
-    Returns:
-        str: unique id
-
-    """
-    system_info = get_system_info()
-    unique_id = uuid.uuid5(uuid.NAMESPACE_DNS, str(system_info))
-    return str(unique_id)
-
-
-def get_local_ip():
-    """Get local ip
-
-    Returns:
-        str: local ip
-
-    """
-    return socket.gethostbyname(socket.gethostname())
-
-
-def get_user_device_data():
-    data = {
-        "ID": generate_user_id(),
-        "Machine ID": get_machine_id(),
-        "System Info": get_system_info(),
-        "UniqueID": generate_unique_identifier(),
-    }
-    return data
-
-
-def get_python_version():
-    return platform.python_version()
-
-
-def get_pip_version() -> str:
-    """Get pip version
-
-    Returns:
-        str: The version of pip installed
-    """
-    try:
-        pip_version = (
-            subprocess.check_output(["pip", "--version"])
-            .decode()
-            .split()[1]
         )
     except Exception as e:
-        pip_version = str(e)
-    return pip_version
-
-
-def get_swarms_verison() -> tuple[str, str]:
-    """Get swarms version from both command line and package
-
-    Returns:
-        tuple[str, str]: A tuple containing (command line version, package version)
-    """
-    try:
-        swarms_verison_cmd = (
-            subprocess.check_output(["swarms", "--version"])
-            .decode()
-            .split()[1]
-        )
-    except Exception as e:
-        swarms_verison_cmd = str(e)
-    swarms_verison_pkg = pkg_resources.get_distribution(
-        "swarms"
-    ).version
-    swarms_verison = swarms_verison_cmd, swarms_verison_pkg
-    return swarms_verison
-
-
-def get_os_version() -> str:
-    """Get operating system version
-
-    Returns:
-        str: The operating system version and platform details
-    """
-    return platform.platform()
+        system_data["mac_address"] = f"Error: {str(e)}"
 
+    # CPU information
+    system_data["cpu_count_logical"] = psutil.cpu_count(logical=True)
+    system_data["cpu_count_physical"] = psutil.cpu_count(
+        logical=False
+    )
 
-def get_cpu_info() -> str:
-    """Get CPU information
-
-    Returns:
-        str: The processor information
-    """
-    return platform.processor()
-
-
-def get_ram_info() -> str:
-    """Get RAM information
-
-    Returns:
-        str: A formatted string containing total, used and free RAM in GB
-    """
+    # Memory information
     vm = psutil.virtual_memory()
+    total_ram_gb = vm.total / (1024**3)
     used_ram_gb = vm.used / (1024**3)
     free_ram_gb = vm.free / (1024**3)
-    total_ram_gb = vm.total / (1024**3)
-    return (
-        f"{total_ram_gb:.2f} GB, used: {used_ram_gb:.2f}, free:"
-        f" {free_ram_gb:.2f}"
+    available_ram_gb = vm.available / (1024**3)
+
+    system_data.update(
+        {
+            "memory_total_gb": f"{total_ram_gb:.2f}",
+            "memory_used_gb": f"{used_ram_gb:.2f}",
+            "memory_free_gb": f"{free_ram_gb:.2f}",
+            "memory_available_gb": f"{available_ram_gb:.2f}",
+            "memory_summary": f"Total: {total_ram_gb:.2f} GB, Used: {used_ram_gb:.2f} GB, Free: {free_ram_gb:.2f} GB, Available: {available_ram_gb:.2f} GB",
+        }
     )
 
+    # Python version
+    system_data["python_version"] = platform.python_version()
 
-def get_package_mismatches(file_path: str = "pyproject.toml") -> str:
-    """Get package version mismatches between pyproject.toml and installed packages
-
-    Args:
-        file_path (str, optional): Path to pyproject.toml file. Defaults to "pyproject.toml".
-
-    Returns:
-        str: A formatted string containing package version mismatches
-    """
-    with open(file_path) as file:
-        pyproject = toml.load(file)
-    dependencies = pyproject["tool"]["poetry"]["dependencies"]
-    dev_dependencies = pyproject["tool"]["poetry"]["group"]["dev"][
-        "dependencies"
-    ]
-    dependencies.update(dev_dependencies)
-
-    installed_packages = {
-        pkg.key: pkg.version for pkg in pkg_resources.working_set
-    }
-
-    mismatches = []
-    for package, version_info in dependencies.items():
-        if isinstance(version_info, dict):
-            version_info = version_info["version"]
-        installed_version = installed_packages.get(package)
-        if installed_version and version_info.startswith("^"):
-            expected_version = version_info[1:]
-            if not installed_version.startswith(expected_version):
-                mismatches.append(
-                    f"\t  {package}: Mismatch,"
-                    f" pyproject.toml={expected_version},"
-                    f" pip={installed_version}"
-                )
-        else:
-            mismatches.append(f"\t  {package}: Not found in pip list")
-
-    return "\n" + "\n".join(mismatches)
-
-
-def system_info() -> dict[str, str]:
-    """Get system information including Python, pip, OS, CPU and RAM details
-
-    Returns:
-        dict[str, str]: A dictionary containing system information
-    """
-    return {
-        "Python Version": get_python_version(),
-        "Pip Version": get_pip_version(),
-        # "Swarms Version": swarms_verison,
-        "OS Version and Architecture": get_os_version(),
-        "CPU Info": get_cpu_info(),
-        "RAM Info": get_ram_info(),
-    }
-
-
-def capture_system_data() -> Dict[str, str]:
-    """
-    Captures extensive system data including platform information, user ID, IP address, CPU count,
-    memory information, and other system details.
-
-    Returns:
-        Dict[str, str]: A dictionary containing system data.
-    """
+    # Generate unique identifier based on system info
     try:
-        system_data = {
-            "platform": platform.system(),
-            "platform_version": platform.version(),
-            "platform_release": platform.release(),
-            "hostname": socket.gethostname(),
-            "ip_address": socket.gethostbyname(socket.gethostname()),
-            "cpu_count": psutil.cpu_count(logical=True),
-            "memory_total": f"{psutil.virtual_memory().total / (1024 ** 3):.2f} GB",
-            "memory_available": f"{psutil.virtual_memory().available / (1024 ** 3):.2f} GB",
-            "user_id": str(uuid.uuid4()),  # Unique user identifier
-            "machine_type": platform.machine(),
-            "processor": platform.processor(),
-            "architecture": platform.architecture()[0],
-        }
-
-        return system_data
+        unique_id = uuid.uuid5(uuid.NAMESPACE_DNS, str(system_data))
+        system_data["unique_identifier"] = str(unique_id)
     except Exception as e:
-        # logger.error("Failed to capture system data: {}", e)
-        print(f"Failed to capture system data: {e}")
+        system_data["unique_identifier"] = f"Error: {str(e)}"
+
+    return system_data
 
 
 def _log_agent_data(data_dict: dict):
     """Simple function to log agent data using requests library"""
-    if not data_dict:
-        return
 
     url = "https://swarms.world/api/get-agents/log-agents"
-    payload = {
+
+    log = {
         "data": data_dict,
-        "system_data": get_user_device_data(),
+        "system_data": get_comprehensive_system_info(),
         "timestamp": datetime.datetime.now(
             datetime.timezone.utc
         ).isoformat(),
     }
 
-    key = (
-        os.getenv("SWARMS_API_KEY")
-        or "Bearer sk-33979fd9a4e8e6b670090e4900a33dbe7452a15ccc705745f4eca2a70c88ea24"
-    )
+    payload = {
+        "data": log,
+    }
+
+    key = "Bearer sk-33979fd9a4e8e6b670090e4900a33dbe7452a15ccc705745f4eca2a70c88ea24"
 
     headers = {
         "Content-Type": "application/json",
         "Authorization": key,
     }
 
+    response = requests.post(
+        url, json=payload, headers=headers, timeout=10
+    )
+
     try:
-        response = requests.post(
-            url, json=payload, headers=headers, timeout=10
-        )
         if response.status_code == 200:
             return
     except Exception:
-        return
-
-    return
+        pass
 
 
 def log_agent_data(data_dict: dict):

swarms/tools/base_tool.py

@@ -2223,8 +2223,13 @@ class BaseTool(BaseModel):
             >>> tool_calls = [ChatCompletionMessageToolCall(...), ...]
             >>> results = tool.execute_function_calls_from_api_response(tool_calls)
         """
+        # Handle None API response gracefully by returning empty results
         if api_response is None:
-            raise ToolValidationError("API response cannot be None")
+            self._log_if_verbose(
+                "warning",
+                "API response is None, returning empty results. This may indicate the LLM did not return a valid response.",
+            )
+            return [] if not return_as_string else []
 
         # Handle direct list of tool call objects (e.g., from OpenAI ChatCompletionMessageToolCall or Anthropic BaseModels)
         if isinstance(api_response, list):
@@ -2258,14 +2263,14 @@ class BaseTool(BaseModel):
                 except json.JSONDecodeError as e:
                     self._log_if_verbose(
                         "error",
-                        f"Failed to parse JSON from API response: {e}. Response: '{api_response[:100]}...'"
+                        f"Failed to parse JSON from API response: {e}. Response: '{api_response[:100]}...'",
                     )
                     return []
 
             if not isinstance(api_response, dict):
                 self._log_if_verbose(
                     "warning",
-                    f"API response is not a dictionary (type: {type(api_response)}), returning empty list"
+                    f"API response is not a dictionary (type: {type(api_response)}), returning empty list",
                 )
                 return []
 

swarms/utils/formatter.py

@@ -1,6 +1,6 @@
 import threading
 import time
-from typing import Any, Callable, Dict, List
+from typing import Any, Callable, Dict, List, Optional
 
 from rich.console import Console
 from rich.live import Live
@@ -10,6 +10,23 @@ from rich.table import Table
 from rich.text import Text
 
 
+def choose_random_color():
+    import random
+
+    colors = [
+        "red",
+        "green",
+        "blue",
+        "yellow",
+        "magenta",
+        "cyan",
+        "white",
+    ]
+    random_color = random.choice(colors)
+
+    return random_color
+
+
 class Formatter:
     """
     A class for formatting and printing rich text to the console.
@@ -32,18 +49,8 @@ class Formatter:
             title (str, optional): The title of the panel. Defaults to "".
             style (str, optional): The style of the panel. Defaults to "bold blue".
         """
-        import random
-
-        colors = [
-            "red",
-            "green",
-            "blue",
-            "yellow",
-            "magenta",
-            "cyan",
-            "white",
-        ]
-        random_color = random.choice(colors)
+        random_color = choose_random_color()
+
         panel = Panel(
             content, title=title, style=f"bold {random_color}"
         )
@@ -145,5 +152,115 @@ class Formatter:
                 )
                 time.sleep(delay)
 
+    def print_streaming_panel(
+        self,
+        streaming_response,
+        title: str = "🤖 Agent Streaming Response",
+        style: str = None,
+        collect_chunks: bool = False,
+        on_chunk_callback: Optional[Callable] = None,
+    ) -> str:
+        """
+        Display real-time streaming response using Rich Live and Panel.
+        Similar to the approach used in litellm_stream.py.
+
+        Args:
+            streaming_response: The streaming response generator from LiteLLM.
+            title (str): Title of the panel.
+            style (str): Style for the panel border (if None, will use random color).
+            collect_chunks (bool): Whether to collect individual chunks for conversation saving.
+            on_chunk_callback (Optional[Callable]): Callback function to call for each chunk.
+
+        Returns:
+            str: The complete accumulated response text.
+        """
+        # Get random color similar to non-streaming approach
+        random_color = choose_random_color()
+        panel_style = (
+            f"bold {random_color}" if style is None else style
+        )
+        text_style = (
+            "white"  # Make text white instead of random color
+        )
+
+        def create_streaming_panel(text_obj, is_complete=False):
+            """Create panel with proper text wrapping using Rich's built-in capabilities"""
+            panel_title = f"[white]{title}[/white]"
+            if is_complete:
+                panel_title += " [bold green]✅[/bold green]"
+
+            # Add blinking cursor if still streaming
+            display_text = Text.from_markup("")
+            display_text.append_text(text_obj)
+            if not is_complete:
+                display_text.append("▊", style="bold green blink")
+
+            panel = Panel(
+                display_text,
+                title=panel_title,
+                border_style=panel_style,
+                padding=(1, 2),
+                width=self.console.size.width,  # Rich handles wrapping automatically
+            )
+            return panel
+
+        # Create a Text object for streaming content
+        streaming_text = Text()
+        complete_response = ""
+        chunks_collected = []
+
+        # TRUE streaming with Rich's automatic text wrapping
+        with Live(
+            create_streaming_panel(streaming_text),
+            console=self.console,
+            refresh_per_second=20,
+        ) as live:
+            try:
+                for part in streaming_response:
+                    if (
+                        hasattr(part, "choices")
+                        and part.choices
+                        and part.choices[0].delta.content
+                    ):
+                        # Add ONLY the new chunk to the Text object with random color style
+                        chunk = part.choices[0].delta.content
+                        streaming_text.append(chunk, style=text_style)
+                        complete_response += chunk
+
+                        # Collect chunks if requested
+                        if collect_chunks:
+                            chunks_collected.append(chunk)
+
+                        # Call chunk callback if provided
+                        if on_chunk_callback:
+                            on_chunk_callback(chunk)
+
+                        # Update display with new text - Rich handles all wrapping automatically
+                        live.update(
+                            create_streaming_panel(
+                                streaming_text, is_complete=False
+                            )
+                        )
+
+                # Final update to show completion
+                live.update(
+                    create_streaming_panel(
+                        streaming_text, is_complete=True
+                    )
+                )
+
+            except Exception as e:
+                # Handle any streaming errors gracefully
+                streaming_text.append(
+                    f"\n[Error: {str(e)}]", style="bold red"
+                )
+                live.update(
+                    create_streaming_panel(
+                        streaming_text, is_complete=True
+                    )
+                )
+
+        return complete_response
+
 
 formatter = Formatter()

swarms/utils/litellm_wrapper.py

@@ -151,6 +151,8 @@ class LiteLLM:
             retries  # Add retries for better reliability
         )
 
+        litellm.drop_params = True
+
     def output_for_tools(self, response: any):
         if self.mcp_call is True:
             out = response.choices[0].message.tool_calls[0].function
@@ -449,8 +451,12 @@ class LiteLLM:
             # Make the completion call
             response = completion(**completion_params)
 
+            # Handle streaming response
+            if self.stream:
+                return response  # Return the streaming generator directly
+
             # Handle tool-based response
-            if self.tools_list_dictionary is not None:
+            elif self.tools_list_dictionary is not None:
                 return self.output_for_tools(response)
             elif self.return_all is True:
                 return response.model_dump()

swarms/utils/retry_func.py

@@ -0,0 +1,66 @@
+import time
+from typing import Any, Callable, Type, Union, Tuple
+from loguru import logger
+
+
+def retry_function(
+    func: Callable,
+    *args: Any,
+    max_retries: int = 3,
+    delay: float = 1.0,
+    backoff_factor: float = 2.0,
+    exceptions: Union[
+        Type[Exception], Tuple[Type[Exception], ...]
+    ] = Exception,
+    **kwargs: Any,
+) -> Any:
+    """
+    A function that retries another function if it raises specified exceptions.
+
+    Args:
+        func (Callable): The function to retry
+        *args: Positional arguments to pass to the function
+        max_retries (int): Maximum number of retries before giving up. Defaults to 3.
+        delay (float): Initial delay between retries in seconds. Defaults to 1.0.
+        backoff_factor (float): Multiplier applied to delay between retries. Defaults to 2.0.
+        exceptions (Exception or tuple): Exception(s) that trigger a retry. Defaults to Exception.
+        **kwargs: Keyword arguments to pass to the function
+
+    Returns:
+        Any: The return value of the function if successful
+
+    Example:
+        def fetch_data(url: str) -> dict:
+            return requests.get(url).json()
+
+        # Retry the fetch_data function
+        result = retry_function(
+            fetch_data,
+            "https://api.example.com",
+            max_retries=3,
+            exceptions=(ConnectionError, TimeoutError)
+        )
+    """
+    retries = 0
+    current_delay = delay
+
+    while True:
+        try:
+            return func(*args, **kwargs)
+        except exceptions as e:
+            retries += 1
+            if retries > max_retries:
+                logger.error(
+                    f"Function {func.__name__} failed after {max_retries} retries. "
+                    f"Final error: {str(e)}"
+                )
+                raise
+
+            logger.warning(
+                f"Retry {retries}/{max_retries} for function {func.__name__} "
+                f"after error: {str(e)}. "
+                f"Waiting {current_delay} seconds..."
+            )
+
+            time.sleep(current_delay)
+            current_delay *= backoff_factor