用 fontTools 拆掉大众点评的字体反爬，评分数字才不会再错位

import asyncio
import logging
import random
import time
from dataclasses import dataclass
from typing import Optional

import httpx

logger = logging.getLogger(__name__)


@dataclass
class ProxyNode:
    """代理节点，带健康度用于调度时剔除。"""
    url: str
    failures: int = 0
    last_used: float = 0.0

    @property
    def healthy(self) -> bool:
        return self.failures < 3


class ProxyPool:
    """亿牛云短效动态 IP 池的本地封装：预热、加权选取、失败剔除。"""

    def __init__(self, api_url: str, refill_threshold: int = 5) -> None:
        self._api_url = api_url
        self._nodes: list[ProxyNode] = []
        self._refill_threshold = refill_threshold
        self._lock = asyncio.Lock()

    async def acquire(self) -> ProxyNode:
        async with self._lock:
            if len(self._nodes) < self._refill_threshold:
                await self._refill()
            node = self._select()
            node.last_used = time.monotonic()
            return node

    async def _refill(self) -> None:
        # 调用亿牛云取 IP 接口，这里只示意返回结构
        async with httpx.AsyncClient() as client:
            resp = await client.get(self._api_url, timeout=5.0)
            for ip in resp.json().get("proxies", []):
                self._nodes.append(ProxyNode(url=ip))

    def _select(self) -> ProxyNode:
        healthy = [n for n in self._nodes if n.healthy]
        return random.choice(healthy) if healthy else self._nodes[0]

    def report_failure(self, node: ProxyNode) -> None:
        node.failures += 1
        if not node.healthy:
            self._nodes.remove(node)


class TokenBucket:
    """异步令牌桶，控制全局 QPS，比固定 sleep 更接近真实流量形态。"""

    def __init__(self, rate: float, capacity: float) -> None:
        self._rate = rate
        self._capacity = capacity
        self._tokens = capacity
        self._updated = time.monotonic()
        self._lock = asyncio.Lock()

    async def acquire(self) -> None:
        async with self._lock:
            now = time.monotonic()
            self._tokens = min(self._capacity, self._tokens + (now - self._updated) * self._rate)
            self._updated = now
            if self._tokens < 1:
                await asyncio.sleep((1 - self._tokens) / self._rate)
                self._tokens = 0
            else:
                self._tokens -= 1

from fontTools.ttLib import TTFont


class FontCipher:
    """把点评自定义字体还原成真实字符，字形轮廓做指纹。"""

    def __init__(self, baseline: TTFont) -> None:
        self._baseline = baseline

    def decode(self, text: str, font: TTFont) -> str:
        glyph_map = self._build_map(font)
        return "".join(glyph_map.get(ch, ch) for ch in text)

    def _build_map(self, font: TTFont) -> dict[str, str]:
        # 用字形轮廓与基准字体比对，得到 unicode 到真实字符的映射
        mapping: dict[str, str] = {}
        for unicode_val, glyph_name in font.getBestCmap().items():
            real = self._match_glyph(font, glyph_name)
            if real is not None:
                mapping[chr(unicode_val)] = real
        return mapping

    def _match_glyph(self, font: TTFont, name: str) -> Optional[str]:
        # 实际实现按轮廓点相似度匹配基准字体，这里留接口
        return None