Upload folder using huggingface_hub (part 11)

.gitattributes

@@ -63,3 +63,4 @@ tau2/domains/telecom/tasks.json filter=lfs diff=lfs merge=lfs -text
 tau2/domains/telecom/tasks_full.json filter=lfs diff=lfs merge=lfs -text
 tau2/domains/telecom/tasks_voice.json filter=lfs diff=lfs merge=lfs -text
 toolbench/toolenv/tools/Business/ziff.json filter=lfs diff=lfs merge=lfs -text
+toolbench/toolenv/tools/Data/twitter_data.json filter=lfs diff=lfs merge=lfs -text

toolbench/toolenv/tools/Data/railway_periods.json

@@ -0,0 +1,53 @@
+{
+    "tool_name":"Railway Periods",
+    "tool_description":"An API to calculate the railway period of a UTC date in milliseconds since epoch (Unix timestamp).",
+    "title":"Railway Periods",
+    "pricing":"FREEMIUM",
+    "score":{
+        "avgServiceLevel":100,
+        "avgLatency":5504,
+        "avgSuccessRate":100,
+        "popularityScore":8.1,
+        "__typename":"Score"
+    },
+    "home_url":"https://rapidapi.com/GavinBeattie/api/railway-periods/",
+    "host":"railway-periods.p.rapidapi.com",
+    "api_list":[
+        {
+            "name":"Get Railway Period for UTC date",
+            "url":"https://railway-periods.p.rapidapi.com/millis/{millis}",
+            "description":"This endpoint will return railway period between:\n{\"millis\":\"0\",\"railwayPeriod\":\"1969-1970 P10\"} (01/01/1970 00:00:00)\nAnd\n{\"millis\":\"8640000000000\",\"railwayPeriod\":\"2243-2244 P8\"} (17/10/2243 00:00:00)",
+            "method":"GET",
+            "required_parameters":[
+                {
+                    "name":"millis",
+                    "type":"NUMBER",
+                    "description":"",
+                    "default":"1654470000000"
+                }
+            ],
+            "optional_parameters":[],
+            "code":"import requests\n\nurl = \"https://railway-periods.p.rapidapi.com/millis/{millis}\"\n\nheaders = {\n    \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n    \"X-RapidAPI-Host\": \"railway-periods.p.rapidapi.com\"\n}\n\nresponse = requests.get(url, headers=headers)\n\nprint(response.json())\n",
+            "statuscode":200,
+            "body":{
+                "millis":"1654470000000",
+                "railwayPeriod":"2022-2023 P3"
+            },
+            "headers":{
+                "access-control-allow-credentials":"true",
+                "access-control-allow-origin":"*",
+                "connection":"keep-alive",
+                "content-length":"57",
+                "content-type":"application/json; charset=utf-8",
+                "date":"Mon, 06 Jun 2022 22:57:23 GMT",
+                "etag":"W/\"39-l5YFPg0nB2pL6zJIKN+eUHR0T2Q\"",
+                "server":"RapidAPI-1.2.8",
+                "via":"1.1 vegur",
+                "x-powered-by":"Express",
+                "x-rapidapi-region":"AWS - eu-west-1",
+                "x-rapidapi-version":"1.2.8"
+            },
+            "schema":{}
+        }
+    ]
+}

toolbench/toolenv/tools/Data/railway_periods/api.py

@@ -0,0 +1,32 @@
+import requests
+import json
+from datetime import date, datetime, timedelta
+import os
+
+from typing import Optional, Dict, Union, List
+
+
+def get_railway_period_for_utc_date(millis: int, toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "This endpoint will return railway period between:
+		{"millis":"0","railwayPeriod":"1969-1970 P10"} (01/01/1970 00:00:00)
+		And
+		{"millis":"8640000000000","railwayPeriod":"2243-2244 P8"} (17/10/2243 00:00:00)"
+    
+    """
+    url = f"https://railway-periods.p.rapidapi.com/millis/{millis}"
+    querystring = {}
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "railway-periods.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+

toolbench/toolenv/tools/Data/rainforest/api.py

@@ -0,0 +1,1352 @@
+import requests
+import json
+from datetime import date, datetime, timedelta
+import os
+
+from typing import Optional, Dict, Union, List
+
+
+def author_page(type: str, url: str=None, format_id: str=None, amazon_domain: str='amazon.com', asin: str='B000APVZ7W', page: int=None, sort_by: str=None, customer_location: str=None, toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "The Author Page Parameters are applicable when making a request with type=author_page to retrieve data from the authors page single author on Amazon - the author is specified using either the author asin and amazon_domain parameters or the url parameter (where the url parameter contains a link to an Amazon authors page). The parameters should be appended as querystring parameters to the Product Data API GET HTTP request.
+		
+		Author Page data is retrieved from the author page for a single author on Amazon."
+    url: 
+The Amazon author page URL to retrieve data from.
+
+Note: If the url parameter is supplied then the amazon_domain and asin parameters are ignored.
+        format_id: 
+A format ID to determine the format of author titles returned in the titles array. Format ID's are returned in the format_ids array in each type=author_page results (this is necessary are the format_id value is dynamic and can change over time).
+        amazon_domain: The Amazon domain to retrieve author page data for the author specified in the asin parameter. For a full list of supported Amazon domains see Supported Amazon Domains.
+
+Note: If the amazon_domain and asin parameters are supplied then the url parameter is ignored.
+        asin: 
+The Amazon author ASIN to retrieve author page data for. Used in combination with the amazon_domain parameter.
+
+Note: If the asin and amazon_domain parameters are supplied then the url parameter is ignored.
+        page: The current page of search results to retrieve. Inspect the pagination.total_pages property in the Search results to see how many pages of search results are available.
+
+update value of num to get additional pages
+        sort_by: Determines the sort order of author titles array that is returned. Valid values are:
+popularity
+Sort the author titles array by most popular first.
+price_low_to_high
+Sort the author titles array by lowest price first.
+price_high_to_low
+Sort the author titles array by highest price first.
+average_review
+Sort the author titles array by highest average review first.
+publication_date
+Sort the author titles array by most recent publication date first.
+most_reviews
+Sort the author titles array by those with the most reviews first.
+
+        customer_location: Rainforest API supports retrieving data from the following Customer Locations.
+
+The Customer Locations is specified via the customer_location request parameter.
+
+The Customer Location determines the location that Rainforest uses when retrieving pages from Amazon. This is useful, for example, for seeing details of how a product appears on amazon.com, to a customer located in a different country. Can be used to identify cross-border shipping data and opportunities.
+
+If no value for customer_location is supplied then Rainforest defaults to making the request from the country of the Amazon page requested - i.e. \"France\" for requests for pages from \"amazon.fr\".
+
+The table below shows which customer_location values can be used in combination with requests to which amazon_domains. If you require another Amazon domain / customer location combination please contact our support team.
+
+See the Request Parameters documentation for more information.
+        
+    """
+    url = f"https://rainforest2.p.rapidapi.com/request"
+    querystring = {'type': type, }
+    if url:
+        querystring['url'] = url
+    if format_id:
+        querystring['format_id'] = format_id
+    if amazon_domain:
+        querystring['amazon_domain'] = amazon_domain
+    if asin:
+        querystring['asin'] = asin
+    if page:
+        querystring['page'] = page
+    if sort_by:
+        querystring['sort_by'] = sort_by
+    if customer_location:
+        querystring['customer_location'] = customer_location
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "rainforest2.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+
+def also_bought(type: str, url: str=None, asin: str='B084ZF5D65', amazon_domain: str='amazon.com', customer_location: str=None, toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "The Also Bought Parameters are applicable when making a request with type=also_bought to retrieve also bought details for a single product on Amazon - the product is specified using either the asin and amazon_domain parameters or the url parameter (where the url parameter contains a link to an Amazon product page). The parameters should be appended as querystring parameters to the Product Data APIGETHTTP request.
+		
+		Also bought details are retrieved from the product page for a single product on Amazon. An type=also_bought request will automatically paginate through all of the pages of also-bought data and return every also bought result."
+    url: The Amazon product page URL to retrieve also bought results from.
+
+        asin: The Amazon ASIN (product ID) to retrieve also bought details for. Used in combination with the amazon_domain parameter.
+
+Note: If the asin and amazon_domain parameters are supplied then the url parameter is ignored.
+        amazon_domain: 
+The Amazon domain to retrieve also bought details from for the product specified in the asin parameter. For a full list of supported Amazon domains see Supported Amazon Domains.
+
+Note: If the amazon_domain and asin parameters are supplied then the url parameter is ignored.
+        customer_location: Rainforest API supports retrieving data from the following Customer Locations.
+
+The Customer Locations is specified via the customer_location request parameter.
+
+The Customer Location determines the location that Rainforest uses when retrieving pages from Amazon. This is useful, for example, for seeing details of how a product appears on amazon.com, to a customer located in a different country. Can be used to identify cross-border shipping data and opportunities.
+
+If no value for customer_location is supplied then Rainforest defaults to making the request from the country of the Amazon page requested - i.e. \"France\" for requests for pages from \"amazon.fr\".
+
+The table below shows which customer_location values can be used in combination with requests to which amazon_domains. If you require another Amazon domain / customer location combination please contact our support team.
+
+See the Request Parameters documentation for more information.
+        
+    """
+    url = f"https://rainforest2.p.rapidapi.com/request"
+    querystring = {'type': type, }
+    if url:
+        querystring['url'] = url
+    if asin:
+        querystring['asin'] = asin
+    if amazon_domain:
+        querystring['amazon_domain'] = amazon_domain
+    if customer_location:
+        querystring['customer_location'] = customer_location
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "rainforest2.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+
+def offers(type: str, offers_prime: bool=None, offers_condition_used_very_good: bool=None, offers_condition_used_acceptable: bool=None, offers_condition_new: bool=None, url: str=None, page: int=None, offers_condition_used_like_new: bool=None, amazon_domain: str='amazon.com', asin: str='B073JYC4XM', gtin: str=None, offers_condition_used_good: bool=None, offers_free_shipping: bool=None, customer_location: str=None, show_different_asins: bool=None, toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "Offers are retrieved from the offers listing popup window for a single product on Amazon.
+		
+		The Offers Parameters are applicable when making a request with type=offers to retrieve seller Offers for a single product on Amazon - the product is specified using either the asin and amazon_domain parameters or the url parameter (where the url parameter contains a link to an Amazon product offers page). The parameters should be appended as querystring parameters to the Product Data APIGETHTTP request."
+    offers_prime: 
+Limit the offers returned to just those that are Prime-eligible. Valid values are:
+true
+Only include offers that are Prime-eligible.
+false
+Include all offers, regardless of whether they are Prime-eligible or not.
+        page: The current page of search results to retrieve. Inspect the pagination.total_pages property in the Search results to see how many pages of search results are available.
+
+update value of num to get additional pages
+        amazon_domain: The Amazon domain to retrieve Offers for the product specified in the asin parameter from. For a full list of supported Amazon domains see [Supported Amazon Domains.](https://www.rainforestapi.com/docs/product-data-api/reference/amazon-domains)
+
+**Note: If the amazon_domain and asin parameters are supplied then the url parameter is ignored.**
+        asin: The Amazon ASIN (product ID) to retrieve Offers for. Used in combination with the amazon_domain parameter.
+
+**Note: If the asin and amazon_domain parameters are supplied then the url parameter is ignored.**
+        gtin: A GTIN, ISBN, UPC or EAN code to retrieve results for. Internally Rainforest will first convert the GTIN/ISBN/UPC/EAN to an Amazon ASIN, then retrieve the results for that ASIN from Amazon. Used in combination with the amazon_domain parameter.
+
+Note: If the gtin and amazon_domain parameters are supplied then the url parameter is ignored.
+        offers_free_shipping: 
+Limit the offers returned to just those that have Free Shipping. Valid values are:
+true
+Only include offers that have Free Shipping.
+false
+Include all offers, regardless of whether they have Free Shipping or not.
+        customer_location: Rainforest API supports retrieving data from the following Customer Locations.
+
+The Customer Locations is specified via the customer_location request parameter.
+
+The Customer Location determines the location that Rainforest uses when retrieving pages from Amazon. This is useful, for example, for seeing details of how a product appears on amazon.com, to a customer located in a different country. Can be used to identify cross-border shipping data and opportunities.
+
+If no value for customer_location is supplied then Rainforest defaults to making the request from the country of the Amazon page requested - i.e. `France` for requests for pages from `amazon.fr`
+
+The table below shows which customer_location values can be used in combination with requests to which amazon_domains. If you require another Amazon domain / customer location combination please contact our support team.
+
+See the Request Parameters documentation for more information.
+        show_different_asins: Sometimes Amazon will return Offers from ASINs other than the ASIN supplied in the asin request parameter (for example, when the original ASIN is out of stock). show_different_asins controls whether you want these other-ASIN offer results returned, or not. Can be set to true to include offers from other ASINs, or false (the default) to hide offers from ASINs other than the ASIN supplied in the asin parameter. Note that if you supply a url instead of asin in your request this parameter is ignored.
+        
+    """
+    url = f"https://rainforest2.p.rapidapi.com/request"
+    querystring = {'type': type, }
+    if offers_prime:
+        querystring['offers_prime'] = offers_prime
+    if offers_condition_used_very_good:
+        querystring['offers_condition_used_very_good'] = offers_condition_used_very_good
+    if offers_condition_used_acceptable:
+        querystring['offers_condition_used_acceptable'] = offers_condition_used_acceptable
+    if offers_condition_new:
+        querystring['offers_condition_new'] = offers_condition_new
+    if url:
+        querystring['url'] = url
+    if page:
+        querystring['page'] = page
+    if offers_condition_used_like_new:
+        querystring['offers_condition_used_like_new'] = offers_condition_used_like_new
+    if amazon_domain:
+        querystring['amazon_domain'] = amazon_domain
+    if asin:
+        querystring['asin'] = asin
+    if gtin:
+        querystring['gtin'] = gtin
+    if offers_condition_used_good:
+        querystring['offers_condition_used_good'] = offers_condition_used_good
+    if offers_free_shipping:
+        querystring['offers_free_shipping'] = offers_free_shipping
+    if customer_location:
+        querystring['customer_location'] = customer_location
+    if show_different_asins:
+        querystring['show_different_asins'] = show_different_asins
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "rainforest2.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+
+def questions(type: str, asin: str='B073JYC4XM', sort_by: str=None, customer_location: str=None, amazon_domain: str='amazon.com', page: int=None, url: str=None, toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "The Questions Parameters are applicable when making a request with type=questions to retrieve customer Questions & Answers for a single product on Amazon - the product is specified using either the asin and amazon_domain parameters or the url parameter (where the url parameter contains a link to an Amazon product page). The parameters should be appended as querystring parameters to the Product Data APIGETHTTP request.
+		
+		Questions are retrieved from the customer questions page for a single product on Amazon"
+    asin: The Amazon ASIN (product ID) to retrieve Questions & Answers for. Used in combination with the amazon_domain parameter.
+
+**Note: If the asin and amazon_domain parameters are supplied then the url parameter is ignored.**
+        sort_by: Determines the sort order of Questions & Answers to return. Valid values are:
+
+most_helpful
+Returns Questions & Answers with the most helpful first.
+most_recent
+Returns Questions & Answers in date order, with the most recent first.
+
+        customer_location: Rainforest API supports retrieving data from the following Customer Locations.
+
+The Customer Locations is specified via the customer_location request parameter.
+
+The Customer Location determines the location that Rainforest uses when retrieving pages from Amazon. This is useful, for example, for seeing details of how a product appears on amazon.com, to a customer located in a different country. Can be used to identify cross-border shipping data and opportunities.
+
+If no value for customer_location is supplied then Rainforest defaults to making the request from the country of the Amazon page requested - i.e. \\\"France\\\" for requests for pages from \\\"amazon.fr\\\".
+
+The table below shows which customer_location values can be used in combination with requests to which amazon_domains. If you require another Amazon domain / customer location combination please contact our support team.
+
+See the Request Parameters documentation for more information.
+        amazon_domain: The Amazon domain to retrieve Questions & Answers for the product specified in the asin parameter from. For a full list of supported Amazon domains see Supported Amazon Domains.
+
+**Note: If the amazon_domain and asin parameters are supplied then the url parameter is ignored.**
+        page: The current page of search results to retrieve. Inspect the pagination.total_pages property in the Search results to see how many pages of search results are available.
+
+update value of num to get additional pages
+        url: The Amazon product-page URL to retrieve Questions & Answers from.
+
+**Note: If the url parameter is supplied then the amazon_domain and asin parameters are ignored.**
+        
+    """
+    url = f"https://rainforest2.p.rapidapi.com/request"
+    querystring = {'type': type, }
+    if asin:
+        querystring['asin'] = asin
+    if sort_by:
+        querystring['sort_by'] = sort_by
+    if customer_location:
+        querystring['customer_location'] = customer_location
+    if amazon_domain:
+        querystring['amazon_domain'] = amazon_domain
+    if page:
+        querystring['page'] = page
+    if url:
+        querystring['url'] = url
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "rainforest2.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+
+def deals(type: str, prime_eligible: bool=None, minimum_rating: str='1_and_up', deal_states: str=None, amazon_domain: str='amazon.com', category_id: str='2619525011', url: str=None, sort_by: str='price_high_to_low', deal_types: str='best_deal', toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "The Deals Parameters are applicable when making a request with type=deals to retrieve Lightning Deal / Daily Deals results for an Amazon lightning deals / daily deals / 'goldbox' page. The category of deals and Amazon domain are specified using the category_id and amazon_domain parameter. The parameters should be appended as querystring parameters to the Product Data APIGETHTTP request.
+		
+		Deals results are retrieved from the deals listing page on Amazon.
+		
+		You can retrieve category IDs for each amazon_domain using the Categories API. Category IDs are also returned in the categories array in each type=deals response.
+		
+		Multiple category IDs can be supplied, comma seperated, in the category_id parameter. For example, to request deals for Beauty (3760911) and Electronics (172282) categories on amazon.com the parameters would be category_id=3760911,172282&amazon_domain=amazon.com.
+		
+		If you wish to retrieve Deals from the deals homepage for a given amazon_domain, simply omit the category_id parameter entirely."
+    minimum_rating: Only include deals for products with a customer rating meeting the specified criteria. If you omit the minimum_rating parameter deals for products with any rating are included. Valid values are:
+
+1_and_up
+Include deals for products with a 1-star customer rating and upwards.
+2_and_up
+Include deals for products with a 2-star customer rating and upwards.
+3_and_up
+Include deals for products with a 3-star customer rating and upwards.
+4_and_up
+Include deals for products with a 4-star customer rating and upwards.
+        deal_states: The types of deal state to include. If you omit the deal_states parameter then all deal states are included.
+
+**Note multiple deal states can be specified, comma-separated.**
+
+Valid values are:
+- available
+- Include available-state deals.
+
+upcoming
+Include upcoming-state deals.
+expired
+Include expired-state deals.
+        amazon_domain: The Amazon domain to retrieve Deals from for the category ID(s) specified in the category_id parameter. For a full list of supported Amazon domains see Supported Amazon Domains.
+        category_id: A comma-seperated list of Deals category IDs to retrieve deals results from, as returned by the Categories API. Category IDs are also returned in the categories array in each type=deals response.
+
+Multiple category IDs can be supplied, comma seperated, in the category_id parameter. For example, to request deals for Beauty (3760911) and Electronics (172282) categories on amazon.com the parameters would be category_id=3760911,172282&amazon_domain=amazon.com.
+
+If you wish to retrieve Deals from the deals homepage for a given amazon_domain, simply omit the category_id parameter entirely.
+        url: The Amazon deals page URL to retrieve deals results from. This parameter, as it specifies a URL, should itself be url encoded.
+
+**Note using the url parameter for Deals requests is not recommended as due to the session and pagination characteristics of the Deals pages simply specifying the url can prove unreliable in all but the simplest use-cases. It is recommended that you use the category_id and amazon_domain parameters to specify your Deals request instead.**
+        sort_by: Determines the sort order of the deals returned.
+
+Valid values are:
+
+featured
+Sort by featured deals.
+discount_low_to_high
+Sort by discount, lowest discount first.
+discount_high_to_low
+Sort by discount, highest discount first.
+price_low_to_high
+Sort by price, lowest price first.
+price_high_to_low
+Sort by price, highest price first.
+        deal_types: The types of deal to include. If you omit the deal_types parameter then all deal types are included.
+
+**Note multiple deal types can be specified, comma-separated.**
+Valid values are:
+
+deal_of_the_day
+Include deal-of-the-day deals.
+lightning_deal
+Include lightning deals.
+best_deal
+Include best-deal deals.
+        
+    """
+    url = f"https://rainforest2.p.rapidapi.com/request"
+    querystring = {'type': type, }
+    if prime_eligible:
+        querystring['prime_eligible'] = prime_eligible
+    if minimum_rating:
+        querystring['minimum_rating'] = minimum_rating
+    if deal_states:
+        querystring['deal_states'] = deal_states
+    if amazon_domain:
+        querystring['amazon_domain'] = amazon_domain
+    if category_id:
+        querystring['category_id'] = category_id
+    if url:
+        querystring['url'] = url
+    if sort_by:
+        querystring['sort_by'] = sort_by
+    if deal_types:
+        querystring['deal_types'] = deal_types
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "rainforest2.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+
+def autcomplete(search_term: str, type: str, amazon_domain: str, autcomplete_alias: str=None, toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "When making a request with the type parameter set to type=autocomplete Rainforest API will return autocomplete suggestions for the search term specified in the search_term parameter, on the Amazon domain specified in the amazon_domain parameter.
+		You may scope your autocomplete request to an Amazon autocomplete alias (synonymous with a product area or top-level category) by specifying the alias using the autocomplete_alias parameter. The available autocomplete_alias values vary depending on the amazon_domain used. You can find a full list of all autocomplete aliaes, per Amazon-domain, in the autocomplete aliases reference."
+    search_term: The search term to get autocomplete suggestions for. Used in combination with the amazon_domain parameter.
+        type: The Amazon domain to retrieve autocomplete details from for the search term specified in the search_term parameter. For a full list of supported Amazon domains see Supported Amazon Domains.
+        autcomplete_alias: 
+The alias to use to scope the autocomplete request. Autocomplete aliases can be thought of as the \"category\" area that the autocomplete request runs in. If none is specified then Rainforest will default to running the autocomplete request in the top-level \"All Departments\" autocomplete alias.
+
+For a full list of supported Autocomplete Aliases see Supported Autocomplete Aliases.
+        
+    """
+    url = f"https://rainforest2.p.rapidapi.com/request"
+    querystring = {'search_term': search_term, 'type': type, 'amazon_domain': amazon_domain, }
+    if autcomplete_alias:
+        querystring['autcomplete_alias'] = autcomplete_alias
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "rainforest2.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+
+def asin_to_gtin(amazon_domain: str, type: str, asin: str, toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "When making a request with the type parameter set to type=asin_to_gtin Rainforest API will attempt to look up GTIN / EAN / UPC / ISBN numbers for the ASIN and Amazon domain specified in the asin and amazon_domain parameters."
+    amazon_domain: The Amazon domain to retrieve ASIN to GTIN details from for the ASIN specified in the asin parameter. For a full list of supported Amazon domains see Supported Amazon Domains.
+        asin: The Amazon ASIN (product ID) to retrieve GTIN(s) for. Used in combination with the amazon_domain parameter.
+        
+    """
+    url = f"https://rainforest2.p.rapidapi.com/request"
+    querystring = {'amazon_domain': amazon_domain, 'type': type, 'asin': asin, }
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "rainforest2.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+
+def formats_editions(type: str, amazon_domain: str=None, url: str=None, asin: str=None, page: str=None, toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "The Formats & Editions Parameters are applicable when making a request with the type parameter set to type=formats_editions Rainforest API will return data from the Formats & Editions popup (typically shown on books and collectables product pages to list all of the ASINs of different formats of the current ASIN) for the product specified in either the asin and amazon_domain parameters or the url parameter. The parameters should be appended as querystring parameters to the Product Data APIGETHTTP request.
+		
+		Formats & Editions data is retrieved from the Formats & Editions popup for a single product on Amazon"
+    amazon_domain: 
+The Amazon domain to retrieve Formats & Editions for the product specified in the asin parameter from. For a full list of supported Amazon domains see Supported Amazon Domains.
+
+Note: If the amazon_domain and asin parameters are supplied then the url parameter is ignored.
+        url: The Amazon product-page URL to retrieve Formats & Editions from.
+
+Note: If the url parameter is supplied then the amazon_domain and asin parameters are ignor
+        asin: The Amazon ASIN (product ID) to retrieve Formats & Editions for. Used in combination with the amazon_domain parameter.
+
+Note: If the asin and amazon_domain parameters are supplied then the url parameter is ignored.
+        page: The current page of search results to retrieve. Inspect the pagination.total_pages property in the Search results to see how many pages of search results are available.
+
+update value of num to get additional pages
+        
+    """
+    url = f"https://rainforest2.p.rapidapi.com/request"
+    querystring = {'type': type, }
+    if amazon_domain:
+        querystring['amazon_domain'] = amazon_domain
+    if url:
+        querystring['url'] = url
+    if asin:
+        querystring['asin'] = asin
+    if page:
+        querystring['page'] = page
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "rainforest2.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+
+def question_answers(type: str, question_id: str='Tx2YPKCGKAORFA4', page: int=None, amazon_domain: str='amazon.com', customer_location: str=None, url: str=None, toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "The Question Answers Parameters are applicable when making a request with type=question_answers to retrieve all answers for a single question on Amazon - the question is specified using either the question_id and amazon_domain parameters or the url parameter (where the url parameter contains a link to a question answers page). The parameters should be appended as querystring parameters to the Product Data APIGETHTTP request.
+		
+		Question Answers are retrieved from the customer question answers page for a single question on Amazon."
+    question_id: The ID of the question to retrieve answers for.
+
+Rainforest API returns question_id's from `type=questions` requests in the id parameter. See the questions parameters for further information.
+        page: The current page of search results to retrieve. Inspect the pagination.total_pages property in the Search results to see how many pages of search results are available.
+
+update value of num to get additional pages
+        amazon_domain: The Amazon domain to retrieve answers for the question specified in the question_id parameter from. For a full list of supported Amazon domains see Supported Amazon Domains.
+
+**Note: If the amazon_domain and question_id parameters are supplied then the url parameter is ignored**.
+        customer_location: Rainforest API supports retrieving data from the following Customer Locations.
+
+The Customer Locations is specified via the customer_location request parameter.
+
+The Customer Location determines the location that Rainforest uses when retrieving pages from Amazon. This is useful, for example, for seeing details of how a product appears on amazon.com, to a customer located in a different country. Can be used to identify cross-border shipping data and opportunities.
+
+If no value for customer_location is supplied then Rainforest defaults to making the request from the country of the Amazon page requested - i.e. \\\"France\\\" for requests for pages from \\\"amazon.fr\\\".
+
+The table below shows which customer_location values can be used in combination with requests to which amazon_domains. If you require another Amazon domain / customer location combination please contact our support team.
+
+See the Request Parameters documentation for more information.
+        url: The Amazon product-page URL to retrieve Question Answers from.
+
+**Note: If the url parameter is supplied then the amazon_domain and question_id parameters are ignored.**
+        
+    """
+    url = f"https://rainforest2.p.rapidapi.com/request"
+    querystring = {'type': type, }
+    if question_id:
+        querystring['question_id'] = question_id
+    if page:
+        querystring['page'] = page
+    if amazon_domain:
+        querystring['amazon_domain'] = amazon_domain
+    if customer_location:
+        querystring['customer_location'] = customer_location
+    if url:
+        querystring['url'] = url
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "rainforest2.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+
+def reviews(type: str, url: str=None, global_reviews: bool=None, review_stars: str=None, sort_by: str=None, search_term: str=None, page: int=None, reviewer_type: str=None, review_media_type: str=None, customer_location: str=None, gtin: str=None, asin: str='B073JYC4XM', amazon_domain: str='amazon.com', review_format: str=None, show_different_asins: bool=None, review_id: str=None, toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "The Reviews Parameters are applicable when making a request with type=reviews to retrieve customer Reviews for a single product on Amazon - the product is specified using either the asin and amazon_domain parameters or the url parameter (where the url parameter contains a link to an Amazon reviews page). The parameters should be appended as querystring parameters to the Product Data APIGETHTTP request.
+		
+		Reviews are retrieved from the customer reviews page for a single product on Amazon."
+    url: The Amazon product-page URL to retrieve Reviews from.
+
+**Note: If the url parameter is supplied then the amazon_domain and asin parameters are ignored.**
+        global_reviews: Determines whether Global Reviews are included, or not Global Reviews are reviews from other Amazon domains outside of the Amazon domain specified in the request. Valid values are:
+
+true
+The default, Global Reviews are included in the results.
+false
+Global reviews are excluded from the results.
+        review_stars: The star rating of reviews to retrieve. Valid values are:
+
+- all_stars
+- five_star
+- four_star
+- three_star
+- two_star
+- one_star
+- all_positive
+- all_critical
+        sort_by: Determines the sort order of reviews to return. Valid values are:
+
+- most_helpful
+- most_recent
+        search_term: A search term to use to search reviews.
+        page: The current page of search results to retrieve. Inspect the `pagination.total_pages` property in the Search results to see how many pages of search results are available.
+
+update value of num to get additional pages
+        reviewer_type: The type of reviewer to retrieve reviews from. Valid values are:
+
+`verified_purchase`
+Include reviews by Amazon Verified Purchasers only.
+`all`
+Include all reviews, regardless of whether they are from Amazon Verified Purchasers or not.
+        review_media_type: Filter the reviews to those containing a specific media type. Valid values are:
+
+all_reviews
+Include reviews with text, images or video.
+media_reviews_only
+Include only reviews containing images or video.
+        customer_location: Rainforest API supports retrieving data from the following Customer Locations.
+
+The Customer Locations is specified via the customer_location request parameter.
+
+The Customer Location determines the location that Rainforest uses when retrieving pages from Amazon. This is useful, for example, for seeing details of how a product appears on amazon.com, to a customer located in a different country. Can be used to identify cross-border shipping data and opportunities.
+
+If no value for customer_location is supplied then Rainforest defaults to making the request from the country of the Amazon page requested - i.e. \\\"France\\\" for requests for pages from \\\"amazon.fr\\\".
+
+The table below shows which customer_location values can be used in combination with requests to which amazon_domains. If you require another Amazon domain / customer location combination please contact our support team.
+        gtin: A GTIN, ISBN, UPC or EAN code to retrieve results for. Internally Rainforest will first convert the GTIN/ISBN/UPC/EAN to an Amazon ASIN, then retrieve the results for that ASIN from Amazon. Used in combination with the amazon_domain parameter.
+
+**Note: If the gtin and amazon_domain parameters are supplied then the url parameter is ignored.**
+        asin: The Amazon ASIN (product ID) to retrieve Reviews for. Used in combination with the amazon_domain parameter.
+
+**Note: If the asin and amazon_domain parameters are supplied then the url parameter is ignored.**
+        amazon_domain: The Amazon domain to retrieve Reviews for the product specified in the asin parameter from. For a full list of supported Amazon domains see Supported Amazon Domains.
+
+**Note: If the amazon_domain and asin parameters are supplied then the url parameter is ignored.**
+        review_format: he type of reviewer to retrieve reviews from. Valid values are:
+
+all_formats
+Include reviews of any product format/variant.
+current_format
+Include reviews relating specifically to the current format/variant.
+        show_different_asins: 
+Sometimes Amazon will return Reviews from ASINs other than the ASIN supplied in the asin request parameter (for example, when the original ASIN is out of stock). show_different_asins controls whether you want these other-ASIN review results returned, or not. Can be set to true (the default) to include reviews from other ASINs, or false to hide reviews from ASINs other than the ASIN supplied in the asin parameter. Note that if you supply a url instead of asin in your request this parameter is ignored.
+
+Note in the event of `show_different_asins=false` and the ASIN shown by Amazon being different from the requested ASIN, then all fields apart from product will be removed from the response.
+        review_id: A single Review ID, as returned by a prior type=reviews request, to retrieve. Useful if you wish to check for the presence of a single review. Use in combination with the amazon_domain parameter.
+        
+    """
+    url = f"https://rainforest2.p.rapidapi.com/request"
+    querystring = {'type': type, }
+    if url:
+        querystring['url'] = url
+    if global_reviews:
+        querystring['global_reviews'] = global_reviews
+    if review_stars:
+        querystring['review_stars'] = review_stars
+    if sort_by:
+        querystring['sort_by'] = sort_by
+    if search_term:
+        querystring['search_term'] = search_term
+    if page:
+        querystring['page'] = page
+    if reviewer_type:
+        querystring['reviewer_type'] = reviewer_type
+    if review_media_type:
+        querystring['review_media_type'] = review_media_type
+    if customer_location:
+        querystring['customer_location'] = customer_location
+    if gtin:
+        querystring['gtin'] = gtin
+    if asin:
+        querystring['asin'] = asin
+    if amazon_domain:
+        querystring['amazon_domain'] = amazon_domain
+    if review_format:
+        querystring['review_format'] = review_format
+    if show_different_asins:
+        querystring['show_different_asins'] = show_different_asins
+    if review_id:
+        querystring['review_id'] = review_id
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "rainforest2.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+
+def reviewer_comments(asin: str, review_id: str, amazon_domain: str, type: str, sort_by: str=None, customer_location: str=None, toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "The Review Comments Parameters are applicable when making a request with type=review_comments to retrieve customer Review Comments for a single customer review on Amazon - the review is specified using the review_id, asin and amazon_domain parameters. The parameters should be appended as querystring parameters to the Product Data APIGETHTTP request.
+		
+		Review comments are retrieved from the customer reviews page for a single customer review for a single product on Amazon."
+    asin: The Amazon ASIN to retrieve Review Comments for. Used in combination with the amazon_domain and review_id parameters.
+        review_id: The Review ID, as returned by a type=reviews request, to retrieve Review Comments for. Used in combination with the amazon_domain and asin parameters.
+        amazon_domain: The Amazon domain to retrieve Review Comments for the Review ID specified in the review_id parameter and ASIN specified in the asin parameter. For a full list of supported Amazon domains see Supported Amazon Domains. Used in combination with the asin and review_id parameters.
+        sort_by: An optional sort order for the returned review comments. Valid values are:
+
+- most_recent 
+- oldest
+        customer_location: Rainforest API supports retrieving data from the following Customer Locations.
+
+The Customer Locations is specified via the customer_location request parameter.
+
+The Customer Location determines the location that Rainforest uses when retrieving pages from Amazon. This is useful, for example, for seeing details of how a product appears on amazon.com, to a customer located in a different country. Can be used to identify cross-border shipping data and opportunities.
+
+If no value for customer_location is supplied then Rainforest defaults to making the request from the country of the Amazon page requested - i.e. \\\"France\\\" for requests for pages from \\\"amazon.fr\\\".
+
+The table below shows which customer_location values can be used in combination with requests to which amazon_domains. If you require another Amazon domain / customer location combination please contact our support team.
+
+See the Request Parameters documentation for more information.
+        
+    """
+    url = f"https://rainforest2.p.rapidapi.com/request"
+    querystring = {'asin': asin, 'review_id': review_id, 'amazon_domain': amazon_domain, 'type': type, }
+    if sort_by:
+        querystring['sort_by'] = sort_by
+    if customer_location:
+        querystring['customer_location'] = customer_location
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "rainforest2.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+
+def wishlist(type: str, url: str=None, amazon_domain: str='amazon.com', wishlist_id: str='38B3V3AT7UH9B', sort_by: str=None, next_page_token: str=None, toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "The Wishlist Parameters are applicable when making a request with the type parameter set to type=wishlist Rainforest API will return data from the Wishlist page for the wishlist specified in either the wishlist_id and amazon_domain parameters or the url parameter. The parameters should be appended as querystring parameters to the Product Data APIGETHTTP request.
+		
+		Wishlist data is retrieved from the Wishlist popup."
+    url: 
+The Amazon wishlist-page URL to retrieve Wishlist results from.
+
+Note: If the url parameter is supplied then the amazon_domain and wishlist_url parameters are ignored.
+        amazon_domain: 
+The Amazon domain to retrieve Wishlist for the product specified in the asin parameter from. For a full list of supported Amazon domains see Supported Amazon Domains.
+
+Note: If the amazon_domain and asin parameters are supplied then the url parameter is ignored.
+        wishlist_id: 
+The Amazon wishlist ID to retrieve Wishlist results for. Used in combination with the amazon_domain parameter. The wishlist ID can be found in any Amazon wishlist URL after the /ls/ component of the wishlist URL.
+
+Note: If the wishlist_id and amazon_domain parameters are supplied then the url parameter is ignored.
+        sort_by: 
+Determines the sort order of wishlist items to return. Omit the sort_by parameter to return results in the default sort order. Valid values are:
+price_high_to_low
+Returns highest priced wishlist items first.
+price_low_to_high
+Returns lowest priced wishlist items first.
+priority_high_to_low
+Returns highest priority wishlist items first.
+        next_page_token: the current page of Wishlist results to retrieve. Inspect the pagination.next_page_token property in the Wishlist results to retrieve the next_page_token of the subsequent page.
+        
+    """
+    url = f"https://rainforest2.p.rapidapi.com/request"
+    querystring = {'type': type, }
+    if url:
+        querystring['url'] = url
+    if amazon_domain:
+        querystring['amazon_domain'] = amazon_domain
+    if wishlist_id:
+        querystring['wishlist_id'] = wishlist_id
+    if sort_by:
+        querystring['sort_by'] = sort_by
+    if next_page_token:
+        querystring['next_page_token'] = next_page_token
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "rainforest2.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+
+def charts(type: str, url: str='https://www.amazon.com/charts', customer_location: str=None, toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "The Charts parameters are applicable when making a request with type=charts to retrieve Charts results. The Charts page can be specified using the url parameter. The parameters should be appended as querystring parameters to the Product Data APIGETHTTP request.
+		
+		Charts results are retrieved from the charts page on Amazon."
+    url: The Charts page URL to retrieve Charts results from. Be sure to URL-encode the url parameter.
+        customer_location: Rainforest API supports retrieving data from the following Customer Locations.
+
+The Customer Locations is specified via the customer_location request parameter.
+
+The Customer Location determines the location that Rainforest uses when retrieving pages from Amazon. This is useful, for example, for seeing details of how a product appears on amazon.com, to a customer located in a different country. Can be used to identify cross-border shipping data and opportunities.
+
+If no value for customer_location is supplied then Rainforest defaults to making the request from the country of the Amazon page requested - i.e. \"France\" for requests for pages from \"amazon.fr\".
+
+The table below shows which customer_location values can be used in combination with requests to which amazon_domains. If you require another Amazon domain / customer location combination please contact our support team.
+
+See the Request Parameters documentation for more information.
+        
+    """
+    url = f"https://rainforest2.p.rapidapi.com/request"
+    querystring = {'type': type, }
+    if url:
+        querystring['url'] = url
+    if customer_location:
+        querystring['customer_location'] = customer_location
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "rainforest2.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+
+def store(type: str, page: str=None, amazon_domain: str='amazon.com', store_id: str='70F3122D-4966-4242-A8A6-871C8D7E6F8B', url: str=None, customer_location: str=None, toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "The Store parameters are applicable when making a request with type=store to retrieve Brand Store results for a Brand Store. The Brand Store can be specified either by the url parameter, or by a combination of the store_id and amazon_domain parameters. The parameters should be appended as querystring parameters to the Product Data APIGETHTTP request."
+    page: The current page of search results to retrieve. Inspect the pagination.total_pages property in the Search results to see how many pages of search results are available.
+
+update value of num to get additional pages
+        amazon_domain: 
+The Amazon domain to retrieve Brand Store results from. For a full list of supported Amazon domains see Supported Amazon Domains. Should be used in combination with the store_id parameter.
+
+Note if the url parameter is supplied then the amazon_domain parameter is ignored as the url itself specifies the Amazon domain.
+        store_id: 
+A Brand Store ID to retrieve results from. Should be used in combination with the amazon_domain parameter.
+
+Note if the url parameter is supplied then the store_id parameter is ignored as the url itself specifies the store ID.
+        url: 
+The Brand Store page URL to retrieve Brand Store results from. Be sure to URL-encode the url parameter.
+
+Note the url parameter is supplied, the store_id and amazon_domain parameters cannot be used (as the url itself defines the Store ID and Amazon domain used).
+        customer_location: Rainforest API supports retrieving data from the following Customer Locations.
+
+The Customer Locations is specified via the customer_location request parameter.
+
+The Customer Location determines the location that Rainforest uses when retrieving pages from Amazon. This is useful, for example, for seeing details of how a product appears on amazon.com, to a customer located in a different country. Can be used to identify cross-border shipping data and opportunities.
+
+If no value for customer_location is supplied then Rainforest defaults to making the request from the country of the Amazon page requested - i.e. \"France\" for requests for pages from \"amazon.fr\".
+
+The table below shows which customer_location values can be used in combination with requests to which amazon_domains. If you require another Amazon domain / customer location combination please contact our support team.
+
+See the Request Parameters documentation for more information.
+        
+    """
+    url = f"https://rainforest2.p.rapidapi.com/request"
+    querystring = {'type': type, }
+    if page:
+        querystring['page'] = page
+    if amazon_domain:
+        querystring['amazon_domain'] = amazon_domain
+    if store_id:
+        querystring['store_id'] = store_id
+    if url:
+        querystring['url'] = url
+    if customer_location:
+        querystring['customer_location'] = customer_location
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "rainforest2.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+
+def seller_products(type: str, url: str=None, amazon_domain: str='amazon.com', seller_id: str='A02211013Q5HP3OMSZC7W', refinements: str=None, page: int=None, customer_location: str=None, toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "The Seller Products Parameters are applicable when making a request with type=seller_products to retrieve seller product listing results for a single seller on Amazon - the seller is specified using either the seller_id and amazon_domain parameters or the url parameter (where the url parameter contains a link to an Amazon seller product listing page). The parameters should be appended as querystring parameters to the Product Data APIGETHTTP request.
+		
+		Seller product listing results are retrieved from the seller product listings page for a single seller on Amazon. You can retrieve the seller_id value for a given seller from other Rainforest requests, such as type=offers requests."
+    url: The Amazon seller products listing page URL to retrieve seller products results from.
+
+        amazon_domain: 
+The Amazon domain to retrieve seller product listings from for the seller specified in the seller_id parameter. For a full list of supported Amazon domains see Supported Amazon Domains.
+
+Note: If the amazon_domain and seller_id parameters are supplied then the url parameter is ignored.
+        seller_id: The Amazon Seller ID to retrieve seller product listings for. Used in combination with the amazon_domain parameter.
+
+Note: If the seller_id and amazon_domain parameters are supplied then the url parameter is ignored. Note: Seller IDs can be retrieved from Rainforest API type=offers requests.
+        refinements: 
+A comma-seperated list of refinement values to filter the seller product results by. These allow you to refine your request by values such as \\\\\\\\\\\\\\\"Reviews rating 4 and over\\\\\\\\\\\\\\\", \\\\\\\\\\\\\\\"price range\\\\\\\\\\\\\\\" and \\\\\\\\\\\\\\\"brand\\\\\\\\\\\\\\\".
+
+Refinement values are returned in the refinements array of each type=seller_products result (if they are displayed). Refinement values are dynamic and change by seller. If you wish to use refinements you should first issue a type=seller_products request without specifying any refinements to retrieve a master list of the avaialble refinements for the given request. You can then cache these refinement values for use on subsequent requests.
+
+For example, to run a type=seller_products request specifying two refinements with values p_85/2470955011 and p_36/2421886011 the value of the refinements parameter would be refinements=p_85/2470955011,p_36/2421886011
+        page: The current page of search results to retrieve. Inspect the pagination.total_pages property in the Search results to see how many pages of search results are available.
+
+update value of num to get additional pages
+        customer_location: Rainforest API supports retrieving data from the following Customer Locations.
+
+The Customer Locations is specified via the customer_location request parameter.
+
+The Customer Location determines the location that Rainforest uses when retrieving pages from Amazon. This is useful, for example, for seeing details of how a product appears on amazon.com, to a customer located in a different country. Can be used to identify cross-border shipping data and opportunities.
+
+If no value for customer_location is supplied then Rainforest defaults to making the request from the country of the Amazon page requested - i.e. \"France\" for requests for pages from \"amazon.fr\".
+
+The table below shows which customer_location values can be used in combination with requests to which amazon_domains. If you require another Amazon domain / customer location combination please contact our support team.
+
+See the Request Parameters documentation for more information.
+        
+    """
+    url = f"https://rainforest2.p.rapidapi.com/request"
+    querystring = {'type': type, }
+    if url:
+        querystring['url'] = url
+    if amazon_domain:
+        querystring['amazon_domain'] = amazon_domain
+    if seller_id:
+        querystring['seller_id'] = seller_id
+    if refinements:
+        querystring['refinements'] = refinements
+    if page:
+        querystring['page'] = page
+    if customer_location:
+        querystring['customer_location'] = customer_location
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "rainforest2.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+
+def seller_feedback(type: str, amazon_domain: str='amazon.com', page: int=None, seller_id: str='A02211013Q5HP3OMSZC7W', customer_location: str=None, toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "The Seller Feedback Parameters are applicable when making a request with type=seller_feedback to retrieve seller customer feedback details for a seller on Amazon - the seller is specified using the seller_id and amazon_domain parameters. The parameters should be appended as querystring parameters to the Product Data APIGETHTTP request.
+		
+		Seller feedback details are retrieved from the feedback section of the seller profile page. You can retrieve the seller_id value for a given seller from other Rainforest requests, such as type=offers requests.
+		
+		A maximum of 5 seller feedback records can be returned per request. You can paginate through multiple pages of seller feedback records using the page parameter. Inspect the pagination.has_next_page property to determine whether there is a next page of results to retrieve."
+    amazon_domain: The Amazon domain to retrieve seller feedback results from for the seller specified in the seller_id parameter. For a full list of supported Amazon domains see Supported Amazon Domains.
+        page: The current page of search results to retrieve. Inspect the pagination.total_pages property in the Search results to see how many pages of search results are available.
+
+update value of num to get additional pages
+        seller_id: 
+The Amazon Seller ID to retrieve seller feedback results for. Used in combination with the amazon_domain parameter.
+
+Note: Seller IDs can be retrieved from Rainforest API type=offers re
+        customer_location: Rainforest API supports retrieving data from the following Customer Locations.
+
+The Customer Locations is specified via the customer_location request parameter.
+
+The Customer Location determines the location that Rainforest uses when retrieving pages from Amazon. This is useful, for example, for seeing details of how a product appears on amazon.com, to a customer located in a different country. Can be used to identify cross-border shipping data and opportunities.
+
+If no value for customer_location is supplied then Rainforest defaults to making the request from the country of the Amazon page requested - i.e. \"France\" for requests for pages from \"amazon.fr\".
+
+The table below shows which customer_location values can be used in combination with requests to which amazon_domains. If you require another Amazon domain / customer location combination please contact our support team.
+
+See the Request Parameters documentation for more information.
+        
+    """
+    url = f"https://rainforest2.p.rapidapi.com/request"
+    querystring = {'type': type, }
+    if amazon_domain:
+        querystring['amazon_domain'] = amazon_domain
+    if page:
+        querystring['page'] = page
+    if seller_id:
+        querystring['seller_id'] = seller_id
+    if customer_location:
+        querystring['customer_location'] = customer_location
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "rainforest2.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+
+def seller_profile(type: str, url: str=None, seller_id: str='A02211013Q5HP3OMSZC7W', amazon_domain: str='amazon.com', customer_location: str=None, toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "The Seller Profile Parameters are applicable when making a request with type=seller_profile to retrieve seller profile details for a single seller on Amazon - the seller is specified using either the seller_id and amazon_domain parameters or the url parameter (where the url parameter contains a link to an Amazon seller profile page). The parameters should be appended as querystring parameters to the Product Data APIGETHTTP request.
+		
+		Seller profile details are retrieved from the seller profile page for a single seller on Amazon. You can retrieve the seller_id value for a given seller from other Rainforest requests, such as type=offers requests.
+		
+		You can use subsequent seller products and seller feedback requests to retrieve iterate all of the products and customer feedback from a given seller."
+    url: The Amazon seller profile page URL of the seller to retrieve results from.
+
+        seller_id: The Amazon Seller ID to retrieve seller profile details for. Used in combination with the amazon_domain parameter.
+
+Note: If the seller_id and amazon_domain parameters are supplied then the url parameter is ignored. Note: Seller IDs can be retrieved from Rainforest API type=offers requests.
+        amazon_domain: The Amazon domain to retrieve seller profile details from for the seller specified in the seller_id parameter. For a full list of supported Amazon domains see Supported Amazon Domains.
+
+Note: If the amazon_domain and seller_id parameters are supplied then the url parameter is ignored.
+        customer_location: Rainforest API supports retrieving data from the following Customer Locations.
+
+The Customer Locations is specified via the customer_location request parameter.
+
+The Customer Location determines the location that Rainforest uses when retrieving pages from Amazon. This is useful, for example, for seeing details of how a product appears on amazon.com, to a customer located in a different country. Can be used to identify cross-border shipping data and opportunities.
+
+If no value for customer_location is supplied then Rainforest defaults to making the request from the country of the Amazon page requested - i.e. \"France\" for requests for pages from \"amazon.fr\".
+
+The table below shows which customer_location values can be used in combination with requests to which amazon_domains. If you require another Amazon domain / customer location combination please contact our support team.
+
+See the Request Parameters documentation for more information.
+        
+    """
+    url = f"https://rainforest2.p.rapidapi.com/request"
+    querystring = {'type': type, }
+    if url:
+        querystring['url'] = url
+    if seller_id:
+        querystring['seller_id'] = seller_id
+    if amazon_domain:
+        querystring['amazon_domain'] = amazon_domain
+    if customer_location:
+        querystring['customer_location'] = customer_location
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "rainforest2.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+
+def reviewer_profile(type: str, reviewer_profile_pages: str=None, url: str=None, amazon_domain: str='amazon.com', reviewer_id: str='AHBEI6Q4F4WHRIFK5CWQMRVPOQMA', toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "When making a request with the type parameter set to type=reviewer_profile Rainforest API will return details of reviewer specified in either the reviewer_id and amazon_domain parameters or the url parameter.
+		
+		Reviewer profile details are retrieved from the reviewer profile page. You can retrieve the reviewer_id value for a given reviewer from other Rainforest requests, such as type=reviews requests."
+    reviewer_profile_pages: The number of pages of reviews to retrieve from the reviewer profile page when `type=reviewer_profile`.
+
+This parameter is different from the more usual page parameter as pagination of reviewer profile reviews is performed from an infinate-scrolling list.
+
+It is not possible to \\\"go to page 3\\\", so the reviewer_profile_pages allows you retrieve \\\"the first X\\\" pages of reviews (a maximum of 10 reviews are returned per page).
+
+Note: that using reviewer_profile_pages decrements a credit for each page of reviews retrieved, for example, reviewer_profile_pages=3 would decrement 3 credits from your balance.
+        url: The Amazon reviewer profile page URL of the reviewer to retrieve results from.
+        amazon_domain: The Amazon domain to retrieve reviewer profile details from for the reviewer specified in the reviewer_id parameter. For a full list of supported Amazon domains see Supported Amazon Domains.
+
+**Note: If the amazon_domain and reviewer_id parameters are supplied then the url parameter is ignored.**
+        reviewer_id: The Amazon Reviewer ID to retrieve reviewer profile details for. Used in combination with the amazon_domain parameter.
+
+**Note: If the reviewer_id and amazon_domain parameters are supplied then the url parameter is ignored. Reviewer IDs can be retrieved from other Rainforest API requests, for example `type=reviews requests`.**
+        
+    """
+    url = f"https://rainforest2.p.rapidapi.com/request"
+    querystring = {'type': type, }
+    if reviewer_profile_pages:
+        querystring['reviewer_profile_pages'] = reviewer_profile_pages
+    if url:
+        querystring['url'] = url
+    if amazon_domain:
+        querystring['amazon_domain'] = amazon_domain
+    if reviewer_id:
+        querystring['reviewer_id'] = reviewer_id
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "rainforest2.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+
+def bestsellers(type: str, url: str=None, page: int=2, amazon_domain: str='amazon.com', category_id: str='bestsellers_appliances', top_free: bool=None, customer_location: str=None, toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "The Bestsellers Parameters are applicable when making a request with type=bestsellers to retrieve Bestseller results from an Amazon bestsellers page - the bestsellers page is specified either using the category_id and amazon_domain parameters (where category_id is a Category ID returned from the Categories API, or by using the url parameter. The parameters should be appended as querystring parameters to the Product Data API GET HTTP request.
+		
+		Note that, if using the url parameter it should be url-encoded.
+		
+		Bestsellers results are retrieved from the bestsellers listing page on Amazon. Rainforest supports all types of Amazon Bestseller pages, bestsellers, new releases, movers & shakers, most wished for and gift ideas."
+    url: The Amazon Bestsellesr results page URL to retrieve bestsellers results from.
+
+**Note: The url parameter should be url-encoded.**
+
+Note: Either the url or category_id & amazon_domain parameters can be used.
+        page: The current page of search results to retrieve. Inspect the pagination.total_pages property in the Search results to see how many pages of search results are available.
+
+update value of num to get additional pages
+        amazon_domain: The Amazon domain to retrieve bestsellers results from. For a full list of supported Amazon domains see Supported Amazon Domains.
+        category_id: A category ID to retrieve bestsellers results from. You must supply a category_id returned from the Categories API in to the category_id parameter.
+        top_free: Set to true to retrieve the \\\\\\\\\\\\\\\"Top 100 Free\\\\\\\\\\\\\\\" version of the specified Bestsellers category_id or url. See screenshot below for how the Top 100 Paid / Top 100 Free bestsellers for a given category are displayed on the Amazon site.
+        customer_location: Rainforest API supports retrieving data from the following Customer Locations.
+
+The Customer Locations is specified via the customer_location request parameter.
+
+The Customer Location determines the location that Rainforest uses when retrieving pages from Amazon. This is useful, for example, for seeing details of how a product appears on amazon.com, to a customer located in a different country. Can be used to identify cross-border shipping data and opportunities.
+
+If no value for customer_location is supplied then Rainforest defaults to making the request from the country of the Amazon page requested - i.e. \\\"France\\\" for requests for pages from \\\"amazon.fr\\\".
+
+The table below shows which customer_location values can be used in combination with requests to which amazon_domains. If you require another Amazon domain / customer location combination please contact our support team.
+
+See the Request Parameters documentation for more information.
+        
+    """
+    url = f"https://rainforest2.p.rapidapi.com/request"
+    querystring = {'type': type, }
+    if url:
+        querystring['url'] = url
+    if page:
+        querystring['page'] = page
+    if amazon_domain:
+        querystring['amazon_domain'] = amazon_domain
+    if category_id:
+        querystring['category_id'] = category_id
+    if top_free:
+        querystring['top_free'] = top_free
+    if customer_location:
+        querystring['customer_location'] = customer_location
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "rainforest2.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+
+def category(type: str, amazon_domain: str='amazon.com', url: str=None, category_id: str='2619526011', refinements: str=None, sort_by: str='average_review', page: int=None, toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "The Category Parameters are applicable when making a request with type=category to retrieve category results for an Amazon category. Categories can be specified either via passing an Amazon category URL in to the url parameter, or by passing a Category ID in to the category_id (where the category_id is returned from the Categories API) and an Amazon domain in to the amazon_domain parameter. The parameters should be appended as querystring parameters to the Product Data APIGETHTTP request."
+    amazon_domain: The Amazon domain to retrieve category results from. For a full list of supported Amazon domains see Supported Amazon Domains.
+        url: The Amazon category results page URL to retrieve category results from. Be sure to URL-encode the url parameter.
+
+Note the url parameter is supplied, the category_id parameter cannot be used (as the url itself defines the category ID used).
+        category_id: 
+A category ID to retrieve results from. You may supply any arbitary value in the category_id parameter however we recommend using a category ID returned from the Categories API as these are known-good category IDs from Amazon.
+
+Rainforest will use the category_id in the following form: https://amazon_domain/s?node=category_id.
+
+Note that pagination for top-level categories is not supported by the Amazon sites. If you wish to iterate the contents of a category the recommended approach is to pick the lowest level categories to perform your iteration / pagination on.
+        refinements: A comma-seperated list of refinement values to filter the category results by. These allow you to refine your category results by values such as \\\\\\\\\\\\\\\"Reviews rating 4 and over\\\\\\\\\\\\\\\", \\\\\\\\\\\\\\\"price range\\\\\\\\\\\\\\\" and \\\\\\\\\\\\\\\"brand\\\\\\\\\\\\\\\".
+
+Refinement values are returned in the refinements array of each type=category result. Refinement values are dynamic and change by category area or search term used. If you wish to use refinements you should first issue a type=category request without specifying any refinements to retrieve a master list of the avaialble refinements for the given category area/search term. You can then cache these refinement values for use on subsequent requests.
+
+For example, to run a type=search request specifying two refinements with values p_85/2470955011 and p_36/2421886011 the value of the refinements parameter would be refinements=p_85/2470955011,p_36/2421886011
+
+Note that sometimes Amazon do not present a explicit refinement value and instead a link is returned. In this instance you should pass the link into the url request parameter of your type=category request to retrieve data from that refinement-filtered page.
+
+        sort_by: Determines the sort order of category results to return. Valid values are:
+most_recent
+Sort category results by newest arrivals.
+price_low_to_high
+Sort category results by lowest to highest price.
+price_high_to_low
+Sort category results by highest to lowest price.
+featured
+Sort category results by featured first.
+average_review
+Sort category results by average customer review.
+        page: The current page of search results to retrieve. Inspect the pagination.total_pages property in the Search results to see how many pages of search results are available.
+
+update value of num to get additional pages
+        
+    """
+    url = f"https://rainforest2.p.rapidapi.com/request"
+    querystring = {'type': type, }
+    if amazon_domain:
+        querystring['amazon_domain'] = amazon_domain
+    if url:
+        querystring['url'] = url
+    if category_id:
+        querystring['category_id'] = category_id
+    if refinements:
+        querystring['refinements'] = refinements
+    if sort_by:
+        querystring['sort_by'] = sort_by
+    if page:
+        querystring['page'] = page
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "rainforest2.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+
+def search(type: str, sort_by: str='featured', refinements: str=None, url: str=None, search_term: str='hiking backpack', amazon_domain: str='amazon.com', page: int=None, category_id: str=None, customer_location: str=None, toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "The Search Parameters are applicable when making a request with type=search to retrieve search results for an Amazon domain - the Amazon domain is specified using the amazon_domain parameter and the search term is specified in the search_term parameter. The parameters should be appended as querystring parameters to the Product Data API GET HTTP request."
+    sort_by: Determines the sort order of search results to return. Valid values are:
+
+- most_recent
+- price_low_to_high
+- price_high_to_low
+- featured
+- average_review
+- 
+
+relevance
+- Sort search results by most relevant first.
+- Applies only to Audible Amazon Domains.
+
+bestsellers
+- Sort search results by best sellers first.
+- Applies only to Audible Amazon Domains.
+
+running_time_ascending
+- Sort search results by shortest running time first, from short to long.
+- Applies only to Audible Amazon Domains.
+
+running_time_descending
+- Sort search results by shortest running time first, from long to short.
+- Applies only to Audible Amazon Domains.
+
+title_ascending
+- Sort search results alphabetically by title from A to Z.
+- Applies only to Audible Amazon Domains.
+
+title_descending
+- Sort search results alphabetically by title from Z to A.
+- Applies only to Audible Amazon Domains.
+        refinements: A comma-seperated list of refinement values to filter the search results by. These allow you to refine your search by values such as \"Reviews rating 4 and over\", \"price range\" and \"brand\".
+
+Refinement values are returned in the refinements array of each type=search result. Refinement values are dynamic and change by category area or search term used. If you wish to use refinements you should first issue a `type=search` request without specifying any refinements to retrieve a master list of the avaialble refinements for the given category area/search term. You can then cache these refinement values for use on subsequent requests.
+
+For example, to run a `type=search` request specifying two refinements with values `p_85/2470955011 `and `p_36/2421886011` the value of the refinements parameter would be `refinements=p_85/2470955011,p_36/2421886011`
+        url: The Amazon search results page URL to retrieve search results from. Be sure to URL-encode the url parameter.
+
+**Note the url parameter is supplied, the search_term parameter cannot be used (as the url itself defines the search term used).**
+        search_term: A search term to use to search products.
+        amazon_domain: The Amazon domain to retrieve search results from. For a full list of supported Amazon domains see [Supported Amazon Domains](https://www.rainforestapi.com/docs/product-data-api/reference/amazon-domains).
+
+**Note: If the amazon_domain and asin parameters are supplied then the url parameter is ignored.**
+        page: The current page of search results to retrieve. Inspect the pagination.total_pages property in the Search results to see how many pages of search results are available.
+
+update value of num to get additional pages
+        category_id: A category ID to limit search results to. You may supply any arbitary value in the category_id parameter however we recommend using a category ID returned from the Categories API as these are known-good category IDs from Amazon.
+
+Rainforest will use the category_id in the following form: `https://amazon_domain/s?node=category_id.`
+
+Note that pagination for top-level categories is not supported by the Amazon sites. If you wish to iterate the contents of a category the recommended approach is to pick the lowest level categories to perform your iteration / pagination on.
+        customer_location: Rainforest API supports retrieving data from the following Customer Locations.
+
+The Customer Locations is specified via the customer_location request parameter.
+
+The Customer Location determines the location that Rainforest uses when retrieving pages from Amazon. This is useful, for example, for seeing details of how a product appears on amazon.com, to a customer located in a different country. Can be used to identify cross-border shipping data and opportunities.
+
+If no value for customer_location is supplied then Rainforest defaults to making the request from the country of the Amazon page requested - i.e. \\\"France\\\" for requests for pages from \\\"amazon.fr\\\".
+
+The table below shows which customer_location values can be used in combination with requests to which amazon_domains. If you require another Amazon domain / customer location combination please contact our support team.
+
+See the Request Parameters documentation for more information.
+        
+    """
+    url = f"https://rainforest2.p.rapidapi.com/request"
+    querystring = {'type': type, }
+    if sort_by:
+        querystring['sort_by'] = sort_by
+    if refinements:
+        querystring['refinements'] = refinements
+    if url:
+        querystring['url'] = url
+    if search_term:
+        querystring['search_term'] = search_term
+    if amazon_domain:
+        querystring['amazon_domain'] = amazon_domain
+    if page:
+        querystring['page'] = page
+    if category_id:
+        querystring['category_id'] = category_id
+    if customer_location:
+        querystring['customer_location'] = customer_location
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "rainforest2.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+
+def single_product(type: str, url: str=None, amazon_domain: str='amazon.com', gtin: str=None, asin: str='B073JYC4XM', customer_location: str=None, toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "The Product Parameters are applicable when making a request with type=product to retrieve details of a single product on Amazon - the product is specified using either the asin and amazon_domain parameters or the url parameter (where the url parameter contains a link to an Amazon product page). The parameters should be appended as querystring parameters to the Product Data API GET HTTP request"
+    url: The Amazon product-page URL to retrieve product details from.
+
+**Ensure that the url parameter is URL-encoded.**
+
+Note: If the url parameter is supplied then the amazon_domain and asin parameters are ignored.
+        amazon_domain: The Amazon domain to retrieve product details from for the product specified in the asin parameter. For a full list of supported Amazon domains see Supported Amazon Domains.
+
+**Note: If the amazon_domain and asin parameters are supplied then the url parameter is ignored.**
+        gtin: A GTIN, ISBN, UPC or EAN code to retrieve results for. Internally Rainforest will first convert the GTIN/ISBN/UPC/EAN to an Amazon ASIN, then retrieve the results for that ASIN from Amazon. Used in combination with the amazon_domain parameter.
+
+**Note: If the gtin and amazon_domain parameters are supplied then the url parameter is ignored.**
+        asin: The Amazon ASIN (product ID) to retrieve product details for. Used in combination with the amazon_domain parameter.
+
+**Note: If the asin and amazon_domain parameters are supplied then the url parameter is ignored.**
+        customer_location: Rainforest API supports retrieving data from the following Customer Locations.
+
+The Customer Locations is specified via the customer_location request parameter.
+
+The Customer Location determines the location that Rainforest uses when retrieving pages from Amazon. This is useful, for example, for seeing details of how a product appears on amazon.com, to a customer located in a different country. Can be used to identify cross-border shipping data and opportunities.
+
+If no value for customer_location is supplied then Rainforest defaults to making the request from the country of the Amazon page requested - i.e. `France` for requests for pages from `amazon.fr`
+
+The table below shows which customer_location values can be used in combination with requests to which amazon_domains. If you require another Amazon domain / customer location combination please contact our support team.
+
+See the Request Parameters documentation for more information.
+        
+    """
+    url = f"https://rainforest2.p.rapidapi.com/request"
+    querystring = {'type': type, }
+    if url:
+        querystring['url'] = url
+    if amazon_domain:
+        querystring['amazon_domain'] = amazon_domain
+    if gtin:
+        querystring['gtin'] = gtin
+    if asin:
+        querystring['asin'] = asin
+    if customer_location:
+        querystring['customer_location'] = customer_location
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "rainforest2.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+

toolbench/toolenv/tools/Data/randgenlocality_api.json

@@ -0,0 +1,54 @@
+{
+    "product_id": "api_00d6e595-cbfa-4d70-8454-9378a1ebbc99",
+    "tool_description": "The RandGenLocality API is a specialized service designed to generate random locality-related data. It empowers developers and users with the ability to create synthetic data for locations, addresses, and geographical information. This API serves as a valuable tool for applications requiring random locality data, including testing, geospatial analysis, and location-based services.",
+    "home_url": "https://rapidapi.com/ryginrauofi3/api/randgenlocality-api/",
+    "name": "RandGenLocality API",
+    "title": "RandGenLocality API",
+    "pricing": "PAID",
+    "tool_name": "RandGenLocality API",
+    "score": {
+        "avgServiceLevel": 100,
+        "avgLatency": 474,
+        "avgSuccessRate": 100,
+        "popularityScore": 9.2,
+        "__typename": "Score"
+    },
+    "host": "randgenlocality-api.p.rapidapi.com",
+    "api_list": [
+        {
+            "name": "newRequest",
+            "url": "https://randgenlocality-api.p.rapidapi.com/api/locality",
+            "description": " ",
+            "method": "POST",
+            "required_parameters": [],
+            "optional_parameters": [],
+            "code": "import requests\n\nurl = \"https://randgenlocality-api.p.rapidapi.com/api/locality\"\n\nheaders = {\n            \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n            \"X-RapidAPI-Host\": \"randgenlocality-api.p.rapidapi.com\"\n        }\n\nresponse = requests.post(url, headers=headers)\nprint(response.json())\n",
+            "convert_code": "import requests\n\nurl = \"https://randgenlocality-api.p.rapidapi.com/api/locality\"\n\nheaders = {\n            \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n            \"X-RapidAPI-Host\": \"randgenlocality-api.p.rapidapi.com\"\n        }\n\nresponse = requests.post(url, headers=headers)\nprint(response.json())\n",
+            "test_endpoint": "",
+            "statuscode": 200,
+            "schema": {
+                "type": "object",
+                "properties": {
+                    "get": {
+                        "type": "string"
+                    },
+                    "parameters": {
+                        "type": "array"
+                    },
+                    "errors": {
+                        "type": "array"
+                    },
+                    "results": {
+                        "type": "integer"
+                    },
+                    "response": {
+                        "type": "array",
+                        "items": {
+                            "type": "object"
+                        }
+                    }
+                }
+            }
+        }
+    ]
+}

toolbench/toolenv/tools/Data/random_article_generator.json

@@ -0,0 +1,116 @@
+{
+    "product_id": "api_55f7d1e2-4c98-4d61-bd63-0faf5bc0302b",
+    "tool_description": "Generates random article with specific word length, keyword density and multiple other parameters.",
+    "home_url": "https://rapidapi.com/bluezero/api/random-article-generator/",
+    "name": "Random Article Generator",
+    "title": "Random Article Generator",
+    "pricing": "FREEMIUM",
+    "tool_name": "Random Article Generator",
+    "score": {
+        "avgServiceLevel": 100,
+        "avgLatency": 391,
+        "avgSuccessRate": 100,
+        "popularityScore": 8.3,
+        "__typename": "Score"
+    },
+    "host": "random-article-generator.p.rapidapi.com",
+    "api_list": [
+        {
+            "name": "Get Article",
+            "url": "https://random-article-generator.p.rapidapi.com/",
+            "description": "Generates random article depending on the settings.",
+            "method": "POST",
+            "required_parameters": [
+                {
+                    "name": "keyword",
+                    "type": "STRING",
+                    "description": "Your keyword around which the article will be written",
+                    "default": "your keyword"
+                }
+            ],
+            "optional_parameters": [
+                {
+                    "name": "wordsMax",
+                    "type": "NUMBER",
+                    "description": "Maximum words per article\nLimit is 5000",
+                    "default": "2000"
+                },
+                {
+                    "name": "minSentencesPerP",
+                    "type": "NUMBER",
+                    "description": "Minimum sentences per paragraph",
+                    "default": "4"
+                },
+                {
+                    "name": "secnondaryKWDensity",
+                    "type": "NUMBER",
+                    "description": "Secondary keywords density",
+                    "default": "5"
+                },
+                {
+                    "name": "maxSentencesPerP",
+                    "type": "NUMBER",
+                    "description": "Maximum sentences per paragraph",
+                    "default": "8"
+                },
+                {
+                    "name": "supporting",
+                    "type": "STRING",
+                    "description": "Supporting keywords separated by new line",
+                    "default": ""
+                },
+                {
+                    "name": "wordsMin",
+                    "type": "NUMBER",
+                    "description": "Minimum words per article\nLimit is 5000",
+                    "default": "2000"
+                },
+                {
+                    "name": "kwDensity",
+                    "type": "NUMBER",
+                    "description": "Keyword density",
+                    "default": "5"
+                },
+                {
+                    "name": "maxSentence",
+                    "type": "NUMBER",
+                    "description": "Maximum words in sentence",
+                    "default": "12"
+                },
+                {
+                    "name": "minSentence",
+                    "type": "NUMBER",
+                    "description": "Minimum words in sentence",
+                    "default": "10"
+                },
+                {
+                    "name": "supportingKWDensity",
+                    "type": "NUMBER",
+                    "description": "Supporting keywords density",
+                    "default": "5"
+                },
+                {
+                    "name": "secondary",
+                    "type": "STRING",
+                    "description": "Secondary keywords separated by new line",
+                    "default": ""
+                },
+                {
+                    "name": "output",
+                    "type": "STRING",
+                    "description": "Output Type (plain, html, htmlp, index)",
+                    "default": "plain"
+                },
+                {
+                    "name": "contentWrapType",
+                    "type": "STRING",
+                    "description": "Content Wrap Type\n\n- randomalpha - words generated from letters\n- randomalphanum - words generated from letters and numbers\n- lorem - lorem ipsum\n- randomenglish - random english words",
+                    "default": "randomenglish"
+                }
+            ],
+            "code": "import requests\n\nurl = \"https://random-article-generator.p.rapidapi.com/\"\nquerystring = {\"wordsMax\": \"2000\", \"minSentencesPerP\": \"4\", \"keyword\": \"your keyword\", \"secnondaryKWDensity\": \"5\", \"maxSentencesPerP\": \"8\", \"supporting\": \"\", \"wordsMin\": \"2000\", \"kwDensity\": \"5\", \"maxSentence\": \"12\", \"minSentence\": \"10\", \"supportingKWDensity\": \"5\", \"secondary\": \"\", \"output\": \"plain\", \"contentWrapType\": \"randomenglish\"}\n\nheaders = {\n            \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n            \"X-RapidAPI-Host\": \"random-article-generator.p.rapidapi.com\"\n        }\n\nresponse = requests.post(url, headers=headers, params=querystring)\nprint(response.json())\n",
+            "convert_code": "import requests\n\nurl = \"https://random-article-generator.p.rapidapi.com/\"\nquerystring = {\"wordsMax\": \"2000\", \"minSentencesPerP\": \"4\", \"keyword\": \"your keyword\", \"secnondaryKWDensity\": \"5\", \"maxSentencesPerP\": \"8\", \"supporting\": \"\", \"wordsMin\": \"2000\", \"kwDensity\": \"5\", \"maxSentence\": \"12\", \"minSentence\": \"10\", \"supportingKWDensity\": \"5\", \"secondary\": \"\", \"output\": \"plain\", \"contentWrapType\": \"randomenglish\"}\n\nheaders = {\n            \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n            \"X-RapidAPI-Host\": \"random-article-generator.p.rapidapi.com\"\n        }\n\nresponse = requests.post(url, headers=headers, params=querystring)\nprint(response.json())\n",
+            "test_endpoint": ""
+        }
+    ]
+}

toolbench/toolenv/tools/Data/random_choise.json

@@ -0,0 +1,54 @@
+{
+    "product_id": "api_0b28d444-70fa-4c68-9bfe-54f60ed88298",
+    "tool_description": "The Random Choice feature is a fun and engaging tool that allows users to make decisions in a spontaneous and exciting way. Whether you're unsure about what to eat for dinner, which movie to watch, or even what activity to do on a weekend, the Random Choice feature has got you covered!  With a simple click or tap, the Random Choice feature selects a random option from a given list, making decision-making entertaining and stress-free. It's like flipping a coin or drawing straws, but in a digit...",
+    "home_url": "https://rapidapi.com/neybamrcr/api/random-choise/",
+    "name": "random choise",
+    "title": "random choise",
+    "pricing": "FREEMIUM",
+    "tool_name": "random choise",
+    "score": {
+        "avgServiceLevel": 100,
+        "avgLatency": 430,
+        "avgSuccessRate": 100,
+        "popularityScore": 9.6,
+        "__typename": "Score"
+    },
+    "host": "random-choise.p.rapidapi.com",
+    "api_list": [
+        {
+            "name": "randomChoise",
+            "url": "https://random-choise.p.rapidapi.com/api/random-choice",
+            "description": " ",
+            "method": "POST",
+            "required_parameters": [],
+            "optional_parameters": [],
+            "code": "import requests\n\nurl = \"https://random-choise.p.rapidapi.com/api/random-choice\"\n\nheaders = {\n            \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n            \"X-RapidAPI-Host\": \"random-choise.p.rapidapi.com\"\n        }\n\nresponse = requests.post(url, headers=headers)\nprint(response.json())\n",
+            "convert_code": "import requests\n\nurl = \"https://random-choise.p.rapidapi.com/api/random-choice\"\n\nheaders = {\n            \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n            \"X-RapidAPI-Host\": \"random-choise.p.rapidapi.com\"\n        }\n\nresponse = requests.post(url, headers=headers)\nprint(response.json())\n",
+            "test_endpoint": "",
+            "statuscode": 200,
+            "schema": {
+                "type": "object",
+                "properties": {
+                    "get": {
+                        "type": "string"
+                    },
+                    "parameters": {
+                        "type": "array"
+                    },
+                    "errors": {
+                        "type": "array"
+                    },
+                    "results": {
+                        "type": "integer"
+                    },
+                    "response": {
+                        "type": "array",
+                        "items": {
+                            "type": "object"
+                        }
+                    }
+                }
+            }
+        }
+    ]
+}

toolbench/toolenv/tools/Data/random_choose_champion_legend_of_league.json

@@ -0,0 +1,54 @@
+{
+    "product_id": "api_0002064d-9187-485c-9b5f-d18a0ff4e120",
+    "tool_description": "The League of Legends Random Champion API allows developers and gamers to retrieve information about a randomly chosen League of Legends champion. This API provides an easy way to introduce variety and fun into the gaming experience by randomly selecting a champion for the player to use in their next match.",
+    "home_url": "https://rapidapi.com/karimymelvyd/api/random-choose-champion-legend-of-league/",
+    "name": "random choose champion legend of league",
+    "title": "random choose champion legend of league",
+    "pricing": "FREEMIUM",
+    "tool_name": "random choose champion legend of league",
+    "score": {
+        "avgServiceLevel": 100,
+        "avgLatency": 436,
+        "avgSuccessRate": 100,
+        "popularityScore": 9.6,
+        "__typename": "Score"
+    },
+    "host": "random-choose-champion-legend-of-league.p.rapidapi.com",
+    "api_list": [
+        {
+            "name": "postChampion",
+            "url": "https://random-choose-champion-legend-of-league.p.rapidapi.com/api/champion",
+            "description": " ",
+            "method": "POST",
+            "required_parameters": [],
+            "optional_parameters": [],
+            "code": "import requests\n\nurl = \"https://random-choose-champion-legend-of-league.p.rapidapi.com/api/champion\"\n\nheaders = {\n            \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n            \"X-RapidAPI-Host\": \"random-choose-champion-legend-of-league.p.rapidapi.com\"\n        }\n\nresponse = requests.post(url, headers=headers)\nprint(response.json())\n",
+            "convert_code": "import requests\n\nurl = \"https://random-choose-champion-legend-of-league.p.rapidapi.com/api/champion\"\n\nheaders = {\n            \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n            \"X-RapidAPI-Host\": \"random-choose-champion-legend-of-league.p.rapidapi.com\"\n        }\n\nresponse = requests.post(url, headers=headers)\nprint(response.json())\n",
+            "test_endpoint": "",
+            "statuscode": 200,
+            "schema": {
+                "type": "object",
+                "properties": {
+                    "get": {
+                        "type": "string"
+                    },
+                    "parameters": {
+                        "type": "array"
+                    },
+                    "errors": {
+                        "type": "array"
+                    },
+                    "results": {
+                        "type": "integer"
+                    },
+                    "response": {
+                        "type": "array",
+                        "items": {
+                            "type": "object"
+                        }
+                    }
+                }
+            }
+        }
+    ]
+}

toolbench/toolenv/tools/Data/random_chunk_api.json

@@ -0,0 +1,529 @@
+{
+    "tool_name": "Random Chunk API",
+    "tool_description": "A simple random picker for names, movies, TV shows, quotes, and numbers. A simple JSON object, user object, and array generator.",
+    "title": "Random Chunk API",
+    "pricing": "FREEMIUM",
+    "score": {
+        "avgServiceLevel": 100,
+        "avgLatency": 30405,
+        "avgSuccessRate": 92,
+        "popularityScore": 8.7,
+        "__typename": "Score"
+    },
+    "home_url": "https://rapidapi.com/rur209-fl23Nrvhxii/api/random-chunk-api/",
+    "host": "random-chunk-api.p.rapidapi.com",
+    "api_list": [
+        {
+            "name": "getRandomColor",
+            "url": "https://random-chunk-api.p.rapidapi.com/api/color",
+            "description": "Get a random quote.",
+            "method": "GET",
+            "required_parameters": [],
+            "optional_parameters": [],
+            "code": "import requests\n\nurl = \"https://random-chunk-api.p.rapidapi.com/api/color\"\n\nheaders = {\n    \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n    \"X-RapidAPI-Host\": \"random-chunk-api.p.rapidapi.com\"\n}\n\nresponse = requests.get(url, headers=headers)\n\nprint(response.json())\n",
+            "statuscode": 200,
+            "body": {},
+            "headers": {},
+            "schema": {
+                "type": "object",
+                "properties": {
+                    "get": {
+                        "type": "string"
+                    },
+                    "parameters": {
+                        "type": "array"
+                    },
+                    "errors": {
+                        "type": "array"
+                    },
+                    "results": {
+                        "type": "integer"
+                    },
+                    "response": {
+                        "type": "array",
+                        "items": {
+                            "type": "object"
+                        }
+                    }
+                }
+            }
+        },
+        {
+            "name": "getRandomQuote",
+            "url": "https://random-chunk-api.p.rapidapi.com/api/quote",
+            "description": "Get a random quote.",
+            "method": "GET",
+            "required_parameters": [],
+            "optional_parameters": [
+                {
+                    "name": "category",
+                    "type": "STRING",
+                    "description": "",
+                    "default": "life"
+                },
+                {
+                    "name": "count",
+                    "type": "NUMBER",
+                    "description": "",
+                    "default": "1"
+                }
+            ],
+            "code": "import requests\n\nurl = \"https://random-chunk-api.p.rapidapi.com/api/quote\"\nquerystring = {\"category\": category, \"count\": count}\n\nheaders = {\n    \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n    \"X-RapidAPI-Host\": \"random-chunk-api.p.rapidapi.com\"\n}\n\nresponse = requests.get(url, headers=headers, params=querystring)\n\nprint(response.json())\n",
+            "statuscode": 200,
+            "body": {},
+            "headers": {},
+            "schema": {
+                "type": "object",
+                "properties": {
+                    "get": {
+                        "type": "string"
+                    },
+                    "parameters": {
+                        "type": "array"
+                    },
+                    "errors": {
+                        "type": "array"
+                    },
+                    "results": {
+                        "type": "integer"
+                    },
+                    "response": {
+                        "type": "array",
+                        "items": {
+                            "type": "object"
+                        }
+                    }
+                }
+            }
+        },
+        {
+            "name": "getRandomArray",
+            "url": "https://random-chunk-api.p.rapidapi.com/api/array",
+            "description": "Generate a random array with numbers, words or mixed values.",
+            "method": "GET",
+            "required_parameters": [],
+            "optional_parameters": [
+                {
+                    "name": "data_type",
+                    "type": "STRING",
+                    "description": "",
+                    "default": "string"
+                },
+                {
+                    "name": "size",
+                    "type": "NUMBER",
+                    "description": "",
+                    "default": "5"
+                }
+            ],
+            "code": "import requests\n\nurl = \"https://random-chunk-api.p.rapidapi.com/api/array\"\nquerystring = {\"data_type\": data_type, \"size\": size}\n\nheaders = {\n    \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n    \"X-RapidAPI-Host\": \"random-chunk-api.p.rapidapi.com\"\n}\n\nresponse = requests.get(url, headers=headers, params=querystring)\n\nprint(response.json())\n",
+            "statuscode": 200,
+            "body": {},
+            "headers": {},
+            "schema": {
+                "type": "object",
+                "properties": {
+                    "get": {
+                        "type": "string"
+                    },
+                    "parameters": {
+                        "type": "array"
+                    },
+                    "errors": {
+                        "type": "array"
+                    },
+                    "results": {
+                        "type": "integer"
+                    },
+                    "response": {
+                        "type": "array",
+                        "items": {
+                            "type": "object"
+                        }
+                    }
+                }
+            }
+        },
+        {
+            "name": "getRandomWord",
+            "url": "https://random-chunk-api.p.rapidapi.com/api/word",
+            "description": "Get random words.",
+            "method": "GET",
+            "required_parameters": [],
+            "optional_parameters": [
+                {
+                    "name": "type",
+                    "type": "STRING",
+                    "description": "",
+                    "default": "adjective"
+                },
+                {
+                    "name": "count",
+                    "type": "NUMBER",
+                    "description": "",
+                    "default": "1"
+                }
+            ],
+            "code": "import requests\n\nurl = \"https://random-chunk-api.p.rapidapi.com/api/word\"\nquerystring = {\"type\": type, \"count\": count}\n\nheaders = {\n    \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n    \"X-RapidAPI-Host\": \"random-chunk-api.p.rapidapi.com\"\n}\n\nresponse = requests.get(url, headers=headers, params=querystring)\n\nprint(response.json())\n",
+            "statuscode": 200,
+            "body": {},
+            "headers": {},
+            "schema": {
+                "type": "object",
+                "properties": {
+                    "get": {
+                        "type": "string"
+                    },
+                    "parameters": {
+                        "type": "array"
+                    },
+                    "errors": {
+                        "type": "array"
+                    },
+                    "results": {
+                        "type": "integer"
+                    },
+                    "response": {
+                        "type": "array",
+                        "items": {
+                            "type": "object"
+                        }
+                    }
+                }
+            }
+        },
+        {
+            "name": "getRandomTvshow",
+            "url": "https://random-chunk-api.p.rapidapi.com/api/tvshow",
+            "description": "Returns random TVshows.",
+            "method": "GET",
+            "required_parameters": [],
+            "optional_parameters": [],
+            "code": "import requests\n\nurl = \"https://random-chunk-api.p.rapidapi.com/api/tvshow\"\n\nheaders = {\n    \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n    \"X-RapidAPI-Host\": \"random-chunk-api.p.rapidapi.com\"\n}\n\nresponse = requests.get(url, headers=headers)\n\nprint(response.json())\n",
+            "statuscode": 200,
+            "body": {},
+            "headers": {},
+            "schema": {
+                "type": "object",
+                "properties": {
+                    "get": {
+                        "type": "string"
+                    },
+                    "parameters": {
+                        "type": "array"
+                    },
+                    "errors": {
+                        "type": "array"
+                    },
+                    "results": {
+                        "type": "integer"
+                    },
+                    "response": {
+                        "type": "array",
+                        "items": {
+                            "type": "object"
+                        }
+                    }
+                }
+            }
+        },
+        {
+            "name": "getRandomMovie",
+            "url": "https://random-chunk-api.p.rapidapi.com/api/movie",
+            "description": "Returns random movies from over 1000 movie list.",
+            "method": "GET",
+            "required_parameters": [],
+            "optional_parameters": [
+                {
+                    "name": "count",
+                    "type": "NUMBER",
+                    "description": "",
+                    "default": "2"
+                }
+            ],
+            "code": "import requests\n\nurl = \"https://random-chunk-api.p.rapidapi.com/api/movie\"\nquerystring = {\"count\": count}\n\nheaders = {\n    \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n    \"X-RapidAPI-Host\": \"random-chunk-api.p.rapidapi.com\"\n}\n\nresponse = requests.get(url, headers=headers, params=querystring)\n\nprint(response.json())\n",
+            "statuscode": 200,
+            "body": {},
+            "headers": {},
+            "schema": {
+                "type": "object",
+                "properties": {
+                    "get": {
+                        "type": "string"
+                    },
+                    "parameters": {
+                        "type": "array"
+                    },
+                    "errors": {
+                        "type": "array"
+                    },
+                    "results": {
+                        "type": "integer"
+                    },
+                    "response": {
+                        "type": "array",
+                        "items": {
+                            "type": "object"
+                        }
+                    }
+                }
+            }
+        },
+        {
+            "name": "getRandomUser",
+            "url": "https://random-chunk-api.p.rapidapi.com/api/user",
+            "description": "Returns random user data such as name, e-mail, etc.",
+            "method": "GET",
+            "required_parameters": [],
+            "optional_parameters": [
+                {
+                    "name": "count",
+                    "type": "NUMBER",
+                    "description": "",
+                    "default": "-2"
+                }
+            ],
+            "code": "import requests\n\nurl = \"https://random-chunk-api.p.rapidapi.com/api/user\"\nquerystring = {\"count\": count}\n\nheaders = {\n    \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n    \"X-RapidAPI-Host\": \"random-chunk-api.p.rapidapi.com\"\n}\n\nresponse = requests.get(url, headers=headers, params=querystring)\n\nprint(response.json())\n",
+            "statuscode": 200,
+            "body": {},
+            "headers": {},
+            "schema": {
+                "type": "object",
+                "properties": {
+                    "get": {
+                        "type": "string"
+                    },
+                    "parameters": {
+                        "type": "array"
+                    },
+                    "errors": {
+                        "type": "array"
+                    },
+                    "results": {
+                        "type": "integer"
+                    },
+                    "response": {
+                        "type": "array",
+                        "items": {
+                            "type": "object"
+                        }
+                    }
+                }
+            }
+        },
+        {
+            "name": "getRandomName",
+            "url": "https://random-chunk-api.p.rapidapi.com/api/name",
+            "description": "Returns random people's names..",
+            "method": "GET",
+            "required_parameters": [],
+            "optional_parameters": [
+                {
+                    "name": "count",
+                    "type": "NUMBER",
+                    "description": "",
+                    "default": "2"
+                },
+                {
+                    "name": "startingLetter",
+                    "type": "STRING",
+                    "description": "",
+                    "default": "X"
+                },
+                {
+                    "name": "type",
+                    "type": "STRING",
+                    "description": "",
+                    "default": ""
+                }
+            ],
+            "code": "import requests\n\nurl = \"https://random-chunk-api.p.rapidapi.com/api/name\"\nquerystring = {\"count\": count, \"startingLetter\": startingletter}\n\nheaders = {\n    \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n    \"X-RapidAPI-Host\": \"random-chunk-api.p.rapidapi.com\"\n}\n\nresponse = requests.get(url, headers=headers, params=querystring)\n\nprint(response.json())\n",
+            "statuscode": 200,
+            "body": {},
+            "headers": {},
+            "schema": {
+                "type": "object",
+                "properties": {
+                    "get": {
+                        "type": "string"
+                    },
+                    "parameters": {
+                        "type": "array"
+                    },
+                    "errors": {
+                        "type": "array"
+                    },
+                    "results": {
+                        "type": "integer"
+                    },
+                    "response": {
+                        "type": "array",
+                        "items": {
+                            "type": "object"
+                        }
+                    }
+                }
+            }
+        },
+        {
+            "name": "getRandomObject",
+            "url": "https://random-chunk-api.p.rapidapi.com/api/object",
+            "description": "Generate simple single-level JSON objects by specifying a JSON object schema with the keys name and value type(boolean, array,)",
+            "method": "POST",
+            "required_parameters": [],
+            "optional_parameters": [],
+            "code": "import requests\n\nurl = \"https://random-chunk-api.p.rapidapi.com/api/object\"\n\nheaders = {\n    \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n    \"X-RapidAPI-Host\": \"random-chunk-api.p.rapidapi.com\"\n}\n\nresponse = requests.post(url, headers=headers)\n\nprint(response.json())\n",
+            "statuscode": 200,
+            "body": {},
+            "headers": {},
+            "schema": {
+                "type": "object",
+                "properties": {
+                    "get": {
+                        "type": "string"
+                    },
+                    "parameters": {
+                        "type": "array"
+                    },
+                    "errors": {
+                        "type": "array"
+                    },
+                    "results": {
+                        "type": "integer"
+                    },
+                    "response": {
+                        "type": "array",
+                        "items": {
+                            "type": "object"
+                        }
+                    }
+                }
+            }
+        },
+        {
+            "name": "getRandomDate",
+            "url": "https://random-chunk-api.p.rapidapi.com/api/date",
+            "description": "Get random date.",
+            "method": "GET",
+            "required_parameters": [],
+            "optional_parameters": [
+                {
+                    "name": "start",
+                    "type": "STRING",
+                    "description": "",
+                    "default": "2022-08-21"
+                },
+                {
+                    "name": "end",
+                    "type": "STRING",
+                    "description": "",
+                    "default": "2023-12-30"
+                }
+            ],
+            "code": "import requests\n\nurl = \"https://random-chunk-api.p.rapidapi.com/api/date\"\nquerystring = {\"start\": start, \"end\": end}\n\nheaders = {\n    \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n    \"X-RapidAPI-Host\": \"random-chunk-api.p.rapidapi.com\"\n}\n\nresponse = requests.get(url, headers=headers, params=querystring)\n\nprint(response.json())\n",
+            "statuscode": 200,
+            "body": {},
+            "headers": {},
+            "schema": {
+                "type": "object",
+                "properties": {
+                    "get": {
+                        "type": "string"
+                    },
+                    "parameters": {
+                        "type": "array"
+                    },
+                    "errors": {
+                        "type": "array"
+                    },
+                    "results": {
+                        "type": "integer"
+                    },
+                    "response": {
+                        "type": "array",
+                        "items": {
+                            "type": "object"
+                        }
+                    }
+                }
+            }
+        },
+        {
+            "name": "getRandomPassword",
+            "url": "https://random-chunk-api.p.rapidapi.com/api/password",
+            "description": "Get random password string.",
+            "method": "GET",
+            "required_parameters": [],
+            "optional_parameters": [
+                {
+                    "name": "length",
+                    "type": "NUMBER",
+                    "description": "",
+                    "default": "10"
+                }
+            ],
+            "code": "import requests\n\nurl = \"https://random-chunk-api.p.rapidapi.com/api/password\"\nquerystring = {\"length\": length}\n\nheaders = {\n    \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n    \"X-RapidAPI-Host\": \"random-chunk-api.p.rapidapi.com\"\n}\n\nresponse = requests.get(url, headers=headers, params=querystring)\n\nprint(response.json())\n",
+            "statuscode": 200,
+            "body": {},
+            "headers": {},
+            "schema": {
+                "type": "object",
+                "properties": {
+                    "get": {
+                        "type": "string"
+                    },
+                    "parameters": {
+                        "type": "array"
+                    },
+                    "errors": {
+                        "type": "array"
+                    },
+                    "results": {
+                        "type": "integer"
+                    },
+                    "response": {
+                        "type": "array",
+                        "items": {
+                            "type": "object"
+                        }
+                    }
+                }
+            }
+        },
+        {
+            "name": "getRandomObject",
+            "url": "https://random-chunk-api.p.rapidapi.com/api/object",
+            "description": "Generate simple single-level JSON objects by specifying a JSON object schema with the keys name and value type(boolean, array,)",
+            "method": "POST",
+            "required_parameters": [],
+            "optional_parameters": [],
+            "code": "import requests\n\nurl = \"https://random-chunk-api.p.rapidapi.com/api/object\"\n\nheaders = {\n            \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n            \"X-RapidAPI-Host\": \"random-chunk-api.p.rapidapi.com\"\n        }\n\nresponse = requests.post(url, headers=headers)\nprint(response.json())\n",
+            "convert_code": "import requests\n\nurl = \"https://random-chunk-api.p.rapidapi.com/api/object\"\n\nheaders = {\n            \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n            \"X-RapidAPI-Host\": \"random-chunk-api.p.rapidapi.com\"\n        }\n\nresponse = requests.post(url, headers=headers)\nprint(response.json())\n",
+            "test_endpoint": "",
+            "statuscode": 200,
+            "schema": {
+                "type": "object",
+                "properties": {
+                    "get": {
+                        "type": "string"
+                    },
+                    "parameters": {
+                        "type": "array"
+                    },
+                    "errors": {
+                        "type": "array"
+                    },
+                    "results": {
+                        "type": "integer"
+                    },
+                    "response": {
+                        "type": "array",
+                        "items": {
+                            "type": "object"
+                        }
+                    }
+                }
+            }
+        }
+    ]
+}

toolbench/toolenv/tools/Data/random_chunk_api/api.py

@@ -0,0 +1,246 @@
+import requests
+import json
+from datetime import date, datetime, timedelta
+import os
+
+from typing import Optional, Dict, Union, List
+
+
+def getrandomcolor(toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "Get a random quote."
+    
+    """
+    url = f"https://random-chunk-api.p.rapidapi.com/api/color"
+    querystring = {}
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "random-chunk-api.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+
+def getrandomquote(category: str='life', count: int=1, toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "Get a random quote."
+    
+    """
+    url = f"https://random-chunk-api.p.rapidapi.com/api/quote"
+    querystring = {}
+    if category:
+        querystring['category'] = category
+    if count:
+        querystring['count'] = count
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "random-chunk-api.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+
+def getrandomarray(data_type: str='string', size: int=5, toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "Generate a random array with numbers, words or mixed values."
+    
+    """
+    url = f"https://random-chunk-api.p.rapidapi.com/api/array"
+    querystring = {}
+    if data_type:
+        querystring['data_type'] = data_type
+    if size:
+        querystring['size'] = size
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "random-chunk-api.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+
+def getrandomword(type: str='adjective', count: int=1, toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "Get random words."
+    
+    """
+    url = f"https://random-chunk-api.p.rapidapi.com/api/word"
+    querystring = {}
+    if type:
+        querystring['type'] = type
+    if count:
+        querystring['count'] = count
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "random-chunk-api.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+
+def getrandomtvshow(toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "Returns random TVshows."
+    
+    """
+    url = f"https://random-chunk-api.p.rapidapi.com/api/tvshow"
+    querystring = {}
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "random-chunk-api.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+
+def getrandommovie(count: int=2, toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "Returns random movies from over 1000 movie list."
+    
+    """
+    url = f"https://random-chunk-api.p.rapidapi.com/api/movie"
+    querystring = {}
+    if count:
+        querystring['count'] = count
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "random-chunk-api.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+
+def getrandomuser(count: int=-2, toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "Returns random user data such as name, e-mail, etc."
+    
+    """
+    url = f"https://random-chunk-api.p.rapidapi.com/api/user"
+    querystring = {}
+    if count:
+        querystring['count'] = count
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "random-chunk-api.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+
+def getrandomname(count: int=2, startingletter: str='X', type: str=None, toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "Returns random people's names.."
+    
+    """
+    url = f"https://random-chunk-api.p.rapidapi.com/api/name"
+    querystring = {}
+    if count:
+        querystring['count'] = count
+    if startingletter:
+        querystring['startingLetter'] = startingletter
+    if type:
+        querystring['type'] = type
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "random-chunk-api.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+
+def getrandomdate(start: str='2022-08-21', end: str='2023-12-30', toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "Get random date."
+    
+    """
+    url = f"https://random-chunk-api.p.rapidapi.com/api/date"
+    querystring = {}
+    if start:
+        querystring['start'] = start
+    if end:
+        querystring['end'] = end
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "random-chunk-api.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+
+def getrandompassword(length: int=10, toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "Get random password string."
+    
+    """
+    url = f"https://random-chunk-api.p.rapidapi.com/api/password"
+    querystring = {}
+    if length:
+        querystring['length'] = length
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "random-chunk-api.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+

toolbench/toolenv/tools/Data/random_dog_photos/api.py

@@ -0,0 +1,29 @@
+import requests
+import json
+from datetime import date, datetime, timedelta
+import os
+
+from typing import Optional, Dict, Union, List
+
+
+def dog_photo_getter(toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "Takes a 'GET' request and returns a random dog photo from the internet"
+    
+    """
+    url = f"https://random-dog-photos.p.rapidapi.com/dog"
+    querystring = {}
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "random-dog-photos.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+

toolbench/toolenv/tools/Data/random_fact.json

@@ -0,0 +1,54 @@
+{
+    "product_id": "api_529e5c65-29c8-4693-a051-6079f4196224",
+    "tool_description": "fact for live random ",
+    "home_url": "https://rapidapi.com/ClaudiaEcon/api/random-fact3/",
+    "name": "random- fact",
+    "title": "random- fact",
+    "pricing": "PAID",
+    "tool_name": "random- fact",
+    "score": {
+        "avgServiceLevel": 100,
+        "avgLatency": 433,
+        "avgSuccessRate": 100,
+        "popularityScore": 9.5,
+        "__typename": "Score"
+    },
+    "host": "random-fact3.p.rapidapi.com",
+    "api_list": [
+        {
+            "name": "postRandomHumman",
+            "url": "https://random-fact3.p.rapidapi.com/api/random-fact",
+            "description": " ",
+            "method": "POST",
+            "required_parameters": [],
+            "optional_parameters": [],
+            "code": "import requests\n\nurl = \"https://random-fact3.p.rapidapi.com/api/random-fact\"\n\nheaders = {\n            \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n            \"X-RapidAPI-Host\": \"random-fact3.p.rapidapi.com\"\n        }\n\nresponse = requests.post(url, headers=headers)\nprint(response.json())\n",
+            "convert_code": "import requests\n\nurl = \"https://random-fact3.p.rapidapi.com/api/random-fact\"\n\nheaders = {\n            \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n            \"X-RapidAPI-Host\": \"random-fact3.p.rapidapi.com\"\n        }\n\nresponse = requests.post(url, headers=headers)\nprint(response.json())\n",
+            "test_endpoint": "",
+            "statuscode": 200,
+            "schema": {
+                "type": "object",
+                "properties": {
+                    "get": {
+                        "type": "string"
+                    },
+                    "parameters": {
+                        "type": "array"
+                    },
+                    "errors": {
+                        "type": "array"
+                    },
+                    "results": {
+                        "type": "integer"
+                    },
+                    "response": {
+                        "type": "array",
+                        "items": {
+                            "type": "object"
+                        }
+                    }
+                }
+            }
+        }
+    ]
+}

toolbench/toolenv/tools/Data/random_famous_quotes.json

@@ -0,0 +1,46 @@
+{
+    "product_id": "53aa60e3e4b0a798dbd1bca3",
+    "tool_description": "Get a random quote in JSON format. \r\n\r\nCurrent categories are:\r\n- famous\r\n- movies",
+    "home_url": "https://rapidapi.com/andruxnet/api/random-famous-quotes/",
+    "name": "Random Famous Quotes",
+    "title": "Random Famous Quotes",
+    "pricing": "FREEMIUM",
+    "tool_name": "Random Famous Quotes",
+    "score": {
+        "avgServiceLevel": 100,
+        "avgLatency": 448,
+        "avgSuccessRate": 100,
+        "popularityScore": 9.7,
+        "__typename": "Score"
+    },
+    "host": "andruxnet-random-famous-quotes.p.rapidapi.com",
+    "api_list": [
+        {
+            "name": "POST endpoint",
+            "url": "https://andruxnet-random-famous-quotes.p.rapidapi.com/",
+            "description": "Post endpoint for quotes by famous people or from popular movies",
+            "method": "POST",
+            "required_parameters": [
+                {
+                    "name": "cat",
+                    "type": "STRING",
+                    "description": "can be either \"movies\" or \"famous\"",
+                    "default": "movies"
+                }
+            ],
+            "optional_parameters": [
+                {
+                    "name": "count",
+                    "type": "NUMBER",
+                    "description": "Number of quotes to return. If omitted, a single quote will be returned. Max number of quotes is 10",
+                    "default": "10"
+                }
+            ],
+            "code": "import requests\n\nurl = \"https://andruxnet-random-famous-quotes.p.rapidapi.com/\"\nquerystring = {\"count\": \"10\", \"cat\": \"movies\"}\n\nheaders = {\n            \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n            \"X-RapidAPI-Host\": \"andruxnet-random-famous-quotes.p.rapidapi.com\"\n        }\n\nresponse = requests.post(url, headers=headers, params=querystring)\nprint(response.json())\n",
+            "convert_code": "import requests\n\nurl = \"https://andruxnet-random-famous-quotes.p.rapidapi.com/\"\nquerystring = {\"count\": \"10\", \"cat\": \"movies\"}\n\nheaders = {\n            \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n            \"X-RapidAPI-Host\": \"andruxnet-random-famous-quotes.p.rapidapi.com\"\n        }\n\nresponse = requests.post(url, headers=headers, params=querystring)\nprint(response.json())\n",
+            "test_endpoint": "",
+            "statuscode": 1,
+            "schema": ""
+        }
+    ]
+}

toolbench/toolenv/tools/Data/random_famous_quotes/api.py

@@ -0,0 +1,35 @@
+import requests
+import json
+from datetime import date, datetime, timedelta
+import os
+
+from typing import Optional, Dict, Union, List
+
+
+def get_endpoint(cat: str='famous', count: int=10, toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "Get endpoint for quotes by famous people or from popular movies"
+    cat: Get quotes inside any of these categories:  "movies" or "famous". If not present get quotes from any category.
+        count: Number of quotes to return. If omitted, a single quote will be returned. Max number of quotes is 10
+        
+    """
+    url = f"https://andruxnet-random-famous-quotes.p.rapidapi.com/"
+    querystring = {}
+    if cat:
+        querystring['cat'] = cat
+    if count:
+        querystring['count'] = count
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "andruxnet-random-famous-quotes.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+

toolbench/toolenv/tools/Data/random_identity_generator/api.py

@@ -0,0 +1,39 @@
+import requests
+import json
+from datetime import date, datetime, timedelta
+import os
+
+from typing import Optional, Dict, Union, List
+
+
+def get_random_identity_default_format(gender: str='male', minage: str='18', maxage: str='65', country: str='us', nameset: str='american', toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "Get a random identity base on the parametes/query provided."
+    
+    """
+    url = f"https://random-identity-generator.p.rapidapi.com/identity"
+    querystring = {}
+    if gender:
+        querystring['gender'] = gender
+    if minage:
+        querystring['minAge'] = minage
+    if maxage:
+        querystring['maxAge'] = maxage
+    if country:
+        querystring['country'] = country
+    if nameset:
+        querystring['nameSet'] = nameset
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "random-identity-generator.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+

toolbench/toolenv/tools/Data/random_indonesian_word.json

@@ -0,0 +1,37 @@
+{
+    "tool_name":"Random Indonesian Word",
+    "tool_description":"An API to get randomize word in Indonesia Language.",
+    "title":"Random Indonesian Word",
+    "pricing":"PAID",
+    "score":{
+        "avgServiceLevel":100,
+        "avgLatency":686,
+        "avgSuccessRate":100,
+        "popularityScore":8.8,
+        "__typename":"Score"
+    },
+    "home_url":"https://rapidapi.com/pararang/api/random-indonesian-word/",
+    "host":"random-indonesian-word.p.rapidapi.com",
+    "api_list":[
+        {
+            "name":"Get Random Words",
+            "url":"https://random-indonesian-word.p.rapidapi.com/words/random",
+            "description":"Get random words in Indonesia Language,  minimal 1 word, and maximal 32 words. The long will be greater than 2 characters.",
+            "method":"GET",
+            "required_parameters":[],
+            "optional_parameters":[
+                {
+                    "name":"limit",
+                    "type":"NUMBER",
+                    "description":"total word, between 1-32",
+                    "default":"5"
+                }
+            ],
+            "code":"import requests\n\nurl = \"https://random-indonesian-word.p.rapidapi.com/words/random\"\nquerystring = {\"limit\": limit}\n\nheaders = {\n    \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n    \"X-RapidAPI-Host\": \"random-indonesian-word.p.rapidapi.com\"\n}\n\nresponse = requests.get(url, headers=headers, params=querystring)\n\nprint(response.json())\n",
+            "statuscode":111,
+            "body":"",
+            "headers":"",
+            "schema":""
+        }
+    ]
+}

toolbench/toolenv/tools/Data/random_indonesian_word/api.py

@@ -0,0 +1,32 @@
+import requests
+import json
+from datetime import date, datetime, timedelta
+import os
+
+from typing import Optional, Dict, Union, List
+
+
+def get_random_words(limit: int=5, toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "Get random words in Indonesia Language,  minimal 1 word, and maximal 32 words. The long will be greater than 2 characters."
+    limit: total word, between 1-32
+        
+    """
+    url = f"https://random-indonesian-word.p.rapidapi.com/words/random"
+    querystring = {}
+    if limit:
+        querystring['limit'] = limit
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "random-indonesian-word.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+

toolbench/toolenv/tools/Data/random_mockup_person.json

@@ -0,0 +1,54 @@
+{
+    "product_id": "api_949c4221-b6cd-48be-911c-86c8bdb29d02",
+    "tool_description": "random mockup person",
+    "home_url": "https://rapidapi.com/jamebornn/api/random-mockup-person/",
+    "name": "random mockup person",
+    "title": "random mockup person",
+    "pricing": "FREEMIUM",
+    "tool_name": "random mockup person",
+    "score": {
+        "avgServiceLevel": 100,
+        "avgLatency": 436,
+        "avgSuccessRate": 100,
+        "popularityScore": 9.7,
+        "__typename": "Score"
+    },
+    "host": "random-mockup-person.p.rapidapi.com",
+    "api_list": [
+        {
+            "name": "getListPerson",
+            "url": "https://random-mockup-person.p.rapidapi.com/api/v1/get-list",
+            "description": " ",
+            "method": "POST",
+            "required_parameters": [],
+            "optional_parameters": [],
+            "code": "import requests\n\nurl = \"https://random-mockup-person.p.rapidapi.com/api/v1/get-list\"\n\nheaders = {\n            \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n            \"X-RapidAPI-Host\": \"random-mockup-person.p.rapidapi.com\"\n        }\n\nresponse = requests.post(url, headers=headers)\nprint(response.json())\n",
+            "convert_code": "import requests\n\nurl = \"https://random-mockup-person.p.rapidapi.com/api/v1/get-list\"\n\nheaders = {\n            \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n            \"X-RapidAPI-Host\": \"random-mockup-person.p.rapidapi.com\"\n        }\n\nresponse = requests.post(url, headers=headers)\nprint(response.json())\n",
+            "test_endpoint": "",
+            "statuscode": 200,
+            "schema": {
+                "type": "object",
+                "properties": {
+                    "get": {
+                        "type": "string"
+                    },
+                    "parameters": {
+                        "type": "array"
+                    },
+                    "errors": {
+                        "type": "array"
+                    },
+                    "results": {
+                        "type": "integer"
+                    },
+                    "response": {
+                        "type": "array",
+                        "items": {
+                            "type": "object"
+                        }
+                    }
+                }
+            }
+        }
+    ]
+}

toolbench/toolenv/tools/Data/random_name_and_gender_generator.json

@@ -0,0 +1,45 @@
+{
+    "tool_name":"Random Name and Gender Generator",
+    "tool_description":"returning random first name , last name and gender (fake)",
+    "title":"Random Name and Gender Generator",
+    "pricing":"FREEMIUM",
+    "score":{
+        "avgServiceLevel":100,
+        "avgLatency":666,
+        "avgSuccessRate":100,
+        "popularityScore":8.3,
+        "__typename":"Score"
+    },
+    "home_url":"https://rapidapi.com/cvexa/api/random-name-and-gender-generator/",
+    "host":"random-name-and-gender-generator.p.rapidapi.com",
+    "api_list":[
+        {
+            "name":"get random first name , last name and gender",
+            "url":"https://random-name-and-gender-generator.p.rapidapi.com/",
+            "description":"get random first name , last name and gender",
+            "method":"GET",
+            "required_parameters":[],
+            "optional_parameters":[],
+            "code":"import requests\n\nurl = \"https://random-name-and-gender-generator.p.rapidapi.com/\"\n\nheaders = {\n    \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n    \"X-RapidAPI-Host\": \"random-name-and-gender-generator.p.rapidapi.com\"\n}\n\nresponse = requests.get(url, headers=headers)\n\nprint(response.json())\n",
+            "statuscode":200,
+            "body":{
+                "firstName":"Stokes",
+                "lastName":"Colon",
+                "gender":"male"
+            },
+            "headers":{
+                "access-control-allow-credentials":"true",
+                "access-control-allow-origin":"*",
+                "connection":"keep-alive",
+                "content-length":"57",
+                "content-type":"application/json",
+                "date":"Tue, 09 Nov 2021 15:45:08 GMT",
+                "server":"RapidAPI-1.2.8",
+                "via":"1.1 vegur",
+                "x-rapidapi-region":"AWS - eu-central-1",
+                "x-rapidapi-version":"1.2.8"
+            },
+            "schema":{}
+        }
+    ]
+}

toolbench/toolenv/tools/Data/random_name_and_gender_generator/api.py

@@ -0,0 +1,29 @@
+import requests
+import json
+from datetime import date, datetime, timedelta
+import os
+
+from typing import Optional, Dict, Union, List
+
+
+def get_random_first_name_last_name_and_gender(toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "get random first name , last name and gender"
+    
+    """
+    url = f"https://random-name-and-gender-generator.p.rapidapi.com/"
+    querystring = {}
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "random-name-and-gender-generator.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+

toolbench/toolenv/tools/Data/random_quote_api/api.py

@@ -0,0 +1,29 @@
+import requests
+import json
+from datetime import date, datetime, timedelta
+import os
+
+from typing import Optional, Dict, Union, List
+
+
+def get_random_quote(toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "Get a random quote with a single HTTP request in a matter of milliseconds."
+    
+    """
+    url = f"https://random-quote-api3.p.rapidapi.com/"
+    querystring = {}
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "random-quote-api3.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+

toolbench/toolenv/tools/Data/random_quotes.json

@@ -0,0 +1,30 @@
+{
+    "product_id": "api_fb58d39e-ff5c-4c74-baac-f7ea94360a67",
+    "tool_description": "random about quotes, get and post quotes from topic",
+    "home_url": "https://rapidapi.com/Consufi/api/random-quotes18/",
+    "name": "random quotes",
+    "title": "random quotes",
+    "pricing": "FREEMIUM",
+    "tool_name": "random quotes",
+    "score": {
+        "avgServiceLevel": 100,
+        "avgLatency": 437,
+        "avgSuccessRate": 100,
+        "popularityScore": 9.7,
+        "__typename": "Score"
+    },
+    "host": "random-quotes18.p.rapidapi.com",
+    "api_list": [
+        {
+            "name": "postTopic",
+            "url": "https://random-quotes18.p.rapidapi.com/api/random-quote-topic",
+            "description": " ",
+            "method": "POST",
+            "required_parameters": [],
+            "optional_parameters": [],
+            "code": "import requests\n\nurl = \"https://random-quotes18.p.rapidapi.com/api/random-quote-topic\"\n\nheaders = {\n            \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n            \"X-RapidAPI-Host\": \"random-quotes18.p.rapidapi.com\"\n        }\n\nresponse = requests.post(url, headers=headers)\nprint(response.json())\n",
+            "convert_code": "import requests\n\nurl = \"https://random-quotes18.p.rapidapi.com/api/random-quote-topic\"\n\nheaders = {\n            \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n            \"X-RapidAPI-Host\": \"random-quotes18.p.rapidapi.com\"\n        }\n\nresponse = requests.post(url, headers=headers)\nprint(response.json())\n",
+            "test_endpoint": ""
+        }
+    ]
+}

toolbench/toolenv/tools/Data/random_quotes_v1.json

@@ -0,0 +1,64 @@
+{
+    "product_id": "api_e4d3b84b-592a-4dff-938f-6aba8f0aedf8",
+    "tool_description": "",
+    "home_url": "https://rapidapi.com/ziaprog/api/random-quotes-v1/",
+    "name": "Random Quotes V1",
+    "title": "Random Quotes V1",
+    "pricing": "FREEMIUM",
+    "tool_name": "Random Quotes V1",
+    "score": {
+        "avgServiceLevel": 100,
+        "avgLatency": 2361,
+        "avgSuccessRate": 100,
+        "popularityScore": 7.7,
+        "__typename": "Score"
+    },
+    "host": "random-quotes-v1.p.rapidapi.com",
+    "api_list": [
+        {
+            "name": "Quotes",
+            "url": "https://random-quotes-v1.p.rapidapi.com/quotes",
+            "description": "Returns 5 random quotes",
+            "method": "GET",
+            "required_parameters": [],
+            "optional_parameters": [],
+            "code": "import requests\n\nurl = \"https://random-quotes-v1.p.rapidapi.com/quotes\"\n\nheaders = {\n            \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n            \"X-RapidAPI-Host\": \"random-quotes-v1.p.rapidapi.com\"\n        }\n\nresponse = requests.get(url, headers=headers)\nprint(response.json())\n",
+            "convert_code": "import requests\n\nurl = \"https://random-quotes-v1.p.rapidapi.com/quotes\"\n\nheaders = {\n            \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n            \"X-RapidAPI-Host\": \"random-quotes-v1.p.rapidapi.com\"\n        }\n\nresponse = requests.get(url, headers=headers)\nprint(response.json())\n",
+            "test_endpoint": {
+                "quotes": [
+                    {
+                        "author": "Stanley Crouch",
+                        "id": 40576,
+                        "keywords": "Culture, Obsession, Popular",
+                        "quote": "Under popular culture's obsession with a naive inclusion, everything is O.K."
+                    },
+                    {
+                        "author": "Stephen Malkmus",
+                        "id": 105500,
+                        "keywords": "Sound, Voice",
+                        "quote": "A good voice isn't so important. It's more important to sound really unique."
+                    },
+                    {
+                        "author": "Christine Lahti",
+                        "id": 95261,
+                        "keywords": "NaN",
+                        "quote": "I like to take up something that is challenging. I like to stretch myself."
+                    },
+                    {
+                        "author": "Marc Wallice",
+                        "id": 170015,
+                        "keywords": "Mother, Friend, Nothing, Want",
+                        "quote": "I got nothing. I got my shoes and my pants. I'm staying with a friend. I stop by my mother's every once in a while to get my calls. I don't want to be anywhere anybody can find me."
+                    },
+                    {
+                        "author": "Abu Bakr",
+                        "id": 9863,
+                        "keywords": "Knowledge, Exploitation, Folly",
+                        "quote": "When knowledge is limited - it leads to folly... When knowledge exceeds a certain limit, it leads to exploitation."
+                    }
+                ]
+            }
+        }
+    ],
+    "standardized_name": "random_quotes_v1"
+}

toolbench/toolenv/tools/Data/random_quotes_v1/api.py

@@ -0,0 +1,29 @@
+import requests
+import json
+from datetime import date, datetime, timedelta
+import os
+
+from typing import Optional, Dict, Union, List
+
+
+def quotes(toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "Returns 5 random quotes"
+    
+    """
+    url = f"https://random-quotes-v1.p.rapidapi.com/quotes"
+    querystring = {}
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "random-quotes-v1.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+

toolbench/toolenv/tools/Data/random_user_by_api_ninjas.json

@@ -0,0 +1,30 @@
+{
+    "tool_name":"Random User by API-Ninjas",
+    "tool_description":"Random user data generator for placeholders and testing. See more info at https://api-ninjas.com/api/randomuser",
+    "title":"Random User by API-Ninjas",
+    "pricing":"FREEMIUM",
+    "score":{
+        "avgServiceLevel":100,
+        "avgLatency":256,
+        "avgSuccessRate":100,
+        "popularityScore":9.8,
+        "__typename":"Score"
+    },
+    "home_url":"https://rapidapi.com/apininjas/api/random-user-by-api-ninjas/",
+    "host":"random-user-by-api-ninjas.p.rapidapi.com",
+    "api_list":[
+        {
+            "name":"/v1/randomuser",
+            "url":"https://random-user-by-api-ninjas.p.rapidapi.com/v1/randomuser",
+            "description":"API Ninjas Random User API endpoint. Returns a fake random user profile.",
+            "method":"GET",
+            "required_parameters":[],
+            "optional_parameters":[],
+            "code":"import requests\n\nurl = \"https://random-user-by-api-ninjas.p.rapidapi.com/v1/randomuser\"\n\nheaders = {\n    \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n    \"X-RapidAPI-Host\": \"random-user-by-api-ninjas.p.rapidapi.com\"\n}\n\nresponse = requests.get(url, headers=headers)\n\nprint(response.json())\n",
+            "statuscode":111,
+            "body":"",
+            "headers":"",
+            "schema":""
+        }
+    ]
+}

toolbench/toolenv/tools/Data/random_user_by_api_ninjas/api.py

@@ -0,0 +1,29 @@
+import requests
+import json
+from datetime import date, datetime, timedelta
+import os
+
+from typing import Optional, Dict, Union, List
+
+
+def v1_randomuser(toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "API Ninjas Random User API endpoint. Returns a fake random user profile."
+    
+    """
+    url = f"https://random-user-by-api-ninjas.p.rapidapi.com/v1/randomuser"
+    querystring = {}
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "random-user-by-api-ninjas.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+

toolbench/toolenv/tools/Data/random_users_data/api.py

@@ -0,0 +1,29 @@
+import requests
+import json
+from datetime import date, datetime, timedelta
+import os
+
+from typing import Optional, Dict, Union, List
+
+
+def get_data(toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "request to get data"
+    
+    """
+    url = f"https://random-users-data.p.rapidapi.com/users.php"
+    querystring = {}
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "random-users-data.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+

toolbench/toolenv/tools/Data/random_word_api.json

@@ -0,0 +1,213 @@
+{
+    "tool_name":"Random Word API",
+    "tool_description":"This easy-to-use, 100% free API randomely picks out words from the entire english dictionnary with many parameters. Supports selecting words of a certain length or that start with a certain letter or a certain string of characters, or both, and much more!",
+    "title":"Random Word API",
+    "pricing":"FREE",
+    "score":{
+        "avgServiceLevel":100,
+        "avgLatency":501,
+        "avgSuccessRate":100,
+        "popularityScore":9.9,
+        "__typename":"Score"
+    },
+    "home_url":"https://rapidapi.com/uiopuiopuiop3385/api/random-word-api/",
+    "host":"random-word-api.p.rapidapi.com",
+    "api_list":[
+        {
+            "name":"Get Word by Length and Start",
+            "url":"https://random-word-api.p.rapidapi.com/LS/{length}/{start}",
+            "description":"Returns a random word of specified length and that starts with specified string.\nFor example, 7 and \"fru\" will return any word that is 7 letters long and starts with \"fru\", such as \"fruiter\".",
+            "method":"GET",
+            "required_parameters":[
+                {
+                    "name":"length",
+                    "type":"NUMBER",
+                    "description":"",
+                    "default":"7"
+                },
+                {
+                    "name":"start",
+                    "type":"string",
+                    "description":"",
+                    "default":"fru"
+                }
+            ],
+            "optional_parameters":[],
+            "code":"import requests\n\nurl = \"https://random-word-api.p.rapidapi.com/LS/{length}/{start}\"\n\nheaders = {\n    \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n    \"X-RapidAPI-Host\": \"random-word-api.p.rapidapi.com\"\n}\n\nresponse = requests.get(url, headers=headers)\n\nprint(response.json())\n",
+            "statuscode":111,
+            "body":"",
+            "headers":"",
+            "schema":""
+        },
+        {
+            "name":"Get Word by Contain",
+            "url":"https://random-word-api.p.rapidapi.com/C/{substring}",
+            "description":"Returns a random word that contains a certain string.\nFor example, if the string is \"le\" then you will get any word that contains the string, whether it's at **the start, the end or the middle**, and you will get for example \"odourless\".",
+            "method":"GET",
+            "required_parameters":[
+                {
+                    "name":"substring",
+                    "type":"string",
+                    "description":"",
+                    "default":"le"
+                }
+            ],
+            "optional_parameters":[],
+            "code":"import requests\n\nurl = \"https://random-word-api.p.rapidapi.com/C/{substring}\"\n\nheaders = {\n    \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n    \"X-RapidAPI-Host\": \"random-word-api.p.rapidapi.com\"\n}\n\nresponse = requests.get(url, headers=headers)\n\nprint(response.json())\n",
+            "statuscode":111,
+            "body":"",
+            "headers":"",
+            "schema":""
+        },
+        {
+            "name":"Get Word by Start",
+            "url":"https://random-word-api.p.rapidapi.com/S/{start}",
+            "description":"Returns a random word that starts with the specified string.\nFor example, \"fru\" will only return words that start with \"fru\", such as \"fruit\"",
+            "method":"GET",
+            "required_parameters":[
+                {
+                    "name":"start",
+                    "type":"string",
+                    "description":"",
+                    "default":"fru"
+                }
+            ],
+            "optional_parameters":[],
+            "code":"import requests\n\nurl = \"https://random-word-api.p.rapidapi.com/S/{start}\"\n\nheaders = {\n    \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n    \"X-RapidAPI-Host\": \"random-word-api.p.rapidapi.com\"\n}\n\nresponse = requests.get(url, headers=headers)\n\nprint(response.json())\n",
+            "statuscode":111,
+            "body":"",
+            "headers":"",
+            "schema":""
+        },
+        {
+            "name":"Get Word by Length and Contain",
+            "url":"https://random-word-api.p.rapidapi.com/LC/{length}/{substring}",
+            "description":"Returns a random word that contains a certain string and contains a certain amount of letters.\nFor example, if the substring is \"le\" and the length \"7\", you will get a word that contains \"le\" and is 7 characters long, such as \"dozzled\".",
+            "method":"GET",
+            "required_parameters":[
+                {
+                    "name":"substring",
+                    "type":"string",
+                    "description":"",
+                    "default":"le"
+                },
+                {
+                    "name":"length",
+                    "type":"NUMBER",
+                    "description":"",
+                    "default":"7"
+                }
+            ],
+            "optional_parameters":[],
+            "code":"import requests\n\nurl = \"https://random-word-api.p.rapidapi.com/LC/{length}/{substring}\"\n\nheaders = {\n    \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n    \"X-RapidAPI-Host\": \"random-word-api.p.rapidapi.com\"\n}\n\nresponse = requests.get(url, headers=headers)\n\nprint(response.json())\n",
+            "statuscode":111,
+            "body":"",
+            "headers":"",
+            "schema":""
+        },
+        {
+            "name":"Get Word by Start and Contain",
+            "url":"https://random-word-api.p.rapidapi.com/SC/{start}/{substring}",
+            "description":"Returns a random word that starts with a certain string and contains a certain string.\nFor example, if the start is \"fru\" and the substring is \"le\", you will get a word that starts with \"fru\" and contains \"le\", such as \"frustules\".",
+            "method":"GET",
+            "required_parameters":[
+                {
+                    "name":"substring",
+                    "type":"string",
+                    "description":"",
+                    "default":"le"
+                },
+                {
+                    "name":"start",
+                    "type":"string",
+                    "description":"",
+                    "default":"fru"
+                }
+            ],
+            "optional_parameters":[],
+            "code":"import requests\n\nurl = \"https://random-word-api.p.rapidapi.com/SC/{start}/{substring}\"\n\nheaders = {\n    \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n    \"X-RapidAPI-Host\": \"random-word-api.p.rapidapi.com\"\n}\n\nresponse = requests.get(url, headers=headers)\n\nprint(response.json())\n",
+            "statuscode":111,
+            "body":"",
+            "headers":"",
+            "schema":""
+        },
+        {
+            "name":"Get Word by Length, Start and Contain",
+            "url":"https://random-word-api.p.rapidapi.com/LSC/{length}/{start}/{substring}",
+            "description":"Returns a random word that is a certain amount of characters long, starts with a certain string and contains a certain string.\nFor example, if the length is 7, the start \"fru\" and the substring \"le\", you will get a 7 letter long word that begins with fru and contains le, like \"frumple\".",
+            "method":"GET",
+            "required_parameters":[
+                {
+                    "name":"start",
+                    "type":"string",
+                    "description":"",
+                    "default":"fru"
+                },
+                {
+                    "name":"length",
+                    "type":"NUMBER",
+                    "description":"",
+                    "default":"7"
+                },
+                {
+                    "name":"substring",
+                    "type":"string",
+                    "description":"",
+                    "default":"le"
+                }
+            ],
+            "optional_parameters":[],
+            "code":"import requests\n\nurl = \"https://random-word-api.p.rapidapi.com/LSC/{length}/{start}/{substring}\"\n\nheaders = {\n    \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n    \"X-RapidAPI-Host\": \"random-word-api.p.rapidapi.com\"\n}\n\nresponse = requests.get(url, headers=headers)\n\nprint(response.json())\n",
+            "statuscode":111,
+            "body":"",
+            "headers":"",
+            "schema":""
+        },
+        {
+            "name":"Get Word by Length",
+            "url":"https://random-word-api.p.rapidapi.com/L/{length}",
+            "description":"Returns a random word that has the specified length. For example, 7 will return any word that is 7 letters long, such as \"swallow\".",
+            "method":"GET",
+            "required_parameters":[
+                {
+                    "name":"length",
+                    "type":"NUMBER",
+                    "description":"",
+                    "default":"7"
+                }
+            ],
+            "optional_parameters":[],
+            "code":"import requests\n\nurl = \"https://random-word-api.p.rapidapi.com/L/{length}\"\n\nheaders = {\n    \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n    \"X-RapidAPI-Host\": \"random-word-api.p.rapidapi.com\"\n}\n\nresponse = requests.get(url, headers=headers)\n\nprint(response.json())\n",
+            "statuscode":111,
+            "body":"",
+            "headers":"",
+            "schema":""
+        },
+        {
+            "name":"Get Word",
+            "url":"https://random-word-api.p.rapidapi.com/get_word",
+            "description":"Returns a random word. No parameters. Just randomness.",
+            "method":"GET",
+            "required_parameters":[],
+            "optional_parameters":[],
+            "code":"import requests\n\nurl = \"https://random-word-api.p.rapidapi.com/get_word\"\n\nheaders = {\n    \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n    \"X-RapidAPI-Host\": \"random-word-api.p.rapidapi.com\"\n}\n\nresponse = requests.get(url, headers=headers)\n\nprint(response.json())\n",
+            "statuscode":111,
+            "body":"",
+            "headers":"",
+            "schema":""
+        },
+        {
+            "name":"Get French Word",
+            "url":"https://random-word-api.p.rapidapi.com/french_word",
+            "description":"Same as random word, but grabs a random french word instead.",
+            "method":"GET",
+            "required_parameters":[],
+            "optional_parameters":[],
+            "code":"import requests\n\nurl = \"https://random-word-api.p.rapidapi.com/french_word\"\n\nheaders = {\n    \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n    \"X-RapidAPI-Host\": \"random-word-api.p.rapidapi.com\"\n}\n\nresponse = requests.get(url, headers=headers)\n\nprint(response.json())\n",
+            "statuscode":111,
+            "body":"",
+            "headers":"",
+            "schema":""
+        }
+    ]
+}

toolbench/toolenv/tools/Data/random_word_api/api.py

@@ -0,0 +1,203 @@
+import requests
+import json
+from datetime import date, datetime, timedelta
+import os
+
+from typing import Optional, Dict, Union, List
+
+
+def get_word_by_length_and_start(length: int, start: str, toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "Returns a random word of specified length and that starts with specified string.
+		For example, 7 and "fru" will return any word that is 7 letters long and starts with "fru", such as "fruiter"."
+    
+    """
+    url = f"https://random-word-api.p.rapidapi.com/ls/{length}/{start}"
+    querystring = {}
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "random-word-api.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+
+def get_word_by_contain(substring: str, toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "Returns a random word that contains a certain string.
+		For example, if the string is "le" then you will get any word that contains the string, whether it's at **the start, the end or the middle**, and you will get for example "odourless"."
+    
+    """
+    url = f"https://random-word-api.p.rapidapi.com/c/{substring}"
+    querystring = {}
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "random-word-api.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+
+def get_word_by_start(start: str, toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "Returns a random word that starts with the specified string.
+		For example, "fru" will only return words that start with "fru", such as "fruit""
+    
+    """
+    url = f"https://random-word-api.p.rapidapi.com/s/{start}"
+    querystring = {}
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "random-word-api.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+
+def get_word_by_length_and_contain(substring: str, length: int, toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "Returns a random word that contains a certain string and contains a certain amount of letters.
+		For example, if the substring is "le" and the length "7", you will get a word that contains "le" and is 7 characters long, such as "dozzled"."
+    
+    """
+    url = f"https://random-word-api.p.rapidapi.com/lc/{length}/{substring}"
+    querystring = {}
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "random-word-api.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+
+def get_word_by_start_and_contain(substring: str, start: str, toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "Returns a random word that starts with a certain string and contains a certain string.
+		For example, if the start is "fru" and the substring is "le", you will get a word that starts with "fru" and contains "le", such as "frustules"."
+    
+    """
+    url = f"https://random-word-api.p.rapidapi.com/sc/{start}/{substring}"
+    querystring = {}
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "random-word-api.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+
+def get_word_by_length_start_and_contain(start: str, length: int, substring: str, toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "Returns a random word that is a certain amount of characters long, starts with a certain string and contains a certain string.
+		For example, if the length is 7, the start "fru" and the substring "le", you will get a 7 letter long word that begins with fru and contains le, like "frumple"."
+    
+    """
+    url = f"https://random-word-api.p.rapidapi.com/lsc/{length}/{start}/{substring}"
+    querystring = {}
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "random-word-api.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+
+def get_word_by_length(length: int, toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "Returns a random word that has the specified length. For example, 7 will return any word that is 7 letters long, such as "swallow"."
+    
+    """
+    url = f"https://random-word-api.p.rapidapi.com/l/{length}"
+    querystring = {}
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "random-word-api.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+
+def get_word(toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "Returns a random word. No parameters. Just randomness."
+    
+    """
+    url = f"https://random-word-api.p.rapidapi.com/get_word"
+    querystring = {}
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "random-word-api.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+
+def get_french_word(toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "Same as random word, but grabs a random french word instead."
+    
+    """
+    url = f"https://random-word-api.p.rapidapi.com/french_word"
+    querystring = {}
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "random-word-api.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+

toolbench/toolenv/tools/Data/random_word_generator.json

@@ -0,0 +1,56 @@
+{
+    "tool_name":"Random Word Generator",
+    "tool_description":"Random words and more provided by RandomWordGenerator.com",
+    "title":"Random Word Generator",
+    "pricing":"FREEMIUM",
+    "score":{
+        "avgServiceLevel":100,
+        "avgLatency":621,
+        "avgSuccessRate":100,
+        "popularityScore":9.1,
+        "__typename":"Score"
+    },
+    "home_url":"https://rapidapi.com/nsanden/api/random-word-generator2/",
+    "host":"random-word-generator2.p.rapidapi.com",
+    "api_list":[
+        {
+            "name":"Generate a random word",
+            "url":"https://random-word-generator2.p.rapidapi.com/word.php",
+            "description":"Scour through thousands of words from the RandomWordGenerator.com database",
+            "method":"GET",
+            "required_parameters":[],
+            "optional_parameters":[
+                {
+                    "name":"api_key",
+                    "type":"STRING",
+                    "description":"",
+                    "default":"5w36eV0FZJu9QIPlpR18"
+                },
+                {
+                    "name":"generator",
+                    "type":"STRING",
+                    "description":"",
+                    "default":"words"
+                }
+            ],
+            "code":"import requests\n\nurl = \"https://random-word-generator2.p.rapidapi.com/word.php\"\nquerystring = {\"api_key\": api_key, \"generator\": generator}\n\nheaders = {\n    \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n    \"X-RapidAPI-Host\": \"random-word-generator2.p.rapidapi.com\"\n}\n\nresponse = requests.get(url, headers=headers, params=querystring)\n\nprint(response.json())\n",
+            "statuscode":111,
+            "body":"",
+            "headers":"",
+            "schema":""
+        },
+        {
+            "name":"Generate a random sentence",
+            "url":"https://random-word-generator2.p.rapidapi.com/sentence.php",
+            "description":"Generate a random sentence",
+            "method":"GET",
+            "required_parameters":[],
+            "optional_parameters":[],
+            "code":"import requests\n\nurl = \"https://random-word-generator2.p.rapidapi.com/sentence.php\"\n\nheaders = {\n    \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n    \"X-RapidAPI-Host\": \"random-word-generator2.p.rapidapi.com\"\n}\n\nresponse = requests.get(url, headers=headers)\n\nprint(response.json())\n",
+            "statuscode":111,
+            "body":"",
+            "headers":"",
+            "schema":""
+        }
+    ]
+}

toolbench/toolenv/tools/Data/random_word_generator/api.py

@@ -0,0 +1,54 @@
+import requests
+import json
+from datetime import date, datetime, timedelta
+import os
+
+from typing import Optional, Dict, Union, List
+
+
+def generate_a_random_word(api_key: str='5w36eV0FZJu9QIPlpR18', generator: str='words', toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "Scour through thousands of words from the RandomWordGenerator.com database"
+    
+    """
+    url = f"https://random-word-generator2.p.rapidapi.com/word.php"
+    querystring = {}
+    if api_key:
+        querystring['api_key'] = api_key
+    if generator:
+        querystring['generator'] = generator
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "random-word-generator2.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+
+def generate_a_random_sentence(toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "Generate a random sentence"
+    
+    """
+    url = f"https://random-word-generator2.p.rapidapi.com/sentence.php"
+    querystring = {}
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "random-word-generator2.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+

toolbench/toolenv/tools/Data/randomcompanyinfoapi.json

@@ -0,0 +1,54 @@
+{
+    "product_id": "api_c6433b0c-bfa4-4898-8630-f48521bf8519",
+    "tool_description": "This API generates random company information including company name, domain name, job industry, country, and job title.",
+    "home_url": "https://rapidapi.com/fhamheramav/api/randomcompanyinfoapi/",
+    "name": "RandomCompanyInfoAPI",
+    "title": "RandomCompanyInfoAPI",
+    "pricing": "PAID",
+    "tool_name": "RandomCompanyInfoAPI",
+    "score": {
+        "avgServiceLevel": 100,
+        "avgLatency": 552,
+        "avgSuccessRate": 100,
+        "popularityScore": 8.7,
+        "__typename": "Score"
+    },
+    "host": "randomcompanyinfoapi.p.rapidapi.com",
+    "api_list": [
+        {
+            "name": "postCompany",
+            "url": "https://randomcompanyinfoapi.p.rapidapi.com/api/gen-company",
+            "description": " ",
+            "method": "POST",
+            "required_parameters": [],
+            "optional_parameters": [],
+            "code": "import requests\n\nurl = \"https://randomcompanyinfoapi.p.rapidapi.com/api/gen-company\"\n\nheaders = {\n            \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n            \"X-RapidAPI-Host\": \"randomcompanyinfoapi.p.rapidapi.com\"\n        }\n\nresponse = requests.post(url, headers=headers)\nprint(response.json())\n",
+            "convert_code": "import requests\n\nurl = \"https://randomcompanyinfoapi.p.rapidapi.com/api/gen-company\"\n\nheaders = {\n            \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n            \"X-RapidAPI-Host\": \"randomcompanyinfoapi.p.rapidapi.com\"\n        }\n\nresponse = requests.post(url, headers=headers)\nprint(response.json())\n",
+            "test_endpoint": "",
+            "statuscode": 200,
+            "schema": {
+                "type": "object",
+                "properties": {
+                    "get": {
+                        "type": "string"
+                    },
+                    "parameters": {
+                        "type": "array"
+                    },
+                    "errors": {
+                        "type": "array"
+                    },
+                    "results": {
+                        "type": "integer"
+                    },
+                    "response": {
+                        "type": "array",
+                        "items": {
+                            "type": "object"
+                        }
+                    }
+                }
+            }
+        }
+    ]
+}

toolbench/toolenv/tools/Data/randomizer.json

@@ -0,0 +1,107 @@
+{
+    "product_id": "api_d6943583-dd23-4e0b-8653-5e04c8d24665",
+    "tool_description": "Fast and straightforward API to retrieve a random sequence of characters!",
+    "home_url": "https://rapidapi.com/tcheetox/api/randomizer/",
+    "name": "Randomizer",
+    "title": "Randomizer",
+    "pricing": "FREE",
+    "tool_name": "Randomizer",
+    "score": {
+        "avgServiceLevel": 100,
+        "avgLatency": 92,
+        "avgSuccessRate": 99,
+        "popularityScore": 8.4,
+        "__typename": "Score"
+    },
+    "host": "randomizer.p.rapidapi.com",
+    "api_list": [
+        {
+            "name": "getRandom",
+            "url": "https://randomizer.p.rapidapi.com/randomizer/{length}",
+            "description": "Retrieve a random sequence of characters matching the provided query attributes",
+            "method": "GET",
+            "required_parameters": [
+                {
+                    "name": "length",
+                    "type": "NUMBER",
+                    "description": "Sequence length",
+                    "default": ""
+                }
+            ],
+            "optional_parameters": [
+                {
+                    "name": "case",
+                    "type": "STRING",
+                    "description": "Force sequence to match case argument",
+                    "default": "all"
+                },
+                {
+                    "name": "extra",
+                    "type": "STRING",
+                    "description": "Allow the use of special characters \n\n **true**              @#\u00e9$%&\u00f9\u00b5\u00a3-_!\u00e8\u00e7\u00e0\u00f9?^) \n\n **extended**      |\"(\u00a7{})\u00b0\u00a8[*]\u00b4`,;./:+=~",
+                    "default": "true"
+                },
+                {
+                    "name": "type",
+                    "type": "STRING",
+                    "description": "Sequence type \n\n **all**          string + number + special",
+                    "default": "all"
+                }
+            ],
+            "code": "import requests\n\nurl = \"https://randomizer.p.rapidapi.com/randomizer/{length}\"\nquerystring = {\"case\": \"all\", \"extra\": \"true\", \"length\": \"\", \"type\": \"all\"}\n\nheaders = {\n            \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n            \"X-RapidAPI-Host\": \"randomizer.p.rapidapi.com\"\n        }\n\nresponse = requests.get(url, headers=headers, params=querystring)\nprint(response.json())\n",
+            "convert_code": "import requests\n\nurl = \"https://randomizer.p.rapidapi.com/randomizer/{length}\"\nquerystring = {\"case\": \"all\", \"extra\": \"true\", \"length\": \"\", \"type\": \"all\"}\n\nheaders = {\n            \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n            \"X-RapidAPI-Host\": \"randomizer.p.rapidapi.com\"\n        }\n\nresponse = requests.get(url, headers=headers, params=querystring)\nprint(response.json())\n",
+            "test_endpoint": {
+                "message": "Unknown query parameter 'length'",
+                "errors": [
+                    {
+                        "path": ".query.length",
+                        "message": "Unknown query parameter 'length'"
+                    }
+                ]
+            },
+            "statuscode": 200,
+            "schema": {
+                "type": "object",
+                "required": [
+                    "data"
+                ],
+                "properties": {
+                    "data": {
+                        "type": "string"
+                    }
+                }
+            }
+        },
+        {
+            "name": "postRandom",
+            "url": "https://randomizer.p.rapidapi.com/randomizer/{length}",
+            "description": "Retrieve a random sequence of characters matching the provided query attributes",
+            "method": "POST",
+            "required_parameters": [
+                {
+                    "name": "length",
+                    "type": "NUMBER",
+                    "description": "Sequence length",
+                    "default": ""
+                }
+            ],
+            "optional_parameters": [],
+            "code": "import requests\n\nurl = \"https://randomizer.p.rapidapi.com/randomizer/{length}\"\nquerystring = {\"length\": \"\"}\n\nheaders = {\n            \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n            \"X-RapidAPI-Host\": \"randomizer.p.rapidapi.com\"\n        }\n\nresponse = requests.post(url, headers=headers, params=querystring)\nprint(response.json())\n",
+            "convert_code": "import requests\n\nurl = \"https://randomizer.p.rapidapi.com/randomizer/{length}\"\nquerystring = {\"length\": \"\"}\n\nheaders = {\n            \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n            \"X-RapidAPI-Host\": \"randomizer.p.rapidapi.com\"\n        }\n\nresponse = requests.post(url, headers=headers, params=querystring)\nprint(response.json())\n",
+            "test_endpoint": "",
+            "statuscode": 200,
+            "schema": {
+                "type": "object",
+                "required": [
+                    "data"
+                ],
+                "properties": {
+                    "data": {
+                        "type": "string"
+                    }
+                }
+            }
+        }
+    ],
+    "standardized_name": "randomizer"
+}

toolbench/toolenv/tools/Data/randomizer/api.py

@@ -0,0 +1,45 @@
+import requests
+import json
+from datetime import date, datetime, timedelta
+import os
+
+from typing import Optional, Dict, Union, List
+
+
+def getrandom(length: int, case: str='all', extra: str='true', type: str='all', toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "Retrieve a random sequence of characters matching the provided query attributes"
+    length: Sequence length
+        case: Force sequence to match case argument
+        extra: Allow the use of special characters 
+
+ **true**              @#é$%&ùµ£-_!èçàù?^) 
+
+ **extended**      |"(§{})°¨[*]´`,;./:+=~
+        type: Sequence type 
+
+ **all**          string + number + special
+        
+    """
+    url = f"https://randomizer.p.rapidapi.com/randomizer/{length}"
+    querystring = {}
+    if case:
+        querystring['case'] = case
+    if extra:
+        querystring['extra'] = extra
+    if type:
+        querystring['type'] = type
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "randomizer.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+

toolbench/toolenv/tools/Data/randompointsgenerator_api.json

@@ -0,0 +1,54 @@
+{
+    "product_id": "api_a737715d-11bd-40e6-9a49-25c278db2f37",
+    "tool_description": "The RandomPointsGenerator API is a versatile tool for generating random sets of data points. Whether you're a developer, data scientist, or researcher, this API allows you to easily create random data points for various purposes, from testing and experimentation to statistical analysis.",
+    "home_url": "https://rapidapi.com/ozgeyasrag/api/randompointsgenerator-api/",
+    "name": " RandomPointsGenerator API",
+    "title": " RandomPointsGenerator API",
+    "pricing": "FREEMIUM",
+    "tool_name": " RandomPointsGenerator API",
+    "score": {
+        "avgServiceLevel": 100,
+        "avgLatency": 487,
+        "avgSuccessRate": 100,
+        "popularityScore": 9.3,
+        "__typename": "Score"
+    },
+    "host": "randompointsgenerator-api.p.rapidapi.com",
+    "api_list": [
+        {
+            "name": "postPoints",
+            "url": "https://randompointsgenerator-api.p.rapidapi.com/api/generate-points",
+            "description": " ",
+            "method": "POST",
+            "required_parameters": [],
+            "optional_parameters": [],
+            "code": "import requests\n\nurl = \"https://randompointsgenerator-api.p.rapidapi.com/api/generate-points\"\n\nheaders = {\n            \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n            \"X-RapidAPI-Host\": \"randompointsgenerator-api.p.rapidapi.com\"\n        }\n\nresponse = requests.post(url, headers=headers)\nprint(response.json())\n",
+            "convert_code": "import requests\n\nurl = \"https://randompointsgenerator-api.p.rapidapi.com/api/generate-points\"\n\nheaders = {\n            \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n            \"X-RapidAPI-Host\": \"randompointsgenerator-api.p.rapidapi.com\"\n        }\n\nresponse = requests.post(url, headers=headers)\nprint(response.json())\n",
+            "test_endpoint": "",
+            "statuscode": 200,
+            "schema": {
+                "type": "object",
+                "properties": {
+                    "get": {
+                        "type": "string"
+                    },
+                    "parameters": {
+                        "type": "array"
+                    },
+                    "errors": {
+                        "type": "array"
+                    },
+                    "results": {
+                        "type": "integer"
+                    },
+                    "response": {
+                        "type": "array",
+                        "items": {
+                            "type": "object"
+                        }
+                    }
+                }
+            }
+        }
+    ]
+}

toolbench/toolenv/tools/Data/randomprofile.json

@@ -0,0 +1,70 @@
+{
+    "product_id": "53aa5b32e4b07e1f4ebec293",
+    "tool_description": "Randomly generated profiles of users for quick and efficient database testing. Ideal for social networks, dating websites, online forums and other people-oriented projects.\r\nIncludes random address, name, date of birth, bank info, credit card number, weight, height, occupation etc.",
+    "home_url": "https://rapidapi.com/randomprofile/api/randomprofile/",
+    "name": "RandomProfile",
+    "title": "RandomProfile",
+    "pricing": "FREE",
+    "tool_name": "RandomProfile",
+    "score": {
+        "avgServiceLevel": 100,
+        "avgLatency": 55,
+        "avgSuccessRate": 100,
+        "popularityScore": 9.1,
+        "__typename": "Score"
+    },
+    "host": "randomprofile.p.rapidapi.com",
+    "api_list": [
+        {
+            "name": "getProfile",
+            "url": "https://randomprofile.p.rapidapi.com/api.php",
+            "description": "Get two randomly generated user profiles",
+            "method": "POST",
+            "required_parameters": [
+                {
+                    "name": "countries",
+                    "type": "STRING",
+                    "description": "Three letter ISO code of the country of residence for the generated profiles. Can be CHN for China, KOR for South Korea, JPN for Japan, GBR for the United Kingdom and USA for United States",
+                    "default": "USA"
+                }
+            ],
+            "optional_parameters": [
+                {
+                    "name": "format",
+                    "type": "STRING",
+                    "description": "The format of the returned result. Can be one of the following: csv, json, xml. By default xml is chosen.",
+                    "default": "csv"
+                },
+                {
+                    "name": "fromAge",
+                    "type": "STRING",
+                    "description": "The minimum age of the generated user, in years old. By default 0 (for babies) is chosen.",
+                    "default": "0"
+                },
+                {
+                    "name": "toAge",
+                    "type": "STRING",
+                    "description": "The maximum age of the generated user, in years old. By default 100 is chosen (which is also the maximum possible value).",
+                    "default": "100"
+                },
+                {
+                    "name": "fullChildren",
+                    "type": "STRING",
+                    "description": "A flag which determines whether profiles under 18 years old should be assigned occupation other than \"child\", and bank info, including credit card number. Can be either 0 or 1, default is 0.",
+                    "default": "1"
+                },
+                {
+                    "name": "packages",
+                    "type": "STRING",
+                    "description": "Comma-separated IDs of the required data packages. Can be 1 for General data (such as name, address, date of birth etc. - see more details on the web site), 2 for Financial (credit card details, bank name, account number), 3 for Physical (height, weight, clothes size, hair and eyes colour). If none specified,1 is chosen by default.",
+                    "default": "1,2,3"
+                }
+            ],
+            "code": "import requests\n\nurl = \"https://randomprofile.p.rapidapi.com/api.php\"\nquerystring = {\"countries\": \"USA\", \"format\": \"csv\", \"fromAge\": \"0\", \"toAge\": \"100\", \"fullChildren\": \"1\", \"packages\": \"1,2,3\"}\n\nheaders = {\n            \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n            \"X-RapidAPI-Host\": \"randomprofile.p.rapidapi.com\"\n        }\n\nresponse = requests.post(url, headers=headers, params=querystring)\nprint(response.json())\n",
+            "convert_code": "import requests\n\nurl = \"https://randomprofile.p.rapidapi.com/api.php\"\nquerystring = {\"countries\": \"USA\", \"format\": \"csv\", \"fromAge\": \"0\", \"toAge\": \"100\", \"fullChildren\": \"1\", \"packages\": \"1,2,3\"}\n\nheaders = {\n            \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n            \"X-RapidAPI-Host\": \"randomprofile.p.rapidapi.com\"\n        }\n\nresponse = requests.post(url, headers=headers, params=querystring)\nprint(response.json())\n",
+            "test_endpoint": "",
+            "statuscode": 1,
+            "schema": ""
+        }
+    ]
+}

toolbench/toolenv/tools/Data/ranking_page/api.py

@@ -0,0 +1,92 @@
+import requests
+import json
+from datetime import date, datetime, timedelta
+import os
+
+from typing import Optional, Dict, Union, List
+
+
+def ranking_csgo(toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "Static ranking API"
+    
+    """
+    url = f"https://ranking-page.p.rapidapi.com/rankings/csgo"
+    querystring = {}
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "ranking-page.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+
+def basketball(toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "Test enpoint to get some data"
+    
+    """
+    url = f"https://ranking-page.p.rapidapi.com/rankings/basketball"
+    querystring = {}
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "ranking-page.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+
+def basketball(toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "Basketball ranking page"
+    
+    """
+    url = f"https://ranking-page.p.rapidapi.com/rankings/basketball"
+    querystring = {}
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "ranking-page.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+
+def ranking_page(toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "Static ranking API"
+    
+    """
+    url = f"https://ranking-page.p.rapidapi.com/rankings"
+    querystring = {}
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "ranking-page.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+

toolbench/toolenv/tools/Data/rapidapi_example/api.py

@@ -0,0 +1,29 @@
+import requests
+import json
+from datetime import date, datetime, timedelta
+import os
+
+from typing import Optional, Dict, Union, List
+
+
+def users(toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "Provides an array of dummy user data."
+    
+    """
+    url = f"https://rapidapi-example.p.rapidapi.com/users"
+    querystring = {}
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "rapidapi-example.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+

toolbench/toolenv/tools/Data/rata_incidenta_romania/api.py

@@ -0,0 +1,50 @@
+import requests
+import json
+from datetime import date, datetime, timedelta
+import os
+
+from typing import Optional, Dict, Union, List
+
+
+def incidenta_pe_zi(data: str, toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "Incidenta in anumita zi (Data in format ZZ.MM.YYYY)"
+    
+    """
+    url = f"https://rata-incidenta-romania.p.rapidapi.com/incidenta/{data}"
+    querystring = {}
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "rata-incidenta-romania.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+
+def incidenta_lista_generala(toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "Lista cu incidenta si data respectiva de cand se masoara"
+    
+    """
+    url = f"https://rata-incidenta-romania.p.rapidapi.com/incidenta"
+    querystring = {}
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "rata-incidenta-romania.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+

toolbench/toolenv/tools/Data/rate_checker_by_wubook/api.py

@@ -0,0 +1,83 @@
+import requests
+import json
+from datetime import date, datetime, timedelta
+import os
+
+from typing import Optional, Dict, Union, List
+
+
+def monitored_competitors_from_a_given_user(user_id: str='auto', format: str='json', toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    ""
+    
+    """
+    url = f"https://community-rate-checker-by-wubook.p.rapidapi.com/user"
+    querystring = {}
+    if user_id:
+        querystring['user_id'] = user_id
+    if format:
+        querystring['format'] = format
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "community-rate-checker-by-wubook.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+
+def snapshots_available_from_a_given_stay(stay_id: str='539dba784e56e1686bbb0f41', format: str='json', toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    ""
+    
+    """
+    url = f"https://community-rate-checker-by-wubook.p.rapidapi.com/stay"
+    querystring = {}
+    if stay_id:
+        querystring['stay_id'] = stay_id
+    if format:
+        querystring['format'] = format
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "community-rate-checker-by-wubook.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+
+def stays_from_a_given_competitor(competitor_id: str='539dba784e56e1686bbb0f40', format: str='json', toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    ""
+    
+    """
+    url = f"https://community-rate-checker-by-wubook.p.rapidapi.com/competitor"
+    querystring = {}
+    if competitor_id:
+        querystring['competitor_id'] = competitor_id
+    if format:
+        querystring['format'] = format
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "community-rate-checker-by-wubook.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+

toolbench/toolenv/tools/Data/rchilli_taxonomy.json

@@ -0,0 +1,39 @@
+{
+    "product_id": "api_731c1acb-22f1-4f16-a713-10b348720f56",
+    "tool_description": "RChilli Taxonomy offers a comprehensive collection of skills and job profiles, along with their related information. This latest version brings a remarkable change in the resume/job searching capability of the users. At present, it offers 41,000+ Skills and 27,000+ Job Profiles. Get the recommended skills and job titles through Skills/Jobs Alias. Create extra tags in search engines through similar skills/jobs. The unique ontology will set a benchmark for storing resumes/jobs with its step-by-...",
+    "home_url": "https://rapidapi.com/rchilli-inc-rchilli-inc-default/api/rchilli-taxonomy1/",
+    "name": "RChilli Taxonomy",
+    "title": "RChilli Taxonomy",
+    "pricing": "PAID",
+    "tool_name": "RChilli Taxonomy",
+    "score": null,
+    "host": "rchilli-taxonomy1.p.rapidapi.com",
+    "api_list": [
+        {
+            "name": "Skill Taxonomy",
+            "url": "https://rchilli-taxonomy1.p.rapidapi.com/taxonomy/skillsearch",
+            "description": "Skill Taxonomy API offers you a detailed information of skill based on search keyword.",
+            "method": "POST",
+            "required_parameters": [],
+            "optional_parameters": [],
+            "code": "import requests\n\nurl = \"https://rchilli-taxonomy1.p.rapidapi.com/taxonomy/skillsearch\"\n\nheaders = {\n            \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n            \"X-RapidAPI-Host\": \"rchilli-taxonomy1.p.rapidapi.com\"\n        }\n\nresponse = requests.post(url, headers=headers)\nprint(response.json())\n",
+            "convert_code": "import requests\n\nurl = \"https://rchilli-taxonomy1.p.rapidapi.com/taxonomy/skillsearch\"\n\nheaders = {\n            \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n            \"X-RapidAPI-Host\": \"rchilli-taxonomy1.p.rapidapi.com\"\n        }\n\nresponse = requests.post(url, headers=headers)\nprint(response.json())\n",
+            "test_endpoint": "",
+            "statuscode": 200,
+            "schema": {}
+        },
+        {
+            "name": "Job Profile Taxonomy",
+            "url": "https://rchilli-taxonomy1.p.rapidapi.com/taxonomy/jobprofilesearch",
+            "description": "Job Profile Taxonomy API offers you a detailed information of Job Profile based on search keyword.",
+            "method": "POST",
+            "required_parameters": [],
+            "optional_parameters": [],
+            "code": "import requests\n\nurl = \"https://rchilli-taxonomy1.p.rapidapi.com/taxonomy/jobprofilesearch\"\n\nheaders = {\n            \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n            \"X-RapidAPI-Host\": \"rchilli-taxonomy1.p.rapidapi.com\"\n        }\n\nresponse = requests.post(url, headers=headers)\nprint(response.json())\n",
+            "convert_code": "import requests\n\nurl = \"https://rchilli-taxonomy1.p.rapidapi.com/taxonomy/jobprofilesearch\"\n\nheaders = {\n            \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n            \"X-RapidAPI-Host\": \"rchilli-taxonomy1.p.rapidapi.com\"\n        }\n\nresponse = requests.post(url, headers=headers)\nprint(response.json())\n",
+            "test_endpoint": "",
+            "statuscode": 200,
+            "schema": {}
+        }
+    ]
+}

toolbench/toolenv/tools/Data/react_weather/api.py

@@ -0,0 +1,29 @@
+import requests
+import json
+from datetime import date, datetime, timedelta
+import os
+
+from typing import Optional, Dict, Union, List
+
+
+def hola(toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "salir"
+    
+    """
+    url = f"https://react-weather3.p.rapidapi.com/"
+    querystring = {}
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "react-weather3.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+

toolbench/toolenv/tools/Data/real_estate_records.json

@@ -0,0 +1,130 @@
+{
+    "tool_name":"Real Estate Records",
+    "tool_description":"Real estate transaction records for New York City and whole New Jersey. Public records have been collected from various sites, standardized using Here.com API, with geolocation information for your consumption. ",
+    "title":"Real Estate Records",
+    "pricing":"FREEMIUM",
+    "score":{
+        "avgServiceLevel":100,
+        "avgLatency":1163,
+        "avgSuccessRate":100,
+        "popularityScore":9.2,
+        "__typename":"Score"
+    },
+    "home_url":"https://rapidapi.com/richliao/api/real-estate-records/",
+    "host":"real-estate-records.p.rapidapi.com",
+    "api_list":[
+        {
+            "name":"transactions",
+            "url":"https://real-estate-records.p.rapidapi.com/search/zipcode",
+            "description":"Show transactions given a zipcode. The API returns 50 records each time in descending order by date and supports pagination. This API requires a subscription cost.\n\nThe returned data shows the summary of information. To get further detail (such as the unit of a building that posts the most recent transaction, use summary API.\n\nSample data of the API when query zipcode 10019 is:\n \"data\": [\n    {\n      \"_id\": {\n        \"STREET_NUMBER\": \"310\",\n        \"STREET\": \"W 56th St\",\n        \"PROPERTY_TYPE\": \"SINGLE RESIDENTIAL COOP UNIT\",\n        \"ZIPCODE\": \"10019\",\n        \"STATE\": \"NY\"\n      },\n      \"lastSalesDate\": \"2021-07-21T00:00:00.000Z\",\n      \"lastSalesAmount\": 514000,\n      \"maxSalesAmount\": 1359000,\n      \"TotalRecords\": 74\n    },",
+            "method":"GET",
+            "required_parameters":[
+                {
+                    "name":"zipcode",
+                    "type":"STRING",
+                    "description":"",
+                    "default":"10019"
+                }
+            ],
+            "optional_parameters":[
+                {
+                    "name":"page",
+                    "type":"STRING",
+                    "description":"",
+                    "default":"1"
+                }
+            ],
+            "code":"import requests\n\nurl = \"https://real-estate-records.p.rapidapi.com/search/zipcode\"\nquerystring = {\"page\": page, \"zipcode\": zipcode}\n\nheaders = {\n    \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n    \"X-RapidAPI-Host\": \"real-estate-records.p.rapidapi.com\"\n}\n\nresponse = requests.get(url, headers=headers, params=querystring)\n\nprint(response.json())\n",
+            "statuscode":111,
+            "body":"",
+            "headers":"",
+            "schema":""
+        },
+        {
+            "name":"detail",
+            "url":"https://real-estate-records.p.rapidapi.com/search/detail",
+            "description":"Return all detailed historical transactions of a given address. To call this API, it requires to call summary API first using address information. Then use the Id value returned from the summary API and call this API with the same Id. This API requires a subscription cost.",
+            "method":"GET",
+            "required_parameters":[
+                {
+                    "name":"id",
+                    "type":"STRING",
+                    "description":"",
+                    "default":"6144a05f3afc5ca06e88a2ab"
+                }
+            ],
+            "optional_parameters":[],
+            "code":"import requests\n\nurl = \"https://real-estate-records.p.rapidapi.com/search/detail\"\nquerystring = {\"id\": id}\n\nheaders = {\n    \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n    \"X-RapidAPI-Host\": \"real-estate-records.p.rapidapi.com\"\n}\n\nresponse = requests.get(url, headers=headers, params=querystring)\n\nprint(response.json())\n",
+            "statuscode":111,
+            "body":"",
+            "headers":"",
+            "schema":""
+        },
+        {
+            "name":"summary",
+            "url":"https://real-estate-records.p.rapidapi.com/search/summary",
+            "description":"Get a summary of property records by units given an address (if it's a multi-unit building). Street number, name and zipcode are needed to match records. The street names are normalized using Here.com conventions. This API requires a subscription cost. \n\nThis API provides details a level further than the \"address\" endpoint. For instance,  for 220 Central Park S, New York, NY 10019 it returns\n  \"data\": [\n    {\n      \"_id\": {\n        \"id\": \"6144a17b3afc5ca06ea0dd95\",\n        \"Loc\": {\n          \"coordinates\": [\n            -73.9802,\n            40.76719\n          ],\n          \"type\": \"Point\"\n        },\n        \"STREET_NUMBER\": \"220\",\n        \"STREET\": \"Central Park S\",\n        \"UNIT\": \"67\",\n        \"PROPERTY_TYPE\": \"SINGLE RESIDENTIAL CONDO UNIT\",\n        \"ZIPCODE\": \"10019\",\n        \"STATE\": \"NY\"\n      },\n      \"lastSalesDate\": \"2021-05-24T00:00:00.000Z\",\n      \"lastSalesAmount\": 59500000,\n      \"maxSalesAmount\": 59500000,\n      \"SQFT\": 0,\n      \"TotalRecords\": 1\n    },\n\nThe API is available for public records for New York City 5 boroughs, all New Jersey Counties and DC. \nSources of information are:\nNJ: http://tax1.co.monmouth.nj.us/cgi-bin/prc6.cgi?&ms_user=monm&passwd=&srch_type=0&adv=0&out_type=0&district=0200\nNYC Acris: https://a836-acris.nyc.gov/DS/DocumentSearch/Index",
+            "method":"GET",
+            "required_parameters":[
+                {
+                    "name":"number",
+                    "type":"STRING",
+                    "description":"",
+                    "default":"220"
+                },
+                {
+                    "name":"street",
+                    "type":"STRING",
+                    "description":"",
+                    "default":"Central Park S"
+                }
+            ],
+            "optional_parameters":[
+                {
+                    "name":"zipcode",
+                    "type":"STRING",
+                    "description":"",
+                    "default":"10019"
+                }
+            ],
+            "code":"import requests\n\nurl = \"https://real-estate-records.p.rapidapi.com/search/summary\"\nquerystring = {\"number\": number, \"street\": street, \"zipcode\": zipcode}\n\nheaders = {\n    \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n    \"X-RapidAPI-Host\": \"real-estate-records.p.rapidapi.com\"\n}\n\nresponse = requests.get(url, headers=headers, params=querystring)\n\nprint(response.json())\n",
+            "statuscode":111,
+            "body":"",
+            "headers":"",
+            "schema":""
+        },
+        {
+            "name":"address",
+            "url":"https://real-estate-records.p.rapidapi.com/search/address",
+            "description":"Get a high level of summary of property records given an address. Street number, name and zipcode are needed to match records. The street names are normalized using Here.com conventions. **This API is free to use.**\n\nIf it's an apartment building, it will return total records available for every property type. For instance,  for 220 Central Park S, New York, NY 10019,  it returns:\n  \"data\": [\n    {\n      \"_id\": {\n        \"STREET_NUMBER\": \"220\",\n        \"STREET\": \"Central Park S\",\n        \"PROPERTY_TYPE\": \"SINGLE RESIDENTIAL CONDO UNIT\",\n        \"ZIPCODE\": \"10019\",\n        \"STATE\": \"NY\"\n      },\n      \"Location\": {\n        \"coordinates\": [\n          -73.9802,\n          40.76719\n        ],\n        \"type\": \"Point\"\n      },\n      \"lastSalesDate\": \"2021-05-24T00:00:00.000Z\",\n      \"lastSalesAmount\": 59500000,\n      \"maxSalesAmount\": 239958219.15,\n      \"TotalRecords\": 100\n    },\n\nThe API is available for public records for New York City 5 boroughs, all New Jersey Counties and DC. \nSources of information are:\nNJ: http://tax1.co.monmouth.nj.us/cgi-bin/prc6.cgi?&ms_user=monm&passwd=&srch_type=0&adv=0&out_type=0&district=0200\nNYC Acris: https://a836-acris.nyc.gov/DS/DocumentSearch/Index",
+            "method":"GET",
+            "required_parameters":[
+                {
+                    "name":"street",
+                    "type":"STRING",
+                    "description":"",
+                    "default":"Central Park S"
+                },
+                {
+                    "name":"number",
+                    "type":"STRING",
+                    "description":"",
+                    "default":"220"
+                }
+            ],
+            "optional_parameters":[
+                {
+                    "name":"zipcode",
+                    "type":"STRING",
+                    "description":"",
+                    "default":"10019"
+                }
+            ],
+            "code":"import requests\n\nurl = \"https://real-estate-records.p.rapidapi.com/search/address\"\nquerystring = {\"street\": street, \"number\": number, \"zipcode\": zipcode}\n\nheaders = {\n    \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n    \"X-RapidAPI-Host\": \"real-estate-records.p.rapidapi.com\"\n}\n\nresponse = requests.get(url, headers=headers, params=querystring)\n\nprint(response.json())\n",
+            "statuscode":111,
+            "body":"",
+            "headers":"",
+            "schema":""
+        }
+    ]
+}

toolbench/toolenv/tools/Data/real_estate_records/api.py

@@ -0,0 +1,175 @@
+import requests
+import json
+from datetime import date, datetime, timedelta
+import os
+
+from typing import Optional, Dict, Union, List
+
+
+def transactions(zipcode: str, page: str='1', toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "Show transactions given a zipcode. The API returns 50 records each time in descending order by date and supports pagination. This API requires a subscription cost.
+		
+		The returned data shows the summary of information. To get further detail (such as the unit of a building that posts the most recent transaction, use summary API.
+		
+		Sample data of the API when query zipcode 10019 is:
+		 "data": [
+		    {
+		      "_id": {
+		        "STREET_NUMBER": "310",
+		        "STREET": "W 56th St",
+		        "PROPERTY_TYPE": "SINGLE RESIDENTIAL COOP UNIT",
+		        "ZIPCODE": "10019",
+		        "STATE": "NY"
+		      },
+		      "lastSalesDate": "2021-07-21T00:00:00.000Z",
+		      "lastSalesAmount": 514000,
+		      "maxSalesAmount": 1359000,
+		      "TotalRecords": 74
+		    },"
+    
+    """
+    url = f"https://real-estate-records.p.rapidapi.com/search/zipcode"
+    querystring = {'zipcode': zipcode, }
+    if page:
+        querystring['page'] = page
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "real-estate-records.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+
+def detail(is_id: str, toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "Return all detailed historical transactions of a given address. To call this API, it requires to call summary API first using address information. Then use the Id value returned from the summary API and call this API with the same Id. This API requires a subscription cost."
+    
+    """
+    url = f"https://real-estate-records.p.rapidapi.com/search/detail"
+    querystring = {'id': is_id, }
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "real-estate-records.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+
+def summary(number: str, street: str, zipcode: str='10019', toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "Get a summary of property records by units given an address (if it's a multi-unit building). Street number, name and zipcode are needed to match records. The street names are normalized using Here.com conventions. This API requires a subscription cost. 
+		
+		This API provides details a level further than the "address" endpoint. For instance,  for 220 Central Park S, New York, NY 10019 it returns
+		  "data": [
+		    {
+		      "_id": {
+		        "id": "6144a17b3afc5ca06ea0dd95",
+		        "Loc": {
+		          "coordinates": [
+		            -73.9802,
+		            40.76719
+		          ],
+		          "type": "Point"
+		        },
+		        "STREET_NUMBER": "220",
+		        "STREET": "Central Park S",
+		        "UNIT": "67",
+		        "PROPERTY_TYPE": "SINGLE RESIDENTIAL CONDO UNIT",
+		        "ZIPCODE": "10019",
+		        "STATE": "NY"
+		      },
+		      "lastSalesDate": "2021-05-24T00:00:00.000Z",
+		      "lastSalesAmount": 59500000,
+		      "maxSalesAmount": 59500000,
+		      "SQFT": 0,
+		      "TotalRecords": 1
+		    },
+		
+		The API is available for public records for New York City 5 boroughs, all New Jersey Counties and DC. 
+		Sources of information are:
+		NJ: http://tax1.co.monmouth.nj.us/cgi-bin/prc6.cgi?&ms_user=monm&passwd=&srch_type=0&adv=0&out_type=0&district=0200
+		NYC Acris: https://a836-acris.nyc.gov/DS/DocumentSearch/Index"
+    
+    """
+    url = f"https://real-estate-records.p.rapidapi.com/search/summary"
+    querystring = {'number': number, 'street': street, }
+    if zipcode:
+        querystring['zipcode'] = zipcode
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "real-estate-records.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+
+def address(street: str, number: str, zipcode: str='10019', toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "Get a high level of summary of property records given an address. Street number, name and zipcode are needed to match records. The street names are normalized using Here.com conventions. **This API is free to use.**
+		
+		If it's an apartment building, it will return total records available for every property type. For instance,  for 220 Central Park S, New York, NY 10019,  it returns:
+		  "data": [
+		    {
+		      "_id": {
+		        "STREET_NUMBER": "220",
+		        "STREET": "Central Park S",
+		        "PROPERTY_TYPE": "SINGLE RESIDENTIAL CONDO UNIT",
+		        "ZIPCODE": "10019",
+		        "STATE": "NY"
+		      },
+		      "Location": {
+		        "coordinates": [
+		          -73.9802,
+		          40.76719
+		        ],
+		        "type": "Point"
+		      },
+		      "lastSalesDate": "2021-05-24T00:00:00.000Z",
+		      "lastSalesAmount": 59500000,
+		      "maxSalesAmount": 239958219.15,
+		      "TotalRecords": 100
+		    },
+		
+		The API is available for public records for New York City 5 boroughs, all New Jersey Counties and DC. 
+		Sources of information are:
+		NJ: http://tax1.co.monmouth.nj.us/cgi-bin/prc6.cgi?&ms_user=monm&passwd=&srch_type=0&adv=0&out_type=0&district=0200
+		NYC Acris: https://a836-acris.nyc.gov/DS/DocumentSearch/Index"
+    
+    """
+    url = f"https://real-estate-records.p.rapidapi.com/search/address"
+    querystring = {'street': street, 'number': number, }
+    if zipcode:
+        querystring['zipcode'] = zipcode
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "real-estate-records.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+

toolbench/toolenv/tools/Data/real_time_climate_index.json

@@ -0,0 +1,30 @@
+{
+    "tool_name":"Real-time climate index",
+    "tool_description":"A standard index scaled 1-100 that compiles the most significant factors underlying climate change. R-TCI will make it easier to conceptualize and understand the nature and urgency of the current climate crises.",
+    "title":"Real-time climate index",
+    "pricing":"FREE",
+    "score":{
+        "avgServiceLevel":100,
+        "avgLatency":1003,
+        "avgSuccessRate":100,
+        "popularityScore":9,
+        "__typename":"Score"
+    },
+    "home_url":"https://rapidapi.com/ezimmerman/api/real-time-climate-index/",
+    "host":"real-time-climate-index.p.rapidapi.com",
+    "api_list":[
+        {
+            "name":"all-data",
+            "url":"https://real-time-climate-index.p.rapidapi.com/api/climate-data",
+            "description":"Gather all data related to R-TCI",
+            "method":"GET",
+            "required_parameters":[],
+            "optional_parameters":[],
+            "code":"import requests\n\nurl = \"https://real-time-climate-index.p.rapidapi.com/api/climate-data\"\n\nheaders = {\n    \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n    \"X-RapidAPI-Host\": \"real-time-climate-index.p.rapidapi.com\"\n}\n\nresponse = requests.get(url, headers=headers)\n\nprint(response.json())\n",
+            "statuscode":111,
+            "body":"",
+            "headers":"",
+            "schema":""
+        }
+    ]
+}

toolbench/toolenv/tools/Data/real_time_climate_index/api.py

@@ -0,0 +1,29 @@
+import requests
+import json
+from datetime import date, datetime, timedelta
+import os
+
+from typing import Optional, Dict, Union, List
+
+
+def all_data(toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "Gather all data related to R-TCI"
+    
+    """
+    url = f"https://real-time-climate-index.p.rapidapi.com/api/climate-data"
+    querystring = {}
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "real-time-climate-index.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+

toolbench/toolenv/tools/Data/real_time_image_search.json

@@ -0,0 +1,128 @@
+{
+    "tool_name":"Real-Time Image Search",
+    "tool_description":"Fast and Simple image web searches in real-time, with support for all filters available on Google Advanced Image Search.",
+    "title":"Real-Time Image Search",
+    "pricing":"FREEMIUM",
+    "score":{
+        "avgServiceLevel":100,
+        "avgLatency":1593,
+        "avgSuccessRate":100,
+        "popularityScore":9.7,
+        "__typename":"Score"
+    },
+    "home_url":"https://rapidapi.com/letscrape-6bRBa3QguO5/api/real-time-image-search/",
+    "host":"real-time-image-search.p.rapidapi.com",
+    "api_list":[
+        {
+            "name":"Search Images",
+            "url":"https://real-time-image-search.p.rapidapi.com/search",
+            "description":"Get real-time image search results from across the web. Supports all Google Images search filters.",
+            "method":"GET",
+            "required_parameters":[
+                {
+                    "name":"query",
+                    "type":"STRING",
+                    "description":"Search query / keyword.",
+                    "default":"beach"
+                }
+            ],
+            "optional_parameters":[
+                {
+                    "name":"region",
+                    "type":"STRING",
+                    "description":"The country / region from which to make the query.\n\n**Allowed values:** 2-letter country code, see [ISO 3166-1 alpha-2](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2)\n**Default:** us.",
+                    "default":"us"
+                },
+                {
+                    "name":"aspect_ratio",
+                    "type":"STRING",
+                    "description":"Find images with a specific aspect ratio.\n\n**Allowed values:** *tall, square, wide, panoramic*",
+                    "default":""
+                },
+                {
+                    "name":"country",
+                    "type":"STRING",
+                    "description":"Find images published in a specific country / region.\n\n**Allowed values:** 2-letter country code, see [ISO 3166-1 alpha-2](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2)",
+                    "default":""
+                },
+                {
+                    "name":"file_type",
+                    "type":"STRING",
+                    "description":"Find images of a specific format / file type.\n\n**Allowed values:** *jpg, jpeg, png, gif, svg, webp, ico, raw*",
+                    "default":""
+                },
+                {
+                    "name":"safe_search",
+                    "type":"BOOLEAN",
+                    "description":"",
+                    "default":""
+                },
+                {
+                    "name":"usage_rights",
+                    "type":"STRING",
+                    "description":"Find images with specific usage rights / license / copyright.\n\n**Allowed values:** *creative_commons, commercial*",
+                    "default":""
+                },
+                {
+                    "name":"color",
+                    "type":"STRING",
+                    "description":"Find images with a specific dominant color.\n\n**Allowed values:** *red, orange, yellow, green, teal, blue, purple, pink, white, gray, black, brown, full, transparent, grayscale*",
+                    "default":""
+                },
+                {
+                    "name":"size",
+                    "type":"STRING",
+                    "description":"Find images of a specific size.\n\n**Allowed values:** *large, medium, icon, 400x300+, 640x480+, 800x600+, 1024x768+, 2mp+, 4mp+, 6mp+, 8mp+, 10mp+, 12mp+, 15mp+, 20mp+, 40mp+, 70mp+*",
+                    "default":""
+                },
+                {
+                    "name":"time",
+                    "type":"STRING",
+                    "description":"Find images last updated in a specific time range.\n\n**Allowed values:** *day, week, month, year*",
+                    "default":""
+                },
+                {
+                    "name":"type",
+                    "type":"STRING",
+                    "description":"Find images of a specific type.\n\n**Allowed values:** *face, photo, clipart, lineart, animated*",
+                    "default":""
+                }
+            ],
+            "code":"import requests\n\nurl = \"https://real-time-image-search.p.rapidapi.com/search\"\nquerystring = {\"region\": region, \"query\": query}\n\nheaders = {\n    \"X-RapidAPI-Key\": \"SIGN-UP-FOR-KEY\",\n    \"X-RapidAPI-Host\": \"real-time-image-search.p.rapidapi.com\"\n}\n\nresponse = requests.get(url, headers=headers, params=querystring)\n\nprint(response.json())\n",
+            "statuscode":200,
+            "body":{
+                "key1":"value",
+                "key2":"value"
+            },
+            "headers":{},
+            "schema":{
+                "type":"object",
+                "properties":{
+                    "status":{
+                        "type":"string"
+                    },
+                    "request_id":{
+                        "type":"string"
+                    },
+                    "parameters":{
+                        "type":"object",
+                        "properties":{
+                            "query":{
+                                "type":"string"
+                            },
+                            "region":{
+                                "type":"string"
+                            }
+                        }
+                    },
+                    "data":{
+                        "type":"array",
+                        "items":{
+                            "type":"object"
+                        }
+                    }
+                }
+            }
+        }
+    ]
+}

toolbench/toolenv/tools/Data/real_time_image_search/api.py

@@ -0,0 +1,78 @@
+import requests
+import json
+from datetime import date, datetime, timedelta
+import os
+
+from typing import Optional, Dict, Union, List
+
+
+def search_images(query: str, region: str='us', aspect_ratio: str=None, country: str=None, file_type: str=None, safe_search: bool=None, usage_rights: str=None, color: str=None, size: str=None, time: str=None, type: str=None, toolbench_rapidapi_key: str='088440d910mshef857391f2fc461p17ae9ejsnaebc918926ff'):
+    """
+    "Get real-time image search results from across the web. Supports all Google Images search filters."
+    query: Search query / keyword.
+        region: The country / region from which to make the query.
+
+**Allowed values:** 2-letter country code, see [ISO 3166-1 alpha-2](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2)
+**Default:** us.
+        aspect_ratio: Find images with a specific aspect ratio.
+
+**Allowed values:** *tall, square, wide, panoramic*
+        country: Find images published in a specific country / region.
+
+**Allowed values:** 2-letter country code, see [ISO 3166-1 alpha-2](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2)
+        file_type: Find images of a specific format / file type.
+
+**Allowed values:** *jpg, jpeg, png, gif, svg, webp, ico, raw*
+        usage_rights: Find images with specific usage rights / license / copyright.
+
+**Allowed values:** *creative_commons, commercial*
+        color: Find images with a specific dominant color.
+
+**Allowed values:** *red, orange, yellow, green, teal, blue, purple, pink, white, gray, black, brown, full, transparent, grayscale*
+        size: Find images of a specific size.
+
+**Allowed values:** *large, medium, icon, 400x300+, 640x480+, 800x600+, 1024x768+, 2mp+, 4mp+, 6mp+, 8mp+, 10mp+, 12mp+, 15mp+, 20mp+, 40mp+, 70mp+*
+        time: Find images last updated in a specific time range.
+
+**Allowed values:** *day, week, month, year*
+        type: Find images of a specific type.
+
+**Allowed values:** *face, photo, clipart, lineart, animated*
+        
+    """
+    url = f"https://real-time-image-search.p.rapidapi.com/search"
+    querystring = {'query': query, }
+    if region:
+        querystring['region'] = region
+    if aspect_ratio:
+        querystring['aspect_ratio'] = aspect_ratio
+    if country:
+        querystring['country'] = country
+    if file_type:
+        querystring['file_type'] = file_type
+    if safe_search:
+        querystring['safe_search'] = safe_search
+    if usage_rights:
+        querystring['usage_rights'] = usage_rights
+    if color:
+        querystring['color'] = color
+    if size:
+        querystring['size'] = size
+    if time:
+        querystring['time'] = time
+    if type:
+        querystring['type'] = type
+    
+    headers = {
+            "X-RapidAPI-Key": toolbench_rapidapi_key,
+            "X-RapidAPI-Host": "real-time-image-search.p.rapidapi.com"
+        }
+
+
+    response = requests.get(url, headers=headers, params=querystring)
+    try:
+        observation = response.json()
+    except:
+        observation = response.text
+    return observation
+