stealth-requests 0.1__tar.gz

stealth_requests-0.1/PKG-INFO

@@ -0,0 +1,110 @@
+Metadata-Version: 2.1
+Name: stealth-requests
+Version: 0.1
+Summary: Make HTTP requests exactly like a browser.
+Home-page: https://github.com/jpjacobpadilla/Stealth-Requests
+Author: Jacob Padilla
+Author-email: Jacob Padilla <jp@jacobpadilla.com>
+License: MIT
+Project-URL: Homepage, https://github.com/jpjacobpadilla/Stealth-Requests
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Requires-Dist: curl_cffi
+Provides-Extra: parsers
+Requires-Dist: lxml; extra == "parsers"
+Requires-Dist: html2text; extra == "parsers"
+Requires-Dist: beautifulsoup4; extra == "parsers"
+
+<p align="center">
+    <img src="https://github.com/jpjacobpadilla/Stealth-Requests/blob/7f83b67a0d62a932663d8216bad7d25971c90aaf/logo.png">
+</p>
+
+<h1 align="center">Stay Undetected While Scraping the Web.</h1>
+
+### The All-In-One Solution to Web Scraping:
+- Mimic the headers sent by a browser when going to a website (GET requests)
+- Automatically handle and update the Referer header & client hint headers
+- Mask the TLS fingerprint of the request using the [curl_cffi](https://curl-cffi.readthedocs.io/en/latest/) package
+- Automatically parse the metadata from HTML responses such as page title, description, thumbnail, author, etc...
+- Easily get an [lxml](https://lxml.de/apidoc/lxml.html) tree or [BeautifulSoup](https://beautiful-soup-4.readthedocs.io/en/latest/) object from the HTTP response. 
+
+### Sending Requests
+
+This package mimics the API of the `requests` package, and thus can be used in basically the same way.
+
+You can send one-off requests like such:
+
+```python
+import stealth_requests and requests
+
+resp = requests.get(link)
+```
+
+Or you can use a `StealthSession` object which will keep track of certain headers for you between requests such as the `Referer` header.
+
+```python
+from stealth_requests import StealthSession
+
+with StealthSession() as s:
+    resp = s.get(link)
+```
+
+When sending a one-off request, or creating a session, you can specify the type of browser that you want the request to mimic - either `safari` or `chrome` (which is the default).
+
+### Sending Requests With Asyncio
+
+This package supports Asyncio in the same way as the `requests` package.
+
+```python
+from stealth_requests import AsyncStealthSession
+
+async with AsyncStealthSession(impersonate='chrome') as s:
+    resp = await s.get(link)
+```
+
+or, for a one off request you can do something like this:
+
+```python
+from curl_cffi import requests
+
+resp = await requests.post(link, data=...)
+```
+
+### Getting Response Metadata
+
+The response returned from this package is a `StealthResponse` which has all of the same methods and attributes as a standard `requests` response, with a few added features. One if automatic parsing of header metadata. The metadata can be accessed from the `meta` attribute, which gives you access to the following data (if it's avaible on the scraped website):
+
+- title: str
+- description: str
+- thumbnail: str
+- author: str
+- keywords: tuple[str]
+- twitter_handle: str
+- robots: tuple[str]
+- canonical: str
+
+Heres an example of how to get the title of a page:
+
+```python
+import stealth_requests and requests
+
+resp = requests.get(link)
+print(resp.meta.title)
+```
+
+### Parsing Response
+
+To make parsing HTML easier, I've also added two popular parsing packages to this project - `Lxml` and `BeautifulSoup4`. To install these add-ons you need to install the parsers extra: `pip install stealth_requests[parsers]`.
+
+To easily get an Lxml tree, you can use `resp.tree()` and to get a BeautifulSoup object, use the `resp.soup()` method.
+
+For simple parsing, I've also added the following convience methods right to the `StealthResponse` object:
+
+- `iterlinks` Iterate through all links in an HTML response
+- `itertext`: Iterate through all text in an HTML response
+- `text_content`: Get all text content in an HTML response
+- `xpath` Go right to using XPATH expressions instead of getting your own Lxml tree.
+
+### Getting HTML response in MarkDown format
+
+Sometimes it's easier to get a webpage in MarkDown format instead of HTML. To do this, use the `resp.markdown()` method, after sending a GET request to a website.

stealth_requests-0.1/README.md

@@ -0,0 +1,93 @@
+<p align="center">
+    <img src="https://github.com/jpjacobpadilla/Stealth-Requests/blob/7f83b67a0d62a932663d8216bad7d25971c90aaf/logo.png">
+</p>
+
+<h1 align="center">Stay Undetected While Scraping the Web.</h1>
+
+### The All-In-One Solution to Web Scraping:
+- Mimic the headers sent by a browser when going to a website (GET requests)
+- Automatically handle and update the Referer header & client hint headers
+- Mask the TLS fingerprint of the request using the [curl_cffi](https://curl-cffi.readthedocs.io/en/latest/) package
+- Automatically parse the metadata from HTML responses such as page title, description, thumbnail, author, etc...
+- Easily get an [lxml](https://lxml.de/apidoc/lxml.html) tree or [BeautifulSoup](https://beautiful-soup-4.readthedocs.io/en/latest/) object from the HTTP response. 
+
+### Sending Requests
+
+This package mimics the API of the `requests` package, and thus can be used in basically the same way.
+
+You can send one-off requests like such:
+
+```python
+import stealth_requests and requests
+
+resp = requests.get(link)
+```
+
+Or you can use a `StealthSession` object which will keep track of certain headers for you between requests such as the `Referer` header.
+
+```python
+from stealth_requests import StealthSession
+
+with StealthSession() as s:
+    resp = s.get(link)
+```
+
+When sending a one-off request, or creating a session, you can specify the type of browser that you want the request to mimic - either `safari` or `chrome` (which is the default).
+
+### Sending Requests With Asyncio
+
+This package supports Asyncio in the same way as the `requests` package.
+
+```python
+from stealth_requests import AsyncStealthSession
+
+async with AsyncStealthSession(impersonate='chrome') as s:
+    resp = await s.get(link)
+```
+
+or, for a one off request you can do something like this:
+
+```python
+from curl_cffi import requests
+
+resp = await requests.post(link, data=...)
+```
+
+### Getting Response Metadata
+
+The response returned from this package is a `StealthResponse` which has all of the same methods and attributes as a standard `requests` response, with a few added features. One if automatic parsing of header metadata. The metadata can be accessed from the `meta` attribute, which gives you access to the following data (if it's avaible on the scraped website):
+
+- title: str
+- description: str
+- thumbnail: str
+- author: str
+- keywords: tuple[str]
+- twitter_handle: str
+- robots: tuple[str]
+- canonical: str
+
+Heres an example of how to get the title of a page:
+
+```python
+import stealth_requests and requests
+
+resp = requests.get(link)
+print(resp.meta.title)
+```
+
+### Parsing Response
+
+To make parsing HTML easier, I've also added two popular parsing packages to this project - `Lxml` and `BeautifulSoup4`. To install these add-ons you need to install the parsers extra: `pip install stealth_requests[parsers]`.
+
+To easily get an Lxml tree, you can use `resp.tree()` and to get a BeautifulSoup object, use the `resp.soup()` method.
+
+For simple parsing, I've also added the following convience methods right to the `StealthResponse` object:
+
+- `iterlinks` Iterate through all links in an HTML response
+- `itertext`: Iterate through all text in an HTML response
+- `text_content`: Get all text content in an HTML response
+- `xpath` Go right to using XPATH expressions instead of getting your own Lxml tree.
+
+### Getting HTML response in MarkDown format
+
+Sometimes it's easier to get a webpage in MarkDown format instead of HTML. To do this, use the `resp.markdown()` method, after sending a GET request to a website.

stealth_requests-0.1/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["setuptools>=42", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "stealth-requests"
+version = "0.1"
+description = "Make HTTP requests exactly like a browser."
+readme = "README.md"
+requires-python = ">=3.6"
+license = { text = "MIT" }
+authors = [
+    { name = "Jacob Padilla", email = "jp@jacobpadilla.com" }
+]
+keywords = [""]
+urls = { "Homepage" = "https://github.com/jpjacobpadilla/Stealth-Requests" }
+
+dependencies = ["curl_cffi"]
+
+[project.optional-dependencies]
+parsers = [
+    "lxml",
+    "html2text",
+    "beautifulsoup4"
+]
+
+[tool.setuptools.packages.find]
+include = ["stealth_requests"]

stealth_requests-0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

stealth_requests-0.1/setup.py

@@ -0,0 +1,27 @@
+from setuptools import setup
+
+
+with open('README.md', 'r', encoding='utf-8') as f:
+    long_description = f.read()
+
+setup(
+    name='stealth-requests',
+    description='Make HTTP requests exactly like a browser.',
+    version='0.1',
+    packages=['stealth_requests'],
+    install_requires=['curl_cffi'],
+    extras_require={
+        'parsers': [
+            'lxml',
+            'html2text',
+            'beautifulsoup4'
+        ]
+    },
+    author = 'Jacob Padilla',
+    author_email = 'jp@jacobpadilla.com',
+    url='https://github.com/jpjacobpadilla/Stealth-Requests',
+    license='MIT',
+    long_description=long_description,
+    long_description_content_type='text/markdown',
+    keywords=''
+)

stealth_requests-0.1/stealth_requests/__init__.py

@@ -0,0 +1,16 @@
+from functools import partial
+from .session import StealthSession, AsyncStealthSession
+from curl_cffi.requests import *
+
+
+def request(method: str, url: str, *args, **kwargs) -> Response:
+    with StealthSession() as s:
+        return s.request(method, url, *args, **kwargs)
+
+head = partial(request, "HEAD")
+get = partial(request, "GET")
+post = partial(request, "POST")
+put = partial(request, "PUT")
+patch = partial(request, "PATCH")
+delete = partial(request, "DELETE")
+options = partial(request, "OPTIONS")

stealth_requests-0.1/stealth_requests/response.py

@@ -0,0 +1,108 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from lxml.html import HtmlElement
+    from bs4 import BeautifulSoup
+
+
+@dataclass
+class Metadata:
+    title: str | None
+    description: str | None
+    thumbnail: str | None
+    author: str | None
+    keywords: tuple[str] | None
+    twitter_handle: str | None
+    robots: tuple[str] | None
+    canonical: str | None
+
+PARSER_IMPORT_SOLUTION = "Install it using 'pip install stealth-requests[parsers]'."
+
+
+class StealthResponse():
+    def __init__(self, resp):
+        self._response = resp
+
+        self._tree = None 
+        self._important_meta_tags = None
+    
+    def __getattr__(self, name):
+        return getattr(self._response, name)
+
+    def _get_tree(self):
+        try:
+            from lxml import html
+        except ImportError:
+            raise ImportError(f'Lxml is not installed. {PARSER_IMPORT_SOLUTION}')
+
+        self._tree = html.fromstring(self.content)
+        return self._tree
+
+    def tree(self) -> HtmlElement:
+        return self._tree or self._get_tree()    
+
+    def soup(self, parser: str = 'html.parser') -> BeautifulSoup:
+        try:
+            from bs4 import BeautifulSoup
+        except ImportError:
+            raise ImportError(f'BeautifulSoup is required for markdown extraction. {PARSER_IMPORT_SOLUTION}')
+
+        return BeautifulSoup(self.content, parser)
+    
+    def markdown(self):
+        try:
+            import html2text
+        except ImportError:
+            raise ImportError(f'Html2text is required for markdown extraction. {PARSER_IMPORT_SOLUTION}')
+
+        text_maker = html2text.HTML2Text()
+        text_maker.ignore_links = True
+        return text_maker.handle(str(self.soup()))
+    
+    def xpath(self, xp: str):
+        return self.tree().xpath(xp)
+
+    def iterlinks(self, *args, **kwargs):
+        return self.tree().iterlinks(*args, **kwargs)
+
+    def itertext(self, *args, **kwargs):
+        return self.tree().itertext(*args, **kwargs)
+
+    def text_content(self, *args, **kwargs):
+        return self.tree().text_content(*args, **kwargs)
+
+    @staticmethod
+    def _format_meta_list(content: str) -> tuple[str]:
+        items = content.split(',')
+        return tuple(item.strip() for item in items)
+
+    def _set_important_meta_tags(self) -> Metadata:
+        tree = self.tree()
+
+        title = tree.xpath('//head/title/text()')
+        description = tree.xpath('//head/meta[@name="description"]/@content')
+        thumbnail = tree.xpath('//head/meta[@property="og:image"]/@content')
+        author = tree.xpath('//head/meta[@name="author"]/@content')
+        keywords = tree.xpath('//head/meta[@name="keywords"]/@content')
+        twitter_handle = tree.xpath('//head/meta[@name="twitter:site"]/@content')
+        robots = tree.xpath('//head/meta[@name="robots"]/@content')
+        canonical = tree.xpath('//head/link[@rel="canonical"]/@content')
+
+        self._important_meta_tags = Metadata(
+            title = title[0] if title else None,
+            description = description[0] if description else None,
+            thumbnail = thumbnail[0] if thumbnail else None,
+            author = author[0] if author else None,
+            keywords = self._format_meta_list(keywords[0]) if keywords else None,
+            twitter_handle = twitter_handle[0] if twitter_handle else None,
+            robots =  self._format_meta_list(robots[0]) if robots else None,
+            canonical = canonical[0] if canonical else None
+        )
+        return self._important_meta_tags
+
+    @property
+    def meta(self):
+        return self._important_meta_tags or self._set_important_meta_tags()

stealth_requests-0.1/stealth_requests/session.py

@@ -0,0 +1,154 @@
+import random
+import json
+from dataclasses import dataclass
+from urllib.parse import urlparse
+from collections import defaultdict
+from functools import partialmethod
+
+from .response import StealthResponse
+
+from curl_cffi.requests.session import Session, AsyncSession
+from curl_cffi.requests.models import Response
+
+
+@dataclass
+class ClientProfile:
+    user_agent: str
+    sec_ch_ua: str
+    sec_ch_ua_mobile: str
+    sec_ch_ua_platform: str
+
+
+class BaseStealthSession:
+    def __init__(
+            self, 
+            client_profile: str = None,
+            impersonate: str = 'chrome124', 
+            **kwargs
+        ):
+        if impersonate.lower() in ('chrome', 'chrome124'):
+            impersonate = 'chrome124'
+        elif impersonate.lower() in ('safari', 'safari_17_0', 'safari17'):
+            impersonate = 'safari17_0'
+
+        self.profile = client_profile or BaseStealthSession.create_profile(impersonate)
+        self.last_request_url = defaultdict(lambda: 'https://www.google.com/')
+        
+        super().__init__(
+            headers=self.initialize_chrome_headers() 
+                if impersonate == 'chrome124' 
+                else self.initialize_safari_headers(),
+            impersonate=impersonate, 
+            **kwargs
+        )
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *_):
+        self.close()
+        return False
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, *_):
+        self.close()
+        return False
+    
+    @staticmethod
+    def create_profile(impersonate: str) -> ClientProfile:
+        import os
+        file_path = os.path.join(os.path.dirname(__file__), 'profiles.json')
+
+        with open(file_path, encoding='utf-8', mode='r') as file:
+            user_agents = json.load(file)
+
+        assert impersonate in user_agents.keys(), f'Please choose one of the supported profiles: {user_agents.keys()}'
+
+        return ClientProfile(
+            user_agent=random.choice(user_agents[impersonate]),
+            sec_ch_ua='"Not A;Brand";v="99", "Chromium";v="124", "Google Chrome";v="124"' if impersonate == 'chrome_124' else None,
+            sec_ch_ua_mobile='?0' if impersonate == 'chrome_124' else None,
+            sec_ch_ua_platform='"macOS"' if impersonate == 'chrome_124' else None
+        )
+        
+    def initialize_chrome_headers(self) -> dict[str, str]:
+        return {
+            "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
+            "Accept-Encoding": "gzip, deflate, br, zstd",
+            "Accept-Language": "en-US,en;q=0.9",
+            "Cache-Control": "no-cache",
+            "Connection": "keep-alive",
+            "Pragma": "no-cache",
+            "Upgrade-Insecure-Requests": "1",
+            "User-Agent": self.profile.user_agent,
+            "Sec-Fetch-Dest": "document",
+            "Sec-Fetch-Mode": "navigate",
+            "Sec-Fetch-Site": "same-origin",
+            "Sec-Fetch-User": "?1",
+            "sec-ch-ua": self.profile.sec_ch_ua,
+            "sec-ch-ua-mobile": self.profile.sec_ch_ua_mobile,
+            "sec-ch-ua-platform": self.profile.sec_ch_ua_platform,
+        } 
+
+    def initialize_safari_headers(self) -> dict[str, str]:
+        return {
+            "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+            "Accept-Encoding": "gzip, deflate, br",
+            "Accept-Language": "en-US,en;q=0.9",
+            "Cache-Control": "no-cache",
+            "Connection": "keep-alive",
+            "Pragma": "no-cache",
+            "Sec-Fetch-Dest": "document",
+            "Sec-Fetch-Mode": "navigate",
+            "Sec-Fetch-Site": "same-origin",
+            "User-Agent": self.profile.user_agent
+        } 
+
+    def get_dynamic_headers(self, url: str) -> dict[str, str]:
+        parsed_url = urlparse(url)
+        host = parsed_url.netloc
+
+        headers = {
+            "Host": host,
+            "Referer": self.last_request_url[host]
+        }
+
+        self.last_request_url[host] = url
+        return headers
+
+
+class StealthSession(BaseStealthSession, Session):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def request(self, method: str, url: str, *args, **kwargs) -> Response:
+        headers = self.get_dynamic_headers(url) | kwargs.pop('headers', {})
+        resp = Session.request(self, method, url, *args, headers=headers, **kwargs)
+        return StealthResponse(resp)
+    
+    head = partialmethod(request, "HEAD")
+    get = partialmethod(request, "GET")
+    post = partialmethod(request, "POST")
+    put = partialmethod(request, "PUT")
+    patch = partialmethod(request, "PATCH")
+    delete = partialmethod(request, "DELETE")
+    options = partialmethod(request, "OPTIONS")
+
+class AsyncStealthSession(BaseStealthSession, AsyncSession):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    async def request(self, method: str, url: str, *args, **kwargs) -> Response:
+        headers = self.get_dynamic_headers(url) | kwargs.pop('headers', {})
+        resp = await AsyncSession.request(self, method, url, *args, headers=headers, **kwargs)
+        return StealthResponse(resp)
+    
+    head = partialmethod(request, "HEAD")
+    get = partialmethod(request, "GET")
+    post = partialmethod(request, "POST")
+    put = partialmethod(request, "PUT")
+    patch = partialmethod(request, "PATCH")
+    delete = partialmethod(request, "DELETE")
+    options = partialmethod(request, "OPTIONS")

stealth_requests-0.1/stealth_requests.egg-info/PKG-INFO

@@ -0,0 +1,110 @@
+Metadata-Version: 2.1
+Name: stealth-requests
+Version: 0.1
+Summary: Make HTTP requests exactly like a browser.
+Home-page: https://github.com/jpjacobpadilla/Stealth-Requests
+Author: Jacob Padilla
+Author-email: Jacob Padilla <jp@jacobpadilla.com>
+License: MIT
+Project-URL: Homepage, https://github.com/jpjacobpadilla/Stealth-Requests
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Requires-Dist: curl_cffi
+Provides-Extra: parsers
+Requires-Dist: lxml; extra == "parsers"
+Requires-Dist: html2text; extra == "parsers"
+Requires-Dist: beautifulsoup4; extra == "parsers"
+
+<p align="center">
+    <img src="https://github.com/jpjacobpadilla/Stealth-Requests/blob/7f83b67a0d62a932663d8216bad7d25971c90aaf/logo.png">
+</p>
+
+<h1 align="center">Stay Undetected While Scraping the Web.</h1>
+
+### The All-In-One Solution to Web Scraping:
+- Mimic the headers sent by a browser when going to a website (GET requests)
+- Automatically handle and update the Referer header & client hint headers
+- Mask the TLS fingerprint of the request using the [curl_cffi](https://curl-cffi.readthedocs.io/en/latest/) package
+- Automatically parse the metadata from HTML responses such as page title, description, thumbnail, author, etc...
+- Easily get an [lxml](https://lxml.de/apidoc/lxml.html) tree or [BeautifulSoup](https://beautiful-soup-4.readthedocs.io/en/latest/) object from the HTTP response. 
+
+### Sending Requests
+
+This package mimics the API of the `requests` package, and thus can be used in basically the same way.
+
+You can send one-off requests like such:
+
+```python
+import stealth_requests and requests
+
+resp = requests.get(link)
+```
+
+Or you can use a `StealthSession` object which will keep track of certain headers for you between requests such as the `Referer` header.
+
+```python
+from stealth_requests import StealthSession
+
+with StealthSession() as s:
+    resp = s.get(link)
+```
+
+When sending a one-off request, or creating a session, you can specify the type of browser that you want the request to mimic - either `safari` or `chrome` (which is the default).
+
+### Sending Requests With Asyncio
+
+This package supports Asyncio in the same way as the `requests` package.
+
+```python
+from stealth_requests import AsyncStealthSession
+
+async with AsyncStealthSession(impersonate='chrome') as s:
+    resp = await s.get(link)
+```
+
+or, for a one off request you can do something like this:
+
+```python
+from curl_cffi import requests
+
+resp = await requests.post(link, data=...)
+```
+
+### Getting Response Metadata
+
+The response returned from this package is a `StealthResponse` which has all of the same methods and attributes as a standard `requests` response, with a few added features. One if automatic parsing of header metadata. The metadata can be accessed from the `meta` attribute, which gives you access to the following data (if it's avaible on the scraped website):
+
+- title: str
+- description: str
+- thumbnail: str
+- author: str
+- keywords: tuple[str]
+- twitter_handle: str
+- robots: tuple[str]
+- canonical: str
+
+Heres an example of how to get the title of a page:
+
+```python
+import stealth_requests and requests
+
+resp = requests.get(link)
+print(resp.meta.title)
+```
+
+### Parsing Response
+
+To make parsing HTML easier, I've also added two popular parsing packages to this project - `Lxml` and `BeautifulSoup4`. To install these add-ons you need to install the parsers extra: `pip install stealth_requests[parsers]`.
+
+To easily get an Lxml tree, you can use `resp.tree()` and to get a BeautifulSoup object, use the `resp.soup()` method.
+
+For simple parsing, I've also added the following convience methods right to the `StealthResponse` object:
+
+- `iterlinks` Iterate through all links in an HTML response
+- `itertext`: Iterate through all text in an HTML response
+- `text_content`: Get all text content in an HTML response
+- `xpath` Go right to using XPATH expressions instead of getting your own Lxml tree.
+
+### Getting HTML response in MarkDown format
+
+Sometimes it's easier to get a webpage in MarkDown format instead of HTML. To do this, use the `resp.markdown()` method, after sending a GET request to a website.

stealth_requests-0.1/stealth_requests.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+README.md
+pyproject.toml
+setup.py
+stealth_requests/__init__.py
+stealth_requests/response.py
+stealth_requests/session.py
+stealth_requests.egg-info/PKG-INFO
+stealth_requests.egg-info/SOURCES.txt
+stealth_requests.egg-info/dependency_links.txt
+stealth_requests.egg-info/requires.txt
+stealth_requests.egg-info/top_level.txt

stealth_requests-0.1/stealth_requests.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

stealth_requests-0.1/stealth_requests.egg-info/requires.txt

@@ -0,0 +1,6 @@
+curl_cffi
+
+[parsers]
+lxml
+html2text
+beautifulsoup4

stealth_requests-0.1/stealth_requests.egg-info/top_level.txt

@@ -0,0 +1 @@
+stealth_requests