universal-mcp-applications 0.1.21__py3-none-any.whl → 0.1.23__py3-none-any.whl

universal_mcp/applications/domain_checker/app.py

@@ -4,7 +4,6 @@ from typing import Any
 
 import dns.resolver
 import requests
-
 from universal_mcp.applications.application import APIApplication
 from universal_mcp.integrations import Integration
 
@@ -94,15 +93,15 @@ class DomainCheckerApp(APIApplication):
     async def check_domain_registration(self, domain: str) -> dict[str, Any]:
         """
         Determines a domain's availability by querying DNS and RDAP servers. For registered domains, it returns details like registrar and key dates. This function provides a comprehensive analysis for a single, fully qualified domain name, unlike `check_keyword_across_tlds_tool` which checks a keyword across multiple domains.
-        
+
         This method performs a comprehensive domain availability check by first checking DNS records
         and then querying RDAP (Registration Data Access Protocol) servers for detailed registration
         information. It provides detailed information about registered domains including registrar,
         registration date, and expiration date.
-        
+
         Args:
             domain: String representing the domain name to check (e.g., "example.com")
-        
+
         Returns:
             Dictionary containing domain availability information with the following keys:
             - domain: The domain name that was checked
@@ -113,12 +112,12 @@ class DomainCheckerApp(APIApplication):
             - has_dns: Boolean indicating if DNS records exist
             - rdap_data_available: Boolean indicating if RDAP data was retrieved
             - note: Additional information when needed
-        
+
         Raises:
             DNSException: When DNS resolution fails due to network issues or invalid domain format
             RequestException: When RDAP queries fail due to network issues or server errors
             ValueError: When the domain parameter is empty or contains invalid characters
-        
+
         Tags:
             domain, availability, registration, dns, rdap, important
         """
@@ -206,15 +205,15 @@ class DomainCheckerApp(APIApplication):
     async def find_available_domains_for_keyword(self, keyword: str) -> dict[str, Any]:
         """
         Checks a keyword's availability across a predefined list of popular TLDs. Using DNS and RDAP lookups, it generates a summary report of available and taken domains. This bulk-check differs from `check_domain_registration`, which deeply analyzes a single, fully-qualified domain.
-        
+
         This method systematically checks a given keyword across 14 popular TLDs including .com, .net,
         .org, .io, .co, .app, .dev, .ai, .me, .info, .xyz, .online, .site, and .tech. It performs
         DNS lookups and RDAP queries to determine domain availability and provides a comprehensive
         report of available and taken domains.
-        
+
         Args:
             keyword: String representing the keyword to check across TLDs (e.g., "myapp")
-        
+
         Returns:
             Dictionary containing TLD availability information with the following keys:
             - keyword: The keyword that was checked
@@ -224,12 +223,12 @@ class DomainCheckerApp(APIApplication):
             - available_domains: List of available domain names
             - taken_domains: List of taken domain names
             - tlds_checked_list: Complete list of TLDs that were checked
-        
+
         Raises:
             DNSException: When DNS resolution fails due to network issues or invalid domain format
             RequestException: When RDAP queries fail due to network issues or server errors
             ValueError: When the keyword parameter is empty or contains invalid characters
-        
+
         Tags:
             tld, keyword, domain-search, availability, bulk-check, important
         """
@@ -267,7 +266,4 @@ class DomainCheckerApp(APIApplication):
         """
         Lists the available tools (methods) for this application.
         """
-        return [
-            self.check_domain_registration, 
-            self.find_available_domains_for_keyword
-            ]
+        return [self.check_domain_registration, self.find_available_domains_for_keyword]

universal_mcp/applications/e2b/app.py

@@ -131,19 +131,19 @@ class E2bApp(APIApplication):
     ) -> str:
         """
         Executes a Python code string in a secure E2B sandbox. It authenticates using the configured API key, runs the code, and returns a formatted string containing the execution's output (stdout/stderr). It raises specific exceptions for authorization failures or general execution issues.
-        
+
         Args:
             code: String containing the Python code to be executed in the sandbox.
-        
+
         Returns:
             A string containing the formatted execution output/logs from running the code.
-        
+
         Raises:
             ToolError: When there are issues with sandbox initialization or code execution,
                        or if the E2B SDK is not installed.
             NotAuthorizedError: When API key authentication fails during sandbox setup.
             ValueError: When provided code string is empty or invalid.
-        
+
         Tags:
             execute, sandbox, code-execution, security, important
         """

universal_mcp/applications/elevenlabs/app.py

@@ -2,13 +2,13 @@ import uuid
 from io import BytesIO
 
 import requests
-
-from elevenlabs import ElevenLabs
 from universal_mcp.applications.application import APIApplication
-from universal_mcp.applications.file_system.app import FileSystemApp
 from universal_mcp.exceptions import NotAuthorizedError
 from universal_mcp.integrations import Integration
 
+from elevenlabs import ElevenLabs
+from universal_mcp.applications.file_system.app import FileSystemApp
+
 
 class ElevenlabsApp(APIApplication):
     def __init__(self, integration: Integration = None, **kwargs) -> None:
@@ -24,7 +24,11 @@ class ElevenlabsApp(APIApplication):
             credentials = self.integration.get_credentials()
             if not credentials:
                 raise NotAuthorizedError("No credentials found")
-            api_key = credentials.get("api_key") or credentials.get("API_KEY") or credentials.get("apiKey")
+            api_key = (
+                credentials.get("api_key")
+                or credentials.get("API_KEY")
+                or credentials.get("apiKey")
+            )
             if not api_key:
                 raise NotAuthorizedError("No api key found")
             self._client = ElevenLabs(api_key=api_key)
@@ -41,17 +45,17 @@ class ElevenlabsApp(APIApplication):
     ) -> bytes:
         """
         Converts a text string into speech using the ElevenLabs API. The function then saves the generated audio to a temporary MP3 file and returns a public URL to access it, rather than the raw audio bytes.
-        
+
         Args:
             text (str): The text to convert to speech.
             voice_id (str): The ID of the voice to use.
             model_id (str, optional): The model to use. Defaults to "eleven_multilingual_v2".
             stability (float, optional): The stability of the voice.
             similarity_boost (float, optional): The similarity boost of the voice.
-        
+
         Returns:
             bytes: The audio data.
-            
+
         Tags:
             important
         """
@@ -77,13 +81,13 @@ class ElevenlabsApp(APIApplication):
     ) -> str:
         """
         Transcribes an audio file into text using the ElevenLabs API. It supports language specification and speaker diarization, providing the inverse operation to the audio-generating `text_to_speech` method. Note: The docstring indicates this is a placeholder for an undocumented endpoint.
-        
+
         Args:
             audio_file_path (str): The path to the audio file.
-        
+
         Returns:
             str: The transcribed text.
-            
+
         Tags:
             important
         """
@@ -104,15 +108,15 @@ class ElevenlabsApp(APIApplication):
     ) -> bytes:
         """
         Downloads an audio file from a URL and converts the speech into a specified target voice using the ElevenLabs API. This function transforms the speaker's voice in an existing recording and returns the new audio data as bytes, distinct from creating audio from text.
-        
+
         Args:
             voice_id (str): The ID of the voice to use for the conversion.
             audio_file_path (str): The path to the audio file to transform.
             model_id (str, optional): The model to use. Defaults to "eleven_multilingual_sts_v2".
-        
+
         Returns:
             bytes: The transformed audio data.
-            
+
         Tags:
             important
         """
@@ -139,8 +143,7 @@ async def demo_text_to_speech():
     A demonstration function that instantiates the `ElevenlabsApp` to test its `text_to_speech` method. It converts a sample string to audio and prints the resulting file URL to the console, serving as a basic usage example when the script is executed directly.
     """
     app = ElevenlabsApp()
-    audio = await app.generate_speech_audio_url("Hello, world!")
-    print(audio)
+    await app.generate_speech_audio_url("Hello, world!")
 
 
 if __name__ == "__main__":

universal_mcp/applications/exa/app.py

@@ -28,7 +28,7 @@ class ExaApp(APIApplication):
     ) -> dict[str, Any]:
         """
         Executes a query against the Exa API's `/search` endpoint, returning a list of results. This function supports extensive filtering by search type, category, domains, publication dates, and specific text content to refine the search query and tailor the API's response.
-        
+
         Args:
             query (string): The query string for the search. Example: 'Latest developments in LLM capabilities'.
             useAutoprompt (boolean): Autoprompt converts your query to an Exa-style query. Enabled by default for auto search, optional for neural search, and not available for keyword search. Example: 'True'.
@@ -44,10 +44,10 @@ class ExaApp(APIApplication):
             includeText (array): List of strings that must be present in webpage text of results. Currently, only 1 string is supported, of up to 5 words. Example: "['large language model']".
             excludeText (array): List of strings that must not be present in webpage text of results. Currently, only 1 string is supported, of up to 5 words. Example: "['course']".
             contents (object): contents
-        
+
         Returns:
             dict[str, Any]: OK
-        
+
         Tags:
             important
         """
@@ -90,7 +90,7 @@ class ExaApp(APIApplication):
     ) -> dict[str, Any]:
         """
         Finds web pages semantically similar to a given URL. Unlike the `search` function, which uses a text query, this method takes a specific link and returns a list of related results, with options to filter by domain, publication date, and content.
-        
+
         Args:
             url (string): The url for which you would like to find similar links. Example: 'https://arxiv.org/abs/2307.06435'.
             numResults (integer): Number of results to return (up to thousands of results available for custom plans) Example: '10'.
@@ -103,10 +103,10 @@ class ExaApp(APIApplication):
             includeText (array): List of strings that must be present in webpage text of results. Currently, only 1 string is supported, of up to 5 words. Example: "['large language model']".
             excludeText (array): List of strings that must not be present in webpage text of results. Currently, only 1 string is supported, of up to 5 words. Example: "['course']".
             contents (object): contents
-        
+
         Returns:
             dict[str, Any]: OK
-        
+
         Tags:
             important
         """
@@ -145,7 +145,7 @@ class ExaApp(APIApplication):
     ) -> dict[str, Any]:
         """
         Retrieves and processes content from a list of URLs, returning full text, summaries, or highlights. Unlike the search function which finds links, this function fetches the actual page content, with optional support for live crawling to get the most up-to-date information.
-        
+
         Args:
             urls (array): Array of URLs to crawl (backwards compatible with 'ids' parameter). Example: "['https://arxiv.org/pdf/2307.06435']".
             ids (array): Deprecated - use 'urls' instead. Array of document IDs obtained from searches. Example: "['https://arxiv.org/pdf/2307.06435']".
@@ -162,10 +162,10 @@ class ExaApp(APIApplication):
             subpages (integer): The number of subpages to crawl. The actual number crawled may be limited by system constraints. Example: '1'.
             subpageTarget (string): Keyword to find specific subpages of search results. Can be a single string or an array of strings, comma delimited. Example: 'sources'.
             extras (object): Extra parameters to pass.
-        
+
         Returns:
             dict[str, Any]: OK
-        
+
         Tags:
             important
         """
@@ -191,16 +191,16 @@ class ExaApp(APIApplication):
     def answer(self, query, stream=None, text=None, model=None) -> dict[str, Any]:
         """
         Retrieves a direct, synthesized answer for a given query by calling the Exa `/answer` API endpoint. Unlike `search`, which returns web results, this function provides a conclusive response. It supports streaming, including source text, and selecting a search model.
-        
+
         Args:
             query (string): The question or query to answer. Example: 'What is the latest valuation of SpaceX?'.
             stream (boolean): If true, the response is returned as a server-sent events (SSS) stream.
             text (boolean): If true, the response includes full text content in the search results
             model (string): The search model to use for the answer. Exa passes only one query to exa, while exa-pro also passes 2 expanded queries to our search model.
-        
+
         Returns:
             dict[str, Any]: OK
-        
+
         Tags:
             important
         """
@@ -219,8 +219,8 @@ class ExaApp(APIApplication):
 
     def list_tools(self):
         return [
-            self.search_with_filters, 
-            self.find_similar_by_url, 
-            self.fetch_page_content, 
-            self.answer
-            ]
+            self.search_with_filters,
+            self.find_similar_by_url,
+            self.fetch_page_content,
+            self.answer,
+        ]

universal_mcp/applications/falai/app.py

@@ -3,7 +3,6 @@ from typing import Any, Literal
 
 from fal_client import AsyncClient, AsyncRequestHandle, Status
 from loguru import logger
-
 from universal_mcp.applications.application import APIApplication
 from universal_mcp.exceptions import NotAuthorizedError, ToolError
 from universal_mcp.integrations import Integration
@@ -59,20 +58,20 @@ class FalaiApp(APIApplication):
     ) -> Any:
         """
         Executes a Fal AI application synchronously, waiting for completion and returning the result directly. This method is suited for short-running tasks, unlike `submit` which queues a job for asynchronous processing and returns a request ID instead of the final output.
-        
+
         Args:
             arguments: A dictionary of arguments for the application
             application: The name or ID of the Fal application (defaults to 'fal-ai/flux/dev')
             path: Optional subpath for the application endpoint
             timeout: Optional timeout in seconds for the request
             hint: Optional hint for runner selection
-        
+
         Returns:
             The result of the application execution as a Python object (converted from JSON response)
-        
+
         Raises:
             ToolError: Raised when the Fal API request fails, wrapping the original exception
-        
+
         Tags:
             run, execute, ai, synchronous, fal, important
         """
@@ -102,7 +101,7 @@ class FalaiApp(APIApplication):
     ) -> str:
         """
         Submits a job to the Fal AI queue for asynchronous processing, immediately returning a request ID. This contrasts with the `run` method, which waits for completion. The returned ID is used by `check_status`, `get_result`, and `cancel` to manage the job's lifecycle.
-        
+
         Args:
             arguments: A dictionary of arguments for the application
             application: The name or ID of the Fal application, defaulting to 'fal-ai/flux/dev'
@@ -110,13 +109,13 @@ class FalaiApp(APIApplication):
             hint: Optional hint for runner selection
             webhook_url: Optional URL to receive a webhook when the request completes
             priority: Optional queue priority ('normal' or 'low')
-        
+
         Returns:
             The request ID (str) of the submitted asynchronous job
-        
+
         Raises:
             ToolError: Raised when the Fal API request fails, wrapping the original exception
-        
+
         Tags:
             submit, async_job, start, ai, queue
         """
@@ -147,18 +146,18 @@ class FalaiApp(APIApplication):
     ) -> Status:
         """
         Checks the execution state (e.g., Queued, InProgress) of an asynchronous Fal AI job using its request ID. It provides a non-blocking way to monitor jobs initiated via `submit` without fetching the final `result`, and can optionally include logs.
-        
+
         Args:
             request_id: The unique identifier of the submitted request, obtained from a previous submit operation
             application: The name or ID of the Fal application (defaults to 'fal-ai/flux/dev')
             with_logs: Boolean flag to include execution logs in the status response (defaults to False)
-        
+
         Returns:
             A Status object containing the current state of the request (Queued, InProgress, or Completed)
-        
+
         Raises:
             ToolError: Raised when the Fal API request fails or when the provided request ID is invalid
-        
+
         Tags:
             status, check, async_job, monitoring, ai
         """
@@ -182,17 +181,17 @@ class FalaiApp(APIApplication):
     ) -> Any:
         """
         Retrieves the final result of an asynchronous job, identified by its `request_id`. This function waits for the job, initiated via `submit`, to complete. Unlike the non-blocking `check_status`, this method blocks execution to fetch and return the job's actual output upon completion.
-        
+
         Args:
             request_id: The unique identifier of the submitted request
             application: The name or ID of the Fal application (defaults to 'fal-ai/flux/dev')
-        
+
         Returns:
             The result of the application execution, converted from JSON response to Python data structures (dict/list)
-        
+
         Raises:
             ToolError: When the Fal API request fails or the request does not complete successfully
-        
+
         Tags:
             result, async-job, status, wait, ai
         """
@@ -216,17 +215,17 @@ class FalaiApp(APIApplication):
     ) -> None:
         """
         Asynchronously cancels a running or queued Fal AI job using its `request_id`. This function complements the `submit` method, providing a way to terminate asynchronous tasks before completion. It raises a `ToolError` if the cancellation request fails.
-        
+
         Args:
             request_id: The unique identifier of the submitted Fal AI request to cancel
             application: The name or ID of the Fal application (defaults to 'fal-ai/flux/dev')
-        
+
         Returns:
             None. The function doesn't return any value.
-        
+
         Raises:
             ToolError: Raised when the cancellation request fails due to API errors or if the request cannot be cancelled
-        
+
         Tags:
             cancel, async_job, ai, fal, management
         """
@@ -245,16 +244,16 @@ class FalaiApp(APIApplication):
     async def upload_file(self, path: str) -> str:
         """
         Asynchronously uploads a local file to the Fal Content Delivery Network (CDN), returning a public URL. This URL makes the file accessible for use as input in other Fal AI job execution methods like `run` or `submit`. A `ToolError` is raised if the upload fails.
-        
+
         Args:
             path: The absolute or relative path to the local file
-        
+
         Returns:
             A string containing the public URL of the uploaded file on the CDN
-        
+
         Raises:
             ToolError: If the file is not found or if the upload operation fails
-        
+
         Tags:
             upload, file, cdn, storage, async, important
         """
@@ -281,7 +280,7 @@ class FalaiApp(APIApplication):
     ) -> Any:
         """
         A specialized wrapper for the `run` method that synchronously generates images using the 'fal-ai/flux/dev' model. It simplifies image creation with common parameters like `prompt` and `seed`, waits for the task to complete, and directly returns the result containing image URLs and metadata.
-        
+
         Args:
             prompt: The text prompt used to guide the image generation
             seed: Random seed for reproducible image generation (default: 6252023)
@@ -291,13 +290,13 @@ class FalaiApp(APIApplication):
             path: Subpath for the application endpoint (rarely used)
             timeout: Maximum time in seconds to wait for the request to complete
             hint: Hint string for runner selection
-        
+
         Returns:
             A dictionary containing the generated image URLs and related metadata
-        
+
         Raises:
             ToolError: When the image generation request fails or encounters an error
-        
+
         Tags:
             generate, image, ai, async, important, flux, customizable, default
         """

universal_mcp/applications/file_system/app.py

@@ -17,18 +17,18 @@ class FileSystemApp(BaseApplication):
     async def read_file(file_path: str):
         """
         Asynchronously reads the entire content of a specified file in binary mode. This static method takes a file path and returns its data as a bytes object, serving as a fundamental file retrieval operation within the FileSystem application.
-        
+
         Args:
             file_path (str): The path to the file to read.
-        
+
         Returns:
             bytes: The file content as bytes.
-        
+
         Raises:
             FileNotFoundError: If the file doesn't exist.
             IOError: If there's an error reading the file.
-            
-        Tags: 
+
+        Tags:
             important
         """
         with open(file_path, "rb") as f:
@@ -38,12 +38,12 @@ class FileSystemApp(BaseApplication):
     async def write_file(file_data: bytes, file_path: str = None):
         """
         Writes binary data to a specified file path. If no path is provided, it creates a unique temporary file in `/tmp`. The function returns a dictionary confirming success and providing metadata about the new file, including its path and size.
-        
+
         Args:
             file_data (bytes): The data to write to the file.
             file_path (str, optional): The path where to write the file.
                 If None, generates a random path in /tmp. Defaults to None.
-        
+
         Returns:
             dict: A dictionary containing the operation result with keys:
                 - status (str): "success" if the operation completed successfully
@@ -51,11 +51,11 @@ class FileSystemApp(BaseApplication):
                     - url (str): The file path where the data was written
                     - filename (str): The filename (same as url in this implementation)
                     - size (int): The size of the written data in bytes
-        
+
         Raises:
             IOError: If there's an error writing the file.
             PermissionError: If there are insufficient permissions to write to the path.
-            
+
         Tags:
             important
         """