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

swarms/tools/py_func_to_openai_func_str.py

@@ -1,3 +1,5 @@
+import os
+import concurrent.futures
 import functools
 import inspect
 import json
@@ -165,7 +167,7 @@ def get_typed_annotation(
 
 
 def get_typed_signature(
-    call: Callable[..., Any]
+    call: Callable[..., Any],
 ) -> inspect.Signature:
     """Get the signature of a function with type annotations.
 
@@ -240,10 +242,10 @@ class Parameters(BaseModel):
 class Function(BaseModel):
     """A function as defined by the OpenAI API"""
 
+    name: Annotated[str, Field(description="Name of the function")]
     description: Annotated[
         str, Field(description="Description of the function")
     ]
-    name: Annotated[str, Field(description="Name of the function")]
     parameters: Annotated[
         Parameters, Field(description="Parameters of the function")
     ]
@@ -386,7 +388,7 @@ def get_openai_function_schema_from_func(
     function: Callable[..., Any],
     *,
     name: Optional[str] = None,
-    description: str = None,
+    description: Optional[str] = None,
 ) -> Dict[str, Any]:
     """Get a JSON schema for a function as defined by the OpenAI API
 
@@ -429,6 +431,21 @@ def get_openai_function_schema_from_func(
         typed_signature, required
     )
 
+    name = name if name else function.__name__
+    description = description if description else function.__doc__
+
+    if name is None:
+        raise ValueError(
+            "Function name is required but was not provided. Please provide a name for the function "
+            "either through the name parameter or ensure the function has a valid __name__ attribute."
+        )
+
+    if description is None:
+        raise ValueError(
+            "Function description is required but was not provided. Please provide a description "
+            "either through the description parameter or add a docstring to the function."
+        )
+
     if return_annotation is None:
         logger.warning(
             f"The return type of the function '{function.__name__}' is not annotated. Although annotating it is "
@@ -451,16 +468,14 @@ def get_openai_function_schema_from_func(
             + f"The annotations are missing for the following parameters: {', '.join(missing_s)}"
         )
 
-    fname = name if name else function.__name__
-
     parameters = get_parameters(
         required, param_annotations, default_values=default_values
     )
 
     function = ToolFunction(
         function=Function(
+            name=name,
             description=description,
-            name=fname,
             parameters=parameters,
         )
     )
@@ -468,6 +483,29 @@ def get_openai_function_schema_from_func(
     return model_dump(function)
 
 
+def convert_multiple_functions_to_openai_function_schema(
+    functions: List[Callable[..., Any]],
+) -> List[Dict[str, Any]]:
+    """Convert a list of functions to a list of OpenAI function schemas"""
+    # return [
+    #     get_openai_function_schema_from_func(function) for function in functions
+    # ]
+    # Use 40% of cpu cores
+    max_workers = int(os.cpu_count() * 0.8)
+    print(f"max_workers: {max_workers}")
+
+    with concurrent.futures.ThreadPoolExecutor(
+        max_workers=max_workers
+    ) as executor:
+        futures = [
+            executor.submit(
+                get_openai_function_schema_from_func, function
+            )
+            for function in functions
+        ]
+        return [future.result() for future in futures]
+
+
 #
 def get_load_param_if_needed_function(
     t: Any,
@@ -497,7 +535,7 @@ def get_load_param_if_needed_function(
 
 
 def load_basemodels_if_needed(
-    func: Callable[..., Any]
+    func: Callable[..., Any],
 ) -> Callable[..., Any]:
     """A decorator to load the parameters of a function if they are Pydantic models
 

swarms/tools/pydantic_to_json.py

@@ -39,7 +39,6 @@ def check_pydantic_name(pydantic_type: type[BaseModel]) -> str:
 
 def base_model_to_openai_function(
     pydantic_type: type[BaseModel],
-    output_str: bool = False,
 ) -> dict[str, Any]:
     """
     Convert a Pydantic model to a dictionary representation of functions.
@@ -86,34 +85,18 @@ def base_model_to_openai_function(
     _remove_a_key(parameters, "title")
     _remove_a_key(parameters, "additionalProperties")
 
-    if output_str:
-        out = {
-            "function_call": {
-                "name": name,
-            },
-            "functions": [
-                {
-                    "name": name,
-                    "description": schema["description"],
-                    "parameters": parameters,
-                },
-            ],
-        }
-        return str(out)
-
-    else:
-        return {
-            "function_call": {
+    return {
+        "function_call": {
+            "name": name,
+        },
+        "functions": [
+            {
                 "name": name,
+                "description": schema["description"],
+                "parameters": parameters,
             },
-            "functions": [
-                {
-                    "name": name,
-                    "description": schema["description"],
-                    "parameters": parameters,
-                },
-            ],
-        }
+        ],
+    }
 
 
 def multi_base_model_to_openai_function(

swarms/utils/audio_processing.py

@@ -0,0 +1,343 @@
+import base64
+from typing import Union, Dict, Any, Tuple
+import requests
+from pathlib import Path
+import wave
+import numpy as np
+
+
+def encode_audio_to_base64(audio_path: Union[str, Path]) -> str:
+    """
+    Encode a WAV file to base64 string.
+
+    Args:
+        audio_path (Union[str, Path]): Path to the WAV file
+
+    Returns:
+        str: Base64 encoded string of the audio file
+
+    Raises:
+        FileNotFoundError: If the audio file doesn't exist
+        ValueError: If the file is not a valid WAV file
+    """
+    try:
+        audio_path = Path(audio_path)
+        if not audio_path.exists():
+            raise FileNotFoundError(
+                f"Audio file not found: {audio_path}"
+            )
+
+        if not audio_path.suffix.lower() == ".wav":
+            raise ValueError("File must be a WAV file")
+
+        with open(audio_path, "rb") as audio_file:
+            audio_data = audio_file.read()
+            return base64.b64encode(audio_data).decode("utf-8")
+    except Exception as e:
+        raise Exception(f"Error encoding audio file: {str(e)}")
+
+
+def decode_base64_to_audio(
+    base64_string: str, output_path: Union[str, Path]
+) -> None:
+    """
+    Decode a base64 string to a WAV file.
+
+    Args:
+        base64_string (str): Base64 encoded audio data
+        output_path (Union[str, Path]): Path where the WAV file should be saved
+
+    Raises:
+        ValueError: If the base64 string is invalid
+        IOError: If there's an error writing the file
+    """
+    try:
+        output_path = Path(output_path)
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+
+        audio_data = base64.b64decode(base64_string)
+        with open(output_path, "wb") as audio_file:
+            audio_file.write(audio_data)
+    except Exception as e:
+        raise Exception(f"Error decoding audio data: {str(e)}")
+
+
+def download_audio_from_url(
+    url: str, output_path: Union[str, Path]
+) -> None:
+    """
+    Download an audio file from a URL and save it locally.
+
+    Args:
+        url (str): URL of the audio file
+        output_path (Union[str, Path]): Path where the audio file should be saved
+
+    Raises:
+        requests.RequestException: If there's an error downloading the file
+        IOError: If there's an error saving the file
+    """
+    try:
+        output_path = Path(output_path)
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+
+        response = requests.get(url)
+        response.raise_for_status()
+
+        with open(output_path, "wb") as audio_file:
+            audio_file.write(response.content)
+    except Exception as e:
+        raise Exception(f"Error downloading audio file: {str(e)}")
+
+
+def process_audio_with_model(
+    audio_path: Union[str, Path],
+    model: str,
+    prompt: str,
+    voice: str = "alloy",
+    format: str = "wav",
+) -> Dict[str, Any]:
+    """
+    Process an audio file with a model that supports audio input/output.
+
+    Args:
+        audio_path (Union[str, Path]): Path to the input WAV file
+        model (str): Model name to use for processing
+        prompt (str): Text prompt to accompany the audio
+        voice (str, optional): Voice to use for audio output. Defaults to "alloy"
+        format (str, optional): Audio format. Defaults to "wav"
+
+    Returns:
+        Dict[str, Any]: Model response containing both text and audio if applicable
+
+    Raises:
+        ImportError: If litellm is not installed
+        ValueError: If the model doesn't support audio processing
+    """
+    try:
+        from litellm import (
+            completion,
+            supports_audio_input,
+            supports_audio_output,
+        )
+
+        if not supports_audio_input(model):
+            raise ValueError(
+                f"Model {model} does not support audio input"
+            )
+
+        # Encode the audio file
+        encoded_audio = encode_audio_to_base64(audio_path)
+
+        # Prepare the messages
+        messages = [
+            {
+                "role": "user",
+                "content": [
+                    {"type": "text", "text": prompt},
+                    {
+                        "type": "input_audio",
+                        "input_audio": {
+                            "data": encoded_audio,
+                            "format": format,
+                        },
+                    },
+                ],
+            }
+        ]
+
+        # Make the API call
+        response = completion(
+            model=model,
+            modalities=["text", "audio"],
+            audio={"voice": voice, "format": format},
+            messages=messages,
+        )
+
+        return response
+    except ImportError:
+        raise ImportError(
+            "Please install litellm: pip install litellm"
+        )
+    except Exception as e:
+        raise Exception(
+            f"Error processing audio with model: {str(e)}"
+        )
+
+
+def read_wav_file(
+    file_path: Union[str, Path],
+) -> Tuple[np.ndarray, int]:
+    """
+    Read a WAV file and return its audio data and sample rate.
+
+    Args:
+        file_path (Union[str, Path]): Path to the WAV file
+
+    Returns:
+        Tuple[np.ndarray, int]: Audio data as numpy array and sample rate
+
+    Raises:
+        FileNotFoundError: If the file doesn't exist
+        ValueError: If the file is not a valid WAV file
+    """
+    try:
+        file_path = Path(file_path)
+        if not file_path.exists():
+            raise FileNotFoundError(
+                f"Audio file not found: {file_path}"
+            )
+
+        with wave.open(str(file_path), "rb") as wav_file:
+            # Get audio parameters
+            n_channels = wav_file.getnchannels()
+            sample_width = wav_file.getsampwidth()
+            frame_rate = wav_file.getframerate()
+            n_frames = wav_file.getnframes()
+
+            # Read audio data
+            frames = wav_file.readframes(n_frames)
+
+            # Convert to numpy array
+            dtype = np.int16 if sample_width == 2 else np.int8
+            audio_data = np.frombuffer(frames, dtype=dtype)
+
+            # Reshape if stereo
+            if n_channels == 2:
+                audio_data = audio_data.reshape(-1, 2)
+
+            return audio_data, frame_rate
+
+    except Exception as e:
+        raise Exception(f"Error reading WAV file: {str(e)}")
+
+
+def write_wav_file(
+    audio_data: np.ndarray,
+    file_path: Union[str, Path],
+    sample_rate: int,
+    sample_width: int = 2,
+) -> None:
+    """
+    Write audio data to a WAV file.
+
+    Args:
+        audio_data (np.ndarray): Audio data as numpy array
+        file_path (Union[str, Path]): Path where to save the WAV file
+        sample_rate (int): Sample rate of the audio
+        sample_width (int, optional): Sample width in bytes. Defaults to 2 (16-bit)
+
+    Raises:
+        ValueError: If the audio data is invalid
+        IOError: If there's an error writing the file
+    """
+    try:
+        file_path = Path(file_path)
+        file_path.parent.mkdir(parents=True, exist_ok=True)
+
+        # Ensure audio data is in the correct format
+        if audio_data.dtype != np.int16 and sample_width == 2:
+            audio_data = (audio_data * 32767).astype(np.int16)
+        elif audio_data.dtype != np.int8 and sample_width == 1:
+            audio_data = (audio_data * 127).astype(np.int8)
+
+        # Determine number of channels
+        n_channels = (
+            2
+            if len(audio_data.shape) > 1 and audio_data.shape[1] == 2
+            else 1
+        )
+
+        with wave.open(str(file_path), "wb") as wav_file:
+            wav_file.setnchannels(n_channels)
+            wav_file.setsampwidth(sample_width)
+            wav_file.setframerate(sample_rate)
+            wav_file.writeframes(audio_data.tobytes())
+
+    except Exception as e:
+        raise Exception(f"Error writing WAV file: {str(e)}")
+
+
+def normalize_audio(audio_data: np.ndarray) -> np.ndarray:
+    """
+    Normalize audio data to have maximum amplitude of 1.0.
+
+    Args:
+        audio_data (np.ndarray): Input audio data
+
+    Returns:
+        np.ndarray: Normalized audio data
+    """
+    return audio_data / np.max(np.abs(audio_data))
+
+
+def convert_to_mono(audio_data: np.ndarray) -> np.ndarray:
+    """
+    Convert stereo audio to mono by averaging channels.
+
+    Args:
+        audio_data (np.ndarray): Input audio data (stereo)
+
+    Returns:
+        np.ndarray: Mono audio data
+    """
+    if len(audio_data.shape) == 1:
+        return audio_data
+    return np.mean(audio_data, axis=1)
+
+
+def encode_wav_to_base64(
+    audio_data: np.ndarray, sample_rate: int
+) -> str:
+    """
+    Convert audio data to base64 encoded WAV string.
+
+    Args:
+        audio_data (np.ndarray): Audio data
+        sample_rate (int): Sample rate of the audio
+
+    Returns:
+        str: Base64 encoded WAV data
+    """
+    # Create a temporary WAV file in memory
+    with wave.open("temp.wav", "wb") as wav_file:
+        wav_file.setnchannels(1 if len(audio_data.shape) == 1 else 2)
+        wav_file.setsampwidth(2)  # 16-bit
+        wav_file.setframerate(sample_rate)
+        wav_file.writeframes(audio_data.tobytes())
+
+    # Read the file and encode to base64
+    with open("temp.wav", "rb") as f:
+        wav_bytes = f.read()
+
+    # Clean up temporary file
+    Path("temp.wav").unlink()
+
+    return base64.b64encode(wav_bytes).decode("utf-8")
+
+
+def decode_base64_to_wav(
+    base64_string: str,
+) -> Tuple[np.ndarray, int]:
+    """
+    Convert base64 encoded WAV string to audio data and sample rate.
+
+    Args:
+        base64_string (str): Base64 encoded WAV data
+
+    Returns:
+        Tuple[np.ndarray, int]: Audio data and sample rate
+    """
+    # Decode base64 string
+    wav_bytes = base64.b64decode(base64_string)
+
+    # Write to temporary file
+    with open("temp.wav", "wb") as f:
+        f.write(wav_bytes)
+
+    # Read the WAV file
+    audio_data, sample_rate = read_wav_file("temp.wav")
+
+    # Clean up temporary file
+    Path("temp.wav").unlink()
+
+    return audio_data, sample_rate

swarms/utils/history_output_formatter.py

@@ -1,7 +1,7 @@
 import yaml
 from swarms.structs.conversation import Conversation
-
 from typing import Literal, Union, List, Dict, Any
+from swarms.utils.xml_utils import to_xml_string
 
 HistoryOutputType = Literal[
     "list",
@@ -14,13 +14,12 @@ HistoryOutputType = Literal[
     "json",
     "all",
     "yaml",
+    "xml",
     # "dict-final",
     "dict-all-except-first",
     "str-all-except-first",
 ]
 
-output_type: HistoryOutputType
-
 
 def history_output_formatter(
     conversation: Conversation, type: HistoryOutputType = "list"
@@ -39,11 +38,12 @@ def history_output_formatter(
         return conversation.get_str()
     elif type == "yaml":
         return yaml.safe_dump(conversation.to_dict(), sort_keys=False)
-    # elif type == "dict-final":
-    #     return conversation.to_dict()
     elif type == "dict-all-except-first":
         return conversation.return_all_except_first()
     elif type == "str-all-except-first":
         return conversation.return_all_except_first_string()
+    elif type == "xml":
+        data = conversation.to_dict()
+        return to_xml_string(data, root_tag="conversation")
     else:
         raise ValueError(f"Invalid type: {type}")