Update README.md

README.md

@@ -3,4 +3,222 @@ license: mit
 ---
 
 ## FalconNet/FunPay-Minecraft-Lots-Mini-6k
-- Prices are in Rubles
+- Prices are in Rubles
+
+
+### Script used to create this:
+```python
+from __future__ import annotations
+
+import argparse
+import asyncio
+import csv
+import json
+import re
+from dataclasses import dataclass, asdict
+from pathlib import Path
+from typing import List, Optional
+
+from bs4 import BeautifulSoup
+from playwright.async_api import async_playwright, TimeoutError as PlaywrightTimeout
+
+
+@dataclass
+class Lot:
+    """Represents a single offer on FunPay."""
+
+    lot_id: int
+    server: str
+    title: str
+    category: str
+    seller: str
+    reviews: int
+    price: float
+    currency: str
+    link: str
+
+
+class FunpayParser:
+    """High-level API for scraping the public FunPay catalog."""
+
+    BASE_URL = "https://funpay.com"
+
+    def __init__(
+        self,
+        language: str = "ru",
+        currency: str = "RUB",
+        headless: bool = False,
+        timeout: int = 10_000,
+    ) -> None:
+        self.language = language
+        self.currency = currency
+        self.headless = headless
+        self.timeout = timeout
+
+    # ─────────────────────────── internal helpers ──────────────────────────── #
+
+    async def _fetch_html(self, url: str) -> str:
+        """Render *url* with Playwright and return the final HTML source."""
+        async with async_playwright() as p:
+            browser = await p.chromium.launch(headless=self.headless)
+            context = await browser.new_context(
+                locale=self.language,
+                extra_http_headers={
+                    "Accept-Language": self.language,
+                    "User-Agent": (
+                        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+                        "AppleWebKit/537.36 (KHTML, like Gecko) "
+                        "Chrome/124.0.0.0 Safari/537.36"
+                    ),
+                },
+            )
+            # Pre-set currency so the prices are parsed consistently
+            await context.add_cookies(
+                [
+                    {
+                        "name": "cy",
+                        "value": self.currency,
+                        "domain": "funpay.com",
+                        "path": "/",
+                    }
+                ]
+            )
+
+            page = await context.new_page()
+            try:
+                # Navigate and wait for the full page load, including JS content
+                await page.goto(url, wait_until="load", timeout=self.timeout)
+
+                # Явное ожидание появления важного элемента (например, списка лотов)
+                await page.wait_for_selector(".tc-item", timeout=10_000)  # Ждем появления первого лота
+
+            except PlaywrightTimeout:
+                await browser.close()
+                raise RuntimeError(f"Page load timeout: {url}")
+
+            # Accept cookies banner if present
+            try:
+                await page.locator("button:has-text('Agree')").click(timeout=2_000)
+            except PlaywrightTimeout:
+                pass  # banner not shown
+
+            html = await page.content()
+            await browser.close()
+            return html
+
+    def _parse_html(self, html: str) -> List[Lot]:
+        """Extract structured data from the rendered HTML using BeautifulSoup."""
+        soup = BeautifulSoup(html, "lxml")
+        lots: List[Lot] = []
+
+        for anchor in soup.select("a.tc-item"):
+            link = self.BASE_URL + anchor.get("href", "")
+
+            # Server / sub-category (can be empty)
+            server_el = anchor.select_one(".tc-server")
+            server = server_el.get_text(strip=True) if server_el else ""
+
+            # Title / description
+            title_el = anchor.select_one(".tc-desc") or anchor.select_one(".tc-title")
+            title = title_el.get_text(strip=True) if title_el else ""
+
+            # Small badge with an additional category mark
+            badge_el = anchor.select_one(".badge")
+            category = badge_el.get_text(strip=True) if badge_el else ""
+
+            # Seller block
+            seller_el = anchor.select_one(".media-user-name")
+            seller = seller_el.get_text(strip=True) if seller_el else ""
+            # Reviews are rendered as “(1234)”
+            rev_el = anchor.select_one(".rating-count")
+            reviews = int(rev_el.get_text(strip=True).strip("()")) if rev_el else 0
+
+            # Price block
+            price_el = anchor.select_one(".tc-price")
+            price_val, price_curr = 0.0, self.currency
+            if price_el:
+                match = re.match(r"([\d\.,]+)\s*([^\d\s]+)", price_el.get_text(strip=True))
+                if match:
+                    raw, price_curr = match.groups()
+                    price_val = float(raw.replace(",", "."))
+
+            # Lot ID is available only in the lot link
+            match_id = re.search(r"id=(\d+)", link)
+            lot_id = int(match_id.group(1)) if match_id else 0
+
+            lots.append(
+                Lot(
+                    lot_id=lot_id,
+                    server=server,
+                    title=title,
+                    category=category,
+                    seller=seller,
+                    reviews=reviews,
+                    price=price_val,
+                    currency=price_curr,
+                    link=link,
+                )
+            )
+        return lots
+
+    async def _collect_lots(self, section_id: int, pages: int) -> List[Lot]:
+        """Coroutine that loads *pages* pages for *section_id* sequentially."""
+        result: List[Lot] = []
+        for idx in range(1, pages + 1):
+            url = f"{self.BASE_URL}/{self.language}/lots/{section_id}/?page={idx}"
+            html = await self._fetch_html(url)
+            page_lots = self._parse_html(html)
+            if not page_lots:
+                break  # reached last page
+            result.extend(page_lots)
+        return result
+
+    # ───────────────────────────── public API ──────────────────────────────── #
+
+    def parse(self, section_id: int, pages: int = 1) -> List[Lot]:
+        """Synchronously scrape *pages* from a lots section."""
+        return asyncio.run(self._collect_lots(section_id, pages))
+
+
+# I/O helpers remain unchanged
+
+def save_json(lots: List[Lot], path: Path) -> None:
+    path.write_text(json.dumps([asdict(x) for x in lots], ensure_ascii=False, indent=2), "utf-8")
+
+def save_csv(lots: List[Lot], path: Path) -> None:
+    if not lots:
+        return
+    with path.open("w", newline="", encoding="utf-8") as f:
+        writer = csv.DictWriter(f, fieldnames=asdict(lots[0]).keys())
+        writer.writeheader()
+        for row in lots:
+            writer.writerow(asdict(row))
+
+
+# CLI entry unchanged
+if __name__ == "__main__":
+    def _cli() -> None:
+        parser = argparse.ArgumentParser(description="Scrape FunPay lots into JSON/CSV files")
+        parser.add_argument("section", type=int, help="Section numeric ID (e.g. 223 for Minecraft Services)")
+        parser.add_argument("--pages", type=int, default=1, help="Number of paginated screens to scan")
+        parser.add_argument("--out", type=Path, help="Output file (.json or .csv)")
+        parser.add_argument("--headed", action="store_true", help="Run browser in headed mode (for debugging)")
+
+        args = parser.parse_args()
+
+        funpay = FunpayParser(headless=not args.headed)
+        lots = funpay.parse(args.section, pages=args.pages)
+        print(f"Collected {len(lots)} lots from section #{args.section}")
+
+        if args.out:
+            if args.out.suffix == ".json":
+                save_json(lots, args.out)
+            elif args.out.suffix == ".csv":
+                save_csv(lots, args.out)
+            else:
+                raise SystemExit("Supported output formats: .json / .csv")
+            print(f"Saved to {args.out.resolve()}")
+        else:
+            from pprint import pprint
+            pprint(lots[:10])
+```