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

universal_mcp/applications/notion/app.py

@@ -1,5 +1,4 @@
 from typing import Any
-
 from universal_mcp.applications.application import APIApplication
 from universal_mcp.integrations import Integration
 
@@ -15,13 +14,9 @@ class NotionApp(APIApplication):
         credentials = self.integration.get_credentials()
         if "headers" in credentials:
             return credentials["headers"]
-        return {
-            "Authorization": f"Bearer {credentials['access_token']}",
-            "Accept": "application/json",
-            "Notion-Version": "2022-06-28",
-        }
+        return {"Authorization": f"Bearer {credentials['access_token']}", "Accept": "application/json", "Notion-Version": "2022-06-28"}
 
-    def retrieve_a_user(self, id, request_body=None) -> dict[str, Any]:
+    async def retrieve_a_user(self, id, request_body=None) -> dict[str, Any]:
         """
         Retrieves a user's details from the server using their unique identifier.
 
@@ -43,13 +38,11 @@ class NotionApp(APIApplication):
             raise ValueError("Missing required parameter 'id'")
         url = f"{self.base_url}/v1/users/{id}"
         query_params = {}
-        response = self._get(url, params=query_params)
+        response = await self._aget(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def list_all_users(
-        self,
-    ) -> dict[str, Any]:
+    async def list_all_users(self) -> dict[str, Any]:
         """
         Retrieves a complete list of users from the API endpoint.
 
@@ -68,13 +61,11 @@ class NotionApp(APIApplication):
         """
         url = f"{self.base_url}/v1/users"
         query_params = {}
-        response = self._get(url, params=query_params)
+        response = await self._aget(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def retrieve_your_token_sbot_user(
-        self,
-    ) -> dict[str, Any]:
+    async def retrieve_your_token_sbot_user(self) -> dict[str, Any]:
         """
         Retrieves the current user's authentication token information from the SBOT service.
 
@@ -90,11 +81,11 @@ class NotionApp(APIApplication):
         """
         url = f"{self.base_url}/v1/users/me"
         query_params = {}
-        response = self._get(url, params=query_params)
+        response = await self._aget(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def retrieve_a_database(self, id) -> dict[str, Any]:
+    async def retrieve_a_database(self, id) -> dict[str, Any]:
         """
         Retrieves detailed information about a specific database using its unique identifier.
 
@@ -115,11 +106,11 @@ class NotionApp(APIApplication):
             raise ValueError("Missing required parameter 'id'")
         url = f"{self.base_url}/v1/databases/{id}"
         query_params = {}
-        response = self._get(url, params=query_params)
+        response = await self._aget(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def update_a_database(self, id, request_body=None) -> dict[str, Any]:
+    async def update_a_database(self, id, request_body=None) -> dict[str, Any]:
         """
         Updates a database entry with the specified ID using a PATCH request.
 
@@ -145,7 +136,7 @@ class NotionApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def query_a_database(self, id, request_body=None) -> dict[str, Any]:
+    async def query_a_database(self, id, request_body=None) -> dict[str, Any]:
         """
         Executes a database query operation using a specified database ID and optional request parameters
 
@@ -167,11 +158,11 @@ class NotionApp(APIApplication):
             raise ValueError("Missing required parameter 'id'")
         url = f"{self.base_url}/v1/databases/{id}/query"
         query_params = {}
-        response = self._post(url, data=request_body, params=query_params)
+        response = await self._apost(url, data=request_body, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def create_a_database(self, request_body=None) -> dict[str, Any]:
+    async def create_a_database(self, request_body=None) -> dict[str, Any]:
         """
         Creates a new database on the server by sending a POST request to the database endpoint.
 
@@ -191,11 +182,11 @@ class NotionApp(APIApplication):
         """
         url = f"{self.base_url}/v1/databases/"
         query_params = {}
-        response = self._post(url, data=request_body, params=query_params)
+        response = await self._apost(url, data=request_body, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def create_a_page(self, request_body=None) -> dict[str, Any]:
+    async def create_a_page(self, request_body=None) -> dict[str, Any]:
         """
         Creates a new page by sending a POST request to the API endpoint.
 
@@ -214,11 +205,11 @@ class NotionApp(APIApplication):
         """
         url = f"{self.base_url}/v1/pages/"
         query_params = {}
-        response = self._post(url, data=request_body, params=query_params)
+        response = await self._apost(url, data=request_body, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def retrieve_a_page(self, id) -> dict[str, Any]:
+    async def retrieve_a_page(self, id) -> dict[str, Any]:
         """
         Retrieves a specific page's data from a remote server using its unique identifier.
 
@@ -239,11 +230,11 @@ class NotionApp(APIApplication):
             raise ValueError("Missing required parameter 'id'")
         url = f"{self.base_url}/v1/pages/{id}"
         query_params = {}
-        response = self._get(url, params=query_params)
+        response = await self._aget(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def update_page_properties(self, id, request_body=None) -> dict[str, Any]:
+    async def update_page_properties(self, id, request_body=None) -> dict[str, Any]:
         """
         Updates the properties of a page with the specified ID using the provided request body.
 
@@ -270,7 +261,7 @@ class NotionApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def retrieve_a_page_property_item(self, page_id, property_id) -> dict[str, Any]:
+    async def retrieve_a_page_property_item(self, page_id, property_id) -> dict[str, Any]:
         """
         Retrieves a specific property item from a Notion page using the page ID and property ID.
 
@@ -294,11 +285,11 @@ class NotionApp(APIApplication):
             raise ValueError("Missing required parameter 'property_id'")
         url = f"{self.base_url}/v1/pages/{page_id}/properties/{property_id}"
         query_params = {}
-        response = self._get(url, params=query_params)
+        response = await self._aget(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def retrieve_block_children(self, id, page_size=None) -> dict[str, Any]:
+    async def retrieve_block_children(self, id, page_size=None) -> dict[str, Any]:
         """
         Retrieves all child blocks for a specified parent block using its ID via the API.
 
@@ -320,11 +311,11 @@ class NotionApp(APIApplication):
             raise ValueError("Missing required parameter 'id'")
         url = f"{self.base_url}/v1/blocks/{id}/children"
         query_params = {k: v for k, v in [("page_size", page_size)] if v is not None}
-        response = self._get(url, params=query_params)
+        response = await self._aget(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def append_block_children(self, id, request_body=None) -> dict[str, Any]:
+    async def append_block_children(self, id, request_body=None) -> dict[str, Any]:
         """
         Appends child elements to a specified block and returns the updated block data.
 
@@ -350,7 +341,7 @@ class NotionApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def retrieve_a_block(self, id) -> dict[str, Any]:
+    async def retrieve_a_block(self, id) -> dict[str, Any]:
         """
         Retrieves a specific block of data from the API using its unique identifier.
 
@@ -371,11 +362,11 @@ class NotionApp(APIApplication):
             raise ValueError("Missing required parameter 'id'")
         url = f"{self.base_url}/v1/blocks/{id}"
         query_params = {}
-        response = self._get(url, params=query_params)
+        response = await self._aget(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def delete_a_block(self, id) -> dict[str, Any]:
+    async def delete_a_block(self, id) -> dict[str, Any]:
         """
         Deletes a specified block by its ID and returns the server response.
 
@@ -396,11 +387,11 @@ class NotionApp(APIApplication):
             raise ValueError("Missing required parameter 'id'")
         url = f"{self.base_url}/v1/blocks/{id}"
         query_params = {}
-        response = self._delete(url, params=query_params)
+        response = await self._adelete(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def update_a_block(self, id, request_body=None) -> dict[str, Any]:
+    async def update_a_block(self, id, request_body=None) -> dict[str, Any]:
         """
         Updates a specific block resource via a PATCH request to the API endpoint
 
@@ -426,7 +417,7 @@ class NotionApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def search(self, request_body=None) -> dict[str, Any]:
+    async def search(self, request_body=None) -> dict[str, Any]:
         """
         Executes a search operation by sending a POST request to the search endpoint and returns the results
 
@@ -445,13 +436,11 @@ class NotionApp(APIApplication):
         """
         url = f"{self.base_url}/v1/search"
         query_params = {}
-        response = self._post(url, data=request_body, params=query_params)
+        response = await self._apost(url, data=request_body, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def retrieve_comments(
-        self, block_id=None, page_size=None, request_body=None
-    ) -> dict[str, Any]:
+    async def retrieve_comments(self, block_id=None, page_size=None, request_body=None) -> dict[str, Any]:
         """
         Retrieves comments from a remote server with optional block filtering and pagination support.
 
@@ -471,16 +460,12 @@ class NotionApp(APIApplication):
             retrieve, fetch, comments, api, pagination, http
         """
         url = f"{self.base_url}/v1/comments"
-        query_params = {
-            k: v
-            for k, v in [("block_id", block_id), ("page_size", page_size)]
-            if v is not None
-        }
-        response = self._get(url, params=query_params)
+        query_params = {k: v for k, v in [("block_id", block_id), ("page_size", page_size)] if v is not None}
+        response = await self._aget(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def add_comment_to_page(self, request_body=None) -> dict[str, Any]:
+    async def add_comment_to_page(self, request_body=None) -> dict[str, Any]:
         """
         Adds a comment to a page by making an HTTP POST request to the comments endpoint.
 
@@ -499,7 +484,7 @@ class NotionApp(APIApplication):
         """
         url = f"{self.base_url}/v1/comments"
         query_params = {}
-        response = self._post(url, data=request_body, params=query_params)
+        response = await self._apost(url, data=request_body, params=query_params)
         response.raise_for_status()
         return response.json()
 

universal_mcp/applications/onedrive/app.py

@@ -1,7 +1,6 @@
 import base64
 import os
 from typing import Any
-
 from loguru import logger
 from universal_mcp.applications.application import APIApplication
 from universal_mcp.integrations import Integration
@@ -17,7 +16,7 @@ class OnedriveApp(APIApplication):
         super().__init__(name="onedrive", integration=integration, **kwargs)
         self.base_url = "https://graph.microsoft.com/v1.0"
 
-    def get_my_profile(self) -> dict[str, Any]:
+    async def get_my_profile(self) -> dict[str, Any]:
         """
         Fetches the profile for the currently authenticated user, specifically retrieving their ID and user principal name. This function confirms user identity, distinguishing it from `get_drive_info`, which returns details about the OneDrive storage space (e.g., quota) rather than the user's personal profile.
 
@@ -32,10 +31,10 @@ class OnedriveApp(APIApplication):
         """
         url = f"{self.base_url}/me"
         query_params = {"$select": "id,userPrincipalName"}
-        response = self._get(url, params=query_params)
+        response = await self._aget(url, params=query_params)
         return self._handle_response(response)
 
-    def get_drive_info(self) -> dict[str, Any]:
+    async def get_drive_info(self) -> dict[str, Any]:
         """
         Fetches high-level information about the user's entire OneDrive. It returns drive-wide details like the owner and storage quota, differing from `get_item_metadata` which describes a specific item, and `get_my_profile` which retrieves general user account information.
 
@@ -46,7 +45,7 @@ class OnedriveApp(APIApplication):
             drive, storage, quota, info
         """
         url = f"{self.base_url}/me/drive"
-        response = self._get(url)
+        response = await self._aget(url)
         return self._handle_response(response)
 
     def _list_drive_items(self, item_id: str = "root") -> dict[str, Any]:
@@ -63,7 +62,7 @@ class OnedriveApp(APIApplication):
         response = self._get(url)
         return self._handle_response(response)
 
-    def search_files(self, query: str) -> dict[str, Any]:
+    async def search_files(self, query: str) -> dict[str, Any]:
         """
         Searches the user's entire OneDrive for files and folders matching a specified text query. This function performs a comprehensive search from the drive's root, distinguishing it from `list_files` or `list_folders` which only browse the contents of a single directory.
 
@@ -78,12 +77,11 @@ class OnedriveApp(APIApplication):
         """
         if not query:
             raise ValueError("Search query cannot be empty.")
-
         url = f"{self.base_url}/me/drive/root/search(q='{query}')"
-        response = self._get(url)
+        response = await self._aget(url)
         return self._handle_response(response)
 
-    def get_item_metadata(self, item_id: str) -> dict[str, Any]:
+    async def get_item_metadata(self, item_id: str) -> dict[str, Any]:
         """
         Fetches detailed metadata for a specific file or folder using its unique ID. It returns properties like name, size, and type. Unlike `get_document_content`, it doesn't retrieve the file's actual content, focusing solely on the item's attributes for quick inspection without a full download.
 
@@ -98,12 +96,11 @@ class OnedriveApp(APIApplication):
         """
         if not item_id:
             raise ValueError("Missing required parameter 'item_id'.")
-
         url = f"{self.base_url}/me/drive/items/{item_id}"
-        response = self._get(url)
+        response = await self._aget(url)
         return self._handle_response(response)
 
-    def create_folder(self, name: str, parent_id: str = "root") -> dict[str, Any]:
+    async def create_folder(self, name: str, parent_id: str = "root") -> dict[str, Any]:
         """
         Creates a new folder with a specified name within a parent directory, which defaults to the root. Returns metadata for the new folder. Unlike `create_folder_and_list`, this function only creates the folder and returns its specific metadata, not the parent directory's contents.
 
@@ -119,13 +116,12 @@ class OnedriveApp(APIApplication):
         """
         if not name:
             raise ValueError("Folder name cannot be empty.")
-
         url = f"{self.base_url}/me/drive/items/{parent_id}/children"
         data = {"name": name, "folder": {}, "@microsoft.graph.conflictBehavior": "rename"}
-        response = self._post(url, data=data)
+        response = await self._apost(url, data=data)
         return self._handle_response(response)
 
-    def delete_item(self, item_id: str) -> dict[str, Any]:
+    async def delete_item(self, item_id: str) -> dict[str, Any]:
         """
         Permanently deletes a specified file or folder from OneDrive using its unique item ID. This versatile function can remove any type of drive item, distinguished from functions that only list or create specific types. A successful deletion returns an empty response, confirming the item's removal.
 
@@ -140,12 +136,11 @@ class OnedriveApp(APIApplication):
         """
         if not item_id:
             raise ValueError("Missing required parameter 'item_id'.")
-
         url = f"{self.base_url}/me/drive/items/{item_id}"
-        response = self._delete(url)
+        response = await self._adelete(url)
         return self._handle_response(response)
 
-    def download_file(self, item_id: str) -> dict[str, Any]:
+    async def download_file(self, item_id: str) -> dict[str, Any]:
         """
         Retrieves a temporary, pre-authenticated download URL for a specific file using its item ID. This function provides a link for subsequent download, differing from `get_document_content` which directly fetches the file's raw content. The URL is returned within a dictionary.
 
@@ -160,16 +155,15 @@ class OnedriveApp(APIApplication):
         """
         if not item_id:
             raise ValueError("Missing required parameter 'item_id'.")
-
         url = f"{self.base_url}/me/drive/items/{item_id}"
-        response = self._get(url)
+        response = await self._aget(url)
         metadata = self._handle_response(response)
         download_url = metadata.get("@microsoft.graph.downloadUrl")
         if not download_url:
             raise ValueError("Could not retrieve download URL for the item.")
         return {"download_url": download_url}
 
-    def upload_file(self, file_path: str, parent_id: str = "root", file_name: str | None = None) -> dict[str, Any]:
+    async def upload_file(self, file_path: str, parent_id: str = "root", file_name: str | None = None) -> dict[str, Any]:
         """
         Uploads a local binary file (under 4MB) from a given path to a specified OneDrive folder. Unlike `upload_text_file`, which uploads string content, this function reads from the filesystem. The destination filename can be customized, and it returns the new file's metadata upon completion.
 
@@ -186,17 +180,15 @@ class OnedriveApp(APIApplication):
         """
         if not os.path.exists(file_path):
             raise FileNotFoundError(f"The file was not found at path: {file_path}")
-
         if not file_name:
             file_name = os.path.basename(file_path)
-
         url = f"{self.base_url}/me/drive/items/{parent_id}:/{file_name}:/content"
         with open(file_path, "rb") as f:
             data = f.read()
-        response = self._put(url, data=data, content_type="application/octet-stream")
+        response = await self._aput(url, data=data, content_type="application/octet-stream")
         return self._handle_response(response)
 
-    def list_folders(self, item_id: str = "root") -> dict[str, Any]:
+    async def list_folders(self, item_id: str = "root") -> dict[str, Any]:
         """
         Retrieves a list of only the folders within a specified parent directory in OneDrive. Unlike `_list_drive_items` which returns all items, this function filters the results to exclude files. Defaults to the root directory if no parent `item_id` is provided.
 
@@ -213,7 +205,7 @@ class OnedriveApp(APIApplication):
         folders = [item for item in all_items.get("value", []) if "folder" in item]
         return {"value": folders}
 
-    def list_files(self, item_id: str = "root") -> dict[str, Any]:
+    async def list_files(self, item_id: str = "root") -> dict[str, Any]:
         """
         Retrieves a list of files within a specified OneDrive folder, defaulting to the root. Unlike `_list_drive_items` which fetches all items, this function filters the results to exclusively return items identified as files, excluding any subdirectories.
 
@@ -230,7 +222,7 @@ class OnedriveApp(APIApplication):
         files = [item for item in all_items.get("value", []) if "file" in item]
         return {"value": files}
 
-    def create_folder_and_list(self, name: str, parent_id: str = "root") -> dict[str, Any]:
+    async def create_folder_and_list(self, name: str, parent_id: str = "root") -> dict[str, Any]:
         """
         Performs a composite action: creates a new folder, then lists all items (files and folders) within that parent directory. This confirms creation by returning the parent's updated contents, distinct from `create_folder` which only returns the new folder's metadata.
 
@@ -244,10 +236,10 @@ class OnedriveApp(APIApplication):
         Tags:
             create, folder, list, important
         """
-        self.create_folder(name=name, parent_id=parent_id)
+        await self.create_folder(name=name, parent_id=parent_id)
         return self._list_drive_items(item_id=parent_id)
 
-    def upload_text_file(self, content: str, parent_id: str = "root", file_name: str = "new_file.txt") -> dict[str, Any]:
+    async def upload_text_file(self, content: str, parent_id: str = "root", file_name: str = "new_file.txt") -> dict[str, Any]:
         """
         Creates and uploads a new file to OneDrive directly from a string of text content. Unlike `upload_file`, which requires a local file path, this function is specifically for creating a text file from in-memory string data, with a customizable name and destination folder.
 
@@ -264,13 +256,12 @@ class OnedriveApp(APIApplication):
         """
         if not file_name:
             raise ValueError("File name cannot be empty.")
-
         url = f"{self.base_url}/me/drive/items/{parent_id}:/{file_name}:/content"
         data = content.encode("utf-8")
-        response = self._put(url, data=data, content_type="text/plain")
+        response = await self._aput(url, data=data, content_type="text/plain")
         return self._handle_response(response)
 
-    def get_document_content(self, item_id: str) -> dict[str, Any]:
+    async def get_document_content(self, item_id: str) -> dict[str, Any]:
         """
         Retrieves the content of a specific file by its item ID and returns it directly as base64-encoded data. This function is distinct from `download_file`, which only provides a temporary URL for the content, and from `get_item_metadata`, which returns file attributes without the content itself. The function fetches the content by following the file's pre-authenticated download URL.
 
@@ -289,36 +280,23 @@ class OnedriveApp(APIApplication):
         """
         if not item_id:
             raise ValueError("Missing required parameter 'item_id'.")
-
-        metadata = self.get_item_metadata(item_id=item_id)
+        metadata = await self.get_item_metadata(item_id=item_id)
         file_metadata = metadata.get("file")
         if not file_metadata:
             raise ValueError(f"Item with ID '{item_id}' is not a file.")
-
         file_mime_type = file_metadata.get("mimeType", "application/octet-stream")
         file_name = metadata.get("name")
-
         download_url = metadata.get("@microsoft.graph.downloadUrl")
         if not download_url:
             logger.error(f"Could not find @microsoft.graph.downloadUrl in metadata for item {item_id}")
             raise ValueError("Could not retrieve download URL for the item.")
-
-        response = self._get(download_url)
-
+        response = await self._aget(download_url)
         response.raise_for_status()
-
         content = response.content
-
         attachment_type = file_mime_type.split("/")[0] if "/" in file_mime_type else "file"
         if attachment_type not in ["image", "audio", "video", "text"]:
             attachment_type = "file"
-
-        return {
-            "type": attachment_type,
-            "data": content,
-            "mime_type": file_mime_type,
-            "file_name": file_name,
-        }
+        return {"type": attachment_type, "data": content, "mime_type": file_mime_type, "file_name": file_name}
 
     def list_tools(self):
         return [