|
|
--- |
|
|
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]) |
|
|
``` |
