zepto-scraper 0.1.0__tar.gz

zepto_scraper-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Buğrahan Saka
+
+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.

zepto_scraper-0.1.0/MANIFEST.in

@@ -0,0 +1,3 @@
+include README.md LICENSE
+recursive-include tests *.py *.html
+recursive-include examples *.py

zepto_scraper-0.1.0/PKG-INFO

@@ -0,0 +1,154 @@
+Metadata-Version: 2.4
+Name: zepto-scraper
+Version: 0.1.0
+Summary: Scrape Zepto category listings (price, MRP, discount, stock) and product details (seller, shelf life, FSSAI licence) with Python.
+Author: Buğrahan Saka
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/bugrahansss/zepto-scraper
+Project-URL: Source, https://github.com/bugrahansss/zepto-scraper
+Project-URL: Issues, https://github.com/bugrahansss/zepto-scraper/issues
+Project-URL: Scrape.do, https://scrape.do/?utm_source=pypi&utm_medium=package&utm_campaign=zepto-scraper
+Keywords: zepto,web scraping,quick commerce,grocery,scraper,nextjs,india
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Internet :: WWW/HTTP :: Indexing/Search
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.25
+Dynamic: license-file
+
+# zepto-scraper
+
+[![PyPI](https://img.shields.io/pypi/v/zepto-scraper)](https://pypi.org/project/zepto-scraper/)
+[![Python](https://img.shields.io/pypi/pyversions/zepto-scraper)](https://pypi.org/project/zepto-scraper/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+
+A Python scraper for [Zepto](https://www.zepto.com), India's quick-commerce grocery app. Two jobs:
+
+- **Category listings:** start from one subcategory URL, walk its sibling subcategories and get every product card with price, MRP, discount, in-stock flag, **units in stock**, rating and the dark store it came from.
+- **Product details:** turn product pages into a catalog sheet with seller entity, shelf life, FSSAI licence number, country of origin, category path, order limit and the full description.
+
+Output as Python dicts, JSON or CSV. One dependency (`requests`), no browser.
+
+```bash
+pip install zepto-scraper
+```
+
+## Why a plain request fails
+
+Zepto sits behind AWS WAF on CloudFront:
+
+| Request | Status | Body |
+| --- | --- | --- |
+| `requests`, default user agent | 429 | 0 bytes |
+| `requests`, Chrome user agent | 202, `x-amzn-waf-action: challenge` | 0 bytes |
+| Through Scrape.do, no parameters | 200 | full page |
+
+**Watch the 202.** It means "Accepted", so `raise_for_status()` treats it as success and a scraper that only checks for errors writes empty pages without a single failure. This package treats anything but a 200 as an error.
+
+Pages are fetched through the [Scrape.do](https://scrape.do/?utm_source=github&utm_medium=readme&utm_campaign=zepto-scraper) API with a plain request: no `render`, no `super`, no `geoCode`, 1 credit per page. You need a Scrape.do API token; the free plan includes 1,000 credits a month.
+
+## Quick start
+
+```python
+from zepto_scraper import ZeptoScraper
+
+scraper = ZeptoScraper(token="YOUR_SCRAPEDO_TOKEN")  # or set SCRAPEDO_TOKEN
+
+# Any subcategory URL; the scraper walks its siblings in the same category
+rows = scraper.get_category(
+    "https://www.zepto.com/cn/munchies/chips-crisps/cid/d2c2a144-43cd-43e5-b308-92628fa68596/scid/df4f5100-c02f-4906-83b8-ddb744081a7a"
+)
+for row in rows[:3]:
+    print(row["name"], row["price_inr"], row["mrp_inr"], row["in_stock"], row["available_qty"])
+
+product = scraper.get_product(rows[0]["url"])
+print(product["seller"], product["shelf_life"], product["fssai_licence"])
+```
+
+Start from a **subcategory** URL (`/cn/<category>/<subcategory>/cid/.../scid/...`). The category link on Zepto's homepage is not a listing.
+
+### Command line
+
+```bash
+export SCRAPEDO_TOKEN=your_token
+
+# every product in a category, CSV
+zepto-scraper category "<subcategory-url>" -f csv -o zepto-category.csv
+
+# catalog sheet for the first 10 products from that file
+zepto-scraper product -i zepto-category.csv --limit 10 -f csv -o zepto-products.csv
+```
+
+The two commands chain: `product` reads the `url` column of the listing CSV.
+
+### Output
+
+Listing row (from the fictional test page in [`tests/fixtures`](tests/fixtures/subcategory_page.html)):
+
+```json
+{
+  "variant_id": "44444444-4444-4444-8444-444444444440",
+  "name": "Example Chilli Chips",
+  "brand": "Examplo",
+  "pack_size": "1 pack (41 g)",
+  "price_inr": 19.0,
+  "mrp_inr": 20.0,
+  "discount_pct": 5,
+  "in_stock": true,
+  "available_qty": 30,
+  "rating": 4.9,
+  "rating_count": 401062,
+  "subcategory": "Chips & Crisps",
+  "store_id": "33333333-3333-4333-8333-333333333333",
+  "url": "https://www.zepto.com/pn/example-snack-0/pvid/44444444-4444-4444-8444-444444444440"
+}
+```
+
+Product sheet columns: `variant_id, name, brand, category, pack_size, mrp_inr, max_per_order, rating, rating_count, shelf_life, country_of_origin, seller, fssai_licence, image_count, description, url`.
+
+## How it works
+
+**The Next.js stream.** Zepto runs on the Next.js App Router. A subcategory page makes no separate product API call; every product card is streamed into the HTML as `self.__next_f.push([1, "..."])` chunks. Each chunk is a JavaScript string literal, and JSON strings use the same escaping, so `json.loads('"' + chunk + '"')` decodes it. Joined, the chunks are one text with one JSON object per product card.
+
+**Out-of-stock cards.** Card keys are sorted alphabetically. In-stock cards start with `availableQuantity`; out-of-stock cards drop that key and start with `baseProductId`. A parser that anchors only on `availableQuantity` silently skips every out-of-stock product. This one anchors on both, reads each object with `json.JSONDecoder.raw_decode`, and dedupes on the variant id.
+
+**Prices are in paise.** `"discountedSellingPrice": 1900` is ₹19. The scraper divides by 100.
+
+**Siblings.** Every subcategory page links its siblings, all sharing the category `cid`. The same subcategory can appear under a second category slug that renders no products, so only paths under the start URL's own slug are kept.
+
+**Product pages.** The catalog fields come from the schema.org `Product` JSON-LD block (Zepto writes `id` before `type` on the script tag, so the regex does not depend on attribute order). MRP and the order limit come from the stream's `productVariant` object for the exact variant in the URL.
+
+## Limits
+
+- **32 products per subcategory.** Zepto's web pages stop at 32 cards (`endOfPage: true`) and ignore `?page=2`. For wider coverage, walk more subcategories and categories.
+- **One dark store.** Each price and stock count belongs to one dark store. With no location, Zepto serves its default store (east Bengaluru); the `store_id` column records which one. Changing the location through Scrape.do did not move the store in our tests.
+- **Use the listing for price and stock.** Product pages cap the stock count and can lag the listing, so `get_product()` leaves price and stock out on purpose.
+- **No search.** Search results need a browser-computed `request-signature` header, and robots.txt disallows `/search`. Walk categories instead.
+- **Errors.** Non-200 responses (including the 202 challenge) raise `ScrapeError` with the status code. Server errors and 429s are retried twice; client errors are not.
+
+## Responsible use
+
+The scraper reads category (`/cn/`) and product (`/pn/`) pages, which Zepto's robots.txt allows; it does not touch `/search`, `/api/`, cart or account paths. Product data is not personal data. Read Zepto's terms for your use case and keep request rates modest. This is not legal advice.
+
+## Development
+
+```bash
+git clone https://github.com/bugrahansss/zepto-scraper
+cd zepto-scraper
+pip install -e .
+python -m unittest discover -s tests -v
+```
+
+The tests run offline against fictional fixture pages.
+
+## License
+
+MIT
+
+---
+
+Built and tested with [Scrape.do](https://scrape.do/?utm_source=github&utm_medium=readme&utm_campaign=zepto-scraper), October 2026.

zepto_scraper-0.1.0/README.md

@@ -0,0 +1,132 @@
+# zepto-scraper
+
+[![PyPI](https://img.shields.io/pypi/v/zepto-scraper)](https://pypi.org/project/zepto-scraper/)
+[![Python](https://img.shields.io/pypi/pyversions/zepto-scraper)](https://pypi.org/project/zepto-scraper/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+
+A Python scraper for [Zepto](https://www.zepto.com), India's quick-commerce grocery app. Two jobs:
+
+- **Category listings:** start from one subcategory URL, walk its sibling subcategories and get every product card with price, MRP, discount, in-stock flag, **units in stock**, rating and the dark store it came from.
+- **Product details:** turn product pages into a catalog sheet with seller entity, shelf life, FSSAI licence number, country of origin, category path, order limit and the full description.
+
+Output as Python dicts, JSON or CSV. One dependency (`requests`), no browser.
+
+```bash
+pip install zepto-scraper
+```
+
+## Why a plain request fails
+
+Zepto sits behind AWS WAF on CloudFront:
+
+| Request | Status | Body |
+| --- | --- | --- |
+| `requests`, default user agent | 429 | 0 bytes |
+| `requests`, Chrome user agent | 202, `x-amzn-waf-action: challenge` | 0 bytes |
+| Through Scrape.do, no parameters | 200 | full page |
+
+**Watch the 202.** It means "Accepted", so `raise_for_status()` treats it as success and a scraper that only checks for errors writes empty pages without a single failure. This package treats anything but a 200 as an error.
+
+Pages are fetched through the [Scrape.do](https://scrape.do/?utm_source=github&utm_medium=readme&utm_campaign=zepto-scraper) API with a plain request: no `render`, no `super`, no `geoCode`, 1 credit per page. You need a Scrape.do API token; the free plan includes 1,000 credits a month.
+
+## Quick start
+
+```python
+from zepto_scraper import ZeptoScraper
+
+scraper = ZeptoScraper(token="YOUR_SCRAPEDO_TOKEN")  # or set SCRAPEDO_TOKEN
+
+# Any subcategory URL; the scraper walks its siblings in the same category
+rows = scraper.get_category(
+    "https://www.zepto.com/cn/munchies/chips-crisps/cid/d2c2a144-43cd-43e5-b308-92628fa68596/scid/df4f5100-c02f-4906-83b8-ddb744081a7a"
+)
+for row in rows[:3]:
+    print(row["name"], row["price_inr"], row["mrp_inr"], row["in_stock"], row["available_qty"])
+
+product = scraper.get_product(rows[0]["url"])
+print(product["seller"], product["shelf_life"], product["fssai_licence"])
+```
+
+Start from a **subcategory** URL (`/cn/<category>/<subcategory>/cid/.../scid/...`). The category link on Zepto's homepage is not a listing.
+
+### Command line
+
+```bash
+export SCRAPEDO_TOKEN=your_token
+
+# every product in a category, CSV
+zepto-scraper category "<subcategory-url>" -f csv -o zepto-category.csv
+
+# catalog sheet for the first 10 products from that file
+zepto-scraper product -i zepto-category.csv --limit 10 -f csv -o zepto-products.csv
+```
+
+The two commands chain: `product` reads the `url` column of the listing CSV.
+
+### Output
+
+Listing row (from the fictional test page in [`tests/fixtures`](tests/fixtures/subcategory_page.html)):
+
+```json
+{
+  "variant_id": "44444444-4444-4444-8444-444444444440",
+  "name": "Example Chilli Chips",
+  "brand": "Examplo",
+  "pack_size": "1 pack (41 g)",
+  "price_inr": 19.0,
+  "mrp_inr": 20.0,
+  "discount_pct": 5,
+  "in_stock": true,
+  "available_qty": 30,
+  "rating": 4.9,
+  "rating_count": 401062,
+  "subcategory": "Chips & Crisps",
+  "store_id": "33333333-3333-4333-8333-333333333333",
+  "url": "https://www.zepto.com/pn/example-snack-0/pvid/44444444-4444-4444-8444-444444444440"
+}
+```
+
+Product sheet columns: `variant_id, name, brand, category, pack_size, mrp_inr, max_per_order, rating, rating_count, shelf_life, country_of_origin, seller, fssai_licence, image_count, description, url`.
+
+## How it works
+
+**The Next.js stream.** Zepto runs on the Next.js App Router. A subcategory page makes no separate product API call; every product card is streamed into the HTML as `self.__next_f.push([1, "..."])` chunks. Each chunk is a JavaScript string literal, and JSON strings use the same escaping, so `json.loads('"' + chunk + '"')` decodes it. Joined, the chunks are one text with one JSON object per product card.
+
+**Out-of-stock cards.** Card keys are sorted alphabetically. In-stock cards start with `availableQuantity`; out-of-stock cards drop that key and start with `baseProductId`. A parser that anchors only on `availableQuantity` silently skips every out-of-stock product. This one anchors on both, reads each object with `json.JSONDecoder.raw_decode`, and dedupes on the variant id.
+
+**Prices are in paise.** `"discountedSellingPrice": 1900` is ₹19. The scraper divides by 100.
+
+**Siblings.** Every subcategory page links its siblings, all sharing the category `cid`. The same subcategory can appear under a second category slug that renders no products, so only paths under the start URL's own slug are kept.
+
+**Product pages.** The catalog fields come from the schema.org `Product` JSON-LD block (Zepto writes `id` before `type` on the script tag, so the regex does not depend on attribute order). MRP and the order limit come from the stream's `productVariant` object for the exact variant in the URL.
+
+## Limits
+
+- **32 products per subcategory.** Zepto's web pages stop at 32 cards (`endOfPage: true`) and ignore `?page=2`. For wider coverage, walk more subcategories and categories.
+- **One dark store.** Each price and stock count belongs to one dark store. With no location, Zepto serves its default store (east Bengaluru); the `store_id` column records which one. Changing the location through Scrape.do did not move the store in our tests.
+- **Use the listing for price and stock.** Product pages cap the stock count and can lag the listing, so `get_product()` leaves price and stock out on purpose.
+- **No search.** Search results need a browser-computed `request-signature` header, and robots.txt disallows `/search`. Walk categories instead.
+- **Errors.** Non-200 responses (including the 202 challenge) raise `ScrapeError` with the status code. Server errors and 429s are retried twice; client errors are not.
+
+## Responsible use
+
+The scraper reads category (`/cn/`) and product (`/pn/`) pages, which Zepto's robots.txt allows; it does not touch `/search`, `/api/`, cart or account paths. Product data is not personal data. Read Zepto's terms for your use case and keep request rates modest. This is not legal advice.
+
+## Development
+
+```bash
+git clone https://github.com/bugrahansss/zepto-scraper
+cd zepto-scraper
+pip install -e .
+python -m unittest discover -s tests -v
+```
+
+The tests run offline against fictional fixture pages.
+
+## License
+
+MIT
+
+---
+
+Built and tested with [Scrape.do](https://scrape.do/?utm_source=github&utm_medium=readme&utm_campaign=zepto-scraper), October 2026.

zepto_scraper-0.1.0/examples/category_to_products.py

@@ -0,0 +1,44 @@
+"""Walk a Zepto category, then build a catalog sheet for its products.
+
+Usage:
+    export SCRAPEDO_TOKEN=your_token
+    python category_to_products.py "<subcategory-url>" 10
+
+Writes zepto-category.csv (price, MRP, discount, stock per product) and
+zepto-products.csv (seller, shelf life, FSSAI licence for the first N products).
+"""
+
+import csv
+import sys
+
+from zepto_scraper import LISTING_FIELDS, PRODUCT_FIELDS, ScrapeError, ZeptoScraper
+
+
+def write(path, fields, rows):
+    with open(path, "w", newline="", encoding="utf-8") as handle:
+        writer = csv.DictWriter(handle, fieldnames=fields)
+        writer.writeheader()
+        writer.writerows(rows)
+
+
+def main(start_url: str, max_products: int = 10) -> None:
+    scraper = ZeptoScraper()  # reads SCRAPEDO_TOKEN
+    listing = scraper.get_category(start_url)
+    write("zepto-category.csv", LISTING_FIELDS, listing)
+    out_of_stock = sum(1 for row in listing if not row["in_stock"])
+    print(f"Saved {len(listing)} products ({out_of_stock} out of stock) to zepto-category.csv")
+
+    products = []
+    for row in [r for r in listing if r["url"]][:max_products]:
+        try:
+            products.append(scraper.get_product(row["url"]))
+        except (ScrapeError, ValueError) as exc:
+            print(f"skipped {row['url']}: {exc}")
+            continue
+        print(f"{products[-1]['name']} | {products[-1]['seller']} | shelf life {products[-1]['shelf_life']}")
+    write("zepto-products.csv", PRODUCT_FIELDS, products)
+    print(f"Saved {len(products)} products to zepto-products.csv")
+
+
+if __name__ == "__main__":
+    main(sys.argv[1], int(sys.argv[2]) if len(sys.argv) > 2 else 10)

zepto_scraper-0.1.0/pyproject.toml

@@ -0,0 +1,34 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "zepto-scraper"
+version = "0.1.0"
+description = "Scrape Zepto category listings (price, MRP, discount, stock) and product details (seller, shelf life, FSSAI licence) with Python."
+readme = "README.md"
+requires-python = ">=3.8"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Buğrahan Saka" }]
+keywords = ["zepto", "web scraping", "quick commerce", "grocery", "scraper", "nextjs", "india"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Topic :: Internet :: WWW/HTTP :: Indexing/Search",
+]
+dependencies = ["requests>=2.25"]
+
+[project.urls]
+Homepage = "https://github.com/bugrahansss/zepto-scraper"
+Source = "https://github.com/bugrahansss/zepto-scraper"
+Issues = "https://github.com/bugrahansss/zepto-scraper/issues"
+"Scrape.do" = "https://scrape.do/?utm_source=pypi&utm_medium=package&utm_campaign=zepto-scraper"
+
+[project.scripts]
+zepto-scraper = "zepto_scraper.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]

zepto_scraper-0.1.0/setup.cfg

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

zepto_scraper-0.1.0/src/zepto_scraper/__init__.py

@@ -0,0 +1,26 @@
+"""Scrape Zepto category listings and product details with Python."""
+
+from .client import ScrapeError, ZeptoScraper
+from .parser import (
+    LISTING_FIELDS,
+    PRODUCT_FIELDS,
+    decode_rsc,
+    extract_items,
+    parse_listing,
+    parse_product,
+    subcategory_paths,
+)
+
+__all__ = [
+    "LISTING_FIELDS",
+    "PRODUCT_FIELDS",
+    "ScrapeError",
+    "ZeptoScraper",
+    "decode_rsc",
+    "extract_items",
+    "parse_listing",
+    "parse_product",
+    "subcategory_paths",
+]
+
+__version__ = "0.1.0"

zepto_scraper-0.1.0/src/zepto_scraper/cli.py

@@ -0,0 +1,104 @@
+"""Command line entry point: ``zepto-scraper category URL`` / ``zepto-scraper product URL ...``."""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import json
+import sys
+from typing import List, Optional
+
+from . import __version__
+from .client import TOKEN_ENV, ScrapeError, ZeptoScraper
+from .parser import LISTING_FIELDS, PRODUCT_FIELDS
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="zepto-scraper",
+        description="Scrape Zepto category listings and product details into JSON or CSV.",
+    )
+    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    cat = sub.add_parser("category", help="Every product in a category, starting from one subcategory URL")
+    cat.add_argument("url", help="A Zepto subcategory URL (.../cn/<category>/<subcategory>/cid/.../scid/...)")
+    cat.add_argument("--max-subcategories", type=int, default=20)
+
+    prod = sub.add_parser("product", help="Catalog sheet for product pages")
+    prod.add_argument("urls", nargs="*", help="Zepto product URLs (.../pn/<slug>/pvid/<id>)")
+    prod.add_argument("-i", "--input", help="Text file with one URL per line, or a CSV with a 'url' column")
+    prod.add_argument("--limit", type=int, default=0, help="Stop after this many products (0 = all)")
+
+    for p in (cat, prod):
+        p.add_argument("-t", "--token", help=f"Scrape.do API token (default: ${TOKEN_ENV})")
+        p.add_argument("-f", "--format", choices=("json", "csv"), default="json")
+        p.add_argument("-o", "--output", help="Write to this file instead of stdout")
+    return parser
+
+
+def _read_urls(args: argparse.Namespace) -> List[str]:
+    urls = list(args.urls)
+    if args.input:
+        with open(args.input, encoding="utf-8", newline="") as handle:
+            if args.input.endswith(".csv"):
+                urls.extend(row["url"] for row in csv.DictReader(handle) if row.get("url"))
+            else:
+                urls.extend(line.strip() for line in handle if line.strip() and not line.startswith("#"))
+    return urls[: args.limit] if args.limit else urls
+
+
+def _write(rows: List[dict], fields: List[str], fmt: str, stream) -> None:
+    if fmt == "csv":
+        writer = csv.DictWriter(stream, fieldnames=fields)
+        writer.writeheader()
+        writer.writerows(rows)
+    else:
+        json.dump(rows, stream, indent=2, ensure_ascii=False)
+        stream.write("\n")
+
+
+def main(argv: Optional[List[str]] = None) -> int:
+    args = build_parser().parse_args(argv)
+    try:
+        scraper = ZeptoScraper(token=args.token)
+    except ValueError as exc:
+        print(exc, file=sys.stderr)
+        return 2
+
+    failures = 0
+    if args.command == "category":
+        fields = LISTING_FIELDS
+        try:
+            rows = scraper.get_category(args.url, args.max_subcategories)
+        except (ScrapeError, ValueError) as exc:
+            print(f"fail  {args.url}: {exc}", file=sys.stderr)
+            return 1
+        out_of_stock = sum(1 for r in rows if not r["in_stock"])
+        print(f"{len(rows)} products, {out_of_stock} out of stock", file=sys.stderr)
+    else:
+        fields = PRODUCT_FIELDS
+        urls = _read_urls(args)
+        if not urls:
+            print("No URLs given. Pass product URLs or --input FILE.", file=sys.stderr)
+            return 2
+        rows = []
+        for url in urls:
+            try:
+                rows.append(scraper.get_product(url))
+                print(f"ok    {url}", file=sys.stderr)
+            except (ScrapeError, ValueError) as exc:
+                failures += 1
+                print(f"fail  {url}: {exc}", file=sys.stderr)
+
+    if args.output:
+        with open(args.output, "w", encoding="utf-8", newline="" if args.format == "csv" else None) as handle:
+            _write(rows, fields, args.format, handle)
+        print(f"Saved {len(rows)} rows to {args.output}", file=sys.stderr)
+    else:
+        _write(rows, fields, args.format, sys.stdout)
+    return 1 if failures and not rows else 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

zepto_scraper-0.1.0/src/zepto_scraper/client.py

@@ -0,0 +1,94 @@
+"""Fetch Zepto pages through the Scrape.do API.
+
+Zepto sits behind AWS WAF on CloudFront. A plain ``requests`` call gets HTTP 429;
+with a browser user agent it gets HTTP 202, an empty body and
+``x-amzn-waf-action: challenge``. 202 counts as success to
+``raise_for_status()``, so this client checks for ``status_code != 200``.
+
+Through Scrape.do a plain request (no parameters, 1 credit) returns the full page.
+"""
+
+from __future__ import annotations
+
+import os
+import time
+from typing import List, Optional
+
+import requests
+
+from .parser import ZEPTO, parse_listing, parse_product, subcategory_paths
+
+API_URL = "https://api.scrape.do/"
+TOKEN_ENV = "SCRAPEDO_TOKEN"
+
+
+class ScrapeError(RuntimeError):
+    """Raised when a page cannot be fetched."""
+
+    def __init__(self, message: str, status_code: Optional[int] = None):
+        super().__init__(message)
+        self.status_code = status_code
+
+
+class ZeptoScraper:
+    """Fetch and parse Zepto category and product pages.
+
+    >>> scraper = ZeptoScraper(token="YOUR_SCRAPEDO_TOKEN")
+    >>> rows = scraper.get_category("https://www.zepto.com/cn/munchies/chips-crisps/cid/.../scid/...")
+    """
+
+    def __init__(
+        self,
+        token: Optional[str] = None,
+        timeout: float = 120.0,
+        retries: int = 2,
+        session: Optional[requests.Session] = None,
+    ):
+        self.token = token or os.environ.get(TOKEN_ENV, "")
+        if not self.token:
+            raise ValueError(f"A Scrape.do API token is required. Pass token=... or set {TOKEN_ENV}.")
+        self.timeout = timeout
+        self.retries = max(0, retries)
+        self.session = session or requests.Session()
+
+    def fetch(self, url: str) -> str:
+        """Return the raw HTML of ``url``. Anything but a 200 is an error."""
+        params = {"token": self.token, "url": url}
+        last_error: Optional[ScrapeError] = None
+        for attempt in range(self.retries + 1):
+            try:
+                response = self.session.get(API_URL, params=params, timeout=self.timeout)
+            except requests.RequestException as exc:
+                last_error = ScrapeError(f"Request failed: {exc}")
+            else:
+                if response.status_code == 200 and response.text:
+                    return response.text
+                last_error = ScrapeError(
+                    f"Request for {url} failed with status {response.status_code}",
+                    status_code=response.status_code,
+                )
+                # Client errors (bad token, bad URL) will not fix themselves
+                if 400 <= response.status_code < 500 and response.status_code != 429:
+                    break
+            if attempt < self.retries:
+                time.sleep(2 * (attempt + 1))
+        assert last_error is not None
+        raise last_error
+
+    def get_subcategory(self, url: str) -> List[dict]:
+        """Every product card on one subcategory page (at most 32 on Zepto's web pages)."""
+        return parse_listing(self.fetch(url))
+
+    def get_category(self, start_url: str, max_subcategories: int = 20) -> List[dict]:
+        """Walk the start subcategory and its siblings; one row per unique product."""
+        first = self.fetch(start_url)
+        rows = {}
+        for path in subcategory_paths(first, start_url)[:max_subcategories]:
+            html = first if path in start_url else self.fetch(ZEPTO + path)
+            for row in parse_listing(html):
+                rows.setdefault(row["variant_id"], row)
+        return list(rows.values())
+
+    def get_product(self, url: str) -> dict:
+        """Catalog sheet for one product page (seller, shelf life, FSSAI licence...)."""
+        return parse_product(self.fetch(url), url)

zepto_scraper-0.1.0/src/zepto_scraper/parser.py

@@ -0,0 +1,182 @@
+"""Parse Zepto category and product pages.
+
+Zepto runs on the Next.js App Router. Every product card on a subcategory page
+is streamed into the HTML as React Server Components payload, a series of
+``self.__next_f.push([1, "..."])`` script chunks. Product pages carry the same
+stream plus a schema.org ``Product`` block in JSON-LD.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from typing import Dict, List, Optional
+
+ZEPTO = "https://www.zepto.com"
+
+PUSH_RE = re.compile(r'self\.__next_f\.push\(\[1,"((?:[^"\\]|\\.)*)"\]\)')
+# Card keys are sorted alphabetically. In-stock cards start with availableQuantity;
+# out-of-stock cards drop that key and start with baseProductId.
+ITEM_START_RE = re.compile(r'\{"(?:availableQuantity|baseProductId)":')
+PRODUCT_URL_RE = re.compile(r"https://www\.zepto\.com/pn/[a-z0-9-]+/pvid/[0-9a-f-]{36}")
+STORE_RE = re.compile(r'"storeServiceableResponse":\{[^}]*?"storeId":"([0-9a-f-]{36})"')
+LD_RE = re.compile(r'<script[^>]*type="application/ld\+json"[^>]*>(.*?)</script>', re.S)
+
+LISTING_FIELDS = [
+    "variant_id", "name", "brand", "pack_size", "price_inr", "mrp_inr", "discount_pct",
+    "in_stock", "available_qty", "rating", "rating_count", "subcategory", "store_id", "url",
+]
+PRODUCT_FIELDS = [
+    "variant_id", "name", "brand", "category", "pack_size", "mrp_inr", "max_per_order",
+    "rating", "rating_count", "shelf_life", "country_of_origin", "seller", "fssai_licence",
+    "image_count", "description", "url",
+]
+
+_decoder = json.JSONDecoder()
+
+
+def decode_rsc(html: str) -> str:
+    """Join the Next.js stream chunks back into one text.
+
+    Each chunk is a JavaScript string literal; JSON strings use the same escaping,
+    so ``json.loads('"' + chunk + '"')`` gives back the original text.
+    """
+    return "".join(json.loads('"' + chunk + '"') for chunk in PUSH_RE.findall(html))
+
+
+def rupees(paise) -> object:
+    """Zepto stores every price in paise: 1900 means Rs 19."""
+    return paise / 100 if isinstance(paise, (int, float)) and not isinstance(paise, bool) else ""
+
+
+def extract_items(flat: str) -> List[dict]:
+    """Return every product card in a decoded stream, in-stock and out-of-stock."""
+    items: Dict[str, dict] = {}
+    for match in ITEM_START_RE.finditer(flat):
+        try:
+            obj, _ = _decoder.raw_decode(flat, match.start())
+        except json.JSONDecodeError:
+            continue
+        variant = obj.get("productVariant") or {}
+        # Look-alike objects elsewhere in the stream have no product block
+        if variant.get("id") and obj.get("product"):
+            items.setdefault(variant["id"], obj)
+    return list(items.values())
+
+
+def product_urls(flat: str) -> Dict[str, str]:
+    """The page's own product links, keyed by variant id."""
+    return {link.rsplit("/", 1)[1]: link for link in PRODUCT_URL_RE.findall(flat)}
+
+
+def store_id(flat: str) -> str:
+    match = STORE_RE.search(flat)
+    return match.group(1) if match else ""
+
+
+def to_row(item: dict, store: str, urls: Dict[str, str]) -> dict:
+    product = item.get("product") or {}
+    variant = item.get("productVariant") or {}
+    rating = variant.get("ratingSummary") or {}
+    return {
+        "variant_id": variant.get("id", ""),
+        "name": product.get("name", ""),
+        "brand": product.get("brand", ""),
+        "pack_size": variant.get("formattedPacksize", ""),
+        "price_inr": rupees(item.get("discountedSellingPrice")),
+        "mrp_inr": rupees(item.get("mrp")),
+        "discount_pct": item.get("discountPercent", 0),
+        "in_stock": not item.get("outOfStock", False),
+        "available_qty": item.get("availableQuantity", 0),
+        "rating": rating.get("averageRating", ""),
+        "rating_count": rating.get("totalRatings", ""),
+        "subcategory": item.get("primarySubcategoryName", ""),
+        "store_id": store,
+        "url": urls.get(variant.get("id", ""), ""),
+    }
+
+
+def parse_listing(html: str) -> List[dict]:
+    """Every product card on one subcategory page, as flat rows."""
+    flat = decode_rsc(html)
+    store = store_id(flat)
+    urls = product_urls(flat)
+    return [to_row(item, store, urls) for item in extract_items(flat)]
+
+
+def subcategory_paths(html: str, start_url: str) -> List[str]:
+    """The start subcategory plus its siblings, as site paths, deduped on scid.
+
+    The same subcategory can appear under a second category slug that renders no
+    products, so only paths under the start URL's own category slug are kept.
+    """
+    cid_match = re.search(r"/cid/([0-9a-f-]{36})", start_url)
+    if not cid_match or "/cn/" not in start_url:
+        raise ValueError("Start from a Zepto subcategory URL (.../cn/<category>/<subcategory>/cid/.../scid/...)")
+    cid = cid_match.group(1)
+    sub_re = re.compile(r"/cn/[a-z0-9-]+/[a-z0-9-]+/cid/" + cid + r"/scid/[0-9a-f-]{36}")
+    category_slug = start_url.split("/cn/")[1].split("/")[0]
+    start_path = "/cn/" + start_url.split("/cn/", 1)[1].split("?")[0]
+    found: Dict[str, str] = {}
+    for path in [start_path] + sub_re.findall(decode_rsc(html)):
+        if path.split("/")[2] == category_slug:
+            found.setdefault(path.rsplit("/", 1)[1], path)
+    return list(found.values())
+
+
+def product_jsonld(html: str) -> dict:
+    """The schema.org Product block (the page has several JSON-LD blocks)."""
+    for block in LD_RE.findall(html):
+        try:
+            data = json.loads(block)
+        except json.JSONDecodeError:
+            continue
+        if isinstance(data, dict) and data.get("@type") == "Product":
+            return data
+    return {}
+
+
+def variant_data(flat: str, variant_id: str) -> dict:
+    """productVariant carries the printed MRP and order limit for this pack size."""
+    for match in re.finditer(r'"productVariant":\{', flat):
+        try:
+            obj, _ = _decoder.raw_decode(flat, match.end() - 1)
+        except json.JSONDecodeError:
+            continue
+        if obj.get("id") == variant_id:
+            return obj
+    return {}
+
+
+def parse_product(html: str, url: str) -> dict:
+    """Catalog sheet for one product page.
+
+    Price and stock are left out on purpose: the product page caps the stock
+    count and can lag the listing. Use the listing for those.
+    """
+    ld = product_jsonld(html)
+    if not ld:
+        raise ValueError("No Product JSON-LD on the page; it is probably not a Zepto product page")
+    variant_id = url.rstrip("/").rsplit("/", 1)[1]
+    variant = variant_data(decode_rsc(html), variant_id)
+    rating = ld.get("aggregateRating") or {}
+    props = {p.get("name"): p.get("value") for p in ld.get("additionalProperty", []) if isinstance(p, dict)}
+    images = ld.get("image") or []
+    return {
+        "variant_id": variant_id,
+        "name": ld.get("name", ""),
+        "brand": (ld.get("brand") or {}).get("name", "") if isinstance(ld.get("brand"), dict) else ld.get("brand", ""),
+        "category": ld.get("category", ""),
+        "pack_size": ld.get("size", ""),
+        "mrp_inr": rupees(variant.get("mrp")),
+        "max_per_order": variant.get("maxAllowedQuantity", ""),
+        "rating": rating.get("ratingValue", ""),
+        "rating_count": rating.get("ratingCount", ""),
+        "shelf_life": props.get("Shelf life", ""),
+        "country_of_origin": props.get("Country of origin", ""),
+        "seller": props.get("Seller", ""),
+        "fssai_licence": props.get("FSSAI licence number", ""),
+        "image_count": len(images) if isinstance(images, list) else 1,
+        "description": ld.get("description", ""),
+        "url": url,
+    }

zepto_scraper-0.1.0/src/zepto_scraper.egg-info/PKG-INFO

@@ -0,0 +1,154 @@
+Metadata-Version: 2.4
+Name: zepto-scraper
+Version: 0.1.0
+Summary: Scrape Zepto category listings (price, MRP, discount, stock) and product details (seller, shelf life, FSSAI licence) with Python.
+Author: Buğrahan Saka
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/bugrahansss/zepto-scraper
+Project-URL: Source, https://github.com/bugrahansss/zepto-scraper
+Project-URL: Issues, https://github.com/bugrahansss/zepto-scraper/issues
+Project-URL: Scrape.do, https://scrape.do/?utm_source=pypi&utm_medium=package&utm_campaign=zepto-scraper
+Keywords: zepto,web scraping,quick commerce,grocery,scraper,nextjs,india
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Internet :: WWW/HTTP :: Indexing/Search
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.25
+Dynamic: license-file
+
+# zepto-scraper
+
+[![PyPI](https://img.shields.io/pypi/v/zepto-scraper)](https://pypi.org/project/zepto-scraper/)
+[![Python](https://img.shields.io/pypi/pyversions/zepto-scraper)](https://pypi.org/project/zepto-scraper/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+
+A Python scraper for [Zepto](https://www.zepto.com), India's quick-commerce grocery app. Two jobs:
+
+- **Category listings:** start from one subcategory URL, walk its sibling subcategories and get every product card with price, MRP, discount, in-stock flag, **units in stock**, rating and the dark store it came from.
+- **Product details:** turn product pages into a catalog sheet with seller entity, shelf life, FSSAI licence number, country of origin, category path, order limit and the full description.
+
+Output as Python dicts, JSON or CSV. One dependency (`requests`), no browser.
+
+```bash
+pip install zepto-scraper
+```
+
+## Why a plain request fails
+
+Zepto sits behind AWS WAF on CloudFront:
+
+| Request | Status | Body |
+| --- | --- | --- |
+| `requests`, default user agent | 429 | 0 bytes |
+| `requests`, Chrome user agent | 202, `x-amzn-waf-action: challenge` | 0 bytes |
+| Through Scrape.do, no parameters | 200 | full page |
+
+**Watch the 202.** It means "Accepted", so `raise_for_status()` treats it as success and a scraper that only checks for errors writes empty pages without a single failure. This package treats anything but a 200 as an error.
+
+Pages are fetched through the [Scrape.do](https://scrape.do/?utm_source=github&utm_medium=readme&utm_campaign=zepto-scraper) API with a plain request: no `render`, no `super`, no `geoCode`, 1 credit per page. You need a Scrape.do API token; the free plan includes 1,000 credits a month.
+
+## Quick start
+
+```python
+from zepto_scraper import ZeptoScraper
+
+scraper = ZeptoScraper(token="YOUR_SCRAPEDO_TOKEN")  # or set SCRAPEDO_TOKEN
+
+# Any subcategory URL; the scraper walks its siblings in the same category
+rows = scraper.get_category(
+    "https://www.zepto.com/cn/munchies/chips-crisps/cid/d2c2a144-43cd-43e5-b308-92628fa68596/scid/df4f5100-c02f-4906-83b8-ddb744081a7a"
+)
+for row in rows[:3]:
+    print(row["name"], row["price_inr"], row["mrp_inr"], row["in_stock"], row["available_qty"])
+
+product = scraper.get_product(rows[0]["url"])
+print(product["seller"], product["shelf_life"], product["fssai_licence"])
+```
+
+Start from a **subcategory** URL (`/cn/<category>/<subcategory>/cid/.../scid/...`). The category link on Zepto's homepage is not a listing.
+
+### Command line
+
+```bash
+export SCRAPEDO_TOKEN=your_token
+
+# every product in a category, CSV
+zepto-scraper category "<subcategory-url>" -f csv -o zepto-category.csv
+
+# catalog sheet for the first 10 products from that file
+zepto-scraper product -i zepto-category.csv --limit 10 -f csv -o zepto-products.csv
+```
+
+The two commands chain: `product` reads the `url` column of the listing CSV.
+
+### Output
+
+Listing row (from the fictional test page in [`tests/fixtures`](tests/fixtures/subcategory_page.html)):
+
+```json
+{
+  "variant_id": "44444444-4444-4444-8444-444444444440",
+  "name": "Example Chilli Chips",
+  "brand": "Examplo",
+  "pack_size": "1 pack (41 g)",
+  "price_inr": 19.0,
+  "mrp_inr": 20.0,
+  "discount_pct": 5,
+  "in_stock": true,
+  "available_qty": 30,
+  "rating": 4.9,
+  "rating_count": 401062,
+  "subcategory": "Chips & Crisps",
+  "store_id": "33333333-3333-4333-8333-333333333333",
+  "url": "https://www.zepto.com/pn/example-snack-0/pvid/44444444-4444-4444-8444-444444444440"
+}
+```
+
+Product sheet columns: `variant_id, name, brand, category, pack_size, mrp_inr, max_per_order, rating, rating_count, shelf_life, country_of_origin, seller, fssai_licence, image_count, description, url`.
+
+## How it works
+
+**The Next.js stream.** Zepto runs on the Next.js App Router. A subcategory page makes no separate product API call; every product card is streamed into the HTML as `self.__next_f.push([1, "..."])` chunks. Each chunk is a JavaScript string literal, and JSON strings use the same escaping, so `json.loads('"' + chunk + '"')` decodes it. Joined, the chunks are one text with one JSON object per product card.
+
+**Out-of-stock cards.** Card keys are sorted alphabetically. In-stock cards start with `availableQuantity`; out-of-stock cards drop that key and start with `baseProductId`. A parser that anchors only on `availableQuantity` silently skips every out-of-stock product. This one anchors on both, reads each object with `json.JSONDecoder.raw_decode`, and dedupes on the variant id.
+
+**Prices are in paise.** `"discountedSellingPrice": 1900` is ₹19. The scraper divides by 100.
+
+**Siblings.** Every subcategory page links its siblings, all sharing the category `cid`. The same subcategory can appear under a second category slug that renders no products, so only paths under the start URL's own slug are kept.
+
+**Product pages.** The catalog fields come from the schema.org `Product` JSON-LD block (Zepto writes `id` before `type` on the script tag, so the regex does not depend on attribute order). MRP and the order limit come from the stream's `productVariant` object for the exact variant in the URL.
+
+## Limits
+
+- **32 products per subcategory.** Zepto's web pages stop at 32 cards (`endOfPage: true`) and ignore `?page=2`. For wider coverage, walk more subcategories and categories.
+- **One dark store.** Each price and stock count belongs to one dark store. With no location, Zepto serves its default store (east Bengaluru); the `store_id` column records which one. Changing the location through Scrape.do did not move the store in our tests.
+- **Use the listing for price and stock.** Product pages cap the stock count and can lag the listing, so `get_product()` leaves price and stock out on purpose.
+- **No search.** Search results need a browser-computed `request-signature` header, and robots.txt disallows `/search`. Walk categories instead.
+- **Errors.** Non-200 responses (including the 202 challenge) raise `ScrapeError` with the status code. Server errors and 429s are retried twice; client errors are not.
+
+## Responsible use
+
+The scraper reads category (`/cn/`) and product (`/pn/`) pages, which Zepto's robots.txt allows; it does not touch `/search`, `/api/`, cart or account paths. Product data is not personal data. Read Zepto's terms for your use case and keep request rates modest. This is not legal advice.
+
+## Development
+
+```bash
+git clone https://github.com/bugrahansss/zepto-scraper
+cd zepto-scraper
+pip install -e .
+python -m unittest discover -s tests -v
+```
+
+The tests run offline against fictional fixture pages.
+
+## License
+
+MIT
+
+---
+
+Built and tested with [Scrape.do](https://scrape.do/?utm_source=github&utm_medium=readme&utm_campaign=zepto-scraper), October 2026.

zepto_scraper-0.1.0/src/zepto_scraper.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+examples/category_to_products.py
+src/zepto_scraper/__init__.py
+src/zepto_scraper/cli.py
+src/zepto_scraper/client.py
+src/zepto_scraper/parser.py
+src/zepto_scraper.egg-info/PKG-INFO
+src/zepto_scraper.egg-info/SOURCES.txt
+src/zepto_scraper.egg-info/dependency_links.txt
+src/zepto_scraper.egg-info/entry_points.txt
+src/zepto_scraper.egg-info/requires.txt
+src/zepto_scraper.egg-info/top_level.txt
+tests/test_parser.py
+tests/fixtures/product_page.html
+tests/fixtures/subcategory_page.html

zepto_scraper-0.1.0/src/zepto_scraper.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

zepto_scraper-0.1.0/src/zepto_scraper.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+zepto-scraper = zepto_scraper.cli:main

zepto_scraper-0.1.0/src/zepto_scraper.egg-info/requires.txt

@@ -0,0 +1 @@
+requests>=2.25

zepto_scraper-0.1.0/src/zepto_scraper.egg-info/top_level.txt

@@ -0,0 +1 @@
+zepto_scraper

zepto_scraper-0.1.0/tests/fixtures/product_page.html

@@ -0,0 +1 @@
+<!doctype html><html><head><title>Example</title><script type="application/ld+json">{"@type":"Organization","name":"Example"}</script><script id="productSchema" type="application/ld+json">{"@context": "https://schema.org", "@type": "Product", "name": "Example Chilli Chips", "brand": {"@type": "Brand", "name": "Examplo"}, "category": "Munchies > Chips & Crisps", "size": "1 pack (41 g)", "description": "Fictional chips for tests. Ingredients: potato, oil, salt.", "image": ["https://example.com/1.jpg", "https://example.com/2.jpg", "https://example.com/3.jpg"], "aggregateRating": {"@type": "AggregateRating", "ratingValue": 4.9, "ratingCount": 401062}, "additionalProperty": [{"@type": "PropertyValue", "name": "Shelf life", "value": "180 days"}, {"@type": "PropertyValue", "name": "Country of origin", "value": "India"}, {"@type": "PropertyValue", "name": "Seller", "value": "Example Groceries Private Limited"}, {"@type": "PropertyValue", "name": "FSSAI licence number", "value": "10000000000001"}]}</script></head><body><script>self.__next_f.push([1,"1:{\"productVariant\":{\"id\":\"44444444-4444-4444-8444-444444444441\",\"mrp\":2500,\"maxAllowedQuantity\":5}}\n"])</script><script>self.__next_f.push([1,"2:{\"storeProduct\":{\"availableQuantity\":3,\"productVariant\":{\"formattedPacksize\":\"1 pack (41 g)\",\"id\":\"44444444-4444-4444-8444-444444444440\",\"maxAllowedQuantity\":30,\"mrp\":2000}}}\n"])</script></body></html>

zepto_scraper-0.1.0/tests/fixtures/subcategory_page.html

@@ -0,0 +1 @@
+<!doctype html><html><head><title>Example</title></head><body><script>self.__next_f.push([1,"1:[\"$\",\"div\",null,{\"children\":\"layout\"}]\n"])</script><script>self.__next_f.push([1,"2:{\"storeServiceableResponse\":{\"serviceable\":true,\"storeId\":\"33333333-3333-4333-8333-333333333333\"}}\n\"/cn/munchies/chips-crisps/cid/11111111-1111-4111-8111-111111111111/scid/22222222-2222-4222-8222-222222222220\" \"/cn/munchies/namkeens/cid/11111111-1111-4111-8111-111111111111/scid/22222222-2222-4222-8222-222222222221\" \"/cn/snacks/top-picks/cid/11111111-1111-4111-8111-111111111111/scid/22222222-2222-4222-8222-222222222222\" \"/cn/munchies/top-picks/cid/11111111-1111-4111-8111-111111111111/scid/22222222-2222-4222-8222-222222222222\"\n"])</script><script>self.__next_f.push([1,"3:[{\"availableQuantity\":30,\"baseProductId\":\"b-4440\",\"discountPercent\":5,\"discountedSellingPrice\":1900,\"mrp\":2000,\"primarySubcategoryName\":\"Chips & Crisps\",\"product\":{\"brand\":\"Examplo\",\"name\":\"Example Chilli Chips\"},\"productVariant\":{\"formattedPacksize\":\"1 pack (41 g)\",\"id\":\"44444444-4444-4444-8444-444444444440\",\"ratingSummary\":{\"averageRating\":4.9,\"totalRatings\":401062}}},"])</script><script>self.__next_f.push([1,"{\"availableQuantity\":115,\"baseProductId\":\"b-4441\",\"discountPercent\":16,\"discountedSellingPrice\":2100,\"mrp\":2500,\"primarySubcategoryName\":\"Chips & Crisps\",\"product\":{\"brand\":\"Examplo\",\"name\":\"Example Cream & Onion Chips\"},\"productVariant\":{\"formattedPacksize\":\"1 pack (50 g)\",\"id\":\"44444444-4444-4444-8444-444444444441\",\"ratingSummary\":{\"averageRating\":4.5,\"totalRatings\":1200}}},{\"baseProductId\":\"b-4442\",\"discountPercent\":10,\"discountedSellingPrice\":4500,\"mrp\":5000,\"outOfStock\":true,\"primarySubcategoryName\":\"Chips & Crisps\",\"product\":{\"brand\":\"Snackly\",\"name\":\"Example Salted Chips\"},\"productVariant\":{\"formattedPacksize\":\"1 pack (90 g)\",\"id\":\"44444444-4444-4444-8444-444444444442\",\"ratingSummary\":{\"averageRating\":4.5,\"totalRatings\":1200}}},{\"availableQuantity\":9,\"productVariant\":{\"id\":\"44444444-4444-4444-8444-444444444443\"}}]\n\"https://www.zepto.com/pn/example-snack-0/pvid/44444444-4444-4444-8444-444444444440\" \"https://www.zepto.com/pn/example-snack-1/pvid/44444444-4444-4444-8444-444444444441\" \"https://www.zepto.com/pn/example-snack-2/pvid/44444444-4444-4444-8444-444444444442\"\n4:{\"endOfPage\":true}\n"])</script></body></html>

zepto_scraper-0.1.0/tests/test_parser.py

@@ -0,0 +1,136 @@
+import unittest
+from pathlib import Path
+from unittest import mock
+
+from zepto_scraper import (
+    LISTING_FIELDS, PRODUCT_FIELDS, ScrapeError, ZeptoScraper,
+    decode_rsc, extract_items, parse_listing, parse_product, subcategory_paths,
+)
+from zepto_scraper import cli
+
+FIX = Path(__file__).parent / "fixtures"
+LISTING = (FIX / "subcategory_page.html").read_text(encoding="utf-8")
+PRODUCT = (FIX / "product_page.html").read_text(encoding="utf-8")
+CID = "11111111-1111-4111-8111-111111111111"
+START = f"https://www.zepto.com/cn/munchies/chips-crisps/cid/{CID}/scid/22222222-2222-4222-8222-222222222220"
+V0 = "44444444-4444-4444-8444-444444444440"
+PRODUCT_URL = f"https://www.zepto.com/pn/example-snack-0/pvid/{V0}"
+
+
+class FakeResponse:
+    def __init__(self, status, text=""):
+        self.status_code, self.text = status, text
+
+
+class ListingTests(unittest.TestCase):
+    def test_decode_joins_chunks(self):
+        flat = decode_rsc(LISTING)
+        self.assertIn('"endOfPage":true', flat)
+        self.assertIn("storeServiceableResponse", flat)
+
+    def test_out_of_stock_cards_are_kept(self):
+        items = extract_items(decode_rsc(LISTING))
+        self.assertEqual(len(items), 3)  # 2 in stock + 1 out of stock, look-alike skipped
+        self.assertEqual(sum(1 for i in items if i.get("outOfStock")), 1)
+
+    def test_prices_are_converted_from_paise(self):
+        row = next(r for r in parse_listing(LISTING) if r["variant_id"] == V0)
+        self.assertEqual((row["price_inr"], row["mrp_inr"], row["discount_pct"]), (19.0, 20.0, 5))
+
+    def test_row_fields(self):
+        row = next(r for r in parse_listing(LISTING) if r["variant_id"] == V0)
+        self.assertEqual(list(row), LISTING_FIELDS)
+        self.assertEqual(row["available_qty"], 30)
+        self.assertEqual((row["rating"], row["rating_count"]), (4.9, 401062))
+        self.assertEqual(row["store_id"], "33333333-3333-4333-8333-333333333333")
+        self.assertEqual(row["url"], PRODUCT_URL)
+
+    def test_out_of_stock_row(self):
+        row = next(r for r in parse_listing(LISTING) if r["name"] == "Example Salted Chips")
+        self.assertFalse(row["in_stock"])
+        self.assertEqual(row["available_qty"], 0)
+
+    def test_subcategories_dedupe_and_skip_second_slug(self):
+        paths = subcategory_paths(LISTING, START)
+        self.assertEqual(len(paths), 3)
+        self.assertTrue(all(p.startswith("/cn/munchies/") for p in paths))
+        self.assertEqual(paths[0], START.split("zepto.com")[1])
+
+    def test_subcategories_need_a_subcategory_url(self):
+        with self.assertRaises(ValueError):
+            subcategory_paths(LISTING, "https://www.zepto.com/pn/x/pvid/y")
+
+
+class ProductTests(unittest.TestCase):
+    def test_product_sheet(self):
+        row = parse_product(PRODUCT, PRODUCT_URL)
+        self.assertEqual(list(row), PRODUCT_FIELDS)
+        self.assertEqual(row["name"], "Example Chilli Chips")
+        self.assertEqual(row["brand"], "Examplo")
+        self.assertEqual(row["seller"], "Example Groceries Private Limited")
+        self.assertEqual(row["shelf_life"], "180 days")
+        self.assertEqual(row["fssai_licence"], "10000000000001")
+        self.assertEqual(row["image_count"], 3)
+
+    def test_mrp_and_limit_come_from_the_matching_variant(self):
+        row = parse_product(PRODUCT, PRODUCT_URL)
+        self.assertEqual((row["mrp_inr"], row["max_per_order"]), (20.0, 30))
+
+    def test_jsonld_with_id_before_type_is_found(self):
+        self.assertIn('id="productSchema" type="application/ld+json"', PRODUCT)
+        self.assertEqual(parse_product(PRODUCT, PRODUCT_URL)["category"], "Munchies > Chips & Crisps")
+
+    def test_non_product_page_raises(self):
+        with self.assertRaises(ValueError):
+            parse_product(LISTING, PRODUCT_URL)
+
+
+class ClientTests(unittest.TestCase):
+    def scraper(self, *responses):
+        session = mock.Mock()
+        session.get.side_effect = list(responses)
+        return ZeptoScraper(token="t", session=session, retries=1), session
+
+    def test_202_challenge_is_an_error(self):
+        s, _ = self.scraper(FakeResponse(202), FakeResponse(202))
+        with mock.patch("time.sleep"), self.assertRaises(ScrapeError) as ctx:
+            s.fetch(START)
+        self.assertEqual(ctx.exception.status_code, 202)
+
+    def test_client_error_is_not_retried(self):
+        s, session = self.scraper(FakeResponse(401))
+        with self.assertRaises(ScrapeError):
+            s.fetch(START)
+        self.assertEqual(session.get.call_count, 1)
+
+    def test_plain_request_no_extra_parameters(self):
+        s, session = self.scraper(FakeResponse(200, LISTING))
+        s.fetch(START)
+        self.assertEqual(session.get.call_args.kwargs["params"], {"token": "t", "url": START})
+
+    def test_category_walk_dedupes(self):
+        s, session = self.scraper(*[FakeResponse(200, LISTING)] * 3)
+        rows = s.get_category(START)
+        self.assertEqual(len(rows), 3)
+        self.assertEqual(session.get.call_count, 3)  # start page reused, two siblings fetched
+
+    def test_token_required(self):
+        with mock.patch.dict("os.environ", {}, clear=True), self.assertRaises(ValueError):
+            ZeptoScraper()
+
+
+class CliTests(unittest.TestCase):
+    def test_product_csv_input(self):
+        import tempfile, os, csv
+        with tempfile.TemporaryDirectory() as d:
+            inp, out = os.path.join(d, "in.csv"), os.path.join(d, "out.csv")
+            with open(inp, "w", newline="") as f:
+                w = csv.DictWriter(f, fieldnames=["url"]); w.writeheader(); w.writerow({"url": PRODUCT_URL})
+            with mock.patch.object(ZeptoScraper, "fetch", return_value=PRODUCT):
+                code = cli.main(["product", "-t", "x", "-i", inp, "-f", "csv", "-o", out])
+            self.assertEqual(code, 0)
+            self.assertIn("Example Groceries", open(out).read())
+
+
+if __name__ == "__main__":
+    unittest.main()