universal-mcp-applications 0.1.30rc2__py3-none-any.whl → 0.1.36rc2__py3-none-any.whl

universal_mcp/applications/scraper/README.md

@@ -9,7 +9,10 @@ This is automatically generated from OpenAPI schema for the ScraperApp API.
 
 | Tool | Description |
 |------|-------------|
-| `linkedin_post_search` | 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. |
-| `linkedin_list_profile_posts` | 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. |
-| `linkedin_retrieve_profile` | Retrieves a specific LinkedIn user's profile by their unique identifier, which can be an internal provider ID or a public username. This function simplifies data access by delegating the actual profile retrieval request to the integrated Unipile application, distinct from functions that list posts or comments. |
-| `linkedin_list_post_comments` | 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. |
+| `linkedin_list_profile_posts` | Fetches a paginated list of posts from a specific user or company profile using its provider ID. The `is_company` flag must specify the entity type. Unlike `linkedin_search_posts`, this function directly retrieves content from a known profile's feed instead of performing a global keyword search. |
+| `linkedin_retrieve_profile` | Fetches a specific LinkedIn user's profile using their public or internal ID. Unlike `linkedin_search_people`, which discovers multiple users via keywords, this function targets and retrieves detailed data for a single, known individual based on a direct identifier. |
+| `linkedin_list_post_comments` | Fetches a paginated list of comments for a specified LinkedIn post. It can retrieve either top-level comments or threaded replies if an optional `comment_id` is provided. This is a read-only operation, distinct from functions that search for posts or list user-specific content. |
+| `linkedin_search_people` | Performs a paginated search for people on LinkedIn, distinct from searches for companies or jobs. It filters results using keywords, location, industry, and company, internally converting filter names like 'United States' into their required API IDs before making the request. |
+| `linkedin_search_companies` | Executes a paginated LinkedIn search for companies, filtering by optional keywords, location, and industry. Unlike `linkedin_search_people` or `linkedin_search_jobs`, this function specifically sets the API search category to 'companies' to ensure that only company profiles are returned in the search results. |
+| `linkedin_search_posts` | Performs a keyword-based search for LinkedIn posts, allowing results to be filtered by date and sorted by relevance. This function specifically queries the 'posts' category, distinguishing it from other search methods in the class that target people, companies, or jobs, and returns relevant content. |
+| `linkedin_search_jobs` | Executes a LinkedIn search specifically for job listings using keywords and filters like region, industry, and minimum salary. Unlike other search functions targeting people or companies, this is specialized for job listings and converts friendly filter names (e.g., "United States") into their required API IDs. |

universal_mcp/applications/scraper/app.py

@@ -2,13 +2,12 @@ import os
 from dotenv import load_dotenv
 
 load_dotenv()
-
 from typing import Any, Literal
-
 from loguru import logger
 from universal_mcp.applications.application import APIApplication
 from universal_mcp.integrations import Integration
 
+
 class ScraperApp(APIApplication):
     """
     Application for interacting with LinkedIn API.
@@ -29,12 +28,8 @@ class ScraperApp(APIApplication):
         if not self._base_url:
             unipile_dsn = os.getenv("UNIPILE_DSN")
             if not unipile_dsn:
-                logger.error(
-                    "UnipileApp: UNIPILE_DSN environment variable is not set."
-                )
-                raise ValueError(
-                    "UnipileApp: UNIPILE_DSN environment variable is required."
-                )
+                logger.error("UnipileApp: UNIPILE_DSN environment variable is not set.")
+                raise ValueError("UnipileApp: UNIPILE_DSN environment variable is required.")
             self._base_url = f"https://{unipile_dsn}"
         return self._base_url
 
@@ -49,104 +44,44 @@ class ScraperApp(APIApplication):
         Overrides the base class method to use X-Api-Key.
         """
         if not self.integration:
-            logger.warning(
-                "UnipileApp: No integration configured, returning empty headers."
-            )
+            logger.warning("UnipileApp: No integration configured, returning empty headers.")
             return {}
-
         api_key = os.getenv("UNIPILE_API_KEY")
         if not api_key:
-            logger.error(
-                "UnipileApp: API key not found in integration credentials for Unipile."
-            )
-            return {  # Or return minimal headers if some calls might not need auth (unlikely for Unipile)
-                "Content-Type": "application/json",
-                "Cache-Control": "no-cache",
-            }
-
+            logger.error("UnipileApp: API key not found in integration credentials for Unipile.")
+            return {"Content-Type": "application/json", "Cache-Control": "no-cache"}
         logger.debug("UnipileApp: Using X-Api-Key for authentication.")
-        return {
-            "x-api-key": api_key,
-            "Content-Type": "application/json",
-            "Cache-Control": "no-cache",  # Often good practice for APIs
-        }
+        return {"x-api-key": api_key, "Content-Type": "application/json", "Cache-Control": "no-cache"}
 
-    def linkedin_search(
-        self,
-        category: Literal["people", "companies", "posts", "jobs"],
-        cursor: str | None = None,
-        limit: int | None = None,
-        keywords: str | None = None,
-        date_posted: Literal["past_day", "past_week", "past_month"] | None = None,
-        sort_by: Literal["relevance", "date"] = "relevance",
-        minimum_salary_value: int = 40,
-    ) -> dict[str, Any]:
+    def _get_search_parameter_id(self, param_type: str, keywords: str) -> str:
         """
-        Performs a comprehensive LinkedIn search for people, companies, posts, or jobs using keywords.
-        Supports pagination and targets either the classic or Sales Navigator API for posts.
-        For people, companies, and jobs, it uses the classic API.
+        Retrieves the ID for a given LinkedIn search parameter by its name.
 
         Args:
-            category: Type of search to perform. Valid values are "people", "companies", "posts", or "jobs".
-            cursor: Pagination cursor for the next page of entries.
-            limit: Number of items to return (up to 50 for Classic search).
-            keywords: Keywords to search for.
-            date_posted: Filter by when the post was posted (posts only). Valid values are "past_day", "past_week", or "past_month".
-            sort_by: How to sort the results (for posts and jobs). Valid values are "relevance" or "date".
-            minimum_salary_value: The minimum salary to filter for (jobs only).
+            param_type: The type of parameter to search for (e.g., "LOCATION", "COMPANY").
+            keywords: The name of the parameter to find (e.g., "United States").
 
         Returns:
-            A dictionary containing search results and pagination details.
+            The corresponding ID for the search parameter.
 
         Raises:
+            ValueError: If no exact match for the keywords is found.
             httpx.HTTPError: If the API request fails.
-            ValueError: If the category is empty.
-
-        Tags:
-            linkedin, search, people, companies, posts, jobs, api, important
         """
-        if not category:
-            raise ValueError("Category cannot be empty.")
-
-        url = f"{self.base_url}/api/v1/linkedin/search"
-
-        params: dict[str, Any] = {"account_id": self.account_id}
-        if cursor:
-            params["cursor"] = cursor
-        if limit is not None:
-            params["limit"] = limit
-
-        payload: dict[str, Any] = {"api": "classic", "category": category}
-
-        if keywords:
-            payload["keywords"] = keywords
-
-        if category == "posts":
-            if date_posted:
-                payload["date_posted"] = date_posted
-            if sort_by:
-                payload["sort_by"] = sort_by
-
-        elif category == "jobs":
-            payload["minimum_salary"] = {
-                "currency": "USD",
-                "value": minimum_salary_value,
-            }
-            if sort_by:
-                payload["sort_by"] = sort_by
-
-        response = self._post(url, params=params, data=payload)
-        return self._handle_response(response)
-
-    def linkedin_list_profile_posts(
-        self,
-        identifier: str,  # User or Company provider internal ID
-        cursor: str | None = None,
-        limit: int | None = None,  # 1-100 (spec says max 250)
-        is_company: bool | None = None,
+        url = f"{self.base_url}/api/v1/linkedin/search/parameters"
+        params = {"account_id": self.account_id, "keywords": keywords, "type": param_type}
+        response = self._get(url, params=params)
+        results = self._handle_response(response)
+        items = results.get("items", [])
+        if items:
+            return items[0]["id"]
+        raise ValueError(f'Could not find a matching ID for {param_type}: "{keywords}"')
+
+    async def linkedin_list_profile_posts(
+        self, identifier: str, cursor: str | None = None, limit: int | None = None, is_company: bool | None = None
     ) -> dict[str, Any]:
         """
-        Retrieves a paginated list of posts from a specific user or company profile using their provider ID. An authorizing `account_id` is required, and the `is_company` flag must specify the entity type, distinguishing this from `retrieve_post` which fetches a single post by its own ID.
+        Fetches a paginated list of posts from a specific user or company profile using its provider ID. The `is_company` flag must specify the entity type. Unlike `linkedin_search_posts`, this function directly retrieves content from a known profile's feed instead of performing a global keyword search.
 
         Args:
             identifier: The entity's provider internal ID (LinkedIn ID).
@@ -171,13 +106,12 @@ class ScraperApp(APIApplication):
             params["limit"] = limit
         if is_company is not None:
             params["is_company"] = is_company
-
         response = self._get(url, params=params)
         return response.json()
 
-    def linkedin_retrieve_profile(self, identifier: str) -> dict[str, Any]:
+    async def linkedin_retrieve_profile(self, identifier: str) -> dict[str, Any]:
         """
-        Retrieves a specific LinkedIn user's profile using their public or internal ID. Unlike `retrieve_own_profile`, which fetches the authenticated user's details, this function targets and returns data for any specified third-party user profile on the platform.
+        Fetches a specific LinkedIn user's profile using their public or internal ID. Unlike `linkedin_search_people`, which discovers multiple users via keywords, this function targets and retrieves detailed data for a single, known individual based on a direct identifier.
 
         Args:
             identifier: Can be the provider's internal id OR the provider's public id of the requested user.For example, for https://www.linkedin.com/in/manojbajaj95/, the identifier is "manojbajaj95".
@@ -196,15 +130,11 @@ class ScraperApp(APIApplication):
         response = self._get(url, params=params)
         return self._handle_response(response)
 
-    def linkedin_list_post_comments(
-        self,
-        post_id: str,
-        comment_id: str | None = None,
-        cursor: str | None = None,
-        limit: int | None = None,
+    async def linkedin_list_post_comments(
+        self, post_id: str, comment_id: str | None = None, cursor: str | None = None, limit: int | None = None
     ) -> dict[str, Any]:
         """
-        Fetches comments for a specific post. Providing an optional `comment_id` retrieves threaded replies instead of top-level comments. This read-only operation contrasts with `create_post_comment`, which publishes new comments, and `list_content_reactions`, which retrieves 'likes'.
+        Fetches a paginated list of comments for a specified LinkedIn post. It can retrieve either top-level comments or threaded replies if an optional `comment_id` is provided. This is a read-only operation, distinct from functions that search for posts or list user-specific content.
 
         Args:
             post_id: The social ID of the post.
@@ -229,10 +159,191 @@ class ScraperApp(APIApplication):
             params["limit"] = str(limit)
         if comment_id:
             params["comment_id"] = comment_id
-
         response = self._get(url, params=params)
         return response.json()
 
+    async def linkedin_search_people(
+        self,
+        cursor: str | None = None,
+        limit: int | None = None,
+        keywords: str | None = None,
+        location: str | None = None,
+        industry: str | None = None,
+        company: str | None = None,
+    ) -> dict[str, Any]:
+        """
+        Performs a paginated search for people on LinkedIn, distinct from searches for companies or jobs. It filters results using keywords, location, industry, and company, internally converting filter names like 'United States' into their required API IDs before making the request.
+
+        Args:
+            cursor: Pagination cursor for the next page of entries.
+            limit: Number of items to return (up to 50 for Classic search).
+            keywords: Keywords to search for.
+            location: The geographical location to filter people by (e.g., "United States").
+            industry: The industry to filter people by.(e.g., "Software Development".)
+            company: The company to filter people by.(e.g., "Google".)
+
+        Returns:
+            A dictionary containing search results and pagination details.
+
+        Raises:
+            httpx.HTTPError: If the API request fails.
+        """
+        url = f"{self.base_url}/api/v1/linkedin/search"
+        params: dict[str, Any] = {"account_id": self.account_id}
+        if cursor:
+            params["cursor"] = cursor
+        if limit is not None:
+            params["limit"] = limit
+        payload: dict[str, Any] = {"api": "classic", "category": "people"}
+        if keywords:
+            payload["keywords"] = keywords
+        if location:
+            location_id = self._get_search_parameter_id("LOCATION", location)
+            payload["location"] = [location_id]
+        if industry:
+            industry_id = self._get_search_parameter_id("INDUSTRY", industry)
+            payload["industry"] = [industry_id]
+        if company:
+            company_id = self._get_search_parameter_id("COMPANY", company)
+            payload["company"] = [company_id]
+        response = self._post(url, params=params, data=payload)
+        return self._handle_response(response)
+
+    async def linkedin_search_companies(
+        self,
+        cursor: str | None = None,
+        limit: int | None = None,
+        keywords: str | None = None,
+        location: str | None = None,
+        industry: str | None = None,
+    ) -> dict[str, Any]:
+        """
+        Executes a paginated LinkedIn search for companies, filtering by optional keywords, location, and industry. Unlike `linkedin_search_people` or `linkedin_search_jobs`, this function specifically sets the API search category to 'companies' to ensure that only company profiles are returned in the search results.
+
+        Args:
+            cursor: Pagination cursor for the next page of entries.
+            limit: Number of items to return (up to 50 for Classic search).
+            keywords: Keywords to search for.
+            location: The geographical location to filter companies by (e.g., "United States").
+            industry: The industry to filter companies by.(e.g., "Software Development".)
+
+        Returns:
+            A dictionary containing search results and pagination details.
+
+        Raises:
+            httpx.HTTPError: If the API request fails.
+        """
+        url = f"{self.base_url}/api/v1/linkedin/search"
+        params: dict[str, Any] = {"account_id": self.account_id}
+        if cursor:
+            params["cursor"] = cursor
+        if limit is not None:
+            params["limit"] = limit
+        payload: dict[str, Any] = {"api": "classic", "category": "companies"}
+        if keywords:
+            payload["keywords"] = keywords
+        if location:
+            location_id = self._get_search_parameter_id("LOCATION", location)
+            payload["location"] = [location_id]
+        if industry:
+            industry_id = self._get_search_parameter_id("INDUSTRY", industry)
+            payload["industry"] = [industry_id]
+        response = self._post(url, params=params, data=payload)
+        return self._handle_response(response)
+
+    async def linkedin_search_posts(
+        self,
+        cursor: str | None = None,
+        limit: int | None = None,
+        keywords: str | None = None,
+        date_posted: Literal["past_day", "past_week", "past_month"] | None = None,
+        sort_by: Literal["relevance", "date"] = "relevance",
+    ) -> dict[str, Any]:
+        """
+        Performs a keyword-based search for LinkedIn posts, allowing results to be filtered by date and sorted by relevance. This function specifically queries the 'posts' category, distinguishing it from other search methods in the class that target people, companies, or jobs, and returns relevant content.
+
+        Args:
+            cursor: Pagination cursor for the next page of entries.
+            limit: Number of items to return (up to 50 for Classic search).
+            keywords: Keywords to search for.
+            date_posted: Filter by when the post was posted.
+            sort_by: How to sort the results.
+
+        Returns:
+            A dictionary containing search results and pagination details.
+
+        Raises:
+            httpx.HTTPError: If the API request fails.
+        """
+        url = f"{self.base_url}/api/v1/linkedin/search"
+        params: dict[str, Any] = {"account_id": self.account_id}
+        if cursor:
+            params["cursor"] = cursor
+        if limit is not None:
+            params["limit"] = limit
+        payload: dict[str, Any] = {"api": "classic", "category": "posts"}
+        if keywords:
+            payload["keywords"] = keywords
+        if date_posted:
+            payload["date_posted"] = date_posted
+        if sort_by:
+            payload["sort_by"] = sort_by
+        response = self._post(url, params=params, data=payload)
+        return self._handle_response(response)
+
+    async def linkedin_search_jobs(
+        self,
+        cursor: str | None = None,
+        limit: int | None = None,
+        keywords: str | None = None,
+        region: str | None = None,
+        sort_by: Literal["relevance", "date"] = "relevance",
+        minimum_salary_value: int = 40,
+        industry: str | None = None,
+    ) -> dict[str, Any]:
+        """
+        Executes a LinkedIn search specifically for job listings using keywords and filters like region, industry, and minimum salary. Unlike other search functions targeting people or companies, this is specialized for job listings and converts friendly filter names (e.g., "United States") into their required API IDs.
+
+        Args:
+            cursor: Pagination cursor for the next page of entries.
+            limit: Number of items to return (up to 50 for Classic search).
+            keywords: Keywords to search for.
+            region: The geographical region to filter jobs by (e.g., "United States").
+            sort_by: How to sort the results.(e.g., "relevance" or "date".)
+            minimum_salary_value: The minimum salary to filter for.
+            industry: The industry to filter jobs by. (e.g., "Software Development".)
+
+        Returns:
+            A dictionary containing search results and pagination details.
+
+        Raises:
+            httpx.HTTPError: If the API request fails.
+            ValueError: If the specified location is not found.
+        """
+        url = f"{self.base_url}/api/v1/linkedin/search"
+        params: dict[str, Any] = {"account_id": self.account_id}
+        if cursor:
+            params["cursor"] = cursor
+        if limit is not None:
+            params["limit"] = limit
+        payload: dict[str, Any] = {
+            "api": "classic",
+            "category": "jobs",
+            "minimum_salary": {"currency": "USD", "value": minimum_salary_value},
+        }
+        if keywords:
+            payload["keywords"] = keywords
+        if sort_by:
+            payload["sort_by"] = sort_by
+        if region:
+            location_id = self._get_search_parameter_id("LOCATION", region)
+            payload["region"] = location_id
+        if industry:
+            industry_id = self._get_search_parameter_id("INDUSTRY", industry)
+            payload["industry"] = [industry_id]
+        response = self._post(url, params=params, data=payload)
+        return self._handle_response(response)
+
     def list_tools(self):
         """
         Returns a list of available tools/functions in this application.
@@ -241,8 +352,11 @@ class ScraperApp(APIApplication):
             A list of functions that can be used as tools.
         """
         return [
-            self.linkedin_search,
             self.linkedin_list_profile_posts,
             self.linkedin_retrieve_profile,
             self.linkedin_list_post_comments,
+            self.linkedin_search_people,
+            self.linkedin_search_companies,
+            self.linkedin_search_posts,
+            self.linkedin_search_jobs,
         ]

universal_mcp/applications/semanticscholar/app.py

@@ -1,5 +1,4 @@
 from typing import Any
-
 from universal_mcp.applications.application import APIApplication
 from universal_mcp.integrations import Integration
 
@@ -9,7 +8,7 @@ class SemanticscholarApp(APIApplication):
         super().__init__(name="semanticscholar", integration=integration, **kwargs)
         self.base_url = "/graph/v1"
 
-    def post_graph_get_authors(self, fields=None, ids=None) -> dict[str, Any]:
+    async def post_graph_get_authors(self, fields=None, ids=None) -> dict[str, Any]:
         """
         Creates a batch of authors using the provided JSON data in the request body, optionally specifying fields to include in the response via a query parameter.
 
@@ -23,9 +22,7 @@ class SemanticscholarApp(APIApplication):
         Tags:
             Author Data
         """
-        request_body = {
-            "ids": ids,
-        }
+        request_body = {"ids": ids}
         request_body = {k: v for k, v in request_body.items() if v is not None}
         url = f"{self.base_url}/author/batch"
         query_params = {k: v for k, v in [("fields", fields)] if v is not None}
@@ -33,9 +30,7 @@ class SemanticscholarApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def get_graph_get_author_search(
-        self, query, offset=None, limit=None, fields=None
-    ) -> dict[str, Any]:
+    async def get_graph_get_author_search(self, query, offset=None, limit=None, fields=None) -> dict[str, Any]:
         """
         Searches for authors based on a query string with optional pagination and field selection parameters.
 
@@ -52,21 +47,12 @@ class SemanticscholarApp(APIApplication):
             Author Data
         """
         url = f"{self.base_url}/author/search"
-        query_params = {
-            k: v
-            for k, v in [
-                ("offset", offset),
-                ("limit", limit),
-                ("fields", fields),
-                ("query", query),
-            ]
-            if v is not None
-        }
+        query_params = {k: v for k, v in [("offset", offset), ("limit", limit), ("fields", fields), ("query", query)] if v is not None}
         response = self._get(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def get_graph_get_author(self, author_id, fields=None) -> dict[str, Any]:
+    async def get_graph_get_author(self, author_id, fields=None) -> dict[str, Any]:
         """
         Retrieves the profile information for a specific author identified by the `author_id` and returns it with optional fields specified in the `fields` query parameter.
 
@@ -88,9 +74,7 @@ class SemanticscholarApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def get_graph_get_author_papers(
-        self, author_id, offset=None, limit=None, fields=None
-    ) -> dict[str, Any]:
+    async def get_graph_get_author_papers(self, author_id, offset=None, limit=None, fields=None) -> dict[str, Any]:
         """
         Retrieves a paginated list of papers authored by the specified author, with optional field selection.
 
@@ -109,16 +93,12 @@ class SemanticscholarApp(APIApplication):
         if author_id is None:
             raise ValueError("Missing required parameter 'author_id'")
         url = f"{self.base_url}/author/{author_id}/papers"
-        query_params = {
-            k: v
-            for k, v in [("offset", offset), ("limit", limit), ("fields", fields)]
-            if v is not None
-        }
+        query_params = {k: v for k, v in [("offset", offset), ("limit", limit), ("fields", fields)] if v is not None}
         response = self._get(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def get_graph_get_paper_autocomplete(self, query) -> dict[str, Any]:
+    async def get_graph_get_paper_autocomplete(self, query) -> dict[str, Any]:
         """
         Provides an autocomplete suggestion list based on a required query string parameter.
 
@@ -137,7 +117,7 @@ class SemanticscholarApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def post_graph_get_papers(self, fields=None, ids=None) -> dict[str, Any]:
+    async def post_graph_get_papers(self, fields=None, ids=None) -> dict[str, Any]:
         """
         Creates a batch of papers using JSON data in the request body and optionally specifies fields to include in the response.
 
@@ -151,9 +131,7 @@ class SemanticscholarApp(APIApplication):
         Tags:
             Paper Data
         """
-        request_body = {
-            "ids": ids,
-        }
+        request_body = {"ids": ids}
         request_body = {k: v for k, v in request_body.items() if v is not None}
         url = f"{self.base_url}/paper/batch"
         query_params = {k: v for k, v in [("fields", fields)] if v is not None}
@@ -161,7 +139,7 @@ class SemanticscholarApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def get_graph_paper_relevance_search(
+    async def get_graph_paper_relevance_search(
         self,
         query,
         fields=None,
@@ -219,7 +197,7 @@ class SemanticscholarApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def get_graph_paper_bulk_search(
+    async def get_graph_paper_bulk_search(
         self,
         query,
         token=None,
@@ -277,7 +255,7 @@ class SemanticscholarApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def get_graph_paper_title_search(
+    async def get_graph_paper_title_search(
         self,
         query,
         fields=None,
@@ -329,7 +307,7 @@ class SemanticscholarApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def get_graph_get_paper(self, paper_id, fields=None) -> dict[str, Any]:
+    async def get_graph_get_paper(self, paper_id, fields=None) -> dict[str, Any]:
         """
         Retrieves details of a paper by its ID, optionally specifying fields to include in the response.
 
@@ -351,9 +329,7 @@ class SemanticscholarApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def get_graph_get_paper_authors(
-        self, paper_id, offset=None, limit=None, fields=None
-    ) -> dict[str, Any]:
+    async def get_graph_get_paper_authors(self, paper_id, offset=None, limit=None, fields=None) -> dict[str, Any]:
         """
         Retrieves a list of authors for a specific paper identified by the `paper_id`, allowing optional parameters for offset, limit, and fields to customize the response.
 
@@ -372,18 +348,12 @@ class SemanticscholarApp(APIApplication):
         if paper_id is None:
             raise ValueError("Missing required parameter 'paper_id'")
         url = f"{self.base_url}/paper/{paper_id}/authors"
-        query_params = {
-            k: v
-            for k, v in [("offset", offset), ("limit", limit), ("fields", fields)]
-            if v is not None
-        }
+        query_params = {k: v for k, v in [("offset", offset), ("limit", limit), ("fields", fields)] if v is not None}
         response = self._get(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def get_graph_get_paper_citations(
-        self, paper_id, offset=None, limit=None, fields=None
-    ) -> dict[str, Any]:
+    async def get_graph_get_paper_citations(self, paper_id, offset=None, limit=None, fields=None) -> dict[str, Any]:
         """
         Retrieves a list of citations for a specific paper, identified by its paper ID, with optional parameters for offset, limit, and fields.
 
@@ -402,18 +372,12 @@ class SemanticscholarApp(APIApplication):
         if paper_id is None:
             raise ValueError("Missing required parameter 'paper_id'")
         url = f"{self.base_url}/paper/{paper_id}/citations"
-        query_params = {
-            k: v
-            for k, v in [("offset", offset), ("limit", limit), ("fields", fields)]
-            if v is not None
-        }
+        query_params = {k: v for k, v in [("offset", offset), ("limit", limit), ("fields", fields)] if v is not None}
         response = self._get(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def get_graph_get_paper_references(
-        self, paper_id, offset=None, limit=None, fields=None
-    ) -> dict[str, Any]:
+    async def get_graph_get_paper_references(self, paper_id, offset=None, limit=None, fields=None) -> dict[str, Any]:
         """
         Retrieves references for a specific paper by its ID using the "GET" method and allows optional filtering by offset, limit, and fields for customizable output.
 
@@ -432,16 +396,12 @@ class SemanticscholarApp(APIApplication):
         if paper_id is None:
             raise ValueError("Missing required parameter 'paper_id'")
         url = f"{self.base_url}/paper/{paper_id}/references"
-        query_params = {
-            k: v
-            for k, v in [("offset", offset), ("limit", limit), ("fields", fields)]
-            if v is not None
-        }
+        query_params = {k: v for k, v in [("offset", offset), ("limit", limit), ("fields", fields)] if v is not None}
         response = self._get(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def get_snippet_search(self, query, limit=None) -> dict[str, Any]:
+    async def get_snippet_search(self, query, limit=None) -> dict[str, Any]:
         """
         Retrieves a list of search results based on a specified query string, optionally limited by a user-defined number of results, using the "GET" method at the "/snippet/search" endpoint.
 
@@ -456,9 +416,7 @@ class SemanticscholarApp(APIApplication):
             Snippet Text
         """
         url = f"{self.base_url}/snippet/search"
-        query_params = {
-            k: v for k, v in [("query", query), ("limit", limit)] if v is not None
-        }
+        query_params = {k: v for k, v in [("query", query), ("limit", limit)] if v is not None}
         response = self._get(url, params=query_params)
         response.raise_for_status()
         return response.json()