swarms 7.7.8__py3-none-any.whl → 7.8.0__py3-none-any.whl

swarms/utils/index.py

@@ -0,0 +1,226 @@
+def exists(val):
+    return val is not None
+
+
+def format_dict_to_string(data: dict, indent_level=0, use_colon=True):
+    """
+    Recursively formats a dictionary into a multi-line string.
+
+    Args:
+        data (dict): The dictionary to format
+        indent_level (int): Current indentation level for nested structures
+        use_colon (bool): Whether to use "key: value" or "key value" format
+
+    Returns:
+        str: Formatted string representation of the dictionary
+    """
+    if not isinstance(data, dict):
+        return str(data)
+
+    lines = []
+    indent = "  " * indent_level  # 2 spaces per indentation level
+    separator = ": " if use_colon else " "
+
+    for key, value in data.items():
+        if isinstance(value, dict):
+            # Recursive case: nested dictionary
+            lines.append(f"{indent}{key}:")
+            nested_string = format_dict_to_string(
+                value, indent_level + 1, use_colon
+            )
+            lines.append(nested_string)
+        else:
+            # Base case: simple key-value pair
+            lines.append(f"{indent}{key}{separator}{value}")
+
+    return "\n".join(lines)
+
+
+def format_data_structure(
+    data: any, indent_level: int = 0, max_depth: int = 10
+) -> str:
+    """
+    Fast formatter for any Python data structure into readable new-line format.
+
+    Args:
+        data: Any Python data structure to format
+        indent_level (int): Current indentation level for nested structures
+        max_depth (int): Maximum depth to prevent infinite recursion
+
+    Returns:
+        str: Formatted string representation with new lines
+    """
+    if indent_level >= max_depth:
+        return f"{'  ' * indent_level}... (max depth reached)"
+
+    indent = "  " * indent_level
+    data_type = type(data)
+
+    # Fast type checking using type() instead of isinstance() for speed
+    if data_type is dict:
+        if not data:
+            return f"{indent}{{}} (empty dict)"
+
+        lines = []
+        for key, value in data.items():
+            if type(value) in (dict, list, tuple, set):
+                lines.append(f"{indent}{key}:")
+                lines.append(
+                    format_data_structure(
+                        value, indent_level + 1, max_depth
+                    )
+                )
+            else:
+                lines.append(f"{indent}{key}: {value}")
+        return "\n".join(lines)
+
+    elif data_type is list:
+        if not data:
+            return f"{indent}[] (empty list)"
+
+        lines = []
+        for i, item in enumerate(data):
+            if type(item) in (dict, list, tuple, set):
+                lines.append(f"{indent}[{i}]:")
+                lines.append(
+                    format_data_structure(
+                        item, indent_level + 1, max_depth
+                    )
+                )
+            else:
+                lines.append(f"{indent}{item}")
+        return "\n".join(lines)
+
+    elif data_type is tuple:
+        if not data:
+            return f"{indent}() (empty tuple)"
+
+        lines = []
+        for i, item in enumerate(data):
+            if type(item) in (dict, list, tuple, set):
+                lines.append(f"{indent}({i}):")
+                lines.append(
+                    format_data_structure(
+                        item, indent_level + 1, max_depth
+                    )
+                )
+            else:
+                lines.append(f"{indent}{item}")
+        return "\n".join(lines)
+
+    elif data_type is set:
+        if not data:
+            return f"{indent}set() (empty set)"
+
+        lines = []
+        for item in sorted(
+            data, key=str
+        ):  # Sort for consistent output
+            if type(item) in (dict, list, tuple, set):
+                lines.append(f"{indent}set item:")
+                lines.append(
+                    format_data_structure(
+                        item, indent_level + 1, max_depth
+                    )
+                )
+            else:
+                lines.append(f"{indent}{item}")
+        return "\n".join(lines)
+
+    elif data_type is str:
+        # Handle multi-line strings
+        if "\n" in data:
+            lines = data.split("\n")
+            return "\n".join(f"{indent}{line}" for line in lines)
+        return f"{indent}{data}"
+
+    elif data_type in (int, float, bool, type(None)):
+        return f"{indent}{data}"
+
+    else:
+        # Handle other types (custom objects, etc.)
+        if hasattr(data, "__dict__"):
+            # Object with attributes
+            lines = [f"{indent}{data_type.__name__} object:"]
+            for attr, value in data.__dict__.items():
+                if not attr.startswith(
+                    "_"
+                ):  # Skip private attributes
+                    if type(value) in (dict, list, tuple, set):
+                        lines.append(f"{indent}  {attr}:")
+                        lines.append(
+                            format_data_structure(
+                                value, indent_level + 2, max_depth
+                            )
+                        )
+                    else:
+                        lines.append(f"{indent}  {attr}: {value}")
+            return "\n".join(lines)
+        else:
+            # Fallback for other types
+            return f"{indent}{data} ({data_type.__name__})"
+
+
+# test_dict = {
+#     "name": "John",
+#     "age": 30,
+#     "address": {
+#         "street": "123 Main St",
+#         "city": "Anytown",
+#         "state": "CA",
+#         "zip": "12345"
+#     }
+# }
+
+# print(format_dict_to_string(test_dict))
+
+
+# # Example usage of format_data_structure:
+# if __name__ == "__main__":
+#     # Test different data structures
+
+#     # Dictionary
+#     test_dict = {
+#         "name": "John",
+#         "age": 30,
+#         "address": {
+#             "street": "123 Main St",
+#             "city": "Anytown"
+#         }
+#     }
+#     print("=== Dictionary ===")
+#     print(format_data_structure(test_dict))
+#     print()
+
+#     # List
+#     test_list = ["apple", "banana", {"nested": "dict"}, [1, 2, 3]]
+#     print("=== List ===")
+#     print(format_data_structure(test_list))
+#     print()
+
+#     # Tuple
+#     test_tuple = ("first", "second", {"key": "value"}, (1, 2))
+#     print("=== Tuple ===")
+#     print(format_data_structure(test_tuple))
+#     print()
+
+#     # Set
+#     test_set = {"apple", "banana", "cherry"}
+#     print("=== Set ===")
+#     print(format_data_structure(test_set))
+#     print()
+
+#     # Mixed complex structure
+#     complex_data = {
+#         "users": [
+#             {"name": "Alice", "scores": [95, 87, 92]},
+#             {"name": "Bob", "scores": [88, 91, 85]}
+#         ],
+#         "metadata": {
+#             "total_users": 2,
+#             "categories": ("students", "teachers"),
+#             "settings": {"debug": True, "version": "1.0"}
+#         }
+#     }
+#     print("=== Complex Structure ===")
+#     print(format_data_structure(complex_data))

swarms/utils/litellm_wrapper.py

@@ -1,3 +1,4 @@
+from typing import Optional
 import base64
 import requests
 
@@ -6,25 +7,13 @@ from typing import List
 
 from loguru import logger
 import litellm
+from pydantic import BaseModel
 
-try:
-    from litellm import completion, acompletion
-except ImportError:
-    import subprocess
-    import sys
-    import litellm
+from litellm import completion, acompletion
 
-    print("Installing litellm")
-
-    subprocess.check_call(
-        [sys.executable, "-m", "pip", "install", "-U", "litellm"]
-    )
-    print("litellm installed")
-
-    from litellm import completion
-
-    litellm.set_verbose = True
-    litellm.ssl_verify = False
+litellm.set_verbose = True
+litellm.ssl_verify = False
+# litellm._turn_on_debug()
 
 
 class LiteLLMException(Exception):
@@ -86,6 +75,9 @@ class LiteLLM:
         retries: int = 3,
         verbose: bool = False,
         caching: bool = False,
+        mcp_call: bool = False,
+        top_p: float = 1.0,
+        functions: List[dict] = None,
         *args,
         **kwargs,
     ):
@@ -110,6 +102,9 @@ class LiteLLM:
         self.tool_choice = tool_choice
         self.parallel_tool_calls = parallel_tool_calls
         self.caching = caching
+        self.mcp_call = mcp_call
+        self.top_p = top_p
+        self.functions = functions
         self.modalities = []
         self._cached_messages = {}  # Cache for prepared messages
         self.messages = []  # Initialize messages list
@@ -123,6 +118,23 @@ class LiteLLM:
             retries  # Add retries for better reliability
         )
 
+    def output_for_tools(self, response: any):
+        if self.mcp_call is True:
+            out = response.choices[0].message.tool_calls[0].function
+            output = {
+                "function": {
+                    "name": out.name,
+                    "arguments": out.arguments,
+                }
+            }
+            return output
+        else:
+            out = response.choices[0].message.tool_calls
+
+            if isinstance(out, BaseModel):
+                out = out.model_dump()
+            return out
+
     def _prepare_messages(self, task: str) -> list:
         """
         Prepare the messages for the given task.
@@ -222,8 +234,8 @@ class LiteLLM:
     def run(
         self,
         task: str,
-        audio: str = None,
-        img: str = None,
+        audio: Optional[str] = None,
+        img: Optional[str] = None,
         *args,
         **kwargs,
     ):
@@ -250,38 +262,28 @@ class LiteLLM:
                 self.handle_modalities(
                     task=task, audio=audio, img=img
                 )
-                messages = (
-                    self.messages
-                )  # Use modality-processed messages
-
-            if (
-                self.model_name == "openai/o4-mini"
-                or self.model_name == "openai/o3-2025-04-16"
-            ):
-                # Prepare common completion parameters
-                completion_params = {
-                    "model": self.model_name,
-                    "messages": messages,
-                    "stream": self.stream,
-                    # "temperature": self.temperature,
-                    "max_completion_tokens": self.max_tokens,
-                    "caching": self.caching,
-                    **kwargs,
-                }
+                messages = self.messages
 
-            else:
-                # Prepare common completion parameters
-                completion_params = {
-                    "model": self.model_name,
-                    "messages": messages,
-                    "stream": self.stream,
-                    "temperature": self.temperature,
-                    "max_tokens": self.max_tokens,
-                    "caching": self.caching,
-                    **kwargs,
-                }
+            # Base completion parameters
+            completion_params = {
+                "model": self.model_name,
+                "messages": messages,
+                "stream": self.stream,
+                "max_tokens": self.max_tokens,
+                "caching": self.caching,
+                "temperature": self.temperature,
+                "top_p": self.top_p,
+                **kwargs,
+            }
 
-            # Handle tool-based completion
+            # Add temperature for non-o4/o3 models
+            if self.model_name not in [
+                "openai/o4-mini",
+                "openai/o3-2025-04-16",
+            ]:
+                completion_params["temperature"] = self.temperature
+
+            # Add tools if specified
             if self.tools_list_dictionary is not None:
                 completion_params.update(
                     {
@@ -290,28 +292,24 @@ class LiteLLM:
                         "parallel_tool_calls": self.parallel_tool_calls,
                     }
                 )
-                response = completion(**completion_params)
-                return (
-                    response.choices[0]
-                    .message.tool_calls[0]
-                    .function.arguments
-                )
 
-            # Handle modality-based completion
-            if (
-                self.modalities and len(self.modalities) > 1
-            ):  # More than just text
+            if self.functions is not None:
                 completion_params.update(
-                    {"modalities": self.modalities}
+                    {"functions": self.functions}
                 )
-                response = completion(**completion_params)
-                return response.choices[0].message.content
 
-            # Standard completion
-            if self.stream:
-                return completion(**completion_params)
+            # Add modalities if needed
+            if self.modalities and len(self.modalities) >= 2:
+                completion_params["modalities"] = self.modalities
+
+            # Make the completion call
+            response = completion(**completion_params)
+
+            # Handle tool-based response
+            if self.tools_list_dictionary is not None:
+                return self.output_for_tools(response)
             else:
-                response = completion(**completion_params)
+                # Return standard response content
                 return response.choices[0].message.content
 
         except LiteLLMException as error:
@@ -322,7 +320,7 @@ class LiteLLM:
                 )
                 import time
 
-                time.sleep(2)  # Add a small delay before retry
+                time.sleep(2)
                 return self.run(task, audio, img, *args, **kwargs)
             raise error
 

swarms/utils/try_except_wrapper.py

@@ -21,7 +21,7 @@ def retry(
     """
 
     def decorator_retry(
-        func: Callable[..., Any]
+        func: Callable[..., Any],
     ) -> Callable[..., Any]:
         @wraps(func)
         def wrapper_retry(*args, **kwargs) -> Any:
@@ -48,7 +48,7 @@ def retry(
 
 
 def log_execution_time(
-    func: Callable[..., Any]
+    func: Callable[..., Any],
 ) -> Callable[..., Any]:
     """
     A decorator that logs the execution time of a function.

swarms/utils/xml_utils.py

@@ -0,0 +1,42 @@
+import xml.etree.ElementTree as ET
+from typing import Any
+
+
+def dict_to_xml(tag: str, d: dict) -> ET.Element:
+    """Convert a dictionary to an XML Element."""
+    elem = ET.Element(tag)
+    for key, val in d.items():
+        child = ET.Element(str(key))
+        if isinstance(val, dict):
+            child.append(dict_to_xml(str(key), val))
+        elif isinstance(val, list):
+            for item in val:
+                if isinstance(item, dict):
+                    child.append(dict_to_xml(str(key), item))
+                else:
+                    item_elem = ET.Element("item")
+                    item_elem.text = str(item)
+                    child.append(item_elem)
+        else:
+            child.text = str(val)
+        elem.append(child)
+    return elem
+
+
+def to_xml_string(data: Any, root_tag: str = "root") -> str:
+    """Convert a dict or list to an XML string."""
+    if isinstance(data, dict):
+        elem = dict_to_xml(root_tag, data)
+    elif isinstance(data, list):
+        elem = ET.Element(root_tag)
+        for item in data:
+            if isinstance(item, dict):
+                elem.append(dict_to_xml("item", item))
+            else:
+                item_elem = ET.Element("item")
+                item_elem.text = str(item)
+                elem.append(item_elem)
+    else:
+        elem = ET.Element(root_tag)
+        elem.text = str(data)
+    return ET.tostring(elem, encoding="unicode")

{swarms-7.7.8.dist-info → swarms-7.8.0.dist-info}/METADATA

@@ -1,8 +1,7 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: swarms
-Version: 7.7.8
+Version: 7.8.0
 Summary: Swarms - TGSC
-Home-page: https://github.com/kyegomez/swarms
 License: MIT
 Keywords: artificial intelligence,deep learning,optimizers,Prompt Engineering,swarms,agents,llms,transformers,multi-agent,swarms of agents,Enterprise-Grade Agents,Production-Grade Agents,Agents,Multi-Grade-Agents,Swarms,Transformers,LLMs,Prompt Engineering,Agents,Generative Agents,Generative AI,Agent Marketplace,Agent Store,quant,finance,algorithmic trading,portfolio optimization,risk management,financial modeling,machine learning for finance,natural language processing for finance
 Author: Kye Gomez
@@ -15,19 +14,20 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Requires-Dist: PyYAML
 Requires-Dist: aiofiles
 Requires-Dist: aiohttp
 Requires-Dist: asyncio (>=3.4.3,<4.0)
 Requires-Dist: docstring_parser (==0.16)
-Requires-Dist: fastmcp
 Requires-Dist: httpx
 Requires-Dist: litellm
 Requires-Dist: loguru
 Requires-Dist: mcp
 Requires-Dist: networkx
 Requires-Dist: numpy
+Requires-Dist: numpydoc
 Requires-Dist: psutil
 Requires-Dist: pydantic
 Requires-Dist: pypdf (==5.1.0)
@@ -38,6 +38,7 @@ Requires-Dist: tenacity
 Requires-Dist: toml
 Requires-Dist: torch
 Project-URL: Documentation, https://docs.swarms.world
+Project-URL: Homepage, https://github.com/kyegomez/swarms
 Project-URL: Repository, https://github.com/kyegomez/swarms
 Description-Content-Type: text/markdown