webscout 1.0.0__py3-none-any.whl

webscout-1.0.0.dist-info/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 HelpingAI
+
+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.

webscout-1.0.0.dist-info/METADATA

@@ -0,0 +1,627 @@
+Metadata-Version: 2.1
+Name: webscout
+Version: 1.0.0
+Summary: Search for words, documents, images, news, maps, and text translation using the DuckDuckGo.com search engine.
+Home-page: https://github.com/HelpingAI/webscout
+Author: deedy5
+Author-email: koulabhay25@gmail.com
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Internet :: WWW/HTTP :: Indexing/Search
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: docstring-inheritance >=2.1.2
+Requires-Dist: click >=8.1.7
+Requires-Dist: curl-cffi >=0.6.0b7
+Requires-Dist: lxml >=4.9.3
+Requires-Dist: nest-asyncio >=1.6.0
+Provides-Extra: dev
+Requires-Dist: ruff >=0.1.6 ; extra == 'dev'
+Requires-Dist: pytest >=7.4.2 ; extra == 'dev'
+
+Search for words, documents, images, videos, news, maps and text translation using the DuckDuckGo.com search engine. Downloading files and images to a local hard drive.
+
+**⚠️ Warning: use AsyncDDGS in asynchronous code**
+
+## Table of Contents
+- [Table of Contents](#table-of-contents)
+- [Install](#install)
+- [CLI version](#cli-version)
+- [Duckduckgo search operators](#duckduckgo-search-operators)
+- [Regions](#regions)
+- [DDGS and AsyncDDGS classes](#ddgs-and-asyncddgs-classes)
+- [Proxies](#proxies)
+- [Exceptions](#exceptions)
+- [1. text() - text search by duckduckgo.com](#1-text---text-search-by-duckduckgocom)
+- [2. answers() - instant answers by duckduckgo.com](#2-answers---instant-answers-by-duckduckgocom)
+- [3. images() - image search by duckduckgo.com](#3-images---image-search-by-duckduckgocom)
+- [4. videos() - video search by duckduckgo.com](#4-videos---video-search-by-duckduckgocom)
+- [5. news() - news search by duckduckgo.com](#5-news---news-search-by-duckduckgocom)
+- [6. maps() - map search by duckduckgo.com](#6-maps---map-search-by-duckduckgocom)
+- [7. translate() - translation by duckduckgo.com](#7-translate---translation-by-duckduckgocom)
+- [8. suggestions() - suggestions by duckduckgo.com](#8-suggestions---suggestions-by-duckduckgocom)
+
+## Install
+```python
+pip install -U webscout
+```
+
+## CLI version
+
+```python3
+ddgs --help
+```
+or
+```python3
+python -m webscout --help
+```
+
+CLI examples:
+```python3
+# text search
+ddgs text -k "ayrton senna"
+# text search via proxy (example: Tor Browser)
+ddgs text -k "china is a global threat" -p socks5://localhost:9150
+# find and download pdf files
+ddgs text -k "russia filetype:pdf" -m 50 -d
+# find in es-es region and download pdf files via proxy (example: Tor browser)
+ddgs text -k "embajada a tamorlán filetype:pdf" -r es-es -m 50 -d -p socks5://localhost:9150
+# find and download xls files from a specific site
+ddgs text -k "sanctions filetype:xls site:gov.ua" -m 50 -d
+# find and download any doc(x) files from a specific site
+ddgs text -k "filetype:doc site:mos.ru" -m 50 -d
+# find and download images
+ddgs images -k "yuri kuklachev cat theatre" -m 500 -s off -d
+# find in br-br region and download images via proxy (example: Tor browser) in 10 threads
+ddgs images -k "rio carnival" -r br-br -s off -m 500 -d -th 10 -p socks5://localhost:9150
+# get latest news
+ddgs news -k "ukraine war" -s off -t d -m 10
+# get last day's news and save it to a csv file
+ddgs news -k "hubble telescope" -t d -m 50 -o csv
+# get answers and save to a json file
+ddgs answers -k holocaust -o json
+```
+[Go To TOP](#TOP)
+
+## Duckduckgo search operators
+
+| Keywords example |	Result|
+| ---     | ---   |
+| cats dogs |	Results about cats or dogs |
+| "cats and dogs" |	Results for exact term "cats and dogs". If no results are found, related results are shown. |
+| cats -dogs |	Fewer dogs in results |
+| cats +dogs |	More dogs in results |
+| cats filetype:pdf |	PDFs about cats. Supported file types: pdf, doc(x), xls(x), ppt(x), html |
+| dogs site:example.com  |	Pages about dogs from example.com |
+| cats -site:example.com |	Pages about cats, excluding example.com |
+| intitle:dogs |	Page title includes the word "dogs" |
+| inurl:cats  |	Page url includes the word "cats" |
+
+[Go To TOP](#TOP)
+
+## Regions
+<details>
+  <summary>expand</summary>
+
+    xa-ar for Arabia
+    xa-en for Arabia (en)
+    ar-es for Argentina
+    au-en for Australia
+    at-de for Austria
+    be-fr for Belgium (fr)
+    be-nl for Belgium (nl)
+    br-pt for Brazil
+    bg-bg for Bulgaria
+    ca-en for Canada
+    ca-fr for Canada (fr)
+    ct-ca for Catalan
+    cl-es for Chile
+    cn-zh for China
+    co-es for Colombia
+    hr-hr for Croatia
+    cz-cs for Czech Republic
+    dk-da for Denmark
+    ee-et for Estonia
+    fi-fi for Finland
+    fr-fr for France
+    de-de for Germany
+    gr-el for Greece
+    hk-tzh for Hong Kong
+    hu-hu for Hungary
+    in-en for India
+    id-id for Indonesia
+    id-en for Indonesia (en)
+    ie-en for Ireland
+    il-he for Israel
+    it-it for Italy
+    jp-jp for Japan
+    kr-kr for Korea
+    lv-lv for Latvia
+    lt-lt for Lithuania
+    xl-es for Latin America
+    my-ms for Malaysia
+    my-en for Malaysia (en)
+    mx-es for Mexico
+    nl-nl for Netherlands
+    nz-en for New Zealand
+    no-no for Norway
+    pe-es for Peru
+    ph-en for Philippines
+    ph-tl for Philippines (tl)
+    pl-pl for Poland
+    pt-pt for Portugal
+    ro-ro for Romania
+    ru-ru for Russia
+    sg-en for Singapore
+    sk-sk for Slovak Republic
+    sl-sl for Slovenia
+    za-en for South Africa
+    es-es for Spain
+    se-sv for Sweden
+    ch-de for Switzerland (de)
+    ch-fr for Switzerland (fr)
+    ch-it for Switzerland (it)
+    tw-tzh for Taiwan
+    th-th for Thailand
+    tr-tr for Turkey
+    ua-uk for Ukraine
+    uk-en for United Kingdom
+    us-en for United States
+    ue-es for United States (es)
+    ve-es for Venezuela
+    vn-vi for Vietnam
+    wt-wt for No region
+___
+</details>
+
+[Go To TOP](#TOP)
+
+
+## DDGS and AsyncDDGS classes
+
+The DDGS and AsyncDDGS classes are used to retrieve search results from DuckDuckGo.com.
+To use the AsyncDDGS class, you can perform asynchronous operations using Python's asyncio library.
+To initialize an instance of the DDGS or AsyncDDGS classes, you can provide the following optional arguments:
+```python3
+class DDGS:
+    """webscout class to get search results from duckduckgo.com
+
+    Args:
+        headers (dict, optional): Dictionary of headers for the HTTP client. Defaults to None.
+        proxies (Union[dict, str], optional): Proxies for the HTTP client (can be dict or str). Defaults to None.
+        timeout (int, optional): Timeout value for the HTTP client. Defaults to 10.
+    """
+```
+
+Here is an example of initializing the DDGS class:
+```python3
+from webscout import DDGS
+
+with DDGS() as ddgs:
+    results = [r for r in ddgs.text("python programming", max_results=5)]
+    print(results)
+```
+Here is an example of initializing the AsyncDDGS class:
+```python3
+import asyncio
+import logging
+import sys
+from itertools import chain
+from random import shuffle
+
+import requests
+from webscout import AsyncDDGS
+
+# bypass curl-cffi NotImplementedError in windows https://curl-cffi.readthedocs.io/en/latest/faq/
+if sys.platform.lower().startswith("win"):
+    asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
+
+def get_words():
+    word_site = "https://www.mit.edu/~ecprice/wordlist.10000"
+    resp = requests.get(word_site)
+    words = resp.text.splitlines()
+    return words
+
+async def aget_results(word):
+    async with AsyncDDGS(proxies=proxies) as ddgs:
+        results = [r async for r in ddgs.text(word, max_results=None)]
+        return results
+
+async def main():
+    words = get_words()
+    shuffle(words)
+    tasks = []
+    for word in words[:10]:
+        tasks.append(aget_results(word))
+    results = await asyncio.gather(*tasks)
+    print(f"Done")
+    for r in chain.from_iterable(results):
+        print(r)
+    
+
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.DEBUG)
+    asyncio.run(main())
+```
+It is important to note that the DDGS and AsyncDDGS classes should always be used as a context manager (with statement).
+This ensures proper resource management and cleanup, as the context manager will automatically handle opening and closing the HTTP client connection.
+
+[Go To TOP](#TOP)
+
+## Proxies
+Proxy can be specified as a dictionary or just a string
+```python
+proxies = {"http": "socks5://localhost:9150", "https": "socks5://localhost:9150"}
+proxies = "socks5://localhost:9150"
+```
+
+*1. The easiest way. Launch the Tor Browser*
+```python3
+from webscout import DDGS
+
+with DDGS(proxies="socks5://localhost:9150", timeout=20) as ddgs:
+    for r in ddgs.text("something you need", max_results=50):
+        print(r)
+```
+*2. Use any proxy server* (*example with [iproyal residential proxies](https://iproyal.com?r=residential_proxies)*)
+```python3
+from webscout import DDGS
+
+with DDGS(proxies="socks5://user:password@geo.iproyal.com:32325", timeout=20) as ddgs:
+    for r in ddgs.text("something you need", max_results=50):
+        print(r)
+```
+
+[Go To TOP](#TOP)
+
+## Exceptions
+
+Exceptions:
+- `DuckDuckGoSearchException`: Raised when there is a generic exception during the API request.
+
+[Go To TOP](#TOP)
+
+## 1. text() - text search by duckduckgo.com
+
+```python
+def text(
+    keywords: str,
+    region: str = "wt-wt",
+    safesearch: str = "moderate",
+    timelimit: Optional[str] = None,
+    backend: str = "api",
+    max_results: Optional[int] = None,
+) -> Iterator[Dict[str, Optional[str]]]:
+    """webscout text search generator. Query params: https://duckduckgo.com/params
+
+    Args:
+        keywords: keywords for query.
+        region: wt-wt, us-en, uk-en, ru-ru, etc. Defaults to "wt-wt".
+        safesearch: on, moderate, off. Defaults to "moderate".
+        timelimit: d, w, m, y. Defaults to None.
+        backend: api, html, lite. Defaults to api.
+            api - collect data from https://duckduckgo.com,
+            html - collect data from https://html.duckduckgo.com,
+            lite - collect data from https://lite.duckduckgo.com.
+        max_results: max number of results. If None, returns results only from the first response. Defaults to None.
+    Yields:
+        dict with search results.
+
+    """
+```
+***Example***
+```python
+from webscout import DDGS
+
+with DDGS() as ddgs:
+    for r in ddgs.text('live free or die', region='wt-wt', safesearch='off', timelimit='y', max_results=10):
+        print(r)
+
+# Searching for pdf files
+with DDGS() as ddgs:
+    for r in ddgs.text('russia filetype:pdf', region='wt-wt', safesearch='off', timelimit='y', max_results=10):
+        print(r)
+```
+
+[Go To TOP](#TOP)
+
+## 2. answers() - instant answers by duckduckgo.com
+
+```python
+def answers(keywords: str) -> Iterator[Dict[str, Optional[str]]]::
+    """webscout instant answers. Query params: https://duckduckgo.com/params
+
+    Args:
+        keywords: keywords for query.
+
+    Yields:
+        dict with instant answers results.
+
+        """
+```
+***Example***
+```python
+from webscout import DDGS
+
+with DDGS() as ddgs:
+    for r in ddgs.answers("sun"):
+        print(r)
+```
+
+[Go To TOP](#TOP)
+
+## 3. images() - image search by duckduckgo.com
+
+```python
+def images(
+    keywords: str,
+    region: str = "wt-wt",
+    safesearch: str = "moderate",
+    timelimit: Optional[str] = None,
+    size: Optional[str] = None,
+    color: Optional[str] = None,
+    type_image: Optional[str] = None,
+    layout: Optional[str] = None,
+    license_image: Optional[str] = None,
+    max_results: Optional[int] = None,
+) -> Iterator[Dict[str, Optional[str]]]:
+    """webscout images search. Query params: https://duckduckgo.com/params
+
+    Args:
+        keywords: keywords for query.
+        region: wt-wt, us-en, uk-en, ru-ru, etc. Defaults to "wt-wt".
+        safesearch: on, moderate, off. Defaults to "moderate".
+        timelimit: Day, Week, Month, Year. Defaults to None.
+        size: Small, Medium, Large, Wallpaper. Defaults to None.
+        color: color, Monochrome, Red, Orange, Yellow, Green, Blue,
+            Purple, Pink, Brown, Black, Gray, Teal, White. Defaults to None.
+        type_image: photo, clipart, gif, transparent, line.
+            Defaults to None.
+        layout: Square, Tall, Wide. Defaults to None.
+        license_image: any (All Creative Commons), Public (PublicDomain),
+            Share (Free to Share and Use), ShareCommercially (Free to Share and Use Commercially),
+            Modify (Free to Modify, Share, and Use), ModifyCommercially (Free to Modify, Share, and
+            Use Commercially). Defaults to None.
+        max_results: max number of results. If None, returns results only from the first response. Defaults to None.
+
+    Yields:
+        dict with image search results.
+
+    """
+```
+***Example***
+```python
+from webscout import DDGS
+
+with DDGS() as ddgs:
+    keywords = 'butterfly'
+    ddgs_images_gen = ddgs.images(
+      keywords,
+      region="wt-wt",
+      safesearch="off",
+      size=None,
+      color="Monochrome",
+      type_image=None,
+      layout=None,
+      license_image=None,
+      max_results=100,
+    )
+    for r in ddgs_images_gen:
+        print(r)
+```
+
+[Go To TOP](#TOP)
+
+## 4. videos() - video search by duckduckgo.com
+
+```python
+def videos(
+    keywords: str,
+    region: str = "wt-wt",
+    safesearch: str = "moderate",
+    timelimit: Optional[str] = None,
+    resolution: Optional[str] = None,
+    duration: Optional[str] = None,
+    license_videos: Optional[str] = None,
+    max_results: Optional[int] = None,
+) -> Iterator[Dict[str, Optional[str]]]:
+    """webscout videos search. Query params: https://duckduckgo.com/params
+
+    Args:
+        keywords: keywords for query.
+        region: wt-wt, us-en, uk-en, ru-ru, etc. Defaults to "wt-wt".
+        safesearch: on, moderate, off. Defaults to "moderate".
+        timelimit: d, w, m. Defaults to None.
+        resolution: high, standart. Defaults to None.
+        duration: short, medium, long. Defaults to None.
+        license_videos: creativeCommon, youtube. Defaults to None.
+        max_results: max number of results. If None, returns results only from the first response. Defaults to None.
+
+    Yields:
+        dict with videos search results
+
+    """
+```
+***Example***
+```python
+from webscout import DDGS
+
+with DDGS() as ddgs:
+    keywords = 'tesla'
+    ddgs_videos_gen = ddgs.videos(
+      keywords,
+      region="wt-wt",
+      safesearch="off",
+      timelimit="w",
+      resolution="high",
+      duration="medium",
+      max_results=100,
+    )
+    for r in ddgs_videos_gen:
+        print(r)
+```
+
+[Go To TOP](#TOP)
+
+## 5. news() - news search by duckduckgo.com
+
+```python
+def news(
+    keywords: str,
+    region: str = "wt-wt",
+    safesearch: str = "moderate",
+    timelimit: Optional[str] = None,
+    max_results: Optional[int] = None,
+) -> Iterator[Dict[str, Optional[str]]]:
+    """webscout news search. Query params: https://duckduckgo.com/params
+
+    Args:
+        keywords: keywords for query.
+        region: wt-wt, us-en, uk-en, ru-ru, etc. Defaults to "wt-wt".
+        safesearch: on, moderate, off. Defaults to "moderate".
+        timelimit: d, w, m. Defaults to None.
+        max_results: max number of results. If None, returns results only from the first response. Defaults to None.
+
+    Yields:
+        dict with news search results.
+
+    """
+```
+***Example***
+```python
+from webscout import DDGS
+
+with DDGS() as ddgs:
+    keywords = 'holiday'
+    ddgs_news_gen = ddgs.news(
+      keywords,
+      region="wt-wt",
+      safesearch="off",
+      timelimit="m",
+      max_results=20
+    )
+    for r in ddgs_news_gen:
+        print(r)
+```
+
+[Go To TOP](#TOP)
+
+## 6. maps() - map search by duckduckgo.com
+
+```python
+def maps(
+        keywords,
+        place: Optional[str] = None,
+        street: Optional[str] = None,
+        city: Optional[str] = None,
+        county: Optional[str] = None,
+        state: Optional[str] = None,
+        country: Optional[str] = None,
+        postalcode: Optional[str] = None,
+        latitude: Optional[str] = None,
+        longitude: Optional[str] = None,
+        radius: int = 0,
+        max_results: Optional[int] = None,
+    ) -> Iterator[Dict[str, Optional[str]]]:
+        """webscout maps search. Query params: https://duckduckgo.com/params
+
+        Args:
+            keywords: keywords for query
+            place: if set, the other parameters are not used. Defaults to None.
+            street: house number/street. Defaults to None.
+            city: city of search. Defaults to None.
+            county: county of search. Defaults to None.
+            state: state of search. Defaults to None.
+            country: country of search. Defaults to None.
+            postalcode: postalcode of search. Defaults to None.
+            latitude: geographic coordinate (north–south position). Defaults to None.
+            longitude: geographic coordinate (east–west position); if latitude and
+                longitude are set, the other parameters are not used. Defaults to None.
+            radius: expand the search square by the distance in kilometers. Defaults to 0.
+            max_results: max number of results. If None, returns results only from the first response. Defaults to None.
+
+        Yields:
+            dict with maps search results
+
+        """
+```
+***Example***
+```python
+from webscout import DDGS
+
+with DDGS() as ddgs:
+    for r in ddgs.maps("school", place="anantnag", max_results=50):
+        print(r)
+```
+
+[Go To TOP](#TOP)
+
+## 7. translate() - translation by duckduckgo.com
+
+```python
+def translate(
+    self,
+    keywords: str,
+    from_: Optional[str] = None,
+    to: str = "en",
+) -> Optional[Dict[str, Optional[str]]]:
+    """webscout translate
+
+    Args:
+        keywords: string or a list of strings to translate
+        from_: translate from (defaults automatically). Defaults to None.
+        to: what language to translate. Defaults to "en".
+
+    Returns:
+        dict with translated keywords.
+    """
+```
+***Example***
+```python
+from webscout import DDGS
+
+with DDGS() as ddgs:
+    keywords = 'school'
+    r = ddgs.translate(keywords, to="de")
+    print(r)
+```
+
+[Go To TOP](#TOP)
+
+## 8. suggestions() - suggestions by duckduckgo.com
+
+```python
+def suggestions(
+    keywords,
+    region: str = "wt-wt",
+) -> Iterator[Dict[str, Optional[str]]]:
+    """webscout suggestions. Query params: https://duckduckgo.com/params
+
+    Args:
+        keywords: keywords for query.
+        region: wt-wt, us-en, uk-en, ru-ru, etc. Defaults to "wt-wt".
+
+    Yields:
+        dict with suggestions results.
+    """
+```
+***Example***
+```python3
+from webscout import DDGS
+
+with DDGS() as ddgs:
+    for r in ddgs.suggestions("fly"):
+        print(r)
+```
+
+[Go To TOP](#TOP)

webscout-1.0.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+webscout/__init__.py,sha256=zHNzosf3eGFKZElLcJY4g97QLNHF6a8frP5leUd4BPY,547
+webscout/__main__.py,sha256=JdZY7xWYnoQGBZkv2N4VpMDdcPHA16i-Hod7Z1ULev8,135
+webscout/cli.py,sha256=9R8OHJdSVS_koqGLJm70GFwWYQzqgTxuI_zt77JG_p8,17757
+webscout/exceptions.py,sha256=GSidNXKbT3wjrny3hSb9s9t3OeLxU0Rv3IHyn-JSi6M,91
+webscout/models.py,sha256=5iQIdtedT18YuTZ3npoG7kLMwcrKwhQ7928dl_7qZW0,692
+webscout/utils.py,sha256=sIZ466_XgoLcd6IC-GgwzU1cSo2WwfEhKe1FKMMYImw,1658
+webscout/version.py,sha256=pqFP1kZLzWI6kvJ-NjY-bhEQKT2UvH1B18Z6p3x9wXA,64
+webscout/webscout_search.py,sha256=4GkRW7ruRHJAxsRzYHkwSi63ege4Swms--zrVUQNOJI,2640
+webscout/webscout_search_async.py,sha256=LbrSMBCyplBspJagbrSQ6yjtScXrRIHNO5HZTOtasoI,35186
+webscout-1.0.0.dist-info/LICENSE.md,sha256=ple694nFBJxLq83VmOoXLaKHCuN6Zmx4BbcMMLjAWmc,1087
+webscout-1.0.0.dist-info/METADATA,sha256=JlIIZGvMCaPLa9hViDPxMLh6JipkzS5n5Y_tyK2gpa8,19673
+webscout-1.0.0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+webscout-1.0.0.dist-info/entry_points.txt,sha256=0RXrvIkLYLKfJnTn3_5Iv139Wc8qh_AUVhfIzqmZns8,42
+webscout-1.0.0.dist-info/top_level.txt,sha256=nYIw7OKBQDr_Z33IzZUKidRD3zQEo8jOJYkMVMeN334,9
+webscout-1.0.0.dist-info/RECORD,,

webscout-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.42.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

webscout-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ddgs = webscout.cli:cli

webscout-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+webscout