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

universal_mcp/applications/serpapi/app.py

@@ -1,18 +1,16 @@
-from typing import Any  # For type hinting
-
+from typing import Any
 import httpx
 from loguru import logger
 from universal_mcp.applications.application import APIApplication
-from universal_mcp.exceptions import NotAuthorizedError  # For auth errors
-from universal_mcp.integrations import Integration  # For integration type hint
-
-from serpapi import SerpApiClient as SerpApiSearch  # Added SerpApiError
+from universal_mcp.exceptions import NotAuthorizedError
+from universal_mcp.integrations import Integration
+from serpapi import SerpApiClient as SerpApiSearch
 
 
 class SerpapiApp(APIApplication):
     def __init__(self, integration: Integration | None = None, **kwargs: Any) -> None:
         super().__init__(name="serpapi", integration=integration, **kwargs)
-        self._serpapi_api_key: str | None = None  # Cache for the API key
+        self._serpapi_api_key: str | None = None
         self.base_url = "https://serpapi.com/search"
 
     @property
@@ -23,54 +21,33 @@ class SerpapiApp(APIApplication):
         if self._serpapi_api_key is None:
             if not self.integration:
                 logger.error("SerpApi App: Integration not configured.")
-                raise NotAuthorizedError(
-                    "Integration not configured for SerpApi App. Cannot retrieve API key."
-                )
-
+                raise NotAuthorizedError("Integration not configured for SerpApi App. Cannot retrieve API key.")
             try:
                 credentials = self.integration.get_credentials()
             except NotAuthorizedError as e:
-                logger.error(
-                    f"SerpApi App: Authorization error when fetching credentials: {e.message}"
-                )
-                raise  # Re-raise the original NotAuthorizedError
+                logger.error(f"SerpApi App: Authorization error when fetching credentials: {e.message}")
+                raise
             except Exception as e:
-                logger.error(
-                    f"SerpApi App: Unexpected error when fetching credentials: {e}",
-                    exc_info=True,
-                )
+                logger.error(f"SerpApi App: Unexpected error when fetching credentials: {e}", exc_info=True)
                 raise NotAuthorizedError(f"Failed to get SerpApi credentials: {e}")
-
-            api_key = (
-                credentials.get("api_key")
-                or credentials.get("API_KEY")  # Check common variations
-                or credentials.get("apiKey")
-            )
-
+            api_key = credentials.get("api_key") or credentials.get("API_KEY") or credentials.get("apiKey")
             if not api_key:
                 logger.error("SerpApi App: API key not found in credentials.")
-                action_message = "API key for SerpApi is missing. Please ensure it's set in the store (e.g., SERPAPI_API_KEY in credentials)."
-                if hasattr(self.integration, "authorize") and callable(
-                    self.integration.authorize
-                ):
+                action_message = (
+                    "API key for SerpApi is missing. Please ensure it's set in the store (e.g., SERPAPI_API_KEY in credentials)."
+                )
+                if hasattr(self.integration, "authorize") and callable(self.integration.authorize):
                     try:
                         auth_details = self.integration.authorize()
                         if isinstance(auth_details, str):
                             action_message = auth_details
                         elif isinstance(auth_details, dict) and "url" in auth_details:
-                            action_message = (
-                                f"Please authorize via: {auth_details['url']}"
-                            )
-                        elif (
-                            isinstance(auth_details, dict) and "message" in auth_details
-                        ):
+                            action_message = f"Please authorize via: {auth_details['url']}"
+                        elif isinstance(auth_details, dict) and "message" in auth_details:
                             action_message = auth_details["message"]
                     except Exception as auth_e:
-                        logger.warning(
-                            f"Could not retrieve specific authorization action for SerpApi: {auth_e}"
-                        )
+                        logger.warning(f"Could not retrieve specific authorization action for SerpApi: {auth_e}")
                 raise NotAuthorizedError(action_message)
-
             self._serpapi_api_key = api_key
             logger.info("SerpApi API Key successfully retrieved and cached.")
         return self._serpapi_api_key
@@ -93,27 +70,15 @@ class SerpapiApp(APIApplication):
             search, async, web-scraping, api, serpapi, important
         """
         request_params = params or {}
-
         try:
-            current_api_key = self.serpapi_api_key  # This can raise NotAuthorizedError
+            current_api_key = self.serpapi_api_key
             logger.info("Attempting SerpApi search.")
-
-            serpapi_call_params = {
-                "api_key": current_api_key,
-                "engine": "google_light",  # Fastest engine by default
-                **request_params,  # Include any additional parameters from the user
-            }
-
-            # SerpApiSearch (SerpApiClient) uses the 'requests' library and its get_dict() is synchronous.
-            # If true async behavior is needed, this call should be wrapped with asyncio.to_thread.
+            serpapi_call_params = {"api_key": current_api_key, "engine": "google_light", **request_params}
             search_client = SerpApiSearch(serpapi_call_params)
             data = search_client.get_dict()
-
-            # Check for errors returned in the API response body
             if "error" in data:
                 error_message = data["error"]
                 logger.error(f"SerpApi API returned an error: {error_message}")
-                # Keywords indicating authorization/authentication issues
                 auth_error_keywords = [
                     "invalid api key",
                     "authorization failed",
@@ -122,76 +87,42 @@ class SerpapiApp(APIApplication):
                     "account disabled",
                     "private api key is missing",
                 ]
-                if any(
-                    keyword in error_message.lower() for keyword in auth_error_keywords
-                ):
+                if any((keyword in error_message.lower() for keyword in auth_error_keywords)):
                     raise NotAuthorizedError(f"SerpApi Error: {error_message}")
-                return f"SerpApi API Error: {error_message}"  # Other API errors (e.g., missing parameters)
-
-            # Process organic search results if available
+                return f"SerpApi API Error: {error_message}"
             if "organic_results" in data:
                 formatted_results = []
                 for result in data.get("organic_results", []):
                     title = result.get("title", "No title")
                     link = result.get("link", "No link")
                     snippet = result.get("snippet", "No snippet")
-                    formatted_results.append(
-                        f"Title: {title}\nLink: {link}\nSnippet: {snippet}\n"
-                    )
-                return (
-                    "\n".join(formatted_results)
-                    if formatted_results
-                    else "No organic results found."
-                )
+                    formatted_results.append(f"Title: {title}\nLink: {link}\nSnippet: {snippet}\n")
+                return "\n".join(formatted_results) if formatted_results else "No organic results found."
             else:
                 return "No organic results found."
-
-        except (
-            NotAuthorizedError
-        ):  # Catches from self.serpapi_api_key or explicit raise above
+        except NotAuthorizedError:
             logger.error("SerpApi search failed due to an authorization error.")
-            raise  # Re-raise to be handled by the MCP framework
-
-        except httpx.HTTPStatusError as e:  # Kept from original for robustness, though SerpApiClient uses 'requests'
+            raise
+        except httpx.HTTPStatusError as e:
             logger.warning(
                 f"SerpApi search encountered httpx.HTTPStatusError (unexpected with default SerpApiClient): {e.response.status_code}",
                 exc_info=True,
             )
             if e.response.status_code == 429:
                 return "Error: Rate limit exceeded (HTTP 429). Please try again later."
-            elif (
-                e.response.status_code == 401
-            ):  # Key was fetched but rejected by API with HTTP 401
-                raise NotAuthorizedError(
-                    "Error: Invalid API key (HTTP 401). Please check your SERPAPI_API_KEY."
-                )
+            elif e.response.status_code == 401:
+                raise NotAuthorizedError("Error: Invalid API key (HTTP 401). Please check your SERPAPI_API_KEY.")
             else:
                 return f"HTTP Error: {e.response.status_code} - {e.response.text}"
-
-        except Exception as e:  # General catch-all, similar to E2B's final catch
+        except Exception as e:
             error_message_lower = str(e).lower()
             logger.error(f"Unexpected error during SerpApi search: {e}", exc_info=True)
-            # Infer auth error from generic exception message
-            auth_error_keywords = [
-                "authentication",
-                "api key",
-                "unauthorized",
-                "401",
-                "forbidden",
-                "invalid key",
-            ]
-            if any(keyword in error_message_lower for keyword in auth_error_keywords):
-                raise NotAuthorizedError(
-                    f"SerpApi authentication/authorization failed: {str(e)}"
-                )
+            auth_error_keywords = ["authentication", "api key", "unauthorized", "401", "forbidden", "invalid key"]
+            if any((keyword in error_message_lower for keyword in auth_error_keywords)):
+                raise NotAuthorizedError(f"SerpApi authentication/authorization failed: {str(e)}")
             return f"An unexpected error occurred during search: {str(e)}"
 
-    async def google_maps_search(
-        self,
-        q: str | None = None,
-        ll: str | None = None,
-        place_id: str | None = None,
-    ) -> dict[str, Any]:
+    async def google_maps_search(self, q: str | None = None, ll: str | None = None, place_id: str | None = None) -> dict[str, Any]:
         """
         Executes a Google Maps search via SerpApi using a query, coordinates, or place ID. It enhances the results by adding a `google_maps_url` to each location, distinguishing it from `get_google_maps_reviews` which retrieves reviews for a known place.
 
@@ -210,43 +141,23 @@ class SerpapiApp(APIApplication):
         Tags:
             google-maps, search, location, places, important
         """
-
         query_params = {}
-        query_params = {
-            "engine": "google_maps",
-            "api_key": self.serpapi_api_key,
-        }
-
+        query_params = {"engine": "google_maps", "api_key": self.serpapi_api_key}
         if q is not None:
             query_params["q"] = q
-
         if ll is not None:
             query_params["ll"] = ll
-
         if place_id is not None:
             query_params["place_id"] = place_id
-
-        response = self._get(
-            self.base_url,
-            params=query_params,
-        )
+        response = await self._aget(self.base_url, params=query_params)
         data = self._handle_response(response)
-
-        # Add Google Maps URLs for each place in the results
         if "local_results" in data:
             for place in data["local_results"]:
                 if "place_id" in place:
-                    place["google_maps_url"] = (
-                        f"https://www.google.com/maps/place/?q=place_id:{place['place_id']}"
-                    )
-
+                    place["google_maps_url"] = f"https://www.google.com/maps/place/?q=place_id:{place['place_id']}"
         return data
 
-    async def get_google_maps_reviews(
-        self,
-        data_id: str,
-        hl: str | None = None,
-    ) -> dict[str, Any]:
+    async def get_google_maps_reviews(self, data_id: str, hl: str | None = None) -> dict[str, Any]:
         """
         Fetches Google Maps reviews for a specific location via SerpApi using its unique `data_id`. This function uses the `google_maps_reviews` engine, unlike `google_maps_search` which finds locations. Results can be returned in a specified language, defaulting to English.
 
@@ -264,28 +175,14 @@ class SerpapiApp(APIApplication):
         Tags:
             google-maps, reviews, ratings, places, important
         """
-
         query_params = {}
-        query_params = {
-            "engine": "google_maps_reviews",
-            "data_id": data_id,
-            "api_key": self.serpapi_api_key,
-        }
-
+        query_params = {"engine": "google_maps_reviews", "data_id": data_id, "api_key": self.serpapi_api_key}
         if hl is not None:
             query_params["hl"] = hl
         else:
             query_params["hl"] = "en"
-
-        response = self._get(
-            self.base_url,
-            params=query_params,
-        )
+        response = await self._aget(self.base_url, params=query_params)
         return self._handle_response(response)
 
     def list_tools(self) -> list[callable]:
-        return [
-            self.web_search,
-            self.google_maps_search,
-            self.get_google_maps_reviews,
-        ]
+        return [self.web_search, self.google_maps_search, self.get_google_maps_reviews]

universal_mcp/applications/sharepoint/README.md

@@ -1,17 +1,19 @@
-# SharepointApp MCP Server
+# SharePoint Application
 
-An MCP Server for the SharepointApp API.
+This application provides tools for interacting with the Microsoft SharePoint API via Microsoft Graph. It allows you to manage files, folders, and retrieve information about your SharePoint drive.
 
-## 🛠️ Tool List
+## Available Tools
 
-This is automatically generated from OpenAPI schema for the SharepointApp API.
-
-
-| Tool | Description |
-|------|-------------|
-| `list_folders` | Retrieves a list of immediate subfolder names within a specified SharePoint directory. If no path is provided, it defaults to the root drive. This function is distinct from `list_files`, as it exclusively lists directories, not files. |
-| `create_folder_and_list` | Creates a new folder with a given name inside a specified parent directory (or the root). It then returns an updated list of all folder names within that same directory, effectively confirming that the creation operation was successful. |
-| `list_files` | Retrieves metadata for all files in a specified folder. For each file, it returns key details like name, URL, size, and timestamps. This function exclusively lists file properties, distinguishing it from `list_folders` (which lists directories) and `get_document_content` (which retrieves file content). |
-| `upload_text_file` | Uploads string content to create a new file in a specified SharePoint folder. To confirm the operation, it returns an updated list of all files and their metadata from that directory, including the newly created file. |
-| `get_document_content` | Retrieves a file's content from a specified SharePoint path. It returns a dictionary containing the file's name and size, decoding text files as a string and Base64-encoding binary files. Unlike `list_files`, which only fetches metadata, this function provides the actual file content. |
-| `delete_document` | Permanently deletes a specified file from a SharePoint drive using its full path. This is the sole destructive file operation, contrasting with functions that read or create files. It returns `True` on successful deletion and raises an exception on failure, such as if the file is not found. |
+-   `get_my_profile`: Fetches the profile for the currently authenticated user.
+-   `get_drive_info`: Fetches high-level information about the user's SharePoint drive.
+-   `search_files`: Searches for files and folders in the user's SharePoint.
+-   `get_item_metadata`: Fetches metadata for a specific file or folder.
+-   `create_folder`: Creates a new folder.
+-   `delete_item`: Deletes a file or folder.
+-   `download_file`: Retrieves a download URL for a file.
+-   `upload_file`: Uploads a local file.
+-   `list_folders`: Lists all folders in a specified directory.
+-   `list_files`: Lists all files in a specified directory.
+-   `create_folder_and_list`: Creates a folder and then lists the contents of the parent directory.
+-   `upload_text_file`: Uploads content from a string to a new text file.
+-   `get_document_content`: Retrieves the content of a file.