universal-mcp-applications 0.1.21__py3-none-any.whl → 0.1.22__py3-none-any.whl

universal_mcp/applications/scraper/app.py

@@ -1,15 +1,14 @@
-import os
 from dotenv import load_dotenv
 
 load_dotenv()
 
 from typing import Any
 
+from loguru import logger
 from universal_mcp.applications.application import APIApplication
-from universal_mcp.applications.unipile import UnipileApp
-from typing import Any, Optional
 from universal_mcp.integrations import Integration
-from loguru import logger
+
+from universal_mcp.applications.unipile import UnipileApp
 
 
 class ScraperApp(APIApplication):
@@ -33,7 +32,7 @@ class ScraperApp(APIApplication):
             self.account_id = credentials.get("account_id")
             self._unipile_app = UnipileApp(integration=self.integration)
         else:
-            logger.warning(f"Integration not found")
+            logger.warning("Integration not found")
             self.account_id = None
             self._unipile_app = None
 
@@ -41,12 +40,12 @@ class ScraperApp(APIApplication):
         self,
         category: str = "posts",
         api: str = "classic",
-        cursor: Optional[str] = None,
-        limit: Optional[int] = None,
-        keywords: Optional[str] = None,
-        sort_by: Optional[str] = None,
-        date_posted: Optional[str] = None,
-        content_type: Optional[str] = None,
+        cursor: str | None = None,
+        limit: int | None = None,
+        keywords: str | None = None,
+        sort_by: str | None = None,
+        date_posted: str | None = None,
+        content_type: str | None = None,
     ) -> dict[str, Any]:
         """
         Performs a general LinkedIn search for posts using keywords and filters like date and content type. It supports pagination and can utilize either the 'classic' or 'sales_navigator' API, searching broadly across the platform rather than fetching posts from a specific user's profile.
@@ -86,8 +85,8 @@ class ScraperApp(APIApplication):
     def linkedin_list_profile_posts(
         self,
         identifier: str,
-        cursor: Optional[str] = None,
-        limit: Optional[int] = None,
+        cursor: str | None = None,
+        limit: int | None = None,
     ) -> dict[str, Any]:
         """
         Fetches a paginated list of all LinkedIn posts from a specific user or company profile using their unique identifier. This function retrieves content directly from a profile, unlike `linkedin_post_search` which finds posts across LinkedIn based on keywords and other filters.
@@ -143,9 +142,9 @@ class ScraperApp(APIApplication):
     def linkedin_list_post_comments(
         self,
         post_id: str,
-        comment_id: Optional[str] = None,
-        cursor: Optional[str] = None,
-        limit: Optional[int] = None,
+        comment_id: str | None = None,
+        cursor: str | None = None,
+        limit: int | None = None,
     ) -> dict[str, Any]:
         """
         Fetches comments for a specified LinkedIn post. If a `comment_id` is provided, it retrieves replies to that comment instead of top-level comments. This function supports pagination and specifically targets comments, unlike others in the class that search for or list entire posts.
@@ -176,54 +175,54 @@ class ScraperApp(APIApplication):
 
     def linkedin_people_search(
         self,
-        cursor: Optional[str] = None,
-        limit: Optional[int] = None,
-        keywords: Optional[str] = None,
-        last_viewed_at: Optional[int] = None,
-        saved_search_id: Optional[str] = None,
-        recent_search_id: Optional[str] = None,
-        location: Optional[dict[str, Any]] = None,
-        location_by_postal_code: Optional[dict[str, Any]] = None,
-        industry: Optional[dict[str, Any]] = None,
-        first_name: Optional[str] = None,
-        last_name: Optional[str] = None,
-        tenure: Optional[list[dict[str, Any]]] = None,
-        groups: Optional[list[str]] = None,
-        school: Optional[dict[str, Any]] = None,
-        profile_language: Optional[list[str]] = None,
-        company: Optional[dict[str, Any]] = None,
-        company_headcount: Optional[list[dict[str, Any]]] = None,
-        company_type: Optional[list[str]] = None,
-        company_location: Optional[dict[str, Any]] = None,
-        tenure_at_company: Optional[list[dict[str, Any]]] = None,
-        past_company: Optional[dict[str, Any]] = None,
-        function: Optional[dict[str, Any]] = None,
-        role: Optional[dict[str, Any]] = None,
-        tenure_at_role: Optional[list[dict[str, Any]]] = None,
-        seniority: Optional[dict[str, Any]] = None,
-        past_role: Optional[dict[str, Any]] = None,
-        following_your_company: Optional[bool] = None,
-        viewed_your_profile_recently: Optional[bool] = None,
-        network_distance: Optional[list[str]] = None,
-        connections_of: Optional[list[str]] = None,
-        past_colleague: Optional[bool] = None,
-        shared_experiences: Optional[bool] = None,
-        changed_jobs: Optional[bool] = None,
-        posted_on_linkedin: Optional[bool] = None,
-        mentionned_in_news: Optional[bool] = None,
-        persona: Optional[list[str]] = None,
-        account_lists: Optional[dict[str, Any]] = None,
-        lead_lists: Optional[dict[str, Any]] = None,
-        viewed_profile_recently: Optional[bool] = None,
-        messaged_recently: Optional[bool] = None,
-        include_saved_leads: Optional[bool] = None,
-        include_saved_accounts: Optional[bool] = None,
+        cursor: str | None = None,
+        limit: int | None = None,
+        keywords: str | None = None,
+        last_viewed_at: int | None = None,
+        saved_search_id: str | None = None,
+        recent_search_id: str | None = None,
+        location: dict[str, Any] | None = None,
+        location_by_postal_code: dict[str, Any] | None = None,
+        industry: dict[str, Any] | None = None,
+        first_name: str | None = None,
+        last_name: str | None = None,
+        tenure: list[dict[str, Any]] | None = None,
+        groups: list[str] | None = None,
+        school: dict[str, Any] | None = None,
+        profile_language: list[str] | None = None,
+        company: dict[str, Any] | None = None,
+        company_headcount: list[dict[str, Any]] | None = None,
+        company_type: list[str] | None = None,
+        company_location: dict[str, Any] | None = None,
+        tenure_at_company: list[dict[str, Any]] | None = None,
+        past_company: dict[str, Any] | None = None,
+        function: dict[str, Any] | None = None,
+        role: dict[str, Any] | None = None,
+        tenure_at_role: list[dict[str, Any]] | None = None,
+        seniority: dict[str, Any] | None = None,
+        past_role: dict[str, Any] | None = None,
+        following_your_company: bool | None = None,
+        viewed_your_profile_recently: bool | None = None,
+        network_distance: list[str] | None = None,
+        connections_of: list[str] | None = None,
+        past_colleague: bool | None = None,
+        shared_experiences: bool | None = None,
+        changed_jobs: bool | None = None,
+        posted_on_linkedin: bool | None = None,
+        mentionned_in_news: bool | None = None,
+        persona: list[str] | None = None,
+        account_lists: dict[str, Any] | None = None,
+        lead_lists: dict[str, Any] | None = None,
+        viewed_profile_recently: bool | None = None,
+        messaged_recently: bool | None = None,
+        include_saved_leads: bool | None = None,
+        include_saved_accounts: bool | None = None,
     ) -> dict[str, Any]:
         """
         Performs a comprehensive LinkedIn Sales Navigator people search with advanced targeting options.
         This function provides access to LinkedIn's Sales Navigator search capabilities for finding people
         with precise filters including experience, company details, education, and relationship criteria.
-        
+
         Args:
             cursor: Pagination cursor for the next page of entries.
             limit: Number of items to return.
@@ -267,13 +266,13 @@ class ScraperApp(APIApplication):
             messaged_recently: LinkedIn native filter: PEOPLE YOU INTERACTED WITH / MESSAGED. Example: True
             include_saved_leads: LinkedIn native filter: SAVED LEADS AND ACCOUNTS / ALL MY SAVED LEADS. Example: True
             include_saved_accounts: LinkedIn native filter: SAVED LEADS AND ACCOUNTS / ALL MY SAVED ACCOUNTS. Example: True
-        
+
         Returns:
             A dictionary containing search results and pagination details.
-        
+
         Raises:
             httpx.HTTPError: If the API request fails.
-        
+
         Tags:
             linkedin, sales_navigator, people, search, advanced, scraper, api, important
         """
@@ -325,27 +324,27 @@ class ScraperApp(APIApplication):
 
     def linkedin_company_search(
         self,
-        cursor: Optional[str] = None,
-        limit: Optional[int] = None,
-        keywords: Optional[str] = None,
-        last_viewed_at: Optional[int] = None,
-        saved_search_id: Optional[str] = None,
-        recent_search_id: Optional[str] = None,
-        location: Optional[dict[str, Any]] = None,
-        location_by_postal_code: Optional[dict[str, Any]] = None,
-        industry: Optional[dict[str, Any]] = None,
-        company_headcount: Optional[list[dict[str, Any]]] = None,
-        company_type: Optional[list[str]] = None,
-        company_location: Optional[dict[str, Any]] = None,
-        following_your_company: Optional[bool] = None,
-        account_lists: Optional[dict[str, Any]] = None,
-        include_saved_accounts: Optional[bool] = None,
+        cursor: str | None = None,
+        limit: int | None = None,
+        keywords: str | None = None,
+        last_viewed_at: int | None = None,
+        saved_search_id: str | None = None,
+        recent_search_id: str | None = None,
+        location: dict[str, Any] | None = None,
+        location_by_postal_code: dict[str, Any] | None = None,
+        industry: dict[str, Any] | None = None,
+        company_headcount: list[dict[str, Any]] | None = None,
+        company_type: list[str] | None = None,
+        company_location: dict[str, Any] | None = None,
+        following_your_company: bool | None = None,
+        account_lists: dict[str, Any] | None = None,
+        include_saved_accounts: bool | None = None,
     ) -> dict[str, Any]:
         """
         Performs a comprehensive LinkedIn Sales Navigator company search with advanced targeting options.
         This function provides access to LinkedIn's Sales Navigator search capabilities for finding companies
         with precise filters including size, location, industry, and relationship criteria.
-        
+
         Args:
             cursor: Pagination cursor for the next page of entries.
             limit: Number of items to return.
@@ -362,13 +361,13 @@ class ScraperApp(APIApplication):
             following_your_company: LinkedIn native filter: FOLLOWING YOUR COMPANY. Example: True
             account_lists: LinkedIn native filter: ACCOUNT LISTS. Example: {"include": ["account_list_id_1"]}
             include_saved_accounts: LinkedIn native filter: SAVED LEADS AND ACCOUNTS / ALL MY SAVED ACCOUNTS. Example: True
-        
+
         Returns:
             A dictionary containing search results and pagination details.
-        
+
         Raises:
             httpx.HTTPError: If the API request fails.
-        
+
         Tags:
             linkedin, sales_navigator, companies, search, advanced, scraper, api, important
         """

universal_mcp/applications/serpapi/app.py

@@ -2,12 +2,12 @@ from typing import Any  # For type hinting
 
 import httpx
 from loguru import logger
-
-from serpapi import SerpApiClient as SerpApiSearch  # Added SerpApiError
 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
+
 
 class SerpapiApp(APIApplication):
     def __init__(self, integration: Integration | None = None, **kwargs: Any) -> None:
@@ -78,17 +78,17 @@ class SerpapiApp(APIApplication):
     async def web_search(self, params: dict[str, Any] | None = None) -> str:
         """
         Performs a general web search via SerpApi, defaulting to the 'google_light' engine. It accepts custom parameters, retrieves organic results, and formats them into a string with titles, links, and snippets. It also handles API authentication and raises `NotAuthorizedError` for credential-related issues.
-        
+
         Args:
             params: Dictionary of engine-specific parameters (e.g., {'q': 'Coffee', 'engine': 'google_light', 'location': 'Austin, TX'}). Defaults to None.
-        
+
         Returns:
             A formatted string containing search results with titles, links, and snippets, or an error message if the search fails.
-        
+
         Raises:
             NotAuthorizedError: If the API key cannot be retrieved or is invalid/rejected by SerpApi.
             Exception: For other unexpected errors during the search process. (Specific HTTP errors or SerpApiErrors are caught and returned as strings or raise NotAuthorizedError).
-        
+
         Tags:
             search, async, web-scraping, api, serpapi, important
         """
@@ -194,19 +194,19 @@ class SerpapiApp(APIApplication):
     ) -> 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.
-        
+
         Args:
             q (string, optional): The search query for Google Maps (e.g., "Coffee", "Restaurants", "Gas stations").
             ll (string, optional): Latitude and longitude with zoom level in format "@lat,lng,zoom" (e.g., "@40.7455096,-74.0083012,14z"). The zoom attribute ranges from 3z (map completely zoomed out) to 21z (map completely zoomed in). Results are not guaranteed to be within the requested geographic location.
             place_id (string, optional): The unique reference to a place in Google Maps. Place IDs are available for most locations, including businesses, landmarks, parks, and intersections. You can find the place_id using our Google Maps API. place_id can be used without any other optional parameter. place_id and data_cid can't be used together.
-        
+
         Returns:
             dict[str, Any]: Formatted Google Maps search results with place names, addresses, ratings, and other details.
-        
+
         Raises:
             ValueError: Raised when required parameters are missing.
             HTTPStatusError: Raised when the API request fails with detailed error information including status code and response body.
-        
+
         Tags:
             google-maps, search, location, places, important
         """
@@ -249,18 +249,18 @@ class SerpapiApp(APIApplication):
     ) -> 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.
-        
+
         Args:
             data_id (string): The data ID of the place to get reviews for (e.g., "0x89c259af336b3341:0xa4969e07ce3108de").
             hl (string, optional): Language parameter for the search results. Defaults to "en".
-        
+
         Returns:
             dict[str, Any]: Google Maps reviews data with ratings, comments, and other review details.
-        
+
         Raises:
             ValueError: Raised when required parameters are missing.
             HTTPStatusError: Raised when the API request fails with detailed error information including status code and response body.
-        
+
         Tags:
             google-maps, reviews, ratings, places, important
         """

universal_mcp/applications/sharepoint/app.py

@@ -6,7 +6,6 @@ from typing import Any
 
 from loguru import logger
 from office365.graph_client import GraphClient
-
 from universal_mcp.applications.application import BaseApplication
 from universal_mcp.integrations import Integration
 
@@ -37,7 +36,7 @@ class SharepointApp(BaseApplication):
     def client(self):
         """
         A lazy-loaded property that gets or creates an authenticated GraphClient instance. On first access, it uses integration credentials to initialize the client, fetches initial user and site data, and caches the instance for subsequent use, ensuring efficient connection management for all SharePoint operations.
-        
+
         Returns:
             GraphClient: The authenticated GraphClient instance.
         """
@@ -75,13 +74,13 @@ class SharepointApp(BaseApplication):
     def list_folders(self, folder_path: str | None = None) -> list[dict[str, Any]]:
         """
         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.
-        
+
         Args:
             folder_path (Optional[str], optional): The path to the parent folder. If None, lists folders in the root.
-        
+
         Returns:
             List[Dict[str, Any]]: A list of folder names in the specified directory.
-        
+
         Tags:
             important
         """
@@ -98,14 +97,14 @@ class SharepointApp(BaseApplication):
     ) -> dict[str, Any]:
         """
         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.
-        
+
         Args:
             folder_name (str): The name of the folder to create.
             folder_path (str | None, optional): The path to the parent folder. If None, creates in the root.
-        
+
         Returns:
             Dict[str, Any]: The updated list of folders in the target directory.
-        
+
         Tags:
             important
         """
@@ -119,13 +118,13 @@ class SharepointApp(BaseApplication):
     def list_files(self, folder_path: str) -> list[dict[str, Any]]:
         """
         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).
-        
+
         Args:
             folder_path (str): The path to the folder whose documents are to be listed.
-        
+
         Returns:
             List[Dict[str, Any]]: A list of dictionaries containing document metadata.
-        
+
         Tags:
             important
         """
@@ -148,15 +147,15 @@ class SharepointApp(BaseApplication):
     ) -> dict[str, Any]:
         """
         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.
-        
+
         Args:
             file_path (str): The path to the folder where the document will be created.
             file_name (str): The name of the document to create.
             content (str): The content to write into the document.
-        
+
         Returns:
             Dict[str, Any]: The updated list of documents in the folder.
-        
+
         Tags: important
         """
         file = self.client.me.drive.root.get_by_path(file_path)
@@ -168,13 +167,13 @@ class SharepointApp(BaseApplication):
     def get_document_content(self, file_path: str) -> dict[str, Any]:
         """
         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.
-        
+
         Args:
             file_path (str): The path to the document.
-        
+
         Returns:
             Dict[str, Any]: A dictionary containing the document's name, content type, content (as text or base64), and size.
-        
+
         Tags: important
         """
         file = self.client.me.drive.root.get_by_path(file_path).get().execute_query()
@@ -201,13 +200,13 @@ class SharepointApp(BaseApplication):
     def delete_document(self, file_path: str):
         """
         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.
-        
+
         Args:
             file_path (str): The path to the file to delete.
-        
+
         Returns:
             bool: True if the file was deleted successfully.
-        
+
         Tags:
             important
         """

universal_mcp/applications/shopify/app.py

@@ -1,7 +1,6 @@
 from typing import Any
 
 from loguru import logger
-
 from universal_mcp.applications.application import APIApplication
 from universal_mcp.integrations import Integration