Spaces:
Runtime error
Runtime error
File size: 9,395 Bytes
e67043b |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 |
import requests
import json
from datetime import date, datetime, timedelta
import os
from ..tool import Tool
from typing import Optional, List, Dict, Any
from serpapi import GoogleSearch
def build_tool(config) -> Tool:
tool = Tool(
"Google Scholar Info",
"Look up google scholar information",
name_for_model="Google_Scholar",
description_for_model="Plugin for look up Google Scholar information",
logo_url="https://your-app-url.com/.well-known/logo.png",
contact_email="[email protected]",
legal_info_url="[email protected]",
)
KEY = config["subscription_key"]
@tool.get("/search_google_scholar")
def search_google_scholar(
query: str,
engine: str = "google_scholar",
cites: Optional[str] = None,
as_ylo: Optional[int] = None,
as_yhi: Optional[int] = None,
scisbd: Optional[int] = None,
cluster: Optional[str] = None,
hl: Optional[str] = None,
lr: Optional[str] = None,
start: Optional[int] = None,
num: Optional[int] = None,
as_sdt: Optional[str] = None,
safe: Optional[str] = None,
filter: Optional[str] = None,
as_vis: Optional[str] = None,
):
"""
Search for scholarly articles based on a query according to the google scholar
:param query: The query to search for.
:param engine: The search engine to use, default is "google_scholar"
:param cites: The unique ID of an article for triggering "Cited By" searches
:param as_ylo: The starting year for results (e.g., if as_ylo=2018, results before this year will be omitted)
:param as_yhi: The ending year for results (e.g., if as_yhi=2018, results after this year will be omitted)
:param scisbd: Defines articles added in the last year, sorted by date. It can be set to 1 to include only abstracts, or 2 to include everything
:param cluster: The unique ID of an article for triggering "All Versions" searches
:param hl: The language to use for the Google Scholar search
:param lr: One or multiple languages to limit the search to
:param start: The result offset for pagination (0 is the first page of results, 10 is the 2nd page, etc.)
:param num: The maximum number of results to return, limited to 20
:param as_sdt: Can be used either as a search type or a filter
:param safe: The level of filtering for adult content
:param filter: Defines if the filters for 'Similar Results' and 'Omitted Results' are on or off
:param as_vis: Defines whether to include citations or not
:return: Return a list of dictionaries of the papers
"""
params = {
"q": query,
"engine": engine,
"api_key": KEY,
"cites": cites,
"as_ylo": as_ylo,
"as_yhi": as_yhi,
"scisbd": scisbd,
"cluster": cluster,
"hl": hl,
"lr": lr,
"start": start,
"num": num,
"as_sdt": as_sdt,
"safe": safe,
"filter": filter,
"as_vis": as_vis,
}
search = GoogleSearch(params)
results = search.get_dict()
organic_results = results["organic_results"]
return organic_results
@tool.get("/search_author")
def search_author(
author_id: str,
hl: Optional[str] = None,
view_op: Optional[str] = None,
sort: Optional[str] = None,
citation_id: Optional[str] = None,
start: Optional[int] = None,
num: Optional[int] = None,
no_cache: Optional[bool] = None,
async_req: Optional[bool] = None,
output: Optional[str] = None,
):
"""
Search for an author using the Google Scholar Author API.
:param author_id: Required. The ID of an author.
:param hl: Optional. The language to use for the Google Scholar Author search. Default is 'en'.
:param view_op: Optional. Used for viewing specific parts of a page.
:param sort: Optional. Used for sorting and refining articles.
:param citation_id: Optional. Used for retrieving individual article citation.
:param start: Optional. Defines the result offset. Default is 0.
:param num: Optional. Defines the number of results to return. Default is 20.
:param no_cache: Optional. Forces SerpApi to fetch the results even if a cached version is already present. Default is False.
:param async_req: Optional. Defines the way you want to submit your search to SerpApi. Default is False.
:param output: Optional. Defines the final output you want. Default is 'json'.
:return: Returns the search results of the author basic information.
"""
params = {
"engine": "google_scholar_author",
"author_id": author_id,
"api_key": KEY,
"hl": hl,
"view_op": view_op,
"sort": sort,
"citation_id": citation_id,
"start": start,
"num": num,
"no_cache": no_cache,
"async": async_req,
"output": output,
}
search = GoogleSearch(params)
results = search.get_dict()
author = results["author"]
return author
@tool.get("/get_citation")
def get_citation(
q: str,
no_cache: Optional[bool] = None,
async_: Optional[bool] = None,
output: Optional[str] = "json",
) -> Dict[str, Any]:
"""
Function to get citation results from the Google Scholar organic results using the Google Scholar Cite API.
Parameters:
q (str): ID of an individual Google Scholar organic search result.
engine (str, optional): Set to 'google_scholar_cite' to use the Google Scholar API engine. Defaults to 'google_scholar_cite'.
no_cache (bool, optional): If set to True, will force SerpApi to fetch the Google Scholar Cite results even if a cached version is already present. Defaults to None.
async_ (bool, optional): If set to True, will submit search to SerpApi and retrieve results later. Defaults to None.
api_key (str): SerpApi private key to use.
output (str, optional): Final output format. Set to 'json' to get a structured JSON of the results, or 'html' to get the raw html retrieved. Defaults to 'json'.
Returns:
Dict[str, Any]: Returns the search results in the specified format.
"""
params = {
"q": q,
"engine": "google_scholar_cite",
"no_cache": no_cache,
"async": async_,
"api_key": KEY,
"output": output,
}
search = GoogleSearch(params)
results = search.get_dict()
citation = results["citations"]
return citation
@tool.get("/get_profile")
def get_profile(
self,
mauthors: str,
hl: Optional[str] = "en",
after_author: Optional[str] = None,
before_author: Optional[str] = None,
no_cache: Optional[bool] = False,
_async: Optional[bool] = False,
output: Optional[str] = "json",
) -> Dict:
"""
The getProfile function is used to scrape profile results from the Google Scholar Profiles search page.
Args:
mauthors (str): Defines the author you want to search for.
hl (str, optional): Defines the language to use for the Google Scholar Profiles search.
It's a two-letter language code. (e.g., 'en' for English, 'es' for Spanish, or 'fr' for French).
Defaults to 'en'.
after_author (str, optional): Defines the next page token.
It is used for retrieving the next page results.
The parameter has the precedence over before_author parameter. Defaults to None.
before_author (str, optional): Defines the previous page token.
It is used for retrieving the previous page results. Defaults to None.
no_cache (bool, optional): Will force SerpApi to fetch the Google Scholar Profiles results even if a cached version is already present.
Defaults to False.
_async (bool, optional): Defines the way you want to submit your search to SerpApi. Defaults to False.
api_key (str): Defines the SerpApi private key to use.
output (str, optional): Defines the final output you want.
It can be set to 'json' (default) to get a structured JSON of the results,
or 'html' to get the raw html retrieved. Defaults to 'json'.
Returns:
Dict: The Google Scholar Profiles search results.
"""
params = {
"mauthors": mauthors,
"engine": "google_scholar_profiles",
"hl": hl,
"after_author": after_author,
"before_author": before_author,
"engine": "google_scholar_profiles",
"no_cache": no_cache,
"async": _async,
"api_key": KEY,
"output": output,
}
search = GoogleSearch(params)
results = search.get_dict()
profile = results["profiles"]
return profile
return tool
|