universal-mcp-applications 0.1.33__py3-none-any.whl → 0.1.39rc16__py3-none-any.whl

universal_mcp/applications/domain_checker/app.py

@@ -1,42 +1,18 @@
 import logging
 import sys
 from typing import Any
-
 import dns.resolver
 import requests
 from universal_mcp.applications.application import APIApplication
 from universal_mcp.integrations import Integration
 
-# Configure logging
 logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
-    handlers=[logging.StreamHandler(sys.stderr)],
+    level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s", handlers=[logging.StreamHandler(sys.stderr)]
 )
-
 logger = logging.getLogger("domain_checker")
-
-# Constants
 RDAP_BOOTSTRAP_URL = "https://data.iana.org/rdap/dns.json"
 USER_AGENT = "DomainCheckerBot/1.0"
-
-# Top TLDs to check
-TOP_TLDS = [
-    "com",
-    "net",
-    "org",
-    "io",
-    "co",
-    "app",
-    "dev",
-    "ai",
-    "me",
-    "info",
-    "xyz",
-    "online",
-    "site",
-    "tech",
-]
+TOP_TLDS = ["com", "net", "org", "io", "co", "app", "dev", "ai", "me", "info", "xyz", "online", "site", "tech"]
 
 
 class DomainCheckerApp(APIApplication):
@@ -52,22 +28,16 @@ class DomainCheckerApp(APIApplication):
         Fetches a domain's registration details from Registration Data Access Protocol (RDAP) servers. It dynamically selects the appropriate server URL based on the domain's TLD, with special handling for common ones. Returns the JSON data as a dictionary or None if the request fails or data is unavailable.
         """
         try:
-            # Special case for .ch and .li domains
             tld = domain.split(".")[-1].lower()
             if tld in ["ch", "li"]:
                 rdap_url = f"https://rdap.nic.{tld}/domain/{domain}"
-            # Use common RDAP servers for known TLDs
             elif tld in ["com", "net"]:
                 rdap_url = f"https://rdap.verisign.com/{tld}/v1/domain/{domain}"
             elif tld == "org":
-                rdap_url = (
-                    f"https://rdap.publicinterestregistry.org/rdap/domain/{domain}"
-                )
+                rdap_url = f"https://rdap.publicinterestregistry.org/rdap/domain/{domain}"
             else:
                 rdap_url = f"https://rdap.org/domain/{domain}"
-
             headers = {"Accept": "application/rdap+json", "User-Agent": USER_AGENT}
-
             response = requests.get(rdap_url, headers=headers, timeout=5)
             if response.status_code == 200:
                 return response.json()
@@ -122,21 +92,13 @@ class DomainCheckerApp(APIApplication):
             domain, availability, registration, dns, rdap, important
         """
         logger.info(f"Checking domain: {domain}")
-
-        # First check DNS
         has_dns = await self._check_dns(domain)
-
         if has_dns:
-            # Domain exists, get RDAP data if possible
             rdap_data = await self._get_rdap_data(domain)
-
             if rdap_data:
-                # Extract data from RDAP
                 registrar = "Unknown"
                 reg_date = "Unknown"
                 exp_date = "Unknown"
-
-                # Extract registrar
                 entities = rdap_data.get("entities", [])
                 for entity in entities:
                     if "registrar" in entity.get("roles", []):
@@ -146,15 +108,12 @@ class DomainCheckerApp(APIApplication):
                                 if entry[0] in ["fn", "org"] and len(entry) > 3:
                                     registrar = entry[3]
                                     break
-
-                # Extract dates
                 events = rdap_data.get("events", [])
                 for event in events:
                     if event.get("eventAction") == "registration":
                         reg_date = event.get("eventDate", "Unknown")
                     elif event.get("eventAction") == "expiration":
                         exp_date = event.get("eventDate", "Unknown")
-
                 return {
                     "domain": domain,
                     "status": "Registered",
@@ -175,8 +134,6 @@ class DomainCheckerApp(APIApplication):
                     "rdap_data_available": False,
                     "note": "Domain has DNS records but RDAP data couldn't be retrieved",
                 }
-
-        # Try RDAP one more time even if DNS not found
         rdap_data = await self._get_rdap_data(domain)
         if rdap_data:
             return {
@@ -189,8 +146,6 @@ class DomainCheckerApp(APIApplication):
                 "rdap_data_available": True,
                 "note": "Domain found in RDAP registry",
             }
-
-        # If we get here, the domain is likely available
         return {
             "domain": domain,
             "status": "Available",
@@ -233,17 +188,12 @@ class DomainCheckerApp(APIApplication):
             tld, keyword, domain-search, availability, bulk-check, important
         """
         logger.info(f"Checking keyword: {keyword} across TLDs")
-
         available = []
         taken = []
-
-        # Check each TLD in sequence
         for tld in TOP_TLDS:
             domain = f"{keyword}.{tld}"
             has_dns = await self._check_dns(domain)
-
             if not has_dns:
-                # Double-check with RDAP if no DNS
                 rdap_data = await self._get_rdap_data(domain)
                 if not rdap_data:
                     available.append(domain)
@@ -251,7 +201,6 @@ class DomainCheckerApp(APIApplication):
                     taken.append(domain)
             else:
                 taken.append(domain)
-
         return {
             "keyword": keyword,
             "tlds_checked": len(TOP_TLDS),

universal_mcp/applications/e2b/app.py

@@ -1,17 +1,12 @@
 import os
 from typing import Annotated, Any
-
 from loguru import logger
 
 try:
     from e2b_code_interpreter import Sandbox
-
 except ImportError:
     Sandbox = None
-    logger.error(
-        "Failed to import E2B Sandbox. Please ensure 'e2b_code_interpreter' is installed."
-    )
-
+    logger.error("Failed to import E2B Sandbox. Please ensure 'e2b_code_interpreter' is installed.")
 from universal_mcp.applications.application import APIApplication
 from universal_mcp.exceptions import NotAuthorizedError, ToolError
 from universal_mcp.integrations import Integration
@@ -28,66 +23,40 @@ class E2bApp(APIApplication):
         super().__init__(name="e2b", integration=integration, **kwargs)
         self._e2b_api_key: str | None = None
         if Sandbox is None:
-            logger.warning(
-                "E2B Sandbox SDK is not available. E2B tools will not function."
-            )
+            logger.warning("E2B Sandbox SDK is not available. E2B tools will not function.")
 
-    @property
-    def e2b_api_key(self) -> str:
+    async def get_e2b_api_key(self) -> str:
         """
         A property that lazily retrieves and caches the E2B API key from the configured integration. It fetches the key on the first call, handles authentication failures, and raises `NotAuthorizedError` with actionable guidance if the key cannot be obtained.
         """
         if self._e2b_api_key is None:
             if not self.integration:
                 logger.error("E2B App: Integration not configured.")
-                raise NotAuthorizedError(
-                    "Integration not configured for E2B App. Cannot retrieve API key."
-                )
-
+                raise NotAuthorizedError("Integration not configured for E2B App. Cannot retrieve API key.")
             try:
-                credentials = self.integration.get_credentials()
+                credentials = await self.integration.get_credentials_async()
             except NotAuthorizedError as e:
-                logger.error(
-                    f"E2B App: Authorization error when fetching credentials: {e.message}"
-                )
-                raise  # Re-raise the original NotAuthorizedError
+                logger.error(f"E2B App: Authorization error when fetching credentials: {e.message}")
+                raise
             except Exception as e:
-                logger.error(
-                    f"E2B App: Unexpected error when fetching credentials: {e}",
-                    exc_info=True,
-                )
+                logger.error(f"E2B App: Unexpected error when fetching credentials: {e}", exc_info=True)
                 raise NotAuthorizedError(f"Failed to get E2B credentials: {e}")
-
-            api_key = (
-                credentials.get("api_key")
-                or credentials.get("API_KEY")  # Check common variations
-                or credentials.get("apiKey")
-            )
-
+            api_key = credentials.get("api_key") or credentials.get("API_KEY") or credentials.get("apiKey")
             if not api_key:
                 logger.error("E2B App: API key not found in credentials.")
                 action_message = "API key for E2B is missing. Please ensure it's set in the store via MCP frontend or configuration."
-                if hasattr(self.integration, "authorize") and callable(
-                    self.integration.authorize
-                ):
+                if hasattr(self.integration, "authorize") and callable(self.integration.authorize):
                     try:
                         auth_details = self.integration.authorize()
                         if isinstance(auth_details, str):
                             action_message = auth_details
                         elif isinstance(auth_details, dict) and "url" in auth_details:
-                            action_message = (
-                                f"Please authorize via: {auth_details['url']}"
-                            )
-                        elif (
-                            isinstance(auth_details, dict) and "message" in auth_details
-                        ):
+                            action_message = f"Please authorize via: {auth_details['url']}"
+                        elif isinstance(auth_details, dict) and "message" in auth_details:
                             action_message = auth_details["message"]
                     except Exception as auth_e:
-                        logger.warning(
-                            f"Could not retrieve specific authorization action for E2B: {auth_e}"
-                        )
+                        logger.warning(f"Could not retrieve specific authorization action for E2B: {auth_e}")
                 raise NotAuthorizedError(action_message)
-
             self._e2b_api_key = api_key
             logger.info("E2B API Key successfully retrieved and cached.")
         return self._e2b_api_key
@@ -95,40 +64,28 @@ class E2bApp(APIApplication):
     def _format_execution_output(self, execution: Any) -> str:
         """Helper function to format the E2B execution logs nicely."""
         output_parts = []
-
         try:
             logs = getattr(execution, "logs", None)
-
             if logs is not None:
-                # Collect stdout
                 if getattr(logs, "stdout", None):
                     stdout_content = "".join(logs.stdout).strip()
                     if stdout_content:
                         output_parts.append(stdout_content)
-
-                # Collect stderr
                 if getattr(logs, "stderr", None):
                     stderr_content = "".join(logs.stderr).strip()
                     if stderr_content:
                         output_parts.append(f"--- ERROR ---\n{stderr_content}")
-
-            # Fallback: check execution.text (covers expressions returning values)
             if not output_parts and hasattr(execution, "text"):
                 text_content = str(execution.text).strip()
                 if text_content:
                     output_parts.append(text_content)
-
         except Exception as e:
             output_parts.append(f"Failed to format execution output: {e}")
-
         if not output_parts:
             return "Execution finished with no output (stdout/stderr)."
-
         return "\n\n".join(output_parts)
 
-    def execute_python_code(
-        self, code: Annotated[str, "The Python code to execute."]
-    ) -> str:
+    async def execute_python_code(self, code: Annotated[str, "The Python code to execute."]) -> 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.
 
@@ -151,10 +108,9 @@ class E2bApp(APIApplication):
             raise ToolError("E2B Sandbox SDK (e2b_code_interpreter) is not installed.")
         if not code or not isinstance(code, str):
             raise ValueError("Provided code must be a non-empty string.")
-
         try:
             logger.info("Attempting to execute Python code in E2B Sandbox.")
-            os.environ["E2B_API_KEY"] = self.e2b_api_key
+            os.environ["E2B_API_KEY"] = await self.get_e2b_api_key()
             with Sandbox.create() as sandbox:
                 logger.info("E2B Sandbox initialized. Running code.")
                 execution = sandbox.run_code(code)
@@ -164,17 +120,10 @@ class E2bApp(APIApplication):
         except Exception as e:
             logger.exception("E2B code execution failed.")
             lower = str(e).lower()
-            if (
-                "authentication" in lower
-                or "api key" in lower
-                or "401" in lower
-                or "403" in lower
-            ):
+            if "authentication" in lower or "api key" in lower or "401" in lower or ("403" in lower):
                 raise NotAuthorizedError(f"E2B authentication/permission failed: {e}")
             raise ToolError(f"E2B code execution failed: {e}")
 
     def list_tools(self) -> list[callable]:
         """Lists the tools available from the E2bApp."""
-        return [
-            self.execute_python_code,
-        ]
+        return [self.execute_python_code]

universal_mcp/applications/elevenlabs/README.md

@@ -9,6 +9,30 @@ This is automatically generated from OpenAPI schema for the ElevenlabsApp API.
 
 | Tool | Description |
 |------|-------------|
-| `generate_speech_audio_url` | 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. |
-| `speech_to_text` | 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. |
-| `speech_to_speech` | 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. |
+| `text_to_speech` | Converts text to speech and returns the generated audio data. |
+| `speech_to_text` | Transcribes an audio file into text. |
+| `speech_to_speech` | Converts speech from an audio source (URL or local path) to a different voice. |
+| `get_history_items` | Returns a list of generated audio history items. |
+| `get_history_item` | Retrieves a specific history item by ID. |
+| `delete_history_item` | Deletes a history item by ID. |
+| `get_history_item_audio` | Gets the audio for a history item. |
+| `get_voices` | Lists all available voices. |
+| `get_voice` | Gets details of a specific voice. |
+| `delete_voice` | Deletes a voice by ID. |
+| `get_voice_samples` | Gets samples for a specific voice. |
+| `delete_sample` | Deletes a sample. |
+| `convert_text_to_sound_effect` | Converts text to sound effects. |
+| `convert_text_to_dialogue` | Converts a list of text and voice ID pairs into speech (dialogue) and returns synthesized audio. |
+| `remix_voice` | Remixes an existing voice to create a new one based on a description. |
+| `convert_text_to_music` | Generates music based on a text prompt. |
+| `clone_voice` | Clones a voice from provided audio samples (URLs or local paths). |
+| `design_voice` | Generates voice previews based on a text description. |
+| `align_audio` | Aligns text to an audio file, returning timing information for characters and words. |
+| `isolate_audio` | Removes background noise from audio. |
+| `dub_file` | Dubs an audio file into another language. |
+| `get_dubbing_project_metadata` | Gets metadata for a dubbing project. |
+| `get_dubbed_file` | Downloads a dubbed file. |
+| `get_models` | Lists available models. |
+| `get_user_info` | Gets user information. |
+| `get_user_subscription` | Gets user subscription details. |
+| `get_usage` | Gets usage statistics. Defaults to the last 30 days if dates are not provided. |