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

universal_mcp/applications/google_calendar/app.py

@@ -1,6 +1,5 @@
 from datetime import UTC, datetime, timedelta
 from typing import Any
-
 from loguru import logger
 from universal_mcp.applications.application import APIApplication
 from universal_mcp.integrations import Integration
@@ -24,34 +23,19 @@ class GoogleCalendarApp(APIApplication):
         """
         if not dt_string or dt_string == "Unknown":
             return "Unknown"
-
-        # Check if it's just a date (all-day event) or a datetime
         if "T" in dt_string:
-            # It's a datetime - parse and format it
             try:
-                # Handle Z (UTC) suffix by replacing with +00:00 timezone
                 if dt_string.endswith("Z"):
                     dt_string = dt_string.replace("Z", "+00:00")
-
-                # Parse the ISO datetime string
                 dt = datetime.fromisoformat(dt_string)
-
-                # Format to a more readable form
                 return dt.strftime("%Y-%m-%d %I:%M %p")
             except ValueError:
-                # In case of parsing error, return the original
                 logger.warning(f"Could not parse datetime string: {dt_string}")
                 return dt_string
         else:
-            # It's just a date (all-day event)
             return f"{dt_string} (All day)"
 
-    def get_upcoming_events(
-        self,
-        days: int = 1,
-        max_results: int | None = None,
-        time_zone: str | None = None,
-    ) -> dict[str, Any]:
+    async def get_upcoming_events(self, days: int = 1, max_results: int | None = None, time_zone: str | None = None) -> dict[str, Any]:
         """
         Retrieves events for a specified number of days, starting from today. This function simplifies date-range queries by auto-calculating start/end times, unlike the more comprehensive `list_events` function, which offers granular control with explicit time filters, text search, and custom sorting.
 
@@ -74,28 +58,17 @@ class GoogleCalendarApp(APIApplication):
         time_min = f"{today.isoformat()}T00:00:00Z"
         time_max = f"{end_date.isoformat()}T00:00:00Z"
         url = f"{self.base_api_url}/events"
-        params = {
-            "timeMin": time_min,
-            "timeMax": time_max,
-            "singleEvents": "true",
-            "orderBy": "startTime",
-        }
+        params = {"timeMin": time_min, "timeMax": time_max, "singleEvents": "true", "orderBy": "startTime"}
         if max_results is not None:
             params["maxResults"] = str(max_results)
         if time_zone:
             params["timeZone"] = time_zone
         date_range = "today" if days == 1 else f"the next {days} days"
         logger.info(f"Retrieving calendar events for {date_range}")
-        response = self._get(url, params=params)
-
+        response = await self._aget(url, params=params)
         return self._handle_response(response)
 
-    def get_event_by_id(
-        self,
-        event_id: str,
-        max_attendees: int | None = None,
-        time_zone: str | None = None,
-    ) -> dict[str, Any]:
+    async def get_event_by_id(self, event_id: str, max_attendees: int | None = None, time_zone: str | None = None) -> dict[str, Any]:
         """
         Retrieves a specific calendar event using its unique ID. Unlike `list_events`, which fetches multiple events based on date ranges or search queries, this function targets a single, known event. It can optionally limit attendees returned and specify a time zone for date formatting in the response.
 
@@ -121,10 +94,10 @@ class GoogleCalendarApp(APIApplication):
         if time_zone:
             params["timeZone"] = time_zone
         logger.info(f"Retrieving calendar event with ID: {event_id}")
-        response = self._get(url, params=params)
+        response = await self._aget(url, params=params)
         return self._handle_response(response)
 
-    def list_events(
+    async def list_events(
         self,
         max_results: int = 10,
         time_min: str | None = None,
@@ -159,16 +132,11 @@ class GoogleCalendarApp(APIApplication):
             list, retrieve, calendar, events, pagination, api, important
         """
         url = f"{self.base_api_url}/events"
-        params = {
-            "maxResults": str(max_results),
-            "orderBy": order_by,
-            "singleEvents": str(single_events).lower(),
-        }
+        params = {"maxResults": str(max_results), "orderBy": order_by, "singleEvents": str(single_events).lower()}
         if time_min:
             params["timeMin"] = time_min
         else:
-            # Default to current time if not specified
-            now = datetime.utcnow().isoformat() + "Z"  # 'Z' indicates UTC time
+            now = datetime.utcnow().isoformat() + "Z"
             params["timeMin"] = now
         if time_max:
             params["timeMax"] = time_max
@@ -179,11 +147,10 @@ class GoogleCalendarApp(APIApplication):
         if page_token:
             params["pageToken"] = page_token
         logger.info(f"Retrieving calendar events with params: {params}")
-        response = self._get(url, params=params)
-
+        response = await self._aget(url, params=params)
         return self._handle_response(response)
 
-    def create_event(
+    async def create_event(
         self,
         start: dict[str, Any],
         end: dict[str, Any],
@@ -231,7 +198,6 @@ class GoogleCalendarApp(APIApplication):
         Tags:
             create, calendar, event, insert, recurring, important
         """
-
         request_body_data = {
             "start": start,
             "end": end,
@@ -241,19 +207,12 @@ class GoogleCalendarApp(APIApplication):
             "attendees": attendees,
             "recurrence": recurrence,
         }
-        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}/calendars/{calendar_id}/events"
-
-        response = self._post(url, data=request_body_data)
-
+        response = await self._apost(url, data=request_body_data)
         return self._handle_response(response)
 
-    def create_event_from_text(
-        self, text: str, send_updates: str = "none"
-    ) -> dict[str, Any]:
+    async def create_event_from_text(self, text: str, send_updates: str = "none") -> dict[str, Any]:
         """
         Creates a calendar event by parsing a natural language string (e.g., "Meeting tomorrow at 10am"). This offers a user-friendly shortcut, contrasting with the structured `create_event` function which requires explicit fields like start and end times.
 
@@ -273,11 +232,10 @@ class GoogleCalendarApp(APIApplication):
         url = f"{self.base_api_url}/events/quickAdd"
         params = {"text": text, "sendUpdates": send_updates}
         logger.info(f"Creating event via quickAdd: '{text}'")
-        response = self._post(url, data=None, params=params)
-
+        response = await self._apost(url, data=None, params=params)
         return self._handle_response(response)
 
-    def list_recurring_event_instances(
+    async def list_recurring_event_instances(
         self,
         event_id: str,
         max_results: int = 25,
@@ -310,10 +268,7 @@ class GoogleCalendarApp(APIApplication):
             list, retrieve, calendar, events, recurring, pagination, api, important
         """
         url = f"{self.base_api_url}/events/{event_id}/instances"
-        params = {
-            "maxResults": str(max_results),
-            "showDeleted": str(show_deleted).lower(),
-        }
+        params = {"maxResults": str(max_results), "showDeleted": str(show_deleted).lower()}
         if time_min:
             params["timeMin"] = time_min
         if time_max:
@@ -323,11 +278,10 @@ class GoogleCalendarApp(APIApplication):
         if page_token:
             params["pageToken"] = page_token
         logger.info(f"Retrieving instances of recurring event with ID: {event_id}")
-        response = self._get(url, params=params)
-
+        response = await self._aget(url, params=params)
         return self._handle_response(response)
 
-    def delete_event(
+    async def delete_event(
         self,
         calendarId,
         eventId,
@@ -383,10 +337,10 @@ class GoogleCalendarApp(APIApplication):
             ]
             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 replace_event(
+    async def replace_event(
         self,
         event_id: str,
         start: dict[str, Any],
@@ -443,21 +397,16 @@ class GoogleCalendarApp(APIApplication):
             "attendees": attendees,
             "recurrence": recurrence,
         }
-        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}/calendars/{calendar_id}/events/{event_id}"
         params = {"sendUpdates": send_updates}
         if max_attendees is not None:
             params["maxAttendees"] = str(max_attendees)
-
         logger.info(f"Updating calendar event with ID: {event_id}")
-        response = self._put(url, data=request_body_data, params=params)
-
+        response = await self._aput(url, data=request_body_data, params=params)
         return self._handle_response(response)
 
-    def get_primary_calendar_details(self) -> dict[str, Any]:
+    async def get_primary_calendar_details(self) -> dict[str, Any]:
         """
         Retrieves metadata for the user's primary calendar, including its default timezone. This information is essential for creating new events with accurate, timezone-aware start and end times using other functions like `create_event`, preventing potential scheduling errors across different regions.
 
@@ -472,10 +421,10 @@ class GoogleCalendarApp(APIApplication):
         """
         url = f"{self.base_api_url}"
         logger.info("Retrieving user's calendar timezone settings")
-        response = self._get(url)
+        response = await self._aget(url)
         return self._handle_response(response)
 
-    def get_free_busy_info(
+    async def get_free_busy_info(
         self,
         alt=None,
         fields=None,
@@ -554,7 +503,7 @@ class GoogleCalendarApp(APIApplication):
             ]
             if v is not None
         }
-        response = self._post(url, data=request_body, params=query_params)
+        response = await self._apost(url, data=request_body, params=query_params)
         response.raise_for_status()
         return response.json()
 
@@ -568,7 +517,6 @@ class GoogleCalendarApp(APIApplication):
             self.replace_event,
             self.list_recurring_event_instances,
             self.get_primary_calendar_details,
-            # Auto Generated from Openapi spec
             self.delete_event,
             self.get_free_busy_info,
         ]

universal_mcp/applications/google_docs/README.md

@@ -9,17 +9,18 @@ This is automatically generated from OpenAPI schema for the GoogleDocsApp API.
 
 | Tool | Description |
 |------|-------------|
-| `create_document` | Creates a blank Google Document with a specified title using a POST request to the Google Docs API. This is the primary creation method, returning the document's metadata, including the ID required by functions like `get_document` or `insert_text` to perform subsequent operations on the new file. |
-| `get_document` | Retrieves the complete content and metadata for a specific Google Document using its unique ID. This function performs a GET request to the API, returning the full JSON response. It's the primary read operation, contrasting with `create_document` which creates new documents. |
-| `insert_text` | Inserts a text string at a specified index within an existing Google Document using the `batchUpdate` API. This function adds new textual content, distinguishing it from functions that insert non-text elements like tables or apply formatting (`apply_text_style`) to existing content. |
-| `apply_text_style` | Applies character-level formatting such as bold, italic, font size, color, and hyperlinks to a specified text range in a document. This function modifies text appearance, distinguishing it from `update_paragraph_style`, which handles block-level formatting like alignment and headings. |
-| `delete_content_range` | Deletes content within a specified index range in a Google Document via the batchUpdate API. It removes any content based on location, distinguishing it from functions like `delete_header` or `delete_paragraph_bullets`, which remove specific structures or styles instead. |
-| `insert_table` | Inserts a table with specified row and column dimensions at a given index in a Google Document. This function uses the `batchUpdate` API for precise placement, allowing the table to be added to the document's body, a header, or a footer, returning the API's response. |
-| `create_footer` | Creates a footer of a specified type in a Google Document via the batch update API. The footer can optionally be associated with a specific section break, enabling distinct footers for different document sections, distinguishing it from the `create_header` and `create_footnote` functions. |
-| `create_footnote` | Creates a footnote via the batch update API, inserting a numbered reference at a specified index or a segment's end. This function adds an in-body citation, distinguishing it from `create_footer` which creates a content block at the bottom of the page. |
-| `delete_footer` | Deletes a specific footer from a Google Document using its unique ID via a `batchUpdate` request. This operation, the counterpart to `create_footer`, removes an entire footer section, unlike `delete_content_range` which targets text within a specified index range. |
-| `create_header` | Creates a header in a specified Google Document via the batchUpdate API endpoint. This function allows defining the header type and can optionally associate it with a specific section break location. It complements the `delete_header` and `create_footer` functions for managing document structure. |
-| `delete_header` | Removes a specific header from a Google Document using its unique ID. This function sends a `deleteHeader` request to the batch update API, acting as the direct counterpart to `create_header` and distinguishing it from `delete_footer` which removes footers. |
-| `apply_list_style` | Applies a predefined bulleted or numbered list format to paragraphs within a specified range using a `bullet_preset`. This function adds list formatting, distinguishing it from its counterpart, `delete_paragraph_bullets`, and other styling functions like `update_paragraph_style`, which handles alignment and headings. |
-| `delete_paragraph_bullets` | Removes bullet points or numbering from paragraphs within a specified range in a Google Document. This function reverts list formatting via the batch update API, acting as the direct counterpart to `apply_list_style` and preserving the underlying text content, unlike `delete_content_range`. |
-| `update_paragraph_style` | Applies paragraph-level formatting, such as named styles (e.g., 'HEADING_1'), alignment, or text direction, to a specified text range. This function handles block-level styles, distinguishing it from `apply_text_style`, which formats individual characters with attributes like bold or italic. |
+| `create_document` | Creates a blank Google Document with a specified title by sending a POST request to the Google Docs API. The function returns a dictionary containing the new document's metadata, including the unique document ID required by other functions for subsequent modifications or retrieval. Note that you need to call other google_docs functions (e.g. `google_docs__insert_text`) to actually add content after creating the document. |
+| `get_document` | Retrieves the complete, raw JSON object for a Google Document by its ID. This function returns the full, unprocessed API response with all metadata and structural elements, distinguishing it from `get_document_content`, which parses this data to extract only the title and plain text. |
+| `get_document_content` | Retrieves and converts a Google Docs document into Markdown-formatted content. |
+| `insert_text` | Inserts a text string at a specified index within a Google Document using the batchUpdate API. Unlike functions that format existing text or delete content ranges, this method specifically adds new textual content to the document body. |
+| `apply_text_style` | Applies character-level formatting (e.g., bold, italic, color, links) to a specified text range. This function modifies text attributes directly, distinguishing it from `update_paragraph_style` which handles block-level properties like alignment. |
+| `update_paragraph_style` | Applies paragraph-level formatting like alignment, named styles (e.g., 'HEADING_1'), and text direction to a text range in a Google Doc. Distinct from `apply_text_style`, which handles character formatting, this method modifies properties for entire paragraphs using the batchUpdate API. |
+| `delete_content_range` | Removes content from a specified index range in a Google Document via the batchUpdate API. Unlike functions that delete entire elements (e.g., `delete_header`), this provides granular control by targeting content based on its precise start and end location, optionally within a specific segment or tab. |
+| `insert_table` | Inserts a table with specified rows and columns at a given index in a Google Document using the batchUpdate API. It can optionally place the table within specific document segments, such as headers or footers, handling structural additions rather than text or style modifications. |
+| `create_footer` | Creates a footer of a specified type in a Google Document using the batch update API. This function, distinct from `create_header`, can optionally associate the new footer with a specific section break, enabling section-specific footers within the document. |
+| `create_footnote` | Inserts a numbered footnote reference into a Google Document using the batchUpdate API. The footnote can be placed at a precise index or at the end of a document segment, distinct from the `create_footer` function which adds standard page footers. |
+| `delete_footer` | Deletes a specific footer from a Google Document using its unique ID via a batchUpdate API request. This operation removes the entire footer object, optionally within a specific tab, distinguishing it from functions that delete headers (`delete_header`) or general content (`delete_content_range`). |
+| `create_header` | Creates a header of a specified type in a Google Document using the batchUpdate API. This function can optionally associate the new header with a specific section break, distinguishing it from the `create_footer` method, which performs the equivalent action for footers. |
+| `delete_header` | Deletes a specific header from a Google Document using its unique ID via a batchUpdate API request. This function, the counterpart to `create_header`, removes headers and can optionally target a header within a specific tab. It requires both the document and header IDs for the operation. |
+| `apply_list_style` | Applies a predefined list style (bulleted or numbered) to paragraphs within a specified range using a chosen preset. Unlike `delete_paragraph_bullets`, which removes list formatting, this function creates it, distinguishing it from other text and paragraph styling methods in the class. |
+| `delete_paragraph_bullets` | Removes bullet points or numbering from paragraphs within a specified index range in a Google Document. This reverts list formatting to normal text while preserving content, acting as the inverse operation to the `apply_list_style` function. |