llama-index-tools-brightdata 0.1.0__tar.gz

llama_index_tools_brightdata-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) Bright Data
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

llama_index_tools_brightdata-0.1.0/PKG-INFO

@@ -0,0 +1,161 @@
+Metadata-Version: 2.4
+Name: llama-index-tools-brightdata
+Version: 0.1.0
+Summary: llama-index tools Bright Data integration
+Author-email: Bright Data <you@example.com>
+Maintainer: brightdata
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: <4.0,>=3.9
+Requires-Dist: llama-index-core<0.13,>=0.12.0
+Requires-Dist: llama-index>=0.12.34
+Description-Content-Type: text/markdown
+
+# LlamaIndex Tools Integration: Bright Data
+
+This tool connects to [Bright Data](https://brightdata.com/) to enable your agent to crawl websites, search the web, and access structured data from platforms like LinkedIn, Amazon, and social media.
+
+Bright Data's tools provide robust web scraping capabilities with built-in CAPTCHA solving and bot detection avoidance, allowing you to reliably extract data from the web.
+
+## Installation
+
+```bash
+pip install llama-index llama-index-core llama-index-tools-brightdata
+```
+
+## Authentication
+
+To use this tool, you'll need a Bright Data API key. You can obtain one by signing up for a Bright Data account on their [website](https://brightdata.com/).
+
+## Usage
+
+Here's an example of how to use the BrightDataToolSpec with LlamaIndex:
+
+```python
+llm = OpenAI(model="gpt-4o", api_key="your-api-key")
+
+brightdata_tool = BrightDataToolSpec(api_key="your-api-key", zone="unlocker")
+
+tool_list = brightdata_tool.to_tool_list()
+
+for tool in tool_list:
+    tool.original_description = tool.metadata.description
+    tool.metadata.description = "Bright Data web scraping tool"
+
+agent = OpenAIAgent.from_tools(tools=tool_list, llm=llm)
+
+query = (
+    "Find and summarize the latest news about AI from major tech news sites"
+)
+tool_descriptions = "\n\n".join(
+    [
+        f"Tool Name: {tool.metadata.name}\nTool Description: {tool.original_description}"
+        for tool in tool_list
+    ]
+)
+
+query_with_descriptions = f"{tool_descriptions}\n\nQuery: {query}"
+
+response = agent.chat(query_with_descriptions)
+print(response)
+```
+
+## Features
+
+The Bright Data tool provides the following capabilities:
+
+### Web Scraping
+
+- `scrape_as_markdown`: Scrape a webpage and convert the content to Markdown format. This tool can bypass CAPTCHA and bot detection.
+
+```python
+result = brightdata_tool.scrape_as_markdown("https://example.com")
+print(result.text)
+```
+
+### Visual Capture
+
+- `get_screenshot`: Take a screenshot of a webpage and save it to a file.
+
+```python
+screenshot_path = brightdata_tool.get_screenshot(
+    "https://example.com", output_path="example_screenshot.png"
+)
+```
+
+### Search Engine Access
+
+- `search_engine`: Search Google, Bing, or Yandex and get structured search results as JSON or Markdown. Supports advanced parameters for more specific searches.
+
+```python
+search_results = brightdata_tool.search_engine(
+    query="climate change solutions",
+    engine="google",
+    language="en",
+    country_code="us",
+    num_results=20,
+)
+print(search_results.text)
+```
+
+### Structured Web Data Extraction
+
+- `web_data_feed`: Retrieve structured data from various platforms including LinkedIn, Amazon, Instagram, Facebook, X (Twitter), Zillow, and more.
+
+```python
+linkedin_profile = brightdata_tool.web_data_feed(
+    source_type="linkedin_person_profile",
+    url="https://www.linkedin.com/in/username/",
+)
+print(linkedin_profile)
+
+amazon_product = brightdata_tool.web_data_feed(
+    source_type="amazon_product", url="https://www.amazon.com/dp/B08N5KWB9H"
+)
+print(amazon_product)
+```
+
+## Advanced Configuration
+
+The Bright Data tool offers various configuration options for specialized use cases:
+
+### Search Engine Parameters
+
+The `search_engine` function supports advanced parameters like:
+
+- Language targeting (`language` parameter)
+- Country-specific search (`country_code` parameter)
+- Different search types (images, shopping, news, etc.)
+- Pagination controls
+- Mobile device emulation
+- Geolocation targeting
+- Hotel search parameters
+
+```python
+results = brightdata_tool.search_engine(
+    query="best hotels in paris",
+    engine="google",
+    language="fr",
+    country_code="fr",
+    search_type="shopping",
+    device="mobile",
+    hotel_dates="2025-06-01,2025-06-05",
+    hotel_occupancy=2,
+)
+```
+
+### Supported Web Data Sources
+
+The `web_data_feed` function supports retrieving structured data from:
+
+- LinkedIn (profiles and companies)
+- Amazon (products and reviews)
+- Instagram (profiles, posts, reels, comments)
+- Facebook (posts, marketplace listings, company reviews)
+- X/Twitter (posts)
+- Zillow (property listings)
+- Booking.com (hotel listings)
+- YouTube (videos)
+- ZoomInfo (company profiles)
+
+For more information, visit the [Bright Data documentation](https://docs.brightdata.com/).

llama_index_tools_brightdata-0.1.0/README.md

@@ -0,0 +1,148 @@
+# LlamaIndex Tools Integration: Bright Data
+
+This tool connects to [Bright Data](https://brightdata.com/) to enable your agent to crawl websites, search the web, and access structured data from platforms like LinkedIn, Amazon, and social media.
+
+Bright Data's tools provide robust web scraping capabilities with built-in CAPTCHA solving and bot detection avoidance, allowing you to reliably extract data from the web.
+
+## Installation
+
+```bash
+pip install llama-index llama-index-core llama-index-tools-brightdata
+```
+
+## Authentication
+
+To use this tool, you'll need a Bright Data API key. You can obtain one by signing up for a Bright Data account on their [website](https://brightdata.com/).
+
+## Usage
+
+Here's an example of how to use the BrightDataToolSpec with LlamaIndex:
+
+```python
+llm = OpenAI(model="gpt-4o", api_key="your-api-key")
+
+brightdata_tool = BrightDataToolSpec(api_key="your-api-key", zone="unlocker")
+
+tool_list = brightdata_tool.to_tool_list()
+
+for tool in tool_list:
+    tool.original_description = tool.metadata.description
+    tool.metadata.description = "Bright Data web scraping tool"
+
+agent = OpenAIAgent.from_tools(tools=tool_list, llm=llm)
+
+query = (
+    "Find and summarize the latest news about AI from major tech news sites"
+)
+tool_descriptions = "\n\n".join(
+    [
+        f"Tool Name: {tool.metadata.name}\nTool Description: {tool.original_description}"
+        for tool in tool_list
+    ]
+)
+
+query_with_descriptions = f"{tool_descriptions}\n\nQuery: {query}"
+
+response = agent.chat(query_with_descriptions)
+print(response)
+```
+
+## Features
+
+The Bright Data tool provides the following capabilities:
+
+### Web Scraping
+
+- `scrape_as_markdown`: Scrape a webpage and convert the content to Markdown format. This tool can bypass CAPTCHA and bot detection.
+
+```python
+result = brightdata_tool.scrape_as_markdown("https://example.com")
+print(result.text)
+```
+
+### Visual Capture
+
+- `get_screenshot`: Take a screenshot of a webpage and save it to a file.
+
+```python
+screenshot_path = brightdata_tool.get_screenshot(
+    "https://example.com", output_path="example_screenshot.png"
+)
+```
+
+### Search Engine Access
+
+- `search_engine`: Search Google, Bing, or Yandex and get structured search results as JSON or Markdown. Supports advanced parameters for more specific searches.
+
+```python
+search_results = brightdata_tool.search_engine(
+    query="climate change solutions",
+    engine="google",
+    language="en",
+    country_code="us",
+    num_results=20,
+)
+print(search_results.text)
+```
+
+### Structured Web Data Extraction
+
+- `web_data_feed`: Retrieve structured data from various platforms including LinkedIn, Amazon, Instagram, Facebook, X (Twitter), Zillow, and more.
+
+```python
+linkedin_profile = brightdata_tool.web_data_feed(
+    source_type="linkedin_person_profile",
+    url="https://www.linkedin.com/in/username/",
+)
+print(linkedin_profile)
+
+amazon_product = brightdata_tool.web_data_feed(
+    source_type="amazon_product", url="https://www.amazon.com/dp/B08N5KWB9H"
+)
+print(amazon_product)
+```
+
+## Advanced Configuration
+
+The Bright Data tool offers various configuration options for specialized use cases:
+
+### Search Engine Parameters
+
+The `search_engine` function supports advanced parameters like:
+
+- Language targeting (`language` parameter)
+- Country-specific search (`country_code` parameter)
+- Different search types (images, shopping, news, etc.)
+- Pagination controls
+- Mobile device emulation
+- Geolocation targeting
+- Hotel search parameters
+
+```python
+results = brightdata_tool.search_engine(
+    query="best hotels in paris",
+    engine="google",
+    language="fr",
+    country_code="fr",
+    search_type="shopping",
+    device="mobile",
+    hotel_dates="2025-06-01,2025-06-05",
+    hotel_occupancy=2,
+)
+```
+
+### Supported Web Data Sources
+
+The `web_data_feed` function supports retrieving structured data from:
+
+- LinkedIn (profiles and companies)
+- Amazon (products and reviews)
+- Instagram (profiles, posts, reels, comments)
+- Facebook (posts, marketplace listings, company reviews)
+- X/Twitter (posts)
+- Zillow (property listings)
+- Booking.com (hotel listings)
+- YouTube (videos)
+- ZoomInfo (company profiles)
+
+For more information, visit the [Bright Data documentation](https://docs.brightdata.com/).

llama_index_tools_brightdata-0.1.0/llama_index/tools/brightdata/__init__.py

@@ -0,0 +1,3 @@
+from llama_index.tools.brightdata.base import BrightDataToolSpec
+
+__all__ = ["BrightDataToolSpec"]

llama_index_tools_brightdata-0.1.0/llama_index/tools/brightdata/base.py

@@ -0,0 +1,355 @@
+"""Bright Data tool spec for LlamaIndex."""
+
+from typing import Dict, Optional
+from llama_index.core.schema import Document
+from llama_index.core.tools.tool_spec.base import BaseToolSpec
+
+
+class BrightDataToolSpec(BaseToolSpec):
+    """Bright Data tool spec for web scraping and search capabilities."""
+
+    spec_functions = ["scrape_as_markdown", "get_screenshot", "search_engine","web_data_feed"]
+
+    def __init__(
+        self,
+        api_key: str,
+        zone: str = "unblocker",
+        verbose: bool = False,
+    ) -> None:
+        """
+        Initialize with API token and default zone.
+
+        Args:
+            api_key (str): Your Bright Data API token
+            zone (str): Bright Data zone name
+            verbose (bool): Print additional information about requests
+
+        """
+        self._headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {api_key}"
+        }
+        self._api_key = api_key
+        self._zone = zone
+        self._verbose = verbose
+        self._endpoint = "https://api.brightdata.com/request"
+
+    def _make_request(self, payload: Dict) -> str:
+        """
+        Make a request to Bright Data API.
+
+        Args:
+            payload (Dict): Request payload
+
+        Returns:
+            str: Response text
+
+        """
+        import requests
+        import json
+
+        if self._verbose:
+            print(f"[Bright Data] Request: {payload['url']}")
+
+        response = requests.post(
+            self._endpoint,
+            headers=self._headers,
+            data=json.dumps(payload)
+        )
+
+        if response.status_code != 200:
+            raise Exception(f"Failed to scrape: {response.status_code} - {response.text}")
+
+        return response.text
+
+    def scrape_as_markdown(self, url: str, zone: Optional[str] = None) -> Document:
+        """
+        Scrape a webpage and return content in Markdown format.
+
+        Args:
+            url (str): URL to scrape
+            zone (Optional[str]): Override default zone
+
+        Returns:
+            Document: Scraped content as Markdown
+
+        """
+        payload = {
+            "url": url,
+            "zone": zone or self._zone,
+            "format": "raw",
+            "data_format": "markdown"
+        }
+
+        content = self._make_request(payload)
+        return Document(text=content, metadata={"url": url})
+
+    def get_screenshot(self, url: str, output_path: str, zone: Optional[str] = None) -> str:
+        """
+        Take a screenshot of a webpage.
+
+        Args:
+            url (str): URL to screenshot
+            output_path (str): Path to save the screenshot
+            zone (Optional[str]): Override default zone
+
+        Returns:
+            str: Path to saved screenshot
+
+        """
+        import requests
+        import json
+
+        payload = {
+            "url": url,
+            "zone": zone or self._zone,
+            "format": "raw",
+            "data_format": "screenshot"
+        }
+
+        response = requests.post(
+            self._endpoint,
+            headers=self._headers,
+            data=json.dumps(payload)
+        )
+
+        if response.status_code != 200:
+            raise Exception(f"Error {response.status_code}: {response.text}")
+
+        with open(output_path, "wb") as f:
+            f.write(response.content)
+
+        return output_path
+
+    def search_engine(
+        self,
+        query: str,
+        engine: str = "google",
+        zone: Optional[str] = None,
+        language: Optional[str] = None,       # hl parameter, e.g., "en"
+        country_code: Optional[str] = None,   # gl parameter, e.g., "us"
+        search_type: Optional[str] = None,    # tbm parameter (images, shopping, news, etc.)
+        start: Optional[int] = None,          # pagination start index
+        num_results: Optional[int] = 10,      # number of results to return
+        location: Optional[str] = None,       # uule parameter for geo-location
+        device: Optional[str] = None,         # device type for user-agent
+        return_json: bool = False,            # parse results as JSON
+        hotel_dates: Optional[str] = None,    # check-in and check-out dates
+        hotel_occupancy: Optional[int] = None # number of guests
+    ) -> Document:
+        """
+        Search using Google, Bing, or Yandex with advanced parameters and return results in Markdown.
+
+        Args:
+            query (str): Search query
+            engine (str): Search engine - 'google', 'bing', or 'yandex'
+            zone (Optional[str]): Override default zone
+
+            # Google SERP specific parameters
+            language (Optional[str]): Two-letter language code (hl parameter)
+            country_code (Optional[str]): Two-letter country code (gl parameter)
+            search_type (Optional[str]): Type of search (images, shopping, news, etc.)
+            start (Optional[int]): Results pagination offset (0=first page, 10=second page)
+            num_results (Optional[int]): Number of results to return (default 10)
+            location (Optional[str]): Location for search results (uule parameter)
+            device (Optional[str]): Device type (mobile, ios, android, ipad, android_tablet)
+            return_json (bool): Return parsed JSON instead of HTML/Markdown
+
+            # Hotel search parameters
+            hotel_dates (Optional[str]): Check-in and check-out dates (format: YYYY-MM-DD,YYYY-MM-DD)
+            hotel_occupancy (Optional[int]): Number of guests (1-4)
+
+        Returns:
+            Document: Search results as Markdown or JSON
+
+        """
+        encoded_query = self._encode_query(query)
+
+        base_urls = {
+            "google": f"https://www.google.com/search?q={encoded_query}",
+            "bing": f"https://www.bing.com/search?q={encoded_query}",
+            "yandex": f"https://yandex.com/search/?text={encoded_query}"
+        }
+
+        if engine not in base_urls:
+            raise ValueError(f"Unsupported search engine: {engine}. Use 'google', 'bing', or 'yandex'")
+
+        search_url = base_urls[engine]
+
+        if engine == "google":
+            params = []
+
+            if language:
+                params.append(f"hl={language}")
+
+            if country_code:
+                params.append(f"gl={country_code}")
+
+            if search_type:
+                if search_type == "jobs":
+                    params.append("ibp=htl;jobs")
+                else:
+                    search_types = {
+                        "images": "isch",
+                        "shopping": "shop",
+                        "news": "nws"
+                    }
+                    tbm_value = search_types.get(search_type, search_type)
+                    params.append(f"tbm={tbm_value}")
+
+            if start is not None:
+                params.append(f"start={start}")
+
+            if num_results:
+                params.append(f"num={num_results}")
+
+            if location:
+                params.append(f"uule={self._encode_query(location)}")
+
+            if device:
+                device_value = "1"
+
+                if device in ["ios", "iphone"]:
+                    device_value = "ios"
+                elif device == "ipad":
+                    device_value = "ios_tablet"
+                elif device == "android":
+                    device_value = "android"
+                elif device == "android_tablet":
+                    device_value = "android_tablet"
+
+                params.append(f"brd_mobile={device_value}")
+
+            if return_json:
+                params.append("brd_json=1")
+
+            if hotel_dates:
+                params.append(f"hotel_dates={self._encode_query(hotel_dates)}")
+
+            if hotel_occupancy:
+                params.append(f"hotel_occupancy={hotel_occupancy}")
+
+            if params:
+                search_url += "&" + "&".join(params)
+
+        payload = {
+            "url": search_url,
+            "zone": zone or self._zone,
+            "format": "raw",
+            "data_format": "markdown" if not return_json else "raw"
+        }
+
+        content = self._make_request(payload)
+        return Document(text=content, metadata={
+            "query": query,
+            "engine": engine,
+            "url": search_url
+        })
+
+    def web_data_feed(
+        self,
+        source_type: str,
+        url: str,
+        num_of_reviews: Optional[int] = None,
+        timeout: int = 600,
+        polling_interval: int = 1
+    ) -> Dict:
+        """
+        Retrieve structured web data from various sources like LinkedIn, Amazon, Instagram, etc.
+
+        Args:
+            source_type (str): Type of data source (e.g., 'linkedin_person_profile', 'amazon_product')
+            url (str): URL of the web resource to retrieve data from
+            num_of_reviews (Optional[int]): Number of reviews to retrieve (only for facebook_company_reviews)
+            timeout (int): Maximum time in seconds to wait for data retrieval
+            polling_interval (int): Time in seconds between polling attempts
+
+        Returns:
+            Dict: Structured data from the requested source
+
+        """
+        import requests
+        import time
+
+        datasets = {
+            "amazon_product": "gd_l7q7dkf244hwjntr0",
+            "amazon_product_reviews": "gd_le8e811kzy4ggddlq",
+            "linkedin_person_profile": "gd_l1viktl72bvl7bjuj0",
+            "linkedin_company_profile": "gd_l1vikfnt1wgvvqz95w",
+            "zoominfo_company_profile": "gd_m0ci4a4ivx3j5l6nx",
+            "instagram_profiles": "gd_l1vikfch901nx3by4",
+            "instagram_posts": "gd_lk5ns7kz21pck8jpis",
+            "instagram_reels": "gd_lyclm20il4r5helnj",
+            "instagram_comments": "gd_ltppn085pokosxh13",
+            "facebook_posts": "gd_lyclm1571iy3mv57zw",
+            "facebook_marketplace_listings": "gd_lvt9iwuh6fbcwmx1a",
+            "facebook_company_reviews": "gd_m0dtqpiu1mbcyc2g86",
+            "x_posts": "gd_lwxkxvnf1cynvib9co",
+            "zillow_properties_listing": "gd_lfqkr8wm13ixtbd8f5",
+            "booking_hotel_listings": "gd_m5mbdl081229ln6t4a",
+            "youtube_videos": "gd_m5mbdl081229ln6t4a"
+        }
+
+        if source_type not in datasets:
+            valid_sources = ", ".join(datasets.keys())
+            raise ValueError(f"Invalid source_type: {source_type}. Valid options are: {valid_sources}")
+
+        dataset_id = datasets[source_type]
+
+        request_data = {"url": url}
+        if source_type == "facebook_company_reviews" and num_of_reviews is not None:
+            request_data["num_of_reviews"] = str(num_of_reviews)
+
+        trigger_response = requests.post(
+            "https://api.brightdata.com/datasets/v3/trigger",
+            params={"dataset_id": dataset_id, "include_errors": True},
+            headers=self._headers,
+            json=[request_data]
+        )
+
+        trigger_data = trigger_response.json()
+        if not trigger_data.get("snapshot_id"):
+            raise Exception("No snapshot ID returned from trigger request")
+
+        snapshot_id = trigger_data["snapshot_id"]
+        if self._verbose:
+            print(f"[Bright Data] {source_type} triggered with snapshot ID: {snapshot_id}")
+
+        attempts = 0
+        max_attempts = timeout
+
+        while attempts < max_attempts:
+            try:
+                snapshot_response = requests.get(
+                    f"https://api.brightdata.com/datasets/v3/snapshot/{snapshot_id}",
+                    params={"format": "json"},
+                    headers=self._headers
+                )
+
+                snapshot_data = snapshot_response.json()
+
+                if isinstance(snapshot_data, dict) and snapshot_data.get("status") == "running":
+                    if self._verbose:
+                        print(f"[Bright Data] Snapshot not ready, polling again (attempt {attempts + 1}/{max_attempts})")
+                    attempts += 1
+                    time.sleep(polling_interval)
+                    continue
+
+                if self._verbose:
+                    print(f"[Bright Data] Data received after {attempts + 1} attempts")
+
+                return snapshot_data
+
+            except Exception as e:
+                if self._verbose:
+                    print(f"[Bright Data] Polling error: {e!s}")
+                attempts += 1
+                time.sleep(polling_interval)
+
+        raise TimeoutError(f"Timeout after {max_attempts} seconds waiting for {source_type} data")
+
+    @staticmethod
+    def _encode_query(query: str) -> str:
+        """URL encode a search query."""
+        from urllib.parse import quote
+        return quote(query)

llama_index_tools_brightdata-0.1.0/pyproject.toml

@@ -0,0 +1,65 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[dependency-groups]
+dev = [
+    "ipython==8.10.0",
+    "jupyter>=1.0.0,<2",
+    "mypy==0.991",
+    "pre-commit==3.2.0",
+    "pylint==2.15.10",
+    "pytest==7.2.1",
+    "pytest-mock==3.11.1",
+    "ruff==0.0.292",
+    "types-Deprecated>=0.1.0",
+    "types-PyYAML>=6.0.12.12,<7",
+    "types-protobuf>=4.24.0.4,<5",
+    "types-redis==4.5.5.0",
+    "types-requests==2.28.11.8",
+    "types-setuptools==67.1.0.0",
+    "black[jupyter]<=23.9.1,>=23.7.0",
+    "codespell[toml]>=v2.2.6",
+    "diff-cover>=9.2.0",
+    "pytest-cov>=6.1.1",
+]
+
+[project]
+name = "llama-index-tools-brightdata"
+version = "0.1.0"
+description = "llama-index tools Bright Data integration"
+authors = [{name = "Bright Data", email = "you@example.com"}]
+requires-python = ">=3.9,<4.0"
+readme = "README.md"
+license = "MIT"
+maintainers = [{name = "brightdata"}]
+dependencies = [
+    "llama-index>=0.12.34",
+    "llama-index-core>=0.12.0,<0.13",
+]
+
+[tool.codespell]
+check-filenames = true
+check-hidden = true
+skip = "*.csv,*.html,*.json,*.jsonl,*.pdf,*.txt,*.ipynb"
+
+[tool.hatch.build.targets.sdist]
+include = ["llama_index/"]
+exclude = ["**/BUILD"]
+
+[tool.hatch.build.targets.wheel]
+include = ["llama_index/"]
+exclude = ["**/BUILD"]
+
+[tool.llamahub]
+contains_example = false
+import_path = "llama_index.tools.brightdata"
+
+[tool.llamahub.class_authors]
+BrightDataToolSpec = "brightdata"
+
+[tool.mypy]
+disallow_untyped_defs = true
+exclude = ["_static", "build", "examples", "notebooks", "venv"]
+ignore_missing_imports = true
+python_version = "3.8"