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

universal_mcp/applications/youtube/app.py

@@ -1,6 +1,5 @@
 import os
 from typing import Any
-
 from universal_mcp.applications.application import APIApplication
 from universal_mcp.integrations import Integration
 from youtube_transcript_api import YouTubeTranscriptApi
@@ -22,7 +21,7 @@ class YoutubeApp(APIApplication):
         super().__init__(name="youtube", integration=integration, **kwargs)
         self.base_url = "https://www.googleapis.com/youtube/v3"
 
-    def list_job_reports(
+    async def list_job_reports(
         self,
         jobId,
         createdAfter=None,
@@ -68,11 +67,11 @@ class YoutubeApp(APIApplication):
             ]
             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 get_job_report(self, jobId, reportId, onBehalfOfContentOwner=None) -> Any:
+    async def get_job_report(self, jobId, reportId, onBehalfOfContentOwner=None) -> Any:
         """
         Fetches a single, specific report identified by its `reportId` from within a given `jobId`. This retrieves an individual record, distinguishing it from `get_jobs_job_reports`, which returns a list of reports for a job. The request can be made on behalf of a content owner.
 
@@ -96,16 +95,12 @@ class YoutubeApp(APIApplication):
         if reportId is None:
             raise ValueError("Missing required parameter 'reportId'")
         url = f"{self.base_url}/v1/jobs/{jobId}/reports/{reportId}"
-        query_params = {
-            k: v
-            for k, v in [("onBehalfOfContentOwner", onBehalfOfContentOwner)]
-            if v is not None
-        }
-        response = self._get(url, params=query_params)
+        query_params = {k: v for k, v in [("onBehalfOfContentOwner", onBehalfOfContentOwner)] if v is not None}
+        response = await self._aget(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def delete_job(self, jobId, onBehalfOfContentOwner=None) -> Any:
+    async def delete_job(self, jobId, onBehalfOfContentOwner=None) -> Any:
         """
         Deletes a specific job resource using its unique `jobId`, optionally on behalf of a content owner. This action permanently removes the job itself, differentiating it from functions that only retrieve or manage job reports.
 
@@ -126,22 +121,12 @@ class YoutubeApp(APIApplication):
         if jobId is None:
             raise ValueError("Missing required parameter 'jobId'")
         url = f"{self.base_url}/v1/jobs/{jobId}"
-        query_params = {
-            k: v
-            for k, v in [("onBehalfOfContentOwner", onBehalfOfContentOwner)]
-            if v is not None
-        }
-        response = self._delete(url, params=query_params)
+        query_params = {k: v for k, v in [("onBehalfOfContentOwner", onBehalfOfContentOwner)] if v is not None}
+        response = await self._adelete(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def list_jobs(
-        self,
-        includeSystemManaged=None,
-        onBehalfOfContentOwner=None,
-        pageSize=None,
-        pageToken=None,
-    ) -> Any:
+    async def list_jobs(self, includeSystemManaged=None, onBehalfOfContentOwner=None, pageSize=None, pageToken=None) -> Any:
         """
         Retrieves a paginated list of asynchronous jobs from the YouTube Reporting API. Supports filtering by content owner and including system-managed jobs. This function lists multiple jobs, distinct from `get_jobs_job_reports` which retrieves reports for a single job.
 
@@ -171,11 +156,11 @@ class YoutubeApp(APIApplication):
             ]
             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 download_report_media(self, resourceName) -> Any:
+    async def download_report_media(self, resourceName) -> Any:
         """
         Downloads the content of a bulk data report from the YouTube Reporting API by its unique `resourceName`. This function retrieves the actual media file generated by a reporting job, distinct from functions that only fetch report metadata.
 
@@ -196,17 +181,11 @@ class YoutubeApp(APIApplication):
             raise ValueError("Missing required parameter 'resourceName'")
         url = f"{self.base_url}/v1/media/{resourceName}"
         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 get_reporttypes(
-        self,
-        includeSystemManaged=None,
-        onBehalfOfContentOwner=None,
-        pageSize=None,
-        pageToken=None,
-    ) -> Any:
+    async def get_reporttypes(self, includeSystemManaged=None, onBehalfOfContentOwner=None, pageSize=None, pageToken=None) -> Any:
         """
         Retrieves a list of available report types from the YouTube Reporting API, supporting pagination and filtering. This function returns metadata about what kinds of reports can be generated, distinct from functions like `get_reports` that fetch actual report content.
 
@@ -236,13 +215,11 @@ class YoutubeApp(APIApplication):
             ]
             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 delete_captions(
-        self, id=None, onBehalfOf=None, onBehalfOfContentOwner=None
-    ) -> Any:
+    async def delete_captions(self, id=None, onBehalfOf=None, onBehalfOfContentOwner=None) -> Any:
         """
         Deletes a specific YouTube caption resource using its unique ID, with optional delegation for content owners. This management function removes the entire caption track, unlike `get_captions` which only retrieves the transcript text for a given video ID.
 
@@ -262,19 +239,13 @@ class YoutubeApp(APIApplication):
         """
         url = f"{self.base_url}/captions"
         query_params = {
-            k: v
-            for k, v in [
-                ("id", id),
-                ("onBehalfOf", onBehalfOf),
-                ("onBehalfOfContentOwner", onBehalfOfContentOwner),
-            ]
-            if v is not None
+            k: v for k, v in [("id", id), ("onBehalfOf", onBehalfOf), ("onBehalfOfContentOwner", onBehalfOfContentOwner)] if v is not None
         }
-        response = self._delete(url, params=query_params)
+        response = await self._adelete(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def get_transcript_text(self, video_id: str) -> str:
+    async def get_transcript_text(self, video_id: str) -> str:
         """
         Fetches the full text transcript for a YouTube video using its ID. Unlike other methods using the official API, this function utilizes the `youtube-transcript-api` library to extract and concatenate all caption snippets into a single, timestamp-free string of the video's spoken content.
 
@@ -293,36 +264,22 @@ class YoutubeApp(APIApplication):
         """
         if video_id is None:
             raise ValueError("Missing required parameter 'video_id'")
-
         try:
             proxy_username = os.getenv("PROXY_USERNAME")
             proxy_password = os.getenv("PROXY_PASSWORD")
             proxy_port = int(os.getenv("PROXY_PORT", 80))
-
             if not proxy_username or not proxy_password:
-                raise ValueError(
-                    "PROXY_USERNAME and PROXY_PASSWORD must be set when using proxy"
-                )
+                raise ValueError("PROXY_USERNAME and PROXY_PASSWORD must be set when using proxy")
             api = YouTubeTranscriptApi(
-                proxy_config=WebshareProxyConfig(
-                    proxy_username=proxy_username,
-                    proxy_password=proxy_password,
-                    proxy_port=proxy_port,
-                ),
+                proxy_config=WebshareProxyConfig(proxy_username=proxy_username, proxy_password=proxy_password, proxy_port=proxy_port)
             )
             transcript = api.fetch(video_id)
-
-            transcript_text = " ".join(
-                [snippet.text for snippet in transcript.snippets]
-            )
-
+            transcript_text = " ".join([snippet.text for snippet in transcript.snippets])
             return transcript_text
         except Exception as e:
-            raise Exception(
-                f"Failed to retrieve transcript for video {video_id}: {str(e)}"
-            )
+            raise Exception(f"Failed to retrieve transcript for video {video_id}: {str(e)}")
 
-    def delete_comments(self, id=None) -> Any:
+    async def delete_comments(self, id=None) -> Any:
         """
         Permanently removes a specific comment identified by its unique ID via a DELETE request. Unlike moderation functions like `add_comments_mark_as_spam`, which only alter a comment's state, this action is irreversible and deletes the resource. An `id` is required to specify the target comment.
 
@@ -340,10 +297,10 @@ class YoutubeApp(APIApplication):
         """
         url = f"{self.base_url}/comments"
         query_params = {k: v for k, v in [("id", id)] if v is not None}
-        response = self._delete(url, params=query_params)
+        response = await self._adelete(url, params=query_params)
         return self._handle_response(response)
 
-    def mark_comment_as_spam(self, id=None) -> Any:
+    async def mark_comment_as_spam(self, id=None) -> Any:
         """
         Marks a specified YouTube comment as spam via a POST request to the API. This moderation action is distinct from deleting comments (`delete_comments`) or setting other statuses like 'approved' or 'rejected' (`add_comments_set_moderation_status`).
 
@@ -361,13 +318,11 @@ class YoutubeApp(APIApplication):
         """
         url = f"{self.base_url}/comments/markAsSpam"
         query_params = {k: v for k, v in [("id", id)] if v is not None}
-        response = self._post(url, data={}, params=query_params)
+        response = await self._apost(url, data={}, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def set_comment_moderation_status(
-        self, banAuthor=None, id=None, moderationStatus=None
-    ) -> Any:
+    async def set_comment_moderation_status(self, banAuthor=None, id=None, moderationStatus=None) -> Any:
         """
         Sets the moderation status (e.g., 'approved', 'rejected') for specified comments and can optionally ban the author. Unlike `add_comments_mark_as_spam`, this function allows for various moderation states, providing more granular control over comment management.
 
@@ -386,22 +341,12 @@ class YoutubeApp(APIApplication):
             moderation, comments, management, api-client, status-update, ban-author
         """
         url = f"{self.base_url}/comments/setModerationStatus"
-        query_params = {
-            k: v
-            for k, v in [
-                ("banAuthor", banAuthor),
-                ("id", id),
-                ("moderationStatus", moderationStatus),
-            ]
-            if v is not None
-        }
-        response = self._post(url, data={}, params=query_params)
+        query_params = {k: v for k, v in [("banAuthor", banAuthor), ("id", id), ("moderationStatus", moderationStatus)] if v is not None}
+        response = await self._apost(url, data={}, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def delete_live_broadcasts(
-        self, id=None, onBehalfOfContentOwner=None, onBehalfOfContentOwnerChannel=None
-    ) -> Any:
+    async def delete_live_broadcasts(self, id=None, onBehalfOfContentOwner=None, onBehalfOfContentOwnerChannel=None) -> Any:
         """
         Deletes a YouTube live broadcast event by its unique ID via the API. This request can be made on behalf of a content owner or channel. It targets the `/liveBroadcasts` endpoint, distinguishing it from `delete_livestreams` which manages the actual content stream.
 
@@ -429,17 +374,12 @@ class YoutubeApp(APIApplication):
             ]
             if v is not None
         }
-        response = self._delete(url, params=query_params)
+        response = await self._adelete(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def bind_live_broadcast_to_stream(
-        self,
-        id=None,
-        onBehalfOfContentOwner=None,
-        onBehalfOfContentOwnerChannel=None,
-        part=None,
-        streamId=None,
+    async def bind_live_broadcast_to_stream(
+        self, id=None, onBehalfOfContentOwner=None, onBehalfOfContentOwnerChannel=None, part=None, streamId=None
     ) -> Any:
         """
         Binds a YouTube live broadcast to a video stream using their respective IDs. This action associates the broadcast's metadata with the content stream, optionally performing the action on behalf of a content owner, facilitating the link between a planned event and its live video feed.
@@ -472,11 +412,11 @@ class YoutubeApp(APIApplication):
             ]
             if v is not None
         }
-        response = self._post(url, data={}, params=query_params)
+        response = await self._apost(url, data={}, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def control_live_broadcast(
+    async def control_live_broadcast(
         self,
         displaySlate=None,
         id=None,
@@ -521,17 +461,12 @@ class YoutubeApp(APIApplication):
             ]
             if v is not None
         }
-        response = self._post(url, data={}, params=query_params)
+        response = await self._apost(url, data={}, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def transition_live_broadcast(
-        self,
-        broadcastStatus=None,
-        id=None,
-        onBehalfOfContentOwner=None,
-        onBehalfOfContentOwnerChannel=None,
-        part=None,
+    async def transition_live_broadcast(
+        self, broadcastStatus=None, id=None, onBehalfOfContentOwner=None, onBehalfOfContentOwnerChannel=None, part=None
     ) -> Any:
         """
         Changes a YouTube live broadcast's status (e.g., making it 'live' or 'complete') by posting to the API's transition endpoint. This function alters the broadcast's lifecycle state, distinct from other control actions like binding it to a stream, and returns the API's JSON response.
@@ -564,11 +499,11 @@ class YoutubeApp(APIApplication):
             ]
             if v is not None
         }
-        response = self._post(url, data={}, params=query_params)
+        response = await self._apost(url, data={}, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def delete_live_chat_ban(self, id=None) -> Any:
+    async def delete_live_chat_ban(self, id=None) -> Any:
         """
         Deletes a specific YouTube live chat ban using its unique ID. It sends a DELETE request to the `/liveChat/bans` endpoint to revoke the ban, allowing the user to participate in the chat again.
 
@@ -586,11 +521,11 @@ class YoutubeApp(APIApplication):
         """
         url = f"{self.base_url}/liveChat/bans"
         query_params = {k: v for k, v in [("id", id)] if v is not None}
-        response = self._delete(url, params=query_params)
+        response = await self._adelete(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def delete_live_chat_message(self, id=None) -> Any:
+    async def delete_live_chat_message(self, id=None) -> Any:
         """
         Deletes a specific YouTube live chat message identified by its unique ID. This function targets the `/liveChat/messages` endpoint, distinguishing it from `delete_live_chat_bans` and `delete_live_chat_moderators`, which manage different aspects of a live chat.
 
@@ -608,11 +543,11 @@ class YoutubeApp(APIApplication):
         """
         url = f"{self.base_url}/liveChat/messages"
         query_params = {k: v for k, v in [("id", id)] if v is not None}
-        response = self._delete(url, params=query_params)
+        response = await self._adelete(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def delete_live_chat_moderators(self, id=None) -> Any:
+    async def delete_live_chat_moderators(self, id=None) -> Any:
         """
         Deletes a specific YouTube live chat moderator using their unique ID. This function sends a DELETE request to the `/liveChat/moderators` API endpoint and returns the server's JSON response, confirming the successful removal or detailing errors. The moderator ID is a required parameter for this action.
 
@@ -630,11 +565,11 @@ class YoutubeApp(APIApplication):
         """
         url = f"{self.base_url}/liveChat/moderators"
         query_params = {k: v for k, v in [("id", id)] if v is not None}
-        response = self._delete(url, params=query_params)
+        response = await self._adelete(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def delete_videos(self, id=None, onBehalfOfContentOwner=None) -> Any:
+    async def delete_videos(self, id=None, onBehalfOfContentOwner=None) -> Any:
         """
         Deletes a specified YouTube video using its unique ID. The operation can be performed on behalf of a content owner by sending an HTTP DELETE request to the `/videos` endpoint. It's distinct from other video functions that only modify or retrieve metadata, like rating or abuse reports.
 
@@ -652,16 +587,12 @@ class YoutubeApp(APIApplication):
             delete, video-management, api, async_job
         """
         url = f"{self.base_url}/videos"
-        query_params = {
-            k: v
-            for k, v in [("id", id), ("onBehalfOfContentOwner", onBehalfOfContentOwner)]
-            if v is not None
-        }
-        response = self._delete(url, params=query_params)
+        query_params = {k: v for k, v in [("id", id), ("onBehalfOfContentOwner", onBehalfOfContentOwner)] if v is not None}
+        response = await self._adelete(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def get_video_ratings(self, id=None, onBehalfOfContentOwner=None) -> Any:
+    async def get_video_ratings(self, id=None, onBehalfOfContentOwner=None) -> Any:
         """
         Retrieves the authenticated user's rating (e.g., 'like', 'dislike') for specified videos. This function fetches existing rating data, distinct from `add_videos_rate` which submits a new rating, and can be performed on behalf of a content owner.
 
@@ -679,16 +610,12 @@ class YoutubeApp(APIApplication):
             check, video-management
         """
         url = f"{self.base_url}/videos/getRating"
-        query_params = {
-            k: v
-            for k, v in [("id", id), ("onBehalfOfContentOwner", onBehalfOfContentOwner)]
-            if v is not None
-        }
-        response = self._get(url, params=query_params)
+        query_params = {k: v for k, v in [("id", id), ("onBehalfOfContentOwner", onBehalfOfContentOwner)] if v is not None}
+        response = await self._aget(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def rate_video(self, id=None, rating=None) -> Any:
+    async def rate_video(self, id=None, rating=None) -> Any:
         """
         Submits a rating (e.g., 'like', 'dislike') for a video specified by its unique ID. This function sends a POST request to the YouTube API's `/videos/rate` endpoint and returns the server's JSON response upon successful submission.
 
@@ -706,14 +633,12 @@ class YoutubeApp(APIApplication):
             rate, video-management, importance
         """
         url = f"{self.base_url}/videos/rate"
-        query_params = {
-            k: v for k, v in [("id", id), ("rating", rating)] if v is not None
-        }
-        response = self._post(url, data={}, params=query_params)
+        query_params = {k: v for k, v in [("id", id), ("rating", rating)] if v is not None}
+        response = await self._apost(url, data={}, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def report_video_for_abuse(self, onBehalfOfContentOwner=None) -> Any:
+    async def report_video_for_abuse(self, onBehalfOfContentOwner=None) -> Any:
         """
         Reports a video for abuse via a POST request to the YouTube API. An optional parameter allows a content owner to submit the report on behalf of their account, flagging potentially inappropriate content for review by YouTube.
 
@@ -730,16 +655,12 @@ class YoutubeApp(APIApplication):
             report, abuse, video, content, api
         """
         url = f"{self.base_url}/videos/reportAbuse"
-        query_params = {
-            k: v
-            for k, v in [("onBehalfOfContentOwner", onBehalfOfContentOwner)]
-            if v is not None
-        }
-        response = self._post(url, data={}, params=query_params)
+        query_params = {k: v for k, v in [("onBehalfOfContentOwner", onBehalfOfContentOwner)] if v is not None}
+        response = await self._apost(url, data={}, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def set_channel_watermark(self, channelId=None, onBehalfOfContentOwner=None) -> Any:
+    async def set_channel_watermark(self, channelId=None, onBehalfOfContentOwner=None) -> Any:
         """
         Sets a branding watermark on a specified YouTube channel. The operation targets the channel using its ID and can be executed on behalf of a content owner. This function contrasts with `add_watermarks_unset`, which removes the watermark.
 
@@ -757,21 +678,12 @@ class YoutubeApp(APIApplication):
             watermark, youtube, management, channel-config
         """
         url = f"{self.base_url}/watermarks/set"
-        query_params = {
-            k: v
-            for k, v in [
-                ("channelId", channelId),
-                ("onBehalfOfContentOwner", onBehalfOfContentOwner),
-            ]
-            if v is not None
-        }
-        response = self._post(url, data={}, params=query_params)
+        query_params = {k: v for k, v in [("channelId", channelId), ("onBehalfOfContentOwner", onBehalfOfContentOwner)] if v is not None}
+        response = await self._apost(url, data={}, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def unset_channel_watermark(
-        self, channelId=None, onBehalfOfContentOwner=None
-    ) -> Any:
+    async def unset_channel_watermark(self, channelId=None, onBehalfOfContentOwner=None) -> Any:
         """
         Removes the branding watermark for a specified YouTube channel via an API POST request. This operation, the inverse of `add_watermarks_set`, can be executed on behalf of a content owner to unset the channel's current watermark.
 
@@ -789,19 +701,12 @@ class YoutubeApp(APIApplication):
             remove, watermark, youtube
         """
         url = f"{self.base_url}/watermarks/unset"
-        query_params = {
-            k: v
-            for k, v in [
-                ("channelId", channelId),
-                ("onBehalfOfContentOwner", onBehalfOfContentOwner),
-            ]
-            if v is not None
-        }
-        response = self._post(url, data={}, params=query_params)
+        query_params = {k: v for k, v in [("channelId", channelId), ("onBehalfOfContentOwner", onBehalfOfContentOwner)] if v is not None}
+        response = await self._apost(url, data={}, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def get_activities(
+    async def get_activities(
         self,
         channelId=None,
         home=None,
@@ -852,11 +757,11 @@ class YoutubeApp(APIApplication):
             ]
             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 insert_channel_banner(self, channelId=None, onBehalfOfContentOwner=None) -> Any:
+    async def insert_channel_banner(self, channelId=None, onBehalfOfContentOwner=None) -> Any:
         """
         Uploads and sets a new banner image for a specified YouTube channel. This function makes a POST request to the `/channelBanners/insert` endpoint, optionally on behalf of a content owner, and returns details of the newly created banner.
 
@@ -874,19 +779,12 @@ class YoutubeApp(APIApplication):
             insert, channel, banner, youtube-api, management, async_job
         """
         url = f"{self.base_url}/channelBanners/insert"
-        query_params = {
-            k: v
-            for k, v in [
-                ("channelId", channelId),
-                ("onBehalfOfContentOwner", onBehalfOfContentOwner),
-            ]
-            if v is not None
-        }
-        response = self._post(url, data={}, params=query_params)
+        query_params = {k: v for k, v in [("channelId", channelId), ("onBehalfOfContentOwner", onBehalfOfContentOwner)] if v is not None}
+        response = await self._apost(url, data={}, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def delete_channel_sections(self, id=None, onBehalfOfContentOwner=None) -> Any:
+    async def delete_channel_sections(self, id=None, onBehalfOfContentOwner=None) -> Any:
         """
         Deletes a YouTube channel section by its unique ID via an API request. The operation can be performed on behalf of a content owner for delegated management, returning a JSON response upon success or raising an HTTPError for failures like invalid IDs or insufficient permissions.
 
@@ -904,16 +802,12 @@ class YoutubeApp(APIApplication):
             delete, channel-section, management
         """
         url = f"{self.base_url}/channelSections"
-        query_params = {
-            k: v
-            for k, v in [("id", id), ("onBehalfOfContentOwner", onBehalfOfContentOwner)]
-            if v is not None
-        }
-        response = self._delete(url, params=query_params)
+        query_params = {k: v for k, v in [("id", id), ("onBehalfOfContentOwner", onBehalfOfContentOwner)] if v is not None}
+        response = await self._adelete(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def list_channels(
+    async def list_channels(
         self,
         categoryId=None,
         forUsername=None,
@@ -970,11 +864,11 @@ class YoutubeApp(APIApplication):
             ]
             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 get_comment_threads(
+    async def get_comment_threads(
         self,
         allThreadsRelatedToChannelId=None,
         channelId=None,
@@ -1031,13 +925,11 @@ class YoutubeApp(APIApplication):
             ]
             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 get_fanfundingevents(
-        self, hl=None, maxResults=None, pageToken=None, part=None
-    ) -> Any:
+    async def get_fanfundingevents(self, hl=None, maxResults=None, pageToken=None, part=None) -> Any:
         """
         Fetches a list of fan funding events from the YouTube API for the authenticated user's channel. Supports pagination, localization, and partial responses to retrieve customized event data like Super Chat or Super Stickers based on specified filter criteria and response parts.
 
@@ -1058,20 +950,13 @@ class YoutubeApp(APIApplication):
         """
         url = f"{self.base_url}/fanFundingEvents"
         query_params = {
-            k: v
-            for k, v in [
-                ("hl", hl),
-                ("maxResults", maxResults),
-                ("pageToken", pageToken),
-                ("part", part),
-            ]
-            if v is not None
+            k: v for k, v in [("hl", hl), ("maxResults", maxResults), ("pageToken", pageToken), ("part", part)] 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 get_guide_categories(self, hl=None, id=None, part=None, regionCode=None) -> Any:
+    async def get_guide_categories(self, hl=None, id=None, part=None, regionCode=None) -> Any:
         """
         Retrieves a list of official YouTube guide categories (e.g., Music, Sports). This function queries the `/guideCategories` endpoint, allowing results to be filtered by ID or region and localized for a specific language. These are distinct from the categories assigned to individual videos.
 
@@ -1091,21 +976,12 @@ class YoutubeApp(APIApplication):
             get, fetch, guide-categories, api-call
         """
         url = f"{self.base_url}/guideCategories"
-        query_params = {
-            k: v
-            for k, v in [
-                ("hl", hl),
-                ("id", id),
-                ("part", part),
-                ("regionCode", regionCode),
-            ]
-            if v is not None
-        }
-        response = self._get(url, params=query_params)
+        query_params = {k: v for k, v in [("hl", hl), ("id", id), ("part", part), ("regionCode", regionCode)] if v is not None}
+        response = await self._aget(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def get_i18n_languages(self, hl=None, part=None) -> Any:
+    async def get_i18n_languages(self, hl=None, part=None) -> Any:
         """
         Retrieves a list of supported internationalization (i18n) languages from the YouTube API's `/i18nLanguages` endpoint. It can optionally localize the language names in the response. This function is distinct from `get_regions`, which fetches supported geographical regions.
 
@@ -1124,11 +1000,11 @@ class YoutubeApp(APIApplication):
         """
         url = f"{self.base_url}/i18nLanguages"
         query_params = {k: v for k, v in [("hl", hl), ("part", part)] 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 get_i18n_regions(self, hl=None, part=None) -> Any:
+    async def get_i18n_regions(self, hl=None, part=None) -> Any:
         """
         Fetches a list of geographic regions supported by the YouTube API for content localization. It can localize region names using the 'hl' parameter. This is distinct from get_languages, which retrieves supported languages, not geographic areas.
 
@@ -1147,13 +1023,11 @@ class YoutubeApp(APIApplication):
         """
         url = f"{self.base_url}/i18nRegions"
         query_params = {k: v for k, v in [("hl", hl), ("part", part)] 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 delete_livestreams(
-        self, id=None, onBehalfOfContentOwner=None, onBehalfOfContentOwnerChannel=None
-    ) -> Any:
+    async def delete_livestreams(self, id=None, onBehalfOfContentOwner=None, onBehalfOfContentOwnerChannel=None) -> Any:
         """
         Deletes one or more YouTube livestreams by ID via the `/liveStreams` API endpoint, optionally on behalf of a content owner. This function is distinct from `delete_live_broadcasts`, which targets a different live video resource, and returns the server's JSON response upon successful deletion.
 
@@ -1181,11 +1055,11 @@ class YoutubeApp(APIApplication):
             ]
             if v is not None
         }
-        response = self._delete(url, params=query_params)
+        response = await self._adelete(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def delete_playlist_items(self, id=None, onBehalfOfContentOwner=None) -> Any:
+    async def delete_playlist_items(self, id=None, onBehalfOfContentOwner=None) -> Any:
         """
         Deletes one or more YouTube playlist items by their unique IDs. The operation can be performed on behalf of a content owner for delegated authorization, sending a DELETE request to the `/playlistItems` endpoint and returning the server's response.
 
@@ -1203,16 +1077,12 @@ class YoutubeApp(APIApplication):
             delete, playlist-items, management
         """
         url = f"{self.base_url}/playlistItems"
-        query_params = {
-            k: v
-            for k, v in [("id", id), ("onBehalfOfContentOwner", onBehalfOfContentOwner)]
-            if v is not None
-        }
-        response = self._delete(url, params=query_params)
+        query_params = {k: v for k, v in [("id", id), ("onBehalfOfContentOwner", onBehalfOfContentOwner)] if v is not None}
+        response = await self._adelete(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def delete_playlists(self, id=None, onBehalfOfContentOwner=None) -> Any:
+    async def delete_playlists(self, id=None, onBehalfOfContentOwner=None) -> Any:
         """
         Deletes a YouTube playlist by its unique ID via a DELETE request to the API. The operation can be performed on behalf of a specific content owner for delegated management. This function targets the entire playlist, distinct from `delete_play_list_items` which removes individual videos from a playlist.
 
@@ -1230,16 +1100,12 @@ class YoutubeApp(APIApplication):
             delete, playlists, youtube-api, management
         """
         url = f"{self.base_url}/playlists"
-        query_params = {
-            k: v
-            for k, v in [("id", id), ("onBehalfOfContentOwner", onBehalfOfContentOwner)]
-            if v is not None
-        }
-        response = self._delete(url, params=query_params)
+        query_params = {k: v for k, v in [("id", id), ("onBehalfOfContentOwner", onBehalfOfContentOwner)] if v is not None}
+        response = await self._adelete(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def get_search(
+    async def get_search(
         self,
         channelId=None,
         channelType=None,
@@ -1356,13 +1222,11 @@ class YoutubeApp(APIApplication):
             ]
             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 list_sponsors(
-        self, filter=None, maxResults=None, pageToken=None, part=None
-    ) -> Any:
+    async def list_sponsors(self, filter=None, maxResults=None, pageToken=None, part=None) -> Any:
         """
         Retrieves a list of sponsors for the authenticated user's YouTube channel. This function supports filtering, pagination, and specifying which resource parts to include in the response, allowing for flexible and customized data fetching of sponsor information.
 
@@ -1383,20 +1247,13 @@ class YoutubeApp(APIApplication):
         """
         url = f"{self.base_url}/sponsors"
         query_params = {
-            k: v
-            for k, v in [
-                ("filter", filter),
-                ("maxResults", maxResults),
-                ("pageToken", pageToken),
-                ("part", part),
-            ]
-            if v is not None
+            k: v for k, v in [("filter", filter), ("maxResults", maxResults), ("pageToken", pageToken), ("part", part)] 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 delete_subscriptions(self, id=None) -> Any:
+    async def delete_subscriptions(self, id=None) -> Any:
         """
         Deletes a specific YouTube channel subscription identified by its unique ID. This function sends a DELETE request to the `/subscriptions` API endpoint and returns the server's JSON response, confirming the operation's success or failure.
 
@@ -1414,13 +1271,11 @@ class YoutubeApp(APIApplication):
         """
         url = f"{self.base_url}/subscriptions"
         query_params = {k: v for k, v in [("id", id)] if v is not None}
-        response = self._delete(url, params=query_params)
+        response = await self._adelete(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def get_super_chat_events(
-        self, hl=None, maxResults=None, pageToken=None, part=None
-    ) -> Any:
+    async def get_super_chat_events(self, hl=None, maxResults=None, pageToken=None, part=None) -> Any:
         """
         Retrieves a paginated list of Super Chat events from the YouTube Data API. Allows for localization and specifying which resource parts to include in the response. This function is distinct from `get_fanfundingevents`, which fetches a different type of monetary contribution event.
 
@@ -1441,20 +1296,13 @@ class YoutubeApp(APIApplication):
         """
         url = f"{self.base_url}/superChatEvents"
         query_params = {
-            k: v
-            for k, v in [
-                ("hl", hl),
-                ("maxResults", maxResults),
-                ("pageToken", pageToken),
-                ("part", part),
-            ]
-            if v is not None
+            k: v for k, v in [("hl", hl), ("maxResults", maxResults), ("pageToken", pageToken), ("part", part)] 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 set_video_thumbnail(self, onBehalfOfContentOwner=None, videoId=None) -> Any:
+    async def set_video_thumbnail(self, onBehalfOfContentOwner=None, videoId=None) -> Any:
         """
         Sets a custom thumbnail for a specified YouTube video via a POST request to the `/thumbnails/set` API endpoint. The operation can be performed on behalf of a content owner for delegated management of video assets.
 
@@ -1472,19 +1320,12 @@ class YoutubeApp(APIApplication):
             thumbnail, youtube-api, video-management, async-job
         """
         url = f"{self.base_url}/thumbnails/set"
-        query_params = {
-            k: v
-            for k, v in [
-                ("onBehalfOfContentOwner", onBehalfOfContentOwner),
-                ("videoId", videoId),
-            ]
-            if v is not None
-        }
-        response = self._post(url, data={}, params=query_params)
+        query_params = {k: v for k, v in [("onBehalfOfContentOwner", onBehalfOfContentOwner), ("videoId", videoId)] if v is not None}
+        response = await self._apost(url, data={}, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def get_video_abuse_report_reasons(self, hl=None, part=None) -> Any:
+    async def get_video_abuse_report_reasons(self, hl=None, part=None) -> Any:
         """
         Retrieves a list of valid reasons (e.g., spam, hate speech) for reporting abusive video content. Supports response localization using a language code (`hl`) and allows filtering which parts of the reason resource (e.g., ID, snippet) are returned, providing metadata before submitting a report.
 
@@ -1503,11 +1344,11 @@ class YoutubeApp(APIApplication):
         """
         url = f"{self.base_url}/videoAbuseReportReasons"
         query_params = {k: v for k, v in [("hl", hl), ("part", part)] 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 get_video_categories(self, hl=None, id=None, part=None, regionCode=None) -> Any:
+    async def get_video_categories(self, hl=None, id=None, part=None, regionCode=None) -> Any:
         """
         Retrieves official YouTube video categories used for classifying uploaded videos, allowing filtering by ID, region, or language. This is distinct from `get_guecategories`, which fetches channel browsing guides, not categories for individual video uploads.
 
@@ -1527,21 +1368,12 @@ class YoutubeApp(APIApplication):
             fetch, video-categories, api-request, json-response
         """
         url = f"{self.base_url}/videoCategories"
-        query_params = {
-            k: v
-            for k, v in [
-                ("hl", hl),
-                ("id", id),
-                ("part", part),
-                ("regionCode", regionCode),
-            ]
-            if v is not None
-        }
-        response = self._get(url, params=query_params)
+        query_params = {k: v for k, v in [("hl", hl), ("id", id), ("part", part), ("regionCode", regionCode)] if v is not None}
+        response = await self._aget(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def delete_group_items(self, id=None, onBehalfOfContentOwner=None) -> Any:
+    async def delete_group_items(self, id=None, onBehalfOfContentOwner=None) -> Any:
         """
         Deletes specified items from a YouTube Analytics group via an API request. An item can be targeted by its unique ID, and the action can be performed on behalf of a content owner. This function is distinct from `delete_groups`, which removes the entire group.
 
@@ -1559,16 +1391,12 @@ class YoutubeApp(APIApplication):
             delete, groupitems, management
         """
         url = f"{self.base_url}/groupItems"
-        query_params = {
-            k: v
-            for k, v in [("id", id), ("onBehalfOfContentOwner", onBehalfOfContentOwner)]
-            if v is not None
-        }
-        response = self._delete(url, params=query_params)
+        query_params = {k: v for k, v in [("id", id), ("onBehalfOfContentOwner", onBehalfOfContentOwner)] if v is not None}
+        response = await self._adelete(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def delete_groups(self, id=None, onBehalfOfContentOwner=None) -> Any:
+    async def delete_groups(self, id=None, onBehalfOfContentOwner=None) -> Any:
         """
         Deletes a YouTube group by its ID via an API request, optionally on behalf of a content owner. Unlike `delete_groupitems`, which only removes an item from a group, this function deletes the entire group entity.
 
@@ -1586,27 +1414,13 @@ class YoutubeApp(APIApplication):
             delete, management, async_job, api
         """
         url = f"{self.base_url}/groups"
-        query_params = {
-            k: v
-            for k, v in [("id", id), ("onBehalfOfContentOwner", onBehalfOfContentOwner)]
-            if v is not None
-        }
-        response = self._delete(url, params=query_params)
+        query_params = {k: v for k, v in [("id", id), ("onBehalfOfContentOwner", onBehalfOfContentOwner)] if v is not None}
+        response = await self._adelete(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def get_analytics_report(
-        self,
-        currency=None,
-        dimensions=None,
-        end=None,
-        filters=None,
-        ids=None,
-        include=None,
-        max=None,
-        metrics=None,
-        sort=None,
-        start=None,
+    async def get_analytics_report(
+        self, currency=None, dimensions=None, end=None, filters=None, ids=None, include=None, max=None, metrics=None, sort=None, start=None
     ) -> Any:
         """
         Queries the YouTube Analytics API for performance reports, allowing customization via metrics, dimensions, and filters. Unlike `get_jobs_job_reports` which manages bulk report jobs, this function fetches analytical data directly, providing on-demand insights into channel or content performance.
@@ -1649,7 +1463,7 @@ class YoutubeApp(APIApplication):
             ]
             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()