universal-mcp-applications 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

universal_mcp/applications/falai/app.py

@@ -3,6 +3,7 @@ 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

universal_mcp/applications/file_system/__init__.py

@@ -0,0 +1 @@
+from .app import FileSystemApp

universal_mcp/applications/file_system/app.py

@@ -0,0 +1,96 @@
+import os
+import shutil
+import uuid
+
+from universal_mcp.applications.application import BaseApplication
+
+
+class FileSystemApp(BaseApplication):
+    def __init__(self, **kwargs):
+        super().__init__(name="file_system", **kwargs)
+
+    @staticmethod
+    async def _generate_file_path():
+        return f"/tmp/{uuid.uuid4()}"
+
+    @staticmethod
+    async def read_file(file_path: str):
+        """Reads file data from a file path.
+
+        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: 
+            important
+        """
+        with open(file_path, "rb") as f:
+            return f.read()
+
+    @staticmethod
+    async def write_file(file_data: bytes, file_path: str = None):
+        """Writes file data to a file path.
+
+        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
+                - data (dict): Contains file information with keys:
+                    - 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
+        """
+        if file_path is None:
+            file_path = await FileSystemApp._generate_file_path()
+        with open(file_path, "wb") as f:
+            f.write(file_data)
+            result = {
+                "status": "success",
+                "data": {
+                    "url": file_path,
+                    "filename": file_path,
+                    "size": len(file_data),
+                },
+            }
+            return result
+
+    @staticmethod
+    async def delete_file(file_path: str):
+        """Deletes a file from the file system."""
+        os.remove(file_path)
+        return {"status": "success"}
+
+    @staticmethod
+    async def move_file(source_file_path: str, dest_file_path: str):
+        """Moves a file from one path to another."""
+        os.rename(source_file_path, dest_file_path)
+        return {"status": "success"}
+
+    @staticmethod
+    async def copy_file(source_file_path: str, dest_file_path: str):
+        """Copies a file from one path to another."""
+        shutil.copy(source_file_path, dest_file_path)
+        return {"status": "success"}
+
+    def list_tools(self):
+        return [
+            FileSystemApp.read_file,
+            FileSystemApp.write_file,
+        ]

universal_mcp/applications/fireflies/app.py

@@ -1,10 +1,11 @@
-from collections.abc import Callable  # For type hinting
+from collections.abc import Callable
 from typing import Any
 
 from gql import gql
-from universal_mcp.applications import (
+
+from universal_mcp.applications.application import (
     GraphQLApplication,
-)  # Assuming this is in a reachable path
+)
 from universal_mcp.integrations import Integration
 
 

universal_mcp/applications/fpl/app.py

@@ -3,6 +3,7 @@ from datetime import datetime
 from typing import Any
 
 import requests
+
 from universal_mcp.applications.application import APIApplication
 from universal_mcp.integrations import Integration
 

universal_mcp/applications/fpl/utils/fixtures.py

@@ -3,7 +3,7 @@
 import logging
 from typing import Any
 
-from universal_mcp_fpl.utils.api import api
+from .api import api
 
 # Set up logging following project conventions
 logger = logging.getLogger("fpl-mcp-server.fixtures")

universal_mcp/applications/fpl/utils/helper.py

@@ -3,7 +3,7 @@ import logging
 from typing import Any
 
 logger = logging.getLogger("fpl-mcp-server.fixtures")
-from universal_mcp_fpl.utils.api import api
+from .api import api
 
 # Resources
 

universal_mcp/applications/fpl/utils/position_utils.py

@@ -1,6 +1,5 @@
 """Utilities for normalizing position terms in FPL context."""
 
-
 # Comprehensive position mapping dictionary
 POSITION_MAPPINGS = {
     # Standard FPL codes

universal_mcp/applications/{ghost-content → ghost_content}/app.py

@@ -2,6 +2,7 @@ from collections.abc import Callable
 from typing import Any
 
 from loguru import logger
+
 from universal_mcp.applications.application import APIApplication
 from universal_mcp.integrations import Integration
 
@@ -24,7 +25,7 @@ class GhostContentApp(APIApplication):
                          "https://your-ghost-site.com") and 'key' (the Content API key)
                          via `integration.get_credentials()`.
         """
-        super().__init__(name="ghost-content", integration=integration)
+        super().__init__(name="ghost_content", integration=integration)
         self._base_url = None
         self._api_key = None  # Cache the API key
         self._version = None  # Cache the version

universal_mcp/applications/github/app.py

@@ -1,6 +1,7 @@
 from typing import Any
 
 from loguru import logger
+
 from universal_mcp.applications.application import APIApplication
 from universal_mcp.integrations import Integration
 
@@ -4469,7 +4470,8 @@ class GithubApp(APIApplication):
         dependabot_security_updates_enabled_for_new_repositories: bool | None = None,
         dependency_graph_enabled_for_new_repositories: bool | None = None,
         secret_scanning_enabled_for_new_repositories: bool | None = None,
-        secret_scanning_push_protection_enabled_for_new_repositories: bool | None = None,
+        secret_scanning_push_protection_enabled_for_new_repositories: bool
+        | None = None,
         secret_scanning_push_protection_custom_link_enabled: bool | None = None,
         secret_scanning_push_protection_custom_link: str | None = None,
         deploy_keys_enabled_for_repositories: bool | None = None,
@@ -49574,7 +49576,7 @@ class GithubApp(APIApplication):
             self.update_issue,
             self.list_repo_activities,
             # Auto Generated from open api spec
-            self.meta_root,
+            self.meta_get,
             self.list_advisories,
             self.get_advisory_by_id,
             self.apps_get_authenticated,
@@ -49654,7 +49656,6 @@ class GithubApp(APIApplication):
             self.get_stubbed_account,
             self.apps_list_plans_stubbed,
             self.get_plan_accounts,
-            self.meta_get,
             self.get_network_repo_events,
             self.get_notifications,
             self.update_notification,

universal_mcp/applications/{google-calendar → google_calendar}/app.py

@@ -2,13 +2,14 @@ from datetime import UTC, datetime, timedelta
 from typing import Any
 
 from loguru import logger
+
 from universal_mcp.applications.application import APIApplication
 from universal_mcp.integrations import Integration
 
 
 class GoogleCalendarApp(APIApplication):
     def __init__(self, integration: Integration) -> None:
-        super().__init__(name="google-calendar", integration=integration)
+        super().__init__(name="google_calendar", integration=integration)
         self.base_api_url = "https://www.googleapis.com/calendar/v3/calendars/primary"
         self.base_url = "https://www.googleapis.com/calendar/v3"
 

universal_mcp/applications/{google-docs → google_docs}/app.py

@@ -6,7 +6,7 @@ from universal_mcp.integrations import Integration
 
 class GoogleDocsApp(APIApplication):
     def __init__(self, integration: Integration) -> None:
-        super().__init__(name="google-docs", integration=integration)
+        super().__init__(name="google_docs", integration=integration)
         self.base_api_url = "https://docs.googleapis.com/v1/documents"
 
     def create_document(self, title: str) -> dict[str, Any]:

universal_mcp/applications/{google-drive → google_drive}/app.py

@@ -2,6 +2,7 @@ from typing import Any
 
 import httpx
 from loguru import logger
+
 from universal_mcp.applications.application import APIApplication
 from universal_mcp.integrations import Integration
 
@@ -13,7 +14,7 @@ class GoogleDriveApp(APIApplication):
     """
 
     def __init__(self, integration: Integration | None = None) -> None:
-        super().__init__(name="google-drive", integration=integration)
+        super().__init__(name="google_drive", integration=integration)
         self.base_url = "https://www.googleapis.com/drive/v3"
 
     def move_files(

universal_mcp/applications/google_gemini/app.py

@@ -0,0 +1,183 @@
+import uuid
+import wave
+from typing import Annotated  # Added Literal for type hinting
+
+from google import genai
+from google.genai import types
+from loguru import logger
+from PIL import Image
+
+from universal_mcp.applications.application import APIApplication
+from universal_mcp.applications.file_system.app import FileSystemApp
+from universal_mcp.integrations import Integration
+
+
+class GoogleGeminiApp(APIApplication):
+    def __init__(self, integration: Integration = None, **kwargs) -> None:
+        super().__init__(name="google_gemini", integration=integration, **kwargs)
+        self._genai_client = None
+
+    @property
+    def genai_client(self) -> genai.Client:
+        if self._genai_client is not None:
+            return self._genai_client
+        credentials = self.integration.get_credentials()
+        api_key = (
+            credentials.get("api_key")
+            or credentials.get("API_KEY")
+            or credentials.get("apiKey")
+        )
+        if not api_key:
+            raise ValueError("API key not found in integration credentials")
+        self._genai_client = genai.Client(api_key=api_key)
+        return self._genai_client
+
+    async def generate_text(
+        self,
+        prompt: Annotated[str, "The prompt to generate text from"],
+        model: str = "gemini-2.5-flash",
+    ) -> str:
+        """Generates text using the Google Gemini model.
+
+        Args:
+            prompt (str): The prompt to generate text from.
+            model (str, optional): The Gemini model to use for text generation. Defaults to "gemini-2.5-flash".
+
+        Returns:
+            str: The generated text response from the Gemini model.
+
+        Raises:
+            ValueError: If the API key is not found in the integration credentials.
+            Exception: If the underlying client or API call fails.
+
+        Example:
+            response = app.generate_text("Tell me a joke.")
+            
+        Tags:
+            important
+        """
+        response = self.genai_client.generate_content(prompt, model=model)
+        return response.text
+
+    async def generate_image(
+        self,
+        prompt: Annotated[str, "The prompt to generate image from"],
+        image: Annotated[str, "The reference image path"] | None = None,
+        model: str = "gemini-2.5-flash-image-preview",
+    ) -> list:
+        """
+        Generates an image using the Google Gemini model and returns a list of results.
+        Each result is a dict with either 'text' or 'image_bytes' (raw image data).
+
+        Args:
+            prompt (str): The prompt to generate image from.
+            model (str, optional): The Gemini model to use for image generation. Defaults to "gemini-2.5-flash-image-preview".
+
+        Returns:
+            list: A list of dicts, each containing either 'text' or 'image_bytes'.
+            
+        Tags:
+            important
+        """
+        # The Gemini API is synchronous, so run in a thread
+        contents = [prompt]
+        if image:
+            image = Image.open(image)
+            contents.append(image)
+        response = self.genai_client.models.generate_content(
+            model=model,
+            contents=contents,
+        )
+        candidate = response.candidates[0]
+        text = ""
+        for part in candidate.content.parts:
+            if part.text is not None:
+                text += part.text
+            elif part.inline_data is not None:
+                # Return the raw image bytes
+                image_bytes = part.inline_data.data
+                upload_result = await FileSystemApp.write_file(
+                    image_bytes, f"/tmp/{uuid.uuid4()}.png"
+                )
+                logger.info(f"Upload result: {upload_result['status']}")
+                image_url = upload_result["data"]["url"]
+                logger.info(f"Image URL: {image_url}")
+                text += f"![Image]({image_url})"
+        logger.info(f"Text: {text}")
+        return {"text": text}
+
+    async def generate_audio(
+        self,
+        prompt: Annotated[str, "The prompt to generate audio from"],
+        model: str = "gemini-2.5-flash-preview-tts",
+    ) -> str:
+        """Generates audio using the Google Gemini model and returns the uploaded audio URL.
+
+        Args:
+            prompt (str): The prompt to generate audio from.
+            model (str, optional): The Gemini model to use for audio generation. Defaults to "gemini-2.5-flash-preview-tts".
+
+        Returns:
+            str: The URL of the uploaded audio file.
+            
+        Tags:
+            important
+        """
+
+        # Set up the wave file to save the output:
+        def wave_file(filename, pcm, channels=1, rate=24000, sample_width=2):
+            with wave.open(filename, "wb") as wf:
+                wf.setnchannels(channels)
+                wf.setsampwidth(sample_width)
+                wf.setframerate(rate)
+                wf.writeframes(pcm)
+
+        response = self.genai_client.models.generate_content(
+            model=model,
+            contents=prompt,
+            config=types.GenerateContentConfig(
+                response_modalities=["AUDIO"],
+                speech_config=types.SpeechConfig(
+                    voice_config=types.VoiceConfig(
+                        prebuilt_voice_config=types.PrebuiltVoiceConfig(
+                            voice_name="Kore",
+                        )
+                    )
+                ),
+            ),
+        )
+
+        data = response.candidates[0].content.parts[0].inline_data.data
+
+        file_name = "/tmp/audio.wav"
+        wave_file(file_name, data)  # Saves the file to current directory
+        # Upload the audio file directly
+        upload_result = await FileSystemApp.move_file(
+            file_name, f"/tmp/{uuid.uuid4()}.wav"
+        )
+        logger.info(f"Audio upload result: {upload_result['status']}")
+        audio_url = upload_result["data"]["url"]
+        logger.info(f"Audio URL: {audio_url}")
+
+        return audio_url
+
+    def list_tools(self):
+        return [
+            self.generate_text,
+            self.generate_image,
+            self.generate_audio,
+        ]
+
+
+async def test_google_gemini():
+    app = GoogleGeminiApp()
+    result = await app.generate_image(
+        "A beautiful women potrait with red green hair color"
+    )
+    print(result)
+
+
+if __name__ == "__main__":
+    import asyncio
+
+    asyncio.run(test_google_gemini())

universal_mcp/applications/{google-mail → google_mail}/app.py

@@ -4,13 +4,14 @@ from email.message import EmailMessage
 from typing import Any
 
 from loguru import logger
+
 from universal_mcp.applications.application import APIApplication
 from universal_mcp.integrations import Integration
 
 
 class GoogleMailApp(APIApplication):
     def __init__(self, integration: Integration) -> None:
-        super().__init__(name="google-mail", integration=integration)
+        super().__init__(name="google_mail", integration=integration)
         self.base_api_url = "https://gmail.googleapis.com/gmail/v1/users/me"
         self.base_url = "https://gmail.googleapis.com"
 

universal_mcp/applications/{google-searchconsole → google_searchconsole}/app.py

@@ -10,7 +10,7 @@ logger = logging.getLogger(__name__)
 
 class GoogleSearchconsoleApp(APIApplication):
     def __init__(self, integration: Integration = None, **kwargs) -> None:
-        super().__init__(name="google-searchconsole", integration=integration, **kwargs)
+        super().__init__(name="google_searchconsole", integration=integration, **kwargs)
         self.webmasters_base_url = "https://www.googleapis.com/webmasters/v3"
         self.searchconsole_base_url = "https://searchconsole.googleapis.com/v1"
 

universal_mcp/applications/{google-sheet → google_sheet}/app.py

@@ -2,7 +2,8 @@ from typing import Any
 
 from universal_mcp.applications.application import APIApplication
 from universal_mcp.integrations import Integration
-from universal_mcp_google_sheet.helper import (
+
+from .helper import (
     analyze_sheet_for_tables,
     analyze_table_schema,
 )
@@ -15,7 +16,7 @@ class GoogleSheetApp(APIApplication):
     """
 
     def __init__(self, integration: Integration | None = None) -> None:
-        super().__init__(name="google-sheet", integration=integration)
+        super().__init__(name="google_sheet", integration=integration)
         self.base_url = "https://sheets.googleapis.com/v4/spreadsheets"
 
     def create_spreadsheet(self, title: str) -> dict[str, Any]: