| | --- |
| | license: mit |
| | --- |
| | |
| | ## FalconNet/FunPay-Minecraft-Lots-Mini-6k |
| | - 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]) |
| | ``` |
