fraudcrawler 0.3.3__py3-none-any.whl

fraudcrawler/scraping/serp.py

@@ -0,0 +1,251 @@
+import asyncio
+import logging
+from pydantic import BaseModel
+from typing import List
+from urllib.parse import urlparse
+
+from fraudcrawler.settings import MAX_RETRIES, RETRY_DELAY
+from fraudcrawler.base.base import Host, Language, Location, AsyncClient
+import re
+
+logger = logging.getLogger(__name__)
+
+
+class SerpResult(BaseModel):
+    """Model for a single search result from SerpApi."""
+
+    url: str
+    domain: str
+    marketplace_name: str
+    filtered: bool = False
+    filtered_at_stage: str | None = None
+
+
+class SerpApi(AsyncClient):
+    """A client to interact with the SerpApi for performing searches."""
+
+    _endpoint = "https://serpapi.com/search"
+    _engine = "google"
+    _default_marketplace_name = "Google"
+    _hostname_pattern = r"^(?:https?:\/\/)?([^\/:?#]+)"
+
+    def __init__(
+        self,
+        api_key: str,
+        max_retries: int = MAX_RETRIES,
+        retry_delay: int = RETRY_DELAY,
+    ):
+        """Initializes the SerpApiClient with the given API key.
+
+        Args:
+            api_key: The API key for SerpApi.
+            max_retries: Maximum number of retries for API calls.
+            retry_delay: Delay between retries in seconds.
+        """
+        super().__init__()
+        self._api_key = api_key
+        self._max_retries = max_retries
+        self._retry_delay = retry_delay
+
+    def _get_domain(self, url: str) -> str:
+        """Extracts the second-level domain together with the top-level domain (e.g. `google.com`).
+
+        Args:
+            url: The URL to be processed.
+
+        """
+        # Add scheme (if needed -> urlparse requires it)
+        if not url.startswith(("http://", "https://")):
+            url = "http://" + url
+
+        # Get the hostname
+        hostname = urlparse(url).hostname
+        if hostname is None and (match := re.search(self._hostname_pattern, url)):
+            hostname = match.group(1)
+        if hostname is None:
+            logger.warning(
+                f'Failed to extract domain from url="{url}"; full url is returned'
+            )
+            return url
+
+        # Remove www. prefix
+        if hostname and hostname.startswith("www."):
+            hostname = hostname[4:]
+        return hostname
+
+    async def _search(
+        self,
+        search_string: str,
+        language: Language,
+        location: Location,
+        num_results: int,
+    ) -> List[str]:
+        """Performs a search using SerpApi and returns the URLs of the results.
+
+        Args:
+            search_string: The search string (with potentially added site: parameters).
+            language: The language to use for the query ('hl' parameter).
+            location: The location to use for the query ('gl' parameter).
+            num_results: Max number of results to return.
+
+        The SerpAPI parameters are:
+            engine: The search engine to use ('google' NOT 'google_shopping').
+            q: The search string (with potentially added site: parameters).
+            google_domain: The Google domain to use for the search (e.g. google.[com]).
+            location_[requested|used]: The location to use for the search.
+            tbs: The time-based search parameters (e.g. 'ctr:CH&cr:countryCH').
+            gl: The country code to use for the search.
+            hl: The language code to use for the search.
+            num: The number of results to return.
+            api_key: The API key to use for the search.
+        """
+        # Setup the parameters
+        params = {
+            "engine": self._engine,
+            "q": search_string,
+            "google_domain": f"google.{location.code}",
+            "location_requested": location.name,
+            "location_used": location.name,
+            "tbs": f"ctr:{location.code.upper()}&cr:country{location.code.upper()}",
+            "gl": location.code,
+            "hl": language.code,
+            "num": num_results,
+            "api_key": self._api_key,
+        }
+
+        # Perform the request
+        attempts = 0
+        err = None
+        while attempts < self._max_retries:
+            try:
+                logger.debug(
+                    f'Performing SerpAPI search with q="{search_string}" (Attempt {attempts + 1}).'
+                )
+                response = await self.get(url=self._endpoint, params=params)
+                break
+            except Exception as e:
+                logger.error(f"SerpAPI search failed with error: {e}.")
+                err = e
+            attempts += 1
+            if attempts < self._max_retries:
+                await asyncio.sleep(self._retry_delay)
+        if err is not None:
+            raise err
+
+        # Get the organic_results
+        results = response.get("organic_results")
+        if results is None:
+            logger.warning(
+                f'No organic_results key in SerpAPI results for search_string="{search_string}".'
+            )
+            return []
+
+        # Extract urls
+        urls = [res.get("link") for res in results]
+        logger.debug(
+            f'Found {len(urls)} URLs from SerpApi search for q="{search_string}".'
+        )
+        return urls
+
+    @staticmethod
+    def _keep_url(url: str, country_code: str) -> bool:
+        """Determines whether to keep the url based on the country_code.
+
+        Args:
+            url: The URL to investigate.
+            country_code: The country code used to filter the products.
+        """
+        return f".{country_code}" in url.lower() or ".com" in url.lower()
+
+    def _create_serp_result(
+        self,
+        url: str,
+        location: Location,
+        marketplaces: List[Host] | None,
+    ) -> SerpResult:
+        """From a given url it creates the class:`SerpResult` instance.
+
+        If marketplaces is None or the domain can not be extracted, the default marketplace name is used.
+
+        Args:
+            url: The URL to be processed.
+            location:  The location to use for the query.
+            marketplaces: The list of marketplaces to compare the URL against.
+        """
+        # Filter for county code
+        filtered = not self._keep_url(url=url, country_code=location.code)
+        filtered_at_stage = "country code filtering" if filtered else None
+
+        # Get marketplace name
+        domain = self._get_domain(url=url)
+        marketplace_name = self._default_marketplace_name
+        if domain and marketplaces:
+            try:
+                marketplace_name = next(
+                    mp.name
+                    for mp in marketplaces
+                    if domain.lower() in [d.lower() for d in mp.domains]
+                )
+            except StopIteration:
+                logger.warning(f'Failed to find marketplace for domain="{domain}".')
+        return SerpResult(
+            url=url,
+            domain=domain,
+            marketplace_name=marketplace_name,
+            filtered=filtered,
+            filtered_at_stage=filtered_at_stage,
+        )
+
+    async def apply(
+        self,
+        search_term: str,
+        language: Language,
+        location: Location,
+        num_results: int,
+        marketplaces: List[Host] | None = None,
+        excluded_urls: List[Host] | None = None,
+    ) -> List[SerpResult]:
+        """Performs a search using SerpApi, filters based on country code and returns the URLs.
+
+        Args:
+            search_term: The search term to use for the query.
+            language: The language to use for the query.
+            location: The location to use for the query.
+            num_results: Max number of results to return (default: 10).
+            marketplaces: The marketplaces to include in the search.
+            excluded_urls: The URLs to exclude from the search.
+        """
+        # Setup the parameters
+        logger.info(f'Performing SerpAPI search for search_term="{search_term}".')
+
+        # Setup the search string
+        search_string = search_term
+        if marketplaces:
+            sites = [dom for host in marketplaces for dom in host.domains]
+            search_string += " site:" + " OR site:".join(s for s in sites)
+
+        # Perform the search
+        urls = await self._search(
+            search_string=search_string,
+            language=language,
+            location=location,
+            num_results=num_results,
+        )
+
+        # Form the SerpResult objects
+        results = [
+            self._create_serp_result(
+                url=url, location=location, marketplaces=marketplaces
+            )
+            for url in urls
+        ]
+
+        # Filter out the excluded URLs
+        if excluded_urls:
+            excluded = [dom for excl in excluded_urls for dom in excl.domains]
+            results = [res for res in results if res.domain not in excluded]
+
+        logger.info(
+            f'Produced {len(results)} results from SerpApi search with q="{search_string}".'
+        )
+        return results

fraudcrawler/scraping/zyte.py

@@ -0,0 +1,194 @@
+import asyncio
+import logging
+from typing import List
+
+import aiohttp
+
+from fraudcrawler.settings import (
+    MAX_RETRIES,
+    RETRY_DELAY,
+    ZYTE_DEFALUT_PROBABILITY_THRESHOLD,
+)
+from fraudcrawler.base.base import AsyncClient
+
+logger = logging.getLogger(__name__)
+
+
+class ZyteApi(AsyncClient):
+    """A client to interact with the Zyte API for fetching product details."""
+
+    _endpoint = "https://api.zyte.com/v1/extract"
+    _config = {
+        "javascript": False,
+        "browserHtml": False,
+        "screenshot": False,
+        "productOptions": {"extractFrom": "httpResponseBody"},
+        "httpResponseBody": True,
+        "geolocation": "CH",
+        "viewport": {"width": 1280, "height": 1080},
+        "product": True,
+        # "actions": [],
+    }
+
+    def __init__(
+        self,
+        api_key: str,
+        max_retries: int = MAX_RETRIES,
+        retry_delay: int = RETRY_DELAY,
+    ):
+        """Initializes the ZyteApiClient with the given API key and retry configurations.
+
+        Args:
+            api_key: The API key for Zyte API.
+            max_retries: Maximum number of retries for API calls.
+            retry_delay: Delay between retries in seconds.
+        """
+        self._aiohttp_basic_auth = aiohttp.BasicAuth(api_key)
+        self._max_retries = max_retries
+        self._retry_delay = retry_delay
+
+    async def get_details(self, url: str) -> dict:
+        """Fetches product details for a single URL.
+
+        Args:
+            url: The URL to fetch product details from.
+
+        Returns:
+            A dictionary containing the product details, fields include:
+            (c.f. https://docs.zyte.com/zyte-api/usage/reference.html#operation/extract/response/200/product)
+            {
+                "url": str,
+                "statusCode": str,
+                "product": {
+                    "name": str,
+                    "price": str,
+                    "mainImage": {"url": str},
+                    "images": [{"url": str}],
+                    "description": str,
+                    "metadata": {
+                        "probability": float,
+                    },
+                }
+            }
+        """
+        logger.info(f"Fetching product details by Zyte for URL {url}.")
+        attempts = 0
+        err = None
+        while attempts < self._max_retries:
+            try:
+                logger.debug(
+                    f"Fetch product details for URL {url} (Attempt {attempts + 1})."
+                )
+                product = await self.post(
+                    url=self._endpoint,
+                    data={"url": url, **self._config},
+                    auth=self._aiohttp_basic_auth,
+                )
+                return product
+            except Exception as e:
+                logger.debug(
+                    f"Exception occurred while fetching product details for URL {url} (Attempt {attempts + 1})."
+                )
+                err = e
+            attempts += 1
+            if attempts < self._max_retries:
+                await asyncio.sleep(self._retry_delay)
+        if err is not None:
+            raise err
+        return {}
+
+    @staticmethod
+    def keep_product(
+        details: dict, threshold: float = ZYTE_DEFALUT_PROBABILITY_THRESHOLD
+    ) -> bool:
+        """Determines whether to keep the product based on the probability threshold.
+
+        Args:
+            details: A product details data dictionary.
+            threshold: The probability threshold used to filter the products.
+        """
+        try:
+            prob = float(details["product"]["metadata"]["probability"])
+        except KeyError:
+            logger.warning(
+                f"Product with url={details.get('url')} has no probability value - product is ignored"
+            )
+            return False
+        return prob > threshold
+
+    @staticmethod
+    def extract_product_name(details: dict) -> str | None:
+        """Extracts the product name from the product data.
+
+        The input argument is a dictionary of the following structure:
+            {
+                "product": {
+                    "name": str,
+                }
+            }
+        """
+        return details.get("product", {}).get("name")
+
+    @staticmethod
+    def extract_product_price(details: dict) -> str | None:
+        """Extracts the product price from the product data.
+
+        The input argument is a dictionary of the following structure:
+            {
+                "product": {
+                    "price": str,
+                }
+            }
+        """
+        return details.get("product", {}).get("price")
+
+    @staticmethod
+    def extract_product_description(details: dict) -> str | None:
+        """Extracts the product description from the product data.
+
+        The input argument is a dictionary of the following structure:
+            {
+                "product": {
+                    "description": str,
+                }
+            }
+        """
+        return details.get("product", {}).get("description")
+
+    @staticmethod
+    def extract_image_urls(details: dict) -> List[str]:
+        """Extracts the images from the product data.
+
+        The input argument is a dictionary of the following structure:
+            {
+                "product": {
+                    "mainImage": {"url": str},
+                    "images": [{"url": str}],
+                }
+            }
+        """
+        images = []
+        product = details.get("product")
+        if product:
+            # Extract main image URL
+            if (main_img := product.get("mainImage")) and (url := main_img.get("url")):
+                images.append(url)
+            # Extract additional image URLs
+            if urls := product.get("images"):
+                images.extend([img["url"] for img in urls if img.get("url")])
+        return images
+
+    @staticmethod
+    def extract_probability(details: dict) -> float:
+        """Extracts the probability from the product data.
+
+        The input argument is a dictionary of the following structure:
+            {
+                "product": {
+                    "metadata": {
+                        "probability": float,
+                    }
+                }
+            }
+        """
+        return float(details.get("product", {}).get("metadata", {}).get("probability"))

fraudcrawler/settings.py

@@ -0,0 +1,31 @@
+from pathlib import Path
+
+# Generic settings
+MAX_RETRIES = 3
+RETRY_DELAY = 2
+ROOT_DIR = Path(__file__).parents[1]
+
+# Serp settings
+GOOGLE_LOCATIONS_FILENAME = ROOT_DIR / "fraudcrawler" / "base" / "google-locations.json"
+GOOGLE_LANGUAGES_FILENAME = ROOT_DIR / "fraudcrawler" / "base" / "google-languages.json"
+
+# Enrichment settings
+ENRICHMENT_DEFAULT_LIMIT = 10
+
+# Zyte settings
+ZYTE_DEFALUT_PROBABILITY_THRESHOLD = 0.1
+
+# Processor settings
+PROCESSOR_DEFAULT_MODEL = "gpt-4o"
+PROCESSOR_DEFAULT_IF_MISSING = -1
+PROCESSOR_USER_PROMPT_TEMPLATE = (
+    "Context: {context}\n\nProduct Details: {name}\n{description}\\n\nRelevance:"
+)
+
+# Orchestrator settings
+PRODUCT_ITEM_DEFAULT_IS_RELEVANT = -1
+
+# Async settings
+DEFAULT_N_SERP_WKRS = 10
+DEFAULT_N_ZYTE_WKRS = 10
+DEFAULT_N_PROC_WKRS = 10

fraudcrawler-0.3.3.dist-info/LICENSE

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

fraudcrawler-0.3.3.dist-info/METADATA

@@ -0,0 +1,163 @@
+Metadata-Version: 2.3
+Name: fraudcrawler
+Version: 0.3.3
+Summary: Intelligent Market Monitoring
+Home-page: https://github/open-veanu/fraudcrawler
+License: MIT
+Author: Domingo Bertus
+Author-email: hello@veanu.ch
+Requires-Python: >=3.11,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: aiohttp (>=3.11.14,<4.0.0)
+Requires-Dist: openai (>=1.68.2,<2.0.0)
+Requires-Dist: pandas (>=2.2.3,<3.0.0)
+Requires-Dist: pydantic-settings (>=2.8.1,<3.0.0)
+Requires-Dist: requests (>=2.32.3,<3.0.0)
+Project-URL: Repository, https://github/open-veanu/fraudcrawler
+Description-Content-Type: text/markdown
+
+# open-veanu/fraudcrawler
+Intelligent Market Monitoring
+
+The pipeline for monitoring the market has the folling main steps:
+1. search for a given term using SerpAPI
+2. get product information using ZyteAPI
+3. assess relevance of the found products using an OpenAI API
+
+## Installation
+```bash
+python3.11 -m venv .venv
+source .venv/bin/activate
+pip install fraudcrawler
+```
+
+## Usage
+### `.env` file
+Make sure to create an `.env` file with the necessary API keys and credentials (c.f. `.env.example` file).
+
+### Run demo pipeline
+```bash
+python -m fraudcrawler.launch_demo_pipeline
+```
+
+### Customize the pipeline
+Start by initializing the client
+```python
+from fraudcrawler import FraudCrawlerClient
+
+# Initialize the client
+client = FraudCrawlerClient()
+```
+
+For setting up the search we need 5 main objects.
+
+#### `search_term: str`
+The search term for the query (similar to search terms used within major search providers).
+
+#### `language: Language`
+The language used in SerpAPI ('hl' parameter), as well as for the optional search term enrichement (e.g. finding similar and related search terms). `language=Language('German')` creates an object having a language name and a language code as: `Language(name='German', code='de')`.
+
+#### `location: Location`
+The location used in SerpAPI ('gl' parameter). `location=Location('Switzerland')` creates an object having a location name and a location code as `Location(name='Switzerland', code='ch')`.
+
+#### `deepness: Deepness`
+Defines the search depth with the number of results to retrieve and optional enrichment parameters.
+
+#### `prompts: List[Prompt]`
+The list of prompts to classify a given product with (multiple) LLM calls. Each prompt object has a `name`, a `context` (used for defining the user prompt), a `system_prompt` (for defining the classification task), `allowed_classes` (a list of possible classes) and optionally `default_if_missing` (a default class if anything goes wrong).
+
+```python
+from fraudcrawler import Language, Location, Deepness, Prompt
+# Setup the search
+search_term = "sildenafil"
+language = Language(name="German")
+location = Location(name="Switzerland")
+deepness = Deepness(num_results=50)
+prompts = [
+    Prompt(
+        name="relevance",
+        context="This organization is interested in medical products and drugs.",
+        system_prompt=(
+            "You are a helpful and intelligent assistant. Your task is to classify any given product "
+            "as either relevant (1) or not relevant (0), strictly based on the context and product details provided by the user. "
+            "You must consider all aspects of the given context and make a binary decision accordingly. "
+            "If the product aligns with the user's needs, classify it as 1 (relevant); otherwise, classify it as 0 (not relevant). "
+            "Respond only with the number 1 or 0."
+        ),
+        allowed_classes=[0, 1],
+    )
+]
+```
+
+(Optional) Add search term enrichement. This will find related search terms (in a given language) and search for these as well.
+```python
+from fraudcrawler import Enrichment
+deepness.enrichment = Enrichment(
+    additional_terms=5,
+    additional_urls_per_term=10
+)
+```
+
+(Optional) Add marketplaces where we explicitely want to look for (this will focus your search as the :site parameter for a google search)
+```python
+from fraudcrawler import Host
+marketplaces = [
+    Host(name="International", domains="zavamed.com,apomeds.com"),
+    Host(name="National", domains="netdoktor.ch, nobelpharma.ch"),
+]
+```
+
+(Optional) Exclude urls (where you don't want to find products)
+```python
+excluded_urls = [
+    Host(name="Compendium", domains="compendium.ch"),
+]
+```
+
+(Optional) Exclude previously collected urls (intends to save credits)
+```python
+previously_collected_urls = [
+    https://pharmaciedelabateliere.ch/shop/sante/douleurs-inflammations/dafalgan-cpr-eff-500-mg-16-pce/,
+    https://eiche.ch/product/schmerzmittel-52cd81d5d206a/dafalgan-brausetabletten-1336653,
+]
+```
+
+And finally run the pipeline
+```python
+# Execute the pipeline
+client.execute(
+    search_term=search_term,
+    language=language,
+    location=location,
+    deepness=deepness,
+    prompts=prompts,
+    # marketplaces=marketplaces,    # Uncomment this for using marketplaces
+    # excluded_urls=excluded_urls   # Uncomment this for using excluded_urls
+    # previously_collected_urls=previously_collected_urls    # Uncomment this for using previously_selected_urls
+)
+```
+This creates a file with name pattern `<search_term>_<language.code>_<location.code>_<datetime[%Y%m%d%H%M%S]>.csv` inside the folder `data/results/`.
+
+Once the pipeline terminated the results can be loaded and examined as follows:
+```python
+df = client.load_results()
+print(df.head(n=10))
+```
+
+If the client has been used to run multiple pipelines, an overview of the available results (for a given instance of 
+`FraudCrawlerClient`) can be obtained with
+```python
+client.print_available_results()
+```
+
+## Contributing
+see `CONTRIBUTING.md`
+
+### Async Setup
+The following image provides a schematic representation of the package's async setup.
+![Async Setup](https://github.com/open-veanu/fraudcrawler/raw/master/docs/assets/images/Fraudcrawler_Async_Setup.svg)
+

fraudcrawler-0.3.3.dist-info/RECORD

@@ -0,0 +1,20 @@
+fraudcrawler/__init__.py,sha256=2EgoTb2jNcQt1NxUV8za0154kb7ZnHZ_KeKgx21rdFs,679
+fraudcrawler/base/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fraudcrawler/base/base.py,sha256=YgX7cUB3Fta-sXWZu5I-gn85sCfpmoa8M67Whn1m56o,4241
+fraudcrawler/base/client.py,sha256=GcTUMqLfvweLFdHy6CP9tgxsFQiPkc6KyiLcwLnDiw8,4412
+fraudcrawler/base/google-languages.json,sha256=z0VtjMCsCcZq11OkCIb9jMDD1p9Ty4lhV7bq4ddYvec,10748
+fraudcrawler/base/google-locations.json,sha256=UtNu0iSStllvFRTQXMobWKmZR1hKmtgtHftLNgaJTT0,9204345
+fraudcrawler/base/orchestrator.py,sha256=GmJvrP9jKr4FqTKhuU9YMEuZ54gV0asHrSCxhM43onA,23903
+fraudcrawler/launch_demo_pipeline.py,sha256=RIZTtdtZeJPhvSLp1IUjT_nhme_2q6mAGWKoL838E4E,4320
+fraudcrawler/processing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fraudcrawler/processing/processor.py,sha256=sNYK0gY7PsJJS5FMYOiHLXEQJ70buifSokuIiXk5dG4,3715
+fraudcrawler/scraping/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fraudcrawler/scraping/enrich.py,sha256=X1BBZshdZqPmbduzhGwH0ULSzq03L_7bf7_UL8yOQ9E,10608
+fraudcrawler/scraping/serp.py,sha256=wT8vhk0EugcrS2CCvMuCCZrlw1MRI-ahtGYKdNUZQo8,8830
+fraudcrawler/scraping/zyte.py,sha256=ggI4iYG-E_UyiKgUpEFekeUd1giifEfJ_uyFUSJGSLY,6296
+fraudcrawler/settings.py,sha256=eUb7zd2Q7fYUrLk4cl_d48lZ9zaB8iU7M0zFFuZc_-g,786
+fraudcrawler-0.3.3.dist-info/LICENSE,sha256=B-3FuHfe3S0fWAlKlceskPcRhzXq81g-rJ-ddUYb4O8,1062
+fraudcrawler-0.3.3.dist-info/METADATA,sha256=860K3oeNRoAC2Fmr9D4Gd1DYaXw1KOaWSEBeByL4V-U,6030
+fraudcrawler-0.3.3.dist-info/WHEEL,sha256=RaoafKOydTQ7I_I3JTrPCg6kUmTgtm4BornzOqyEfJ8,88
+fraudcrawler-0.3.3.dist-info/entry_points.txt,sha256=1Befm7cM6945y2AA1z9V4gZV63mtSWcAs7ypvgux_Xg,79
+fraudcrawler-0.3.3.dist-info/RECORD,,

fraudcrawler-0.3.3.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.0.0
+Root-Is-Purelib: true
+Tag: py3-none-any

fraudcrawler-0.3.3.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+launch_demo_pipeline=fraudcrawler.launch_demo_pipeline:main
+