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

universal_mcp/applications/google_drive/app.py

@@ -1,5 +1,4 @@
 from typing import Any
-
 import httpx
 from loguru import logger
 from universal_mcp.applications.application import APIApplication
@@ -16,9 +15,7 @@ class GoogleDriveApp(APIApplication):
         super().__init__(name="google_drive", integration=integration)
         self.base_url = "https://www.googleapis.com/drive/v3"
 
-    def move_file(
-        self, file_id: str, add_parents: str, remove_parents: str
-    ) -> dict[str, Any]:
+    async def move_file(self, file_id: str, add_parents: str, remove_parents: str) -> dict[str, Any]:
         """
         Moves a file to a new folder by updating its parent references. This function adds the file to a destination folder (`add_parents`) and removes it from the source (`remove_parents`), offering a focused alternative to the more comprehensive `update_file_metadata` function.
 
@@ -41,11 +38,10 @@ class GoogleDriveApp(APIApplication):
         url = f"{self.base_url}/files/{file_id}"
         data = {}
         params = {"addParents": add_parents, "removeParents": remove_parents}
-        response = self._patch(url, params=params, data=data)
-        response.raise_for_status()
-        return response.json()
+        response = await self._apatch(url, params=params, data=data)
+        return self._handle_response(response)
 
-    def get_drive_info(self) -> dict[str, Any]:
+    async def get_drive_info(self) -> dict[str, Any]:
         """
         Fetches key user and storage quota information for the authenticated Google Drive account. This streamlined function offers a focused alternative to `get_about_info`, which queries the same endpoint but exposes all available API parameters, providing a simpler way to get essential account details.
 
@@ -62,12 +58,10 @@ class GoogleDriveApp(APIApplication):
         """
         url = f"{self.base_url}/about"
         params = {"fields": "storageQuota,user"}
-        response = self._get(url, params=params)
-        return response.json()
+        response = await self._aget(url, params=params)
+        return self._handle_response(response)
 
-    def search_files(
-        self, page_size: int = 10, q: str | None = None, order_by: str | None = None
-    ) -> dict[str, Any]:
+    async def search_files(self, page_size: int = 10, q: str | None = None, order_by: str | None = None) -> dict[str, Any]:
         """
         Searches for files in Google Drive, allowing for powerful filtering, sorting, and pagination.
         This streamlined function offers a more user-friendly alternative to the comprehensive search_files_advanced method, making it ideal for targeted queries like finding files by name, type, or parent folder.
@@ -99,18 +93,15 @@ class GoogleDriveApp(APIApplication):
             list, files, search, google-drive, pagination, important
         """
         url = f"{self.base_url}/files"
-        params = {
-            "pageSize": page_size,
-        }
+        params = {"pageSize": page_size}
         if q:
             params["q"] = q
         if order_by:
             params["orderBy"] = order_by
-        response = self._get(url, params=params)
-        response.raise_for_status()
-        return response.json()
+        response = await self._aget(url, params=params)
+        return self._handle_response(response)
 
-    def get_file_details(self, file_id: str) -> dict[str, Any]:
+    async def get_file_details(self, file_id: str) -> dict[str, Any]:
         """
         Fetches all default metadata for a specific file by its unique ID. This function provides a simple, direct retrieval of a single file's complete attributes, differing from `search_files` which performs broad queries for multiple files based on various criteria.
 
@@ -128,10 +119,10 @@ class GoogleDriveApp(APIApplication):
             retrieve, file, metadata, get, api, important
         """
         url = f"{self.base_url}/files/{file_id}"
-        response = self._get(url)
-        return response.json()
+        response = await self._aget(url)
+        return self._handle_response(response)
 
-    def trash_file(self, file_id: str) -> dict[str, Any]:
+    async def trash_file(self, file_id: str) -> dict[str, Any]:
         """
         Moves a specified file to the trash using its ID. It provides simplified error handling by returning a dictionary with a success or error message, unlike the `permanently_delete_file` function which raises an exception on failure.
 
@@ -149,17 +140,13 @@ class GoogleDriveApp(APIApplication):
         """
         url = f"{self.base_url}/files/{file_id}"
         try:
-            self._delete(url)
+            await self._adelete(url)
             return {"message": "File deleted successfully"}
         except Exception as e:
             return {"error": str(e)}
 
-    def create_text_file(
-        self,
-        file_name: str,
-        text_content: str,
-        parent_id: str = None,
-        mime_type: str = "text/plain",
+    async def create_text_file(
+        self, file_name: str, text_content: str, parent_id: str = None, mime_type: str = "text/plain"
     ) -> dict[str, Any]:
         """
         Creates a file in Google Drive using an in-memory text string. Unlike `upload_file_from_path`, which reads from a local file, this function first creates the file's metadata (name, parent) and then uploads the provided string content, returning the new file's complete metadata upon completion.
@@ -184,20 +171,16 @@ class GoogleDriveApp(APIApplication):
         if parent_id:
             metadata["parents"] = [parent_id]
         create_url = f"{self.base_url}/files"
-        create_response = self._post(create_url, data=metadata)
-        file_data = create_response.json()
+        create_response = await self._apost(create_url, data=metadata)
+        file_data = self._handle_response(create_response)
         file_id = file_data.get("id")
         upload_url = f"https://www.googleapis.com/upload/drive/v3/files/{file_id}?uploadType=media"
-        upload_headers = self._get_headers()
-        upload_headers["Content-Type"] = f"{mime_type}; charset=utf-8"
-        upload_response = httpx.patch(
-            upload_url, headers=upload_headers, content=text_content.encode("utf-8")
+        upload_response = await self._apatch(
+            upload_url, data=text_content.encode("utf-8"), content_type=f"{mime_type}; charset=utf-8"
         )
-        upload_response.raise_for_status()
-        response_data = upload_response.json()
-        return response_data
+        return self._handle_response(upload_response)
 
-    def find_folder_id_by_name(self, folder_name: str) -> str | None:
+    async def find_folder_id_by_name(self, folder_name: str) -> str | None:
         """
         Searches for a non-trashed folder by its exact name, returning the ID of the first match. As a utility for `create_folder`, it resolves parent names to IDs and returns None if the folder isn't found or an API error occurs, logging the failure internally.
 
@@ -215,17 +198,15 @@ class GoogleDriveApp(APIApplication):
         """
         query = f"mimeType='application/vnd.google-apps.folder' and name='{folder_name}' and trashed=false"
         try:
-            response = self._get(
-                f"{self.base_url}/files",
-                params={"q": query, "fields": "files(id,name)"},
-            )
-            files = response.json().get("files", [])
+            response = await self._aget(f"{self.base_url}/files", params={"q": query, "fields": "files(id,name)"})
+            data = self._handle_response(response)
+            files = data.get("files", [])
             return files[0]["id"] if files else None
         except Exception as e:
             logger.error(f"Error finding folder ID by name: {e}")
             return None
 
-    def create_folder(self, folder_name: str, parent_id: str = None) -> dict[str, Any]:
+    async def create_folder(self, folder_name: str, parent_id: str = None) -> dict[str, Any]:
         """
         Creates a new folder in Google Drive, optionally within a parent specified by name or ID. If a parent name is given, it internally resolves it to an ID using the `find_folder_id_by_name` function. Returns the metadata for the newly created folder upon successful creation.
 
@@ -244,33 +225,22 @@ class GoogleDriveApp(APIApplication):
         """
         import re
 
-        metadata = {
-            "name": folder_name,
-            "mimeType": "application/vnd.google-apps.folder",
-        }
+        metadata = {"name": folder_name, "mimeType": "application/vnd.google-apps.folder"}
         if parent_id:
-            if not re.match(r"^[a-zA-Z0-9_-]{28,33}$", parent_id):
-                found_id = self.find_folder_id_by_name(parent_id)
+            if not re.match("^[a-zA-Z0-9_-]{28,33}$", parent_id):
+                found_id = await self.find_folder_id_by_name(parent_id)
                 if found_id:
                     metadata["parents"] = [found_id]
                 else:
-                    raise ValueError(
-                        f"Could not find parent folder with name: {parent_id}"
-                    )
+                    raise ValueError(f"Could not find parent folder with name: {parent_id}")
             else:
                 metadata["parents"] = [parent_id]
         url = f"{self.base_url}/files"
         params = {"supportsAllDrives": "true"}
-        response = self._post(url, data=metadata, params=params)
-        return response.json()
+        response = await self._apost(url, data=metadata, params=params)
+        return self._handle_response(response)
 
-    def upload_file_from_path(
-        self,
-        file_name: str,
-        file_path: str,
-        parent_id: str = None,
-        mime_type: str = None,
-    ) -> dict[str, Any]:
+    async def upload_file_from_path(self, file_name: str, file_path: str, parent_id: str = None, mime_type: str = None) -> dict[str, Any]:
         """
         Uploads a local file to Google Drive by reading its binary content from a path. It creates the file's metadata, uploads the content, and returns the new file's metadata. This differs from `create_text_file` which uses in-memory string content instead of a local file path.
 
@@ -295,24 +265,16 @@ class GoogleDriveApp(APIApplication):
         if parent_id:
             metadata["parents"] = [parent_id]
         create_url = f"{self.base_url}/files"
-        create_response = self._post(create_url, data=metadata)
-        file_data = create_response.json()
+        create_response = await self._apost(create_url, data=metadata)
+        file_data = self._handle_response(create_response)
         file_id = file_data.get("id")
         with open(file_path, "rb") as file_content:
             binary_content = file_content.read()
-
             upload_url = f"https://www.googleapis.com/upload/drive/v3/files/{file_id}?uploadType=media"
-            upload_headers = self._get_headers()
-            upload_headers["Content-Type"] = mime_type
-
-            upload_response = httpx.patch(
-                upload_url, headers=upload_headers, content=binary_content
-            )
-            upload_response.raise_for_status()
-        response_data = upload_response.json()
-        return response_data
+            upload_response = await self._apatch(upload_url, data=binary_content, content_type=mime_type)
+        return self._handle_response(upload_response)
 
-    def list_installed_apps(
+    async def list_installed_apps(
         self,
         appFilterExtensions: str | None = None,
         appFilterMimeTypes: str | None = None,
@@ -379,20 +341,10 @@ class GoogleDriveApp(APIApplication):
             ]
             if v is not None
         }
-        response = self._get(url, params=query_params)
-        response.raise_for_status()
-        if (
-            response.status_code == 204
-            or not response.content
-            or not response.text.strip()
-        ):
-            return None
-        try:
-            return response.json()
-        except ValueError:
-            return None
+        response = await self._aget(url, params=query_params)
+        return self._handle_response(response)
 
-    def get_app_by_id(
+    async def get_app_by_id(
         self,
         appId: str,
         access_token: str | None = None,
@@ -454,20 +406,10 @@ class GoogleDriveApp(APIApplication):
             ]
             if v is not None
         }
-        response = self._get(url, params=query_params)
-        response.raise_for_status()
-        if (
-            response.status_code == 204
-            or not response.content
-            or not response.text.strip()
-        ):
-            return None
-        try:
-            return response.json()
-        except ValueError:
-            return None
+        response = await self._aget(url, params=query_params)
+        return self._handle_response(response)
 
-    def get_about_info(
+    async def get_about_info(
         self,
         alt: str | None = None,
         fields: str | None = None,
@@ -513,20 +455,10 @@ class GoogleDriveApp(APIApplication):
             ]
             if v is not None
         }
-        response = self._get(url, params=query_params)
-        response.raise_for_status()
-        if (
-            response.status_code == 204
-            or not response.content
-            or not response.text.strip()
-        ):
-            return None
-        try:
-            return response.json()
-        except ValueError:
-            return None
+        response = await self._aget(url, params=query_params)
+        return self._handle_response(response)
 
-    def list_drive_changes(
+    async def list_drive_changes(
         self,
         pageToken: str | None = None,
         driveId: str | None = None,
@@ -614,20 +546,10 @@ class GoogleDriveApp(APIApplication):
             ]
             if v is not None
         }
-        response = self._get(url, params=query_params)
-        response.raise_for_status()
-        if (
-            response.status_code == 204
-            or not response.content
-            or not response.text.strip()
-        ):
-            return None
-        try:
-            return response.json()
-        except ValueError:
-            return None
+        response = await self._aget(url, params=query_params)
+        return self._handle_response(response)
 
-    def get_changes_start_token(
+    async def get_changes_start_token(
         self,
         driveId: str | None = None,
         supportsAllDrives: str | None = None,
@@ -685,20 +607,10 @@ class GoogleDriveApp(APIApplication):
             ]
             if v is not None
         }
-        response = self._get(url, params=query_params)
-        response.raise_for_status()
-        if (
-            response.status_code == 204
-            or not response.content
-            or not response.text.strip()
-        ):
-            return None
-        try:
-            return response.json()
-        except ValueError:
-            return None
+        response = await self._aget(url, params=query_params)
+        return self._handle_response(response)
 
-    def watch_drive_changes(
+    async def watch_drive_changes(
         self,
         pageToken: str | None = None,
         driveId: str | None = None,
@@ -791,9 +703,7 @@ class GoogleDriveApp(APIApplication):
             "token": token,
             "type": type,
         }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.base_url}/changes/watch"
         query_params = {
             k: v
@@ -822,25 +732,10 @@ class GoogleDriveApp(APIApplication):
             ]
             if v is not None
         }
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
-        response.raise_for_status()
-        if (
-            response.status_code == 204
-            or not response.content
-            or not response.text.strip()
-        ):
-            return None
-        try:
-            return response.json()
-        except ValueError:
-            return None
+        response = await self._apost(url, data=request_body_data, params=query_params, content_type="application/json")
+        return self._handle_response(response)
 
-    def stop_watching_channel(
+    async def stop_watching_channel(
         self,
         alt: str | None = None,
         fields: str | None = None,
@@ -905,9 +800,7 @@ class GoogleDriveApp(APIApplication):
             "token": token,
             "type": type,
         }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.base_url}/channels/stop"
         query_params = {
             k: v
@@ -922,25 +815,10 @@ class GoogleDriveApp(APIApplication):
             ]
             if v is not None
         }
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
-        response.raise_for_status()
-        if (
-            response.status_code == 204
-            or not response.content
-            or not response.text.strip()
-        ):
-            return None
-        try:
-            return response.json()
-        except ValueError:
-            return None
+        response = await self._apost(url, data=request_body_data, params=query_params, content_type="application/json")
+        return self._handle_response(response)
 
-    def list_file_comments(
+    async def list_file_comments(
         self,
         fileId: str,
         includeDeleted: str | None = None,
@@ -1002,20 +880,10 @@ class GoogleDriveApp(APIApplication):
             ]
             if v is not None
         }
-        response = self._get(url, params=query_params)
-        response.raise_for_status()
-        if (
-            response.status_code == 204
-            or not response.content
-            or not response.text.strip()
-        ):
-            return None
-        try:
-            return response.json()
-        except ValueError:
-            return None
+        response = await self._aget(url, params=query_params)
+        return self._handle_response(response)
 
-    def create_file_comment(
+    async def create_file_comment(
         self,
         fileId: str,
         alt: str | None = None,
@@ -1090,9 +958,7 @@ class GoogleDriveApp(APIApplication):
             "replies": replies,
             "resolved": resolved,
         }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.base_url}/files/{fileId}/comments"
         query_params = {
             k: v
@@ -1107,25 +973,10 @@ class GoogleDriveApp(APIApplication):
             ]
             if v is not None
         }
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
-        response.raise_for_status()
-        if (
-            response.status_code == 204
-            or not response.content
-            or not response.text.strip()
-        ):
-            return None
-        try:
-            return response.json()
-        except ValueError:
-            return None
+        response = await self._apost(url, data=request_body_data, params=query_params, content_type="application/json")
+        return self._handle_response(response)
 
-    def get_file_comment_by_id(
+    async def get_file_comment_by_id(
         self,
         fileId: str,
         commentId: str,
@@ -1182,20 +1033,10 @@ class GoogleDriveApp(APIApplication):
             ]
             if v is not None
         }
-        response = self._get(url, params=query_params)
-        response.raise_for_status()
-        if (
-            response.status_code == 204
-            or not response.content
-            or not response.text.strip()
-        ):
-            return None
-        try:
-            return response.json()
-        except ValueError:
-            return None
+        response = await self._aget(url, params=query_params)
+        return self._handle_response(response)
 
-    def delete_comment(
+    async def delete_comment(
         self,
         fileId: str,
         commentId: str,
@@ -1249,20 +1090,10 @@ class GoogleDriveApp(APIApplication):
             ]
             if v is not None
         }
-        response = self._delete(url, params=query_params)
-        response.raise_for_status()
-        if (
-            response.status_code == 204
-            or not response.content
-            or not response.text.strip()
-        ):
-            return None
-        try:
-            return response.json()
-        except ValueError:
-            return None
+        response = await self._adelete(url, params=query_params)
+        return self._handle_response(response)
 
-    def update_comment(
+    async def update_comment(
         self,
         fileId: str,
         commentId: str,
@@ -1341,9 +1172,7 @@ class GoogleDriveApp(APIApplication):
             "replies": replies,
             "resolved": resolved,
         }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.base_url}/files/{fileId}/comments/{commentId}"
         query_params = {
             k: v
@@ -1358,20 +1187,10 @@ class GoogleDriveApp(APIApplication):
             ]
             if v is not None
         }
-        response = self._patch(url, data=request_body_data, params=query_params)
-        response.raise_for_status()
-        if (
-            response.status_code == 204
-            or not response.content
-            or not response.text.strip()
-        ):
-            return None
-        try:
-            return response.json()
-        except ValueError:
-            return None
+        response = await self._apatch(url, data=request_body_data, params=query_params)
+        return self._handle_response(response)
 
-    def list_shared_drives(
+    async def list_shared_drives(
         self,
         pageSize: str | None = None,
         pageToken: str | None = None,
@@ -1429,20 +1248,10 @@ class GoogleDriveApp(APIApplication):
             ]
             if v is not None
         }
-        response = self._get(url, params=query_params)
-        response.raise_for_status()
-        if (
-            response.status_code == 204
-            or not response.content
-            or not response.text.strip()
-        ):
-            return None
-        try:
-            return response.json()
-        except ValueError:
-            return None
+        response = await self._aget(url, params=query_params)
+        return self._handle_response(response)
 
-    def create_shared_drive(
+    async def create_shared_drive(
         self,
         requestId: str | None = None,
         alt: str | None = None,
@@ -1515,9 +1324,7 @@ class GoogleDriveApp(APIApplication):
             "restrictions": restrictions,
             "themeId": themeId,
         }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.base_url}/drives"
         query_params = {
             k: v
@@ -1533,25 +1340,10 @@ class GoogleDriveApp(APIApplication):
             ]
             if v is not None
         }
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
-        response.raise_for_status()
-        if (
-            response.status_code == 204
-            or not response.content
-            or not response.text.strip()
-        ):
-            return None
-        try:
-            return response.json()
-        except ValueError:
-            return None
+        response = await self._apost(url, data=request_body_data, params=query_params, content_type="application/json")
+        return self._handle_response(response)
 
-    def get_shared_drive_metadata(
+    async def get_shared_drive_metadata(
         self,
         driveId: str,
         useDomainAdminAccess: str | None = None,
@@ -1604,20 +1396,10 @@ class GoogleDriveApp(APIApplication):
             ]
             if v is not None
         }
-        response = self._get(url, params=query_params)
-        response.raise_for_status()
-        if (
-            response.status_code == 204
-            or not response.content
-            or not response.text.strip()
-        ):
-            return None
-        try:
-            return response.json()
-        except ValueError:
-            return None
+        response = await self._aget(url, params=query_params)
+        return self._handle_response(response)
 
-    def delete_shared_drive(
+    async def delete_shared_drive(
         self,
         driveId: str,
         allowItemDeletion: str | None = None,
@@ -1673,20 +1455,10 @@ class GoogleDriveApp(APIApplication):
             ]
             if v is not None
         }
-        response = self._delete(url, params=query_params)
-        response.raise_for_status()
-        if (
-            response.status_code == 204
-            or not response.content
-            or not response.text.strip()
-        ):
-            return None
-        try:
-            return response.json()
-        except ValueError:
-            return None
+        response = await self._adelete(url, params=query_params)
+        return self._handle_response(response)
 
-    def update_shared_drive(
+    async def update_shared_drive(
         self,
         driveId: str,
         useDomainAdminAccess: str | None = None,
@@ -1763,9 +1535,7 @@ class GoogleDriveApp(APIApplication):
             "restrictions": restrictions,
             "themeId": themeId,
         }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.base_url}/drives/{driveId}"
         query_params = {
             k: v
@@ -1781,20 +1551,10 @@ class GoogleDriveApp(APIApplication):
             ]
             if v is not None
         }
-        response = self._patch(url, data=request_body_data, params=query_params)
-        response.raise_for_status()
-        if (
-            response.status_code == 204
-            or not response.content
-            or not response.text.strip()
-        ):
-            return None
-        try:
-            return response.json()
-        except ValueError:
-            return None
+        response = await self._apatch(url, data=request_body_data, params=query_params)
+        return self._handle_response(response)
 
-    def hide_drive(
+    async def hide_drive(
         self,
         driveId: str,
         alt: str | None = None,
@@ -1845,25 +1605,10 @@ class GoogleDriveApp(APIApplication):
             ]
             if v is not None
         }
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
-        response.raise_for_status()
-        if (
-            response.status_code == 204
-            or not response.content
-            or not response.text.strip()
-        ):
-            return None
-        try:
-            return response.json()
-        except ValueError:
-            return None
+        response = await self._apost(url, data=request_body_data, params=query_params, content_type="application/json")
+        return self._handle_response(response)
 
-    def unhide_drive(
+    async def unhide_drive(
         self,
         driveId: str,
         alt: str | None = None,
@@ -1914,25 +1659,10 @@ class GoogleDriveApp(APIApplication):
             ]
             if v is not None
         }
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
-        response.raise_for_status()
-        if (
-            response.status_code == 204
-            or not response.content
-            or not response.text.strip()
-        ):
-            return None
-        try:
-            return response.json()
-        except ValueError:
-            return None
+        response = await self._apost(url, data=request_body_data, params=query_params, content_type="application/json")
+        return self._handle_response(response)
 
-    def search_files_advanced(
+    async def search_files_advanced(
         self,
         corpora: str | None = None,
         driveId: str | None = None,
@@ -2020,20 +1750,10 @@ class GoogleDriveApp(APIApplication):
             ]
             if v is not None
         }
-        response = self._get(url, params=query_params)
-        response.raise_for_status()
-        if (
-            response.status_code == 204
-            or not response.content
-            or not response.text.strip()
-        ):
-            return None
-        try:
-            return response.json()
-        except ValueError:
-            return None
+        response = await self._aget(url, params=query_params)
+        return self._handle_response(response)
 
-    def create_file_metadata(
+    async def create_file_metadata(
         self,
         enforceSingleParent: str | None = None,
         ignoreDefaultVisibility: str | None = None,
@@ -2272,9 +1992,7 @@ class GoogleDriveApp(APIApplication):
             "webViewLink": webViewLink,
             "writersCanShare": writersCanShare,
         }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.base_url}/files"
         query_params = {
             k: v
@@ -2298,25 +2016,10 @@ class GoogleDriveApp(APIApplication):
             ]
             if v is not None
         }
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
-        response.raise_for_status()
-        if (
-            response.status_code == 204
-            or not response.content
-            or not response.text.strip()
-        ):
-            return None
-        try:
-            return response.json()
-        except ValueError:
-            return None
+        response = await self._apost(url, data=request_body_data, params=query_params, content_type="application/json")
+        return self._handle_response(response)
 
-    def generate_file_ids(
+    async def generate_file_ids(
         self,
         count: str | None = None,
         space: str | None = None,
@@ -2371,20 +2074,10 @@ class GoogleDriveApp(APIApplication):
             ]
             if v is not None
         }
-        response = self._get(url, params=query_params)
-        response.raise_for_status()
-        if (
-            response.status_code == 204
-            or not response.content
-            or not response.text.strip()
-        ):
-            return None
-        try:
-            return response.json()
-        except ValueError:
-            return None
+        response = await self._aget(url, params=query_params)
+        return self._handle_response(response)
 
-    def empty_trash(
+    async def empty_trash(
         self,
         driveId: str | None = None,
         enforceSingleParent: str | None = None,
@@ -2436,20 +2129,10 @@ class GoogleDriveApp(APIApplication):
             ]
             if v is not None
         }
-        response = self._delete(url, params=query_params)
-        response.raise_for_status()
-        if (
-            response.status_code == 204
-            or not response.content
-            or not response.text.strip()
-        ):
-            return None
-        try:
-            return response.json()
-        except ValueError:
-            return None
+        response = await self._adelete(url, params=query_params)
+        return self._handle_response(response)
 
-    def permanently_delete_file(
+    async def permanently_delete_file(
         self,
         fileId: str,
         enforceSingleParent: str | None = None,
@@ -2508,20 +2191,10 @@ class GoogleDriveApp(APIApplication):
             ]
             if v is not None
         }
-        response = self._delete(url, params=query_params)
-        response.raise_for_status()
-        if (
-            response.status_code == 204
-            or not response.content
-            or not response.text.strip()
-        ):
-            return None
-        try:
-            return response.json()
-        except ValueError:
-            return None
+        response = await self._adelete(url, params=query_params)
+        return self._handle_response(response)
 
-    def update_file_metadata(
+    async def update_file_metadata(
         self,
         fileId: str,
         addParents: str | None = None,
@@ -2766,9 +2439,7 @@ class GoogleDriveApp(APIApplication):
             "webViewLink": webViewLink,
             "writersCanShare": writersCanShare,
         }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.base_url}/files/{fileId}"
         query_params = {
             k: v
@@ -2793,20 +2464,10 @@ class GoogleDriveApp(APIApplication):
             ]
             if v is not None
         }
-        response = self._patch(url, data=request_body_data, params=query_params)
-        response.raise_for_status()
-        if (
-            response.status_code == 204
-            or not response.content
-            or not response.text.strip()
-        ):
-            return None
-        try:
-            return response.json()
-        except ValueError:
-            return None
+        response = await self._apatch(url, data=request_body_data, params=query_params)
+        return self._handle_response(response)
 
-    def copy_file(
+    async def copy_file(
         self,
         fileId: str,
         enforceSingleParent: str | None = None,
@@ -3047,9 +2708,7 @@ class GoogleDriveApp(APIApplication):
             "webViewLink": webViewLink,
             "writersCanShare": writersCanShare,
         }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.base_url}/files/{fileId}/copy"
         query_params = {
             k: v
@@ -3072,25 +2731,10 @@ class GoogleDriveApp(APIApplication):
             ]
             if v is not None
         }
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
-        response.raise_for_status()
-        if (
-            response.status_code == 204
-            or not response.content
-            or not response.text.strip()
-        ):
-            return None
-        try:
-            return response.json()
-        except ValueError:
-            return None
+        response = await self._apost(url, data=request_body_data, params=query_params, content_type="application/json")
+        return self._handle_response(response)
 
-    def export_file(
+    async def export_file(
         self,
         fileId: str,
         mimeType: str | None = None,
@@ -3143,20 +2787,10 @@ class GoogleDriveApp(APIApplication):
             ]
             if v is not None
         }
-        response = self._get(url, params=query_params)
-        response.raise_for_status()
-        if (
-            response.status_code == 204
-            or not response.content
-            or not response.text.strip()
-        ):
-            return None
-        try:
-            return response.json()
-        except ValueError:
-            return None
+        response = await self._aget(url, params=query_params)
+        return self._handle_response(response)
 
-    def list_file_labels(
+    async def list_file_labels(
         self,
         fileId: str,
         maxResults: str | None = None,
@@ -3212,20 +2846,10 @@ class GoogleDriveApp(APIApplication):
             ]
             if v is not None
         }
-        response = self._get(url, params=query_params)
-        response.raise_for_status()
-        if (
-            response.status_code == 204
-            or not response.content
-            or not response.text.strip()
-        ):
-            return None
-        try:
-            return response.json()
-        except ValueError:
-            return None
+        response = await self._aget(url, params=query_params)
+        return self._handle_response(response)
 
-    def modify_file_labels(
+    async def modify_file_labels(
         self,
         fileId: str,
         alt: str | None = None,
@@ -3266,13 +2890,8 @@ class GoogleDriveApp(APIApplication):
         if fileId is None:
             raise ValueError("Missing required parameter 'fileId'.")
         request_body_data = None
-        request_body_data = {
-            "kind": kind,
-            "labelModifications": labelModifications,
-        }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {"kind": kind, "labelModifications": labelModifications}
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.base_url}/files/{fileId}/modifyLabels"
         query_params = {
             k: v
@@ -3287,25 +2906,10 @@ class GoogleDriveApp(APIApplication):
             ]
             if v is not None
         }
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
-        response.raise_for_status()
-        if (
-            response.status_code == 204
-            or not response.content
-            or not response.text.strip()
-        ):
-            return None
-        try:
-            return response.json()
-        except ValueError:
-            return None
+        response = await self._apost(url, data=request_body_data, params=query_params, content_type="application/json")
+        return self._handle_response(response)
 
-    def watch_file_for_changes(
+    async def watch_file_for_changes(
         self,
         fileId: str,
         acknowledgeAbuse: str | None = None,
@@ -3384,9 +2988,7 @@ class GoogleDriveApp(APIApplication):
             "token": token,
             "type": type,
         }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.base_url}/files/{fileId}/watch"
         query_params = {
             k: v
@@ -3406,25 +3008,10 @@ class GoogleDriveApp(APIApplication):
             ]
             if v is not None
         }
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
-        response.raise_for_status()
-        if (
-            response.status_code == 204
-            or not response.content
-            or not response.text.strip()
-        ):
-            return None
-        try:
-            return response.json()
-        except ValueError:
-            return None
+        response = await self._apost(url, data=request_body_data, params=query_params, content_type="application/json")
+        return self._handle_response(response)
 
-    def list_file_permissions(
+    async def list_file_permissions(
         self,
         fileId: str,
         includePermissionsForView: str | None = None,
@@ -3492,20 +3079,10 @@ class GoogleDriveApp(APIApplication):
             ]
             if v is not None
         }
-        response = self._get(url, params=query_params)
-        response.raise_for_status()
-        if (
-            response.status_code == 204
-            or not response.content
-            or not response.text.strip()
-        ):
-            return None
-        try:
-            return response.json()
-        except ValueError:
-            return None
+        response = await self._aget(url, params=query_params)
+        return self._handle_response(response)
 
-    def create_file_permission(
+    async def create_file_permission(
         self,
         fileId: str,
         emailMessage: str | None = None,
@@ -3605,9 +3182,7 @@ class GoogleDriveApp(APIApplication):
             "type": type,
             "view": view,
         }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.base_url}/files/{fileId}/permissions"
         query_params = {
             k: v
@@ -3630,25 +3205,10 @@ class GoogleDriveApp(APIApplication):
             ]
             if v is not None
         }
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
-        response.raise_for_status()
-        if (
-            response.status_code == 204
-            or not response.content
-            or not response.text.strip()
-        ):
-            return None
-        try:
-            return response.json()
-        except ValueError:
-            return None
+        response = await self._apost(url, data=request_body_data, params=query_params, content_type="application/json")
+        return self._handle_response(response)
 
-    def get_permission_by_id(
+    async def get_permission_by_id(
         self,
         fileId: str,
         permissionId: str,
@@ -3711,20 +3271,10 @@ class GoogleDriveApp(APIApplication):
             ]
             if v is not None
         }
-        response = self._get(url, params=query_params)
-        response.raise_for_status()
-        if (
-            response.status_code == 204
-            or not response.content
-            or not response.text.strip()
-        ):
-            return None
-        try:
-            return response.json()
-        except ValueError:
-            return None
+        response = await self._aget(url, params=query_params)
+        return self._handle_response(response)
 
-    def delete_permission(
+    async def delete_permission(
         self,
         fileId: str,
         permissionId: str,
@@ -3787,20 +3337,10 @@ class GoogleDriveApp(APIApplication):
             ]
             if v is not None
         }
-        response = self._delete(url, params=query_params)
-        response.raise_for_status()
-        if (
-            response.status_code == 204
-            or not response.content
-            or not response.text.strip()
-        ):
-            return None
-        try:
-            return response.json()
-        except ValueError:
-            return None
+        response = await self._adelete(url, params=query_params)
+        return self._handle_response(response)
 
-    def update_permission(
+    async def update_permission(
         self,
         fileId: str,
         permissionId: str,
@@ -3898,9 +3438,7 @@ class GoogleDriveApp(APIApplication):
             "type": type,
             "view": view,
         }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.base_url}/files/{fileId}/permissions/{permissionId}"
         query_params = {
             k: v
@@ -3920,20 +3458,10 @@ class GoogleDriveApp(APIApplication):
             ]
             if v is not None
         }
-        response = self._patch(url, data=request_body_data, params=query_params)
-        response.raise_for_status()
-        if (
-            response.status_code == 204
-            or not response.content
-            or not response.text.strip()
-        ):
-            return None
-        try:
-            return response.json()
-        except ValueError:
-            return None
+        response = await self._apatch(url, data=request_body_data, params=query_params)
+        return self._handle_response(response)
 
-    def list_comment_replies(
+    async def list_comment_replies(
         self,
         fileId: str,
         commentId: str,
@@ -3996,20 +3524,10 @@ class GoogleDriveApp(APIApplication):
             ]
             if v is not None
         }
-        response = self._get(url, params=query_params)
-        response.raise_for_status()
-        if (
-            response.status_code == 204
-            or not response.content
-            or not response.text.strip()
-        ):
-            return None
-        try:
-            return response.json()
-        except ValueError:
-            return None
+        response = await self._aget(url, params=query_params)
+        return self._handle_response(response)
 
-    def create_comment_reply(
+    async def create_comment_reply(
         self,
         fileId: str,
         commentId: str,
@@ -4079,9 +3597,7 @@ class GoogleDriveApp(APIApplication):
             "kind": kind,
             "modifiedTime": modifiedTime,
         }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.base_url}/files/{fileId}/comments/{commentId}/replies"
         query_params = {
             k: v
@@ -4096,25 +3612,10 @@ class GoogleDriveApp(APIApplication):
             ]
             if v is not None
         }
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
-        response.raise_for_status()
-        if (
-            response.status_code == 204
-            or not response.content
-            or not response.text.strip()
-        ):
-            return None
-        try:
-            return response.json()
-        except ValueError:
-            return None
+        response = await self._apost(url, data=request_body_data, params=query_params, content_type="application/json")
+        return self._handle_response(response)
 
-    def get_reply_by_id(
+    async def get_reply_by_id(
         self,
         fileId: str,
         commentId: str,
@@ -4175,20 +3676,10 @@ class GoogleDriveApp(APIApplication):
             ]
             if v is not None
         }
-        response = self._get(url, params=query_params)
-        response.raise_for_status()
-        if (
-            response.status_code == 204
-            or not response.content
-            or not response.text.strip()
-        ):
-            return None
-        try:
-            return response.json()
-        except ValueError:
-            return None
+        response = await self._aget(url, params=query_params)
+        return self._handle_response(response)
 
-    def delete_reply(
+    async def delete_reply(
         self,
         fileId: str,
         commentId: str,
@@ -4246,20 +3737,10 @@ class GoogleDriveApp(APIApplication):
             ]
             if v is not None
         }
-        response = self._delete(url, params=query_params)
-        response.raise_for_status()
-        if (
-            response.status_code == 204
-            or not response.content
-            or not response.text.strip()
-        ):
-            return None
-        try:
-            return response.json()
-        except ValueError:
-            return None
+        response = await self._adelete(url, params=query_params)
+        return self._handle_response(response)
 
-    def update_reply(
+    async def update_reply(
         self,
         fileId: str,
         commentId: str,
@@ -4333,9 +3814,7 @@ class GoogleDriveApp(APIApplication):
             "kind": kind,
             "modifiedTime": modifiedTime,
         }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.base_url}/files/{fileId}/comments/{commentId}/replies/{replyId}"
         query_params = {
             k: v
@@ -4350,20 +3829,10 @@ class GoogleDriveApp(APIApplication):
             ]
             if v is not None
         }
-        response = self._patch(url, data=request_body_data, params=query_params)
-        response.raise_for_status()
-        if (
-            response.status_code == 204
-            or not response.content
-            or not response.text.strip()
-        ):
-            return None
-        try:
-            return response.json()
-        except ValueError:
-            return None
+        response = await self._apatch(url, data=request_body_data, params=query_params)
+        return self._handle_response(response)
 
-    def list_file_revisions(
+    async def list_file_revisions(
         self,
         fileId: str,
         pageSize: str | None = None,
@@ -4419,20 +3888,10 @@ class GoogleDriveApp(APIApplication):
             ]
             if v is not None
         }
-        response = self._get(url, params=query_params)
-        response.raise_for_status()
-        if (
-            response.status_code == 204
-            or not response.content
-            or not response.text.strip()
-        ):
-            return None
-        try:
-            return response.json()
-        except ValueError:
-            return None
+        response = await self._aget(url, params=query_params)
+        return self._handle_response(response)
 
-    def get_revision(
+    async def get_revision(
         self,
         fileId: str,
         revisionId: str,
@@ -4489,20 +3948,10 @@ class GoogleDriveApp(APIApplication):
             ]
             if v is not None
         }
-        response = self._get(url, params=query_params)
-        response.raise_for_status()
-        if (
-            response.status_code == 204
-            or not response.content
-            or not response.text.strip()
-        ):
-            return None
-        try:
-            return response.json()
-        except ValueError:
-            return None
+        response = await self._aget(url, params=query_params)
+        return self._handle_response(response)
 
-    def delete_file_revision(
+    async def delete_file_revision(
         self,
         fileId: str,
         revisionId: str,
@@ -4556,20 +4005,10 @@ class GoogleDriveApp(APIApplication):
             ]
             if v is not None
         }
-        response = self._delete(url, params=query_params)
-        response.raise_for_status()
-        if (
-            response.status_code == 204
-            or not response.content
-            or not response.text.strip()
-        ):
-            return None
-        try:
-            return response.json()
-        except ValueError:
-            return None
+        response = await self._adelete(url, params=query_params)
+        return self._handle_response(response)
 
-    def update_revision(
+    async def update_revision(
         self,
         fileId: str,
         revisionId: str,
@@ -4654,9 +4093,7 @@ class GoogleDriveApp(APIApplication):
             "publishedOutsideDomain": publishedOutsideDomain,
             "size": size,
         }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.base_url}/files/{fileId}/revisions/{revisionId}"
         query_params = {
             k: v
@@ -4671,25 +4108,11 @@ class GoogleDriveApp(APIApplication):
             ]
             if v is not None
         }
-        response = self._patch(url, data=request_body_data, params=query_params)
-        response.raise_for_status()
-        if (
-            response.status_code == 204
-            or not response.content
-            or not response.text.strip()
-        ):
-            return None
-        try:
-            return response.json()
-        except ValueError:
-            return None
+        response = await self._apatch(url, data=request_body_data, params=query_params)
+        return self._handle_response(response)
 
-    def create_permission(
-        self,
-        fileId: str,
-        emailAddress: str | None = None,
-        role: str | None = None,
-        type: str | None = None,
+    async def create_permission(
+        self, fileId: str, emailAddress: str | None = None, role: str | None = None, type: str | None = None
     ) -> dict[str, Any]:
         """
         Grants a specified role (e.g., 'reader') to a user or group for a file. This is a simplified alternative to the comprehensive `create_file_permission` function, focusing only on the core arguments required for basic sharing operations and omitting advanced options like notification settings or ownership transfer.
@@ -4713,33 +4136,12 @@ class GoogleDriveApp(APIApplication):
         if fileId is None:
             raise ValueError("Missing required parameter 'fileId'.")
         request_body_data = None
-        request_body_data = {
-            "emailAddress": emailAddress,
-            "role": role,
-            "type": type,
-        }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
-        url = f"{self.base_url}/drive/v3/files/{fileId}/permissions"
+        request_body_data = {"emailAddress": emailAddress, "role": role, "type": type}
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
+        url = f"{self.base_url}/files/{fileId}/permissions"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
-        response.raise_for_status()
-        if (
-            response.status_code == 204
-            or not response.content
-            or not response.text.strip()
-        ):
-            return None
-        try:
-            return response.json()
-        except ValueError:
-            return None
+        response = await self._apost(url, data=request_body_data, params=query_params, content_type="application/json")
+        return self._handle_response(response)
 
     def list_tools(self):
         return [
@@ -4751,7 +4153,6 @@ class GoogleDriveApp(APIApplication):
             self.create_folder,
             self.get_file_details,
             self.trash_file,
-            # Auto generated from openapi spec
             self.list_installed_apps,
             self.get_app_by_id,
             self.get_about_info,