oniscrape 0.1.0__py3-none-any.whl

fast_scraper/__init__.py

@@ -0,0 +1,37 @@
+from .client import ScraperClient, ScraperRequestError
+from .config import ProxyConfig, RetryConfig, ScraperConfig
+from .cookies.base import BaseCookieStorage
+from .cookies.memory import InMemoryCookieStorage
+from .cookies.redis_storage import RedisCookieStorage
+from .dom.parser import css_all_attr, css_all_text, css_attr, css_text, parse_html
+from .extractors.generic import extract_json_ld, extract_json_scripts
+from .extractors.meta import extract_meta_relay, extract_meta_tokens
+from .extractors.nextjs import extract_next_data, extract_rsc_flight
+from .extractors.nuxt import extract_nuxt_data
+from .pipeline.schema_mapper import map_state_to_model
+from .proxy.manager import ProxyManager
+
+__all__ = [
+    "ScraperClient",
+    "ScraperRequestError",
+    "ScraperConfig",
+    "ProxyConfig",
+    "RetryConfig",
+    "ProxyManager",
+    "BaseCookieStorage",
+    "InMemoryCookieStorage",
+    "RedisCookieStorage",
+    "parse_html",
+    "css_text",
+    "css_all_text",
+    "css_attr",
+    "css_all_attr",
+    "extract_next_data",
+    "extract_rsc_flight",
+    "extract_meta_relay",
+    "extract_meta_tokens",
+    "extract_nuxt_data",
+    "extract_json_ld",
+    "extract_json_scripts",
+    "map_state_to_model",
+]

fast_scraper/client.py

@@ -0,0 +1,175 @@
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
+from typing import Any, TypeVar
+from urllib.parse import urlparse
+
+from curl_cffi.requests import AsyncSession, Response
+from pydantic import BaseModel
+from tenacity import (
+    AsyncRetrying,
+    retry_if_exception_type,
+    stop_after_attempt,
+    wait_exponential,
+)
+
+from .config import ScraperConfig
+from .cookies.base import BaseCookieStorage
+from .cookies.memory import InMemoryCookieStorage
+from .proxy.manager import ProxyManager
+
+T = TypeVar("T", bound=BaseModel)
+
+
+class ScraperRequestError(Exception):
+    """Исключение сетевого сбоя или блокировки антифродом."""
+
+    def __init__(self, message: str, status_code: int | None = None, url: str | None = None):
+        super().__init__(message)
+        self.status_code = status_code
+        self.url = url
+
+
+class ScraperClient:
+    """Асинхронный клиент для парсинга с поддержкой curl_cffi, TLS-фингерпринтов,
+    изоляции прокси-сессий и автоматических ретраев.
+    """
+
+    def __init__(
+        self,
+        config: ScraperConfig | None = None,
+        proxy_manager: ProxyManager | None = None,
+        cookie_storage: BaseCookieStorage | None = None,
+    ):
+        self.config = config or ScraperConfig()
+        self.proxy_manager = proxy_manager or (
+            ProxyManager(self.config.proxy) if self.config.proxy.urls else None
+        )
+        self.cookie_storage = cookie_storage or InMemoryCookieStorage()
+
+    async def __aenter__(self) -> "ScraperClient":
+        return self
+
+    async def __aexit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
+        pass
+
+    @asynccontextmanager
+    async def create_session(
+        self,
+        proxy: str | None = None,
+        impersonate: str | None = None,
+        custom_headers: dict[str, str] | None = None,
+    ) -> AsyncIterator[AsyncSession]:
+        """Создает изолированную сессию под конкретный прокси с гарантированным
+        закрытием сокетов libcurl по завершении блока.
+        """
+        target_impersonate = impersonate or self.config.default_impersonate
+
+        headers = self.config.headers.copy()
+        if custom_headers:
+            headers.update(custom_headers)
+
+        session = AsyncSession(
+            impersonate=target_impersonate,
+            proxy=proxy,
+            headers=headers if headers else None,
+            verify=self.config.verify_ssl,
+            timeout=self.config.timeout_seconds,
+        )
+        try:
+            yield session
+        finally:
+            await session.close()
+
+    async def request(
+        self,
+        method: str,
+        url: str,
+        impersonate: str | None = None,
+        proxy: str | None = None,
+        headers: dict[str, str] | None = None,
+        params: dict[str, Any] | None = None,
+        data: Any = None,
+        json: Any = None,
+        **kwargs: Any,
+    ) -> Response:
+        """Выполняет HTTP-запрос с автоматическим выбором прокси из пула и ретраями."""
+        retry_cfg = self.config.retry
+        domain = urlparse(url).netloc
+
+        retrying = AsyncRetrying(
+            stop=stop_after_attempt(retry_cfg.max_attempts),
+            wait=wait_exponential(
+                multiplier=retry_cfg.min_backoff_seconds,
+                max=retry_cfg.max_backoff_seconds,
+            ),
+            retry=retry_if_exception_type((ScraperRequestError, Exception)),
+            reraise=True,
+        )
+
+        async for attempt in retrying:
+            with attempt:
+                # Выбираем прокси для текущей попытки
+                current_proxy = proxy
+                if current_proxy is None and self.proxy_manager:
+                    current_proxy = self.proxy_manager.get_proxy()
+
+                # Получаем сохраненные куки для домена
+                stored_cookies = await self.cookie_storage.get_cookies(domain)
+
+                try:
+                    async with self.create_session(
+                        proxy=current_proxy,
+                        impersonate=impersonate,
+                        custom_headers=headers,
+                    ) as session:
+                        # Устанавливаем куки в сессию
+                        if stored_cookies:
+                            session.cookies.update(stored_cookies)
+
+                        response = await session.request(
+                            method=method,  # type: ignore[arg-type]
+                            url=url,
+                            params=params,
+                            data=data,
+                            json=json,
+                            **kwargs,
+                        )
+
+                        # Сохраняем новые куки из ответа
+                        if response.cookies:
+                            new_cookies = dict(response.cookies)
+                            if new_cookies:
+                                await self.cookie_storage.set_cookies(domain, new_cookies)
+
+                        # Проверяем антифрод / ошибки статуса
+                        if response.status_code in retry_cfg.retry_status_codes:
+                            if self.proxy_manager and current_proxy:
+                                self.proxy_manager.report_fail(current_proxy)
+                            raise ScraperRequestError(
+                                f"Received retryable status code {response.status_code} for {url}",
+                                status_code=response.status_code,
+                                url=url,
+                            )
+
+                        # Фиксируем успех прокси
+                        if self.proxy_manager and current_proxy:
+                            self.proxy_manager.report_success(current_proxy)
+
+                        return response
+
+                except Exception as exc:
+                    if self.proxy_manager and current_proxy:
+                        self.proxy_manager.report_fail(current_proxy)
+                    if isinstance(exc, ScraperRequestError):
+                        raise
+                    raise ScraperRequestError(
+                        f"Network error during {method} {url}: {exc}", url=url
+                    ) from exc
+
+        raise ScraperRequestError(f"Max attempts exceeded for {url}")
+
+    async def get(self, url: str, **kwargs: Any) -> Response:
+        return await self.request("GET", url, **kwargs)
+
+    async def post(self, url: str, **kwargs: Any) -> Response:
+        return await self.request("POST", url, **kwargs)

fast_scraper/config.py

@@ -0,0 +1,49 @@
+from typing import Literal
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class ProxyConfig(BaseModel):
+    model_config = ConfigDict(frozen=True)
+
+    urls: list[str] = Field(
+        default_factory=list, description="Список URL прокси (socks5://..., http://...)"
+    )
+    cooldown_seconds: float = Field(
+        default=120.0, ge=0.0, description="Время кулдауна заблокированного прокси"
+    )
+    max_fails_before_cooldown: int = Field(
+        default=2, ge=1, description="Количество сбоев до отправки в кулдаун"
+    )
+    strategy: Literal["round_robin", "random", "least_failed"] = Field(
+        default="round_robin", description="Стратегия выбора прокси"
+    )
+
+
+class RetryConfig(BaseModel):
+    model_config = ConfigDict(frozen=True)
+
+    max_attempts: int = Field(default=3, ge=1, description="Максимальное количество попыток")
+    min_backoff_seconds: float = Field(
+        default=0.5, ge=0.0, description="Минимальная пауза между попытками"
+    )
+    max_backoff_seconds: float = Field(default=5.0, ge=0.0, description="Максимальная пауза")
+    retry_status_codes: set[int] = Field(
+        default_factory=lambda: {403, 429, 500, 502, 503, 504},
+        description="HTTP-статусы, требующие повторного запроса",
+    )
+
+
+class ScraperConfig(BaseModel):
+    model_config = ConfigDict(frozen=True)
+
+    default_impersonate: str = Field(
+        default="chrome124", description="Дефолтный профиль TLS-фингерпринта в curl_cffi"
+    )
+    timeout_seconds: float = Field(default=30.0, ge=1.0, description="Таймаут сетевых запросов")
+    verify_ssl: bool = Field(default=True, description="Проверка SSL-сертификатов")
+    proxy: ProxyConfig = Field(default_factory=ProxyConfig, description="Настройки пула прокси")
+    retry: RetryConfig = Field(default_factory=RetryConfig, description="Настройки ретраев")
+    headers: dict[str, str] = Field(
+        default_factory=dict, description="Кастомные дефолтные заголовки"
+    )

fast_scraper/cookies/__init__.py

@@ -0,0 +1,5 @@
+from .base import BaseCookieStorage
+from .memory import InMemoryCookieStorage
+from .redis_storage import RedisCookieStorage
+
+__all__ = ["BaseCookieStorage", "InMemoryCookieStorage", "RedisCookieStorage"]

fast_scraper/cookies/base.py

@@ -0,0 +1,20 @@
+from abc import ABC, abstractmethod
+
+
+class BaseCookieStorage(ABC):
+    """Абстрактное хранилище куки для сессий скрапера."""
+
+    @abstractmethod
+    async def get_cookies(self, domain: str) -> dict[str, str]:
+        """Получить словарь куки для указанного домена."""
+        ...
+
+    @abstractmethod
+    async def set_cookies(self, domain: str, cookies: dict[str, str]) -> None:
+        """Сохранить или обновить куки для домена."""
+        ...
+
+    @abstractmethod
+    async def clear(self, domain: str | None = None) -> None:
+        """Очистить куки для домена или все."""
+        ...

fast_scraper/cookies/memory.py

@@ -0,0 +1,28 @@
+import asyncio
+
+from .base import BaseCookieStorage
+
+
+class InMemoryCookieStorage(BaseCookieStorage):
+    """Потокобезопасное хранилище куки в оперативной памяти."""
+
+    def __init__(self):
+        self._cookies: dict[str, dict[str, str]] = {}
+        self._lock = asyncio.Lock()
+
+    async def get_cookies(self, domain: str) -> dict[str, str]:
+        async with self._lock:
+            return self._cookies.get(domain, {}).copy()
+
+    async def set_cookies(self, domain: str, cookies: dict[str, str]) -> None:
+        async with self._lock:
+            if domain not in self._cookies:
+                self._cookies[domain] = {}
+            self._cookies[domain].update(cookies)
+
+    async def clear(self, domain: str | None = None) -> None:
+        async with self._lock:
+            if domain:
+                self._cookies.pop(domain, None)
+            else:
+                self._cookies.clear()

fast_scraper/cookies/redis_storage.py

@@ -0,0 +1,38 @@
+from typing import Any
+
+import orjson
+
+from .base import BaseCookieStorage
+
+
+class RedisCookieStorage(BaseCookieStorage):
+    """Распределенное асинхронное хранилище куки в Redis."""
+
+    def __init__(self, redis_client: Any, prefix: str = "fast_scraper:cookies:"):
+        self.redis = redis_client
+        self.prefix = prefix
+
+    def _key(self, domain: str) -> str:
+        return f"{self.prefix}{domain}"
+
+    async def get_cookies(self, domain: str) -> dict[str, str]:
+        raw = await self.redis.get(self._key(domain))
+        if not raw:
+            return {}
+        try:
+            return orjson.loads(raw)
+        except Exception:
+            return {}
+
+    async def set_cookies(self, domain: str, cookies: dict[str, str]) -> None:
+        current = await self.get_cookies(domain)
+        current.update(cookies)
+        await self.redis.set(self._key(domain), orjson.dumps(current))
+
+    async def clear(self, domain: str | None = None) -> None:
+        if domain:
+            await self.redis.delete(self._key(domain))
+        else:
+            # Поиск всех ключей с префиксом через SCAN
+            async for key in self.redis.scan_iter(match=f"{self.prefix}*"):
+                await self.redis.delete(key)

fast_scraper/dom/__init__.py

@@ -0,0 +1,15 @@
+from .parser import (
+    css_all_attr,
+    css_all_text,
+    css_attr,
+    css_text,
+    parse_html,
+)
+
+__all__ = [
+    "parse_html",
+    "css_text",
+    "css_all_text",
+    "css_attr",
+    "css_all_attr",
+]

fast_scraper/dom/parser.py

@@ -0,0 +1,52 @@
+from selectolax.lexbor import LexborHTMLParser, LexborNode
+
+
+def parse_html(html: str) -> LexborHTMLParser:
+    """Создает парсер дерева DOM на базе высокопроизводительного C-движка Lexbor."""
+    return LexborHTMLParser(html)
+
+
+def css_text(
+    context: LexborHTMLParser | LexborNode, selector: str, default: str = "", strip: bool = True
+) -> str:
+    """Извлекает текстовое содержимое первого найденного по селектору элемента."""
+    node = context.css_first(selector)
+    if not node or not node.text():
+        return default
+    text = node.text()
+    return text.strip() if strip else text
+
+
+def css_all_text(
+    context: LexborHTMLParser | LexborNode, selector: str, strip: bool = True
+) -> list[str]:
+    """Извлекает список строк из всех найденных по селектору элементов."""
+    nodes = context.css(selector)
+    result: list[str] = []
+    for node in nodes:
+        t = node.text()
+        if t:
+            result.append(t.strip() if strip else t)
+    return result
+
+
+def css_attr(
+    context: LexborHTMLParser | LexborNode, selector: str, attr: str, default: str = ""
+) -> str:
+    """Извлекает значение атрибута первого найденного элемента."""
+    node = context.css_first(selector)
+    if not node:
+        return default
+    val = node.attributes.get(attr)
+    return val if val is not None else default
+
+
+def css_all_attr(context: LexborHTMLParser | LexborNode, selector: str, attr: str) -> list[str]:
+    """Извлекает список значений атрибута для всех найденных элементов."""
+    nodes = context.css(selector)
+    result: list[str] = []
+    for node in nodes:
+        val = node.attributes.get(attr)
+        if val is not None:
+            result.append(val)
+    return result

fast_scraper/extractors/__init__.py

@@ -0,0 +1,14 @@
+from .generic import extract_json_ld, extract_json_scripts
+from .meta import extract_meta_relay, extract_meta_tokens
+from .nextjs import extract_next_data, extract_rsc_flight
+from .nuxt import extract_nuxt_data
+
+__all__ = [
+    "extract_next_data",
+    "extract_rsc_flight",
+    "extract_meta_relay",
+    "extract_meta_tokens",
+    "extract_nuxt_data",
+    "extract_json_ld",
+    "extract_json_scripts",
+]

fast_scraper/extractors/base.py

@@ -0,0 +1,6 @@
+from selectolax.lexbor import LexborHTMLParser
+
+
+def get_html_parser(html: str) -> LexborHTMLParser:
+    """Создает парсер LexborHTMLParser для быстрого поиска по дереву элементов."""
+    return LexborHTMLParser(html)

fast_scraper/extractors/generic.py

@@ -0,0 +1,50 @@
+import re
+from typing import Any
+
+import orjson
+from selectolax.lexbor import LexborHTMLParser
+
+
+def extract_json_ld(html: str) -> list[dict[str, Any]]:
+    """Извлекает структурированную микроразметку Schema.org (application/ld+json)."""
+    parser = LexborHTMLParser(html)
+    results: list[dict[str, Any]] = []
+
+    for script in parser.css('script[type="application/ld+json"]'):
+        text = script.text()
+        if not text:
+            continue
+        try:
+            parsed = orjson.loads(text.strip())
+            if isinstance(parsed, list):
+                results.extend(parsed)
+            elif isinstance(parsed, dict):
+                results.append(parsed)
+        except Exception:
+            continue
+
+    return results
+
+
+def extract_json_scripts(html: str, id_pattern: str | None = None) -> list[dict[str, Any]]:
+    """Извлекает содержимое всех тегов <script type="application/json">,
+    опционально фильтруя по регулярному выражению для id.
+    """
+    parser = LexborHTMLParser(html)
+    results: list[dict[str, Any]] = []
+
+    for script in parser.css('script[type="application/json"]'):
+        script_id = script.attributes.get("id") or ""
+        if id_pattern and not re.search(id_pattern, script_id):
+            continue
+
+        text = script.text()
+        if not text:
+            continue
+        try:
+            parsed = orjson.loads(text.strip())
+            results.append(parsed)
+        except Exception:
+            continue
+
+    return results

fast_scraper/extractors/meta.py

@@ -0,0 +1,53 @@
+import re
+from typing import Any
+
+import orjson
+from selectolax.lexbor import LexborHTMLParser
+
+
+def extract_meta_relay(html: str) -> list[dict[str, Any]]:
+    """Извлекает все preloaded GraphQL-ответы из Relay Stream Cache
+    в Threads / Instagram / Facebook.
+    """
+    parser = LexborHTMLParser(html)
+    results: list[dict[str, Any]] = []
+
+    for script in parser.css('script[type="application/json"][data-sjs]'):
+        text = script.text()
+        if not text:
+            continue
+        try:
+            parsed = orjson.loads(text)
+            if isinstance(parsed, dict) and "require" in parsed:
+                results.append(parsed)
+        except Exception:
+            continue
+
+    return results
+
+
+def extract_meta_tokens(html: str) -> dict[str, str]:
+    """Извлекает токены CSRF и идентификаторы приложения из HTML:
+    - `lsd`: CSRF-токен для POST-запросов к /api/graphql
+    - `app_id`: Идентификатор приложения (например, для x-ig-app-id)
+    - `fb_dtsg`: Маркер безопасности Meta
+    """
+    lsd_match = re.search(r'\["LSD",\[\],{"token":"([^"]+)"\}', html)
+    if not lsd_match:
+        lsd_match = re.search(r'"LSD",\[\],\{"token":"([^"]+)"\}', html)
+    if not lsd_match:
+        lsd_match = re.search(r'name="lsd"\s+value="([^"]+)"', html)
+
+    app_id_match = re.search(r'\["SiteData",\[\],{"app_id":"([^"]+)"\}', html)
+    if not app_id_match:
+        app_id_match = re.search(r'"app_id":"(\d+)"', html)
+
+    dtsg_match = re.search(r'"DTSGInitialData",\[\],{"token":"([^"]+)"\}', html)
+
+    return {
+        "lsd": lsd_match.group(1) if lsd_match else "",
+        "app_id": app_id_match.group(1)
+        if app_id_match
+        else "238260118697367",  # default threads web app id
+        "fb_dtsg": dtsg_match.group(1) if dtsg_match else "",
+    }

fast_scraper/extractors/nextjs.py

@@ -0,0 +1,100 @@
+import re
+from typing import Any
+
+import orjson
+from selectolax.lexbor import LexborHTMLParser
+
+
+def extract_next_data(html: str) -> dict[str, Any]:
+    """Извлекает и парсит JSON-состояние __NEXT_DATA__ из Next.js страницы.
+
+    Raises:
+        ValueError: Если тег __NEXT_DATA__ отсутствует или поврежден.
+    """
+    parser = LexborHTMLParser(html)
+    script_node = parser.css_first("script#__NEXT_DATA__")
+    if not script_node or not script_node.text():
+        raise ValueError("Next.js state (__NEXT_DATA__) not found in HTML")
+
+    text = script_node.text().strip()
+    return orjson.loads(text)
+
+
+def parse_flight_line(line: str) -> tuple[str, str, Any] | None:
+    """Разбирает одну строку React Flight wire-протокола вида:
+    - '0:[\"$\",\"$L1\",null,{...}]'
+    - '1:I[\"module.js\",[\"default\"],\"\"]'
+    - '2:\"some string\"'
+    - '3:HL[\"...\",...]'
+    """
+    line = line.strip()
+    if not line or ":" not in line:
+        return None
+
+    colon_idx = line.find(":")
+    row_id = line[:colon_idx].strip()
+    remainder = line[colon_idx + 1 :].strip()
+
+    if not remainder:
+        return None
+
+    # Проверяем, есть ли префикс тега типа I (Import), M (Module), H (Hint)
+    tag = "J"  # default JSON payload
+    first_char = remainder[0]
+
+    if first_char.isalpha() and len(remainder) > 1 and remainder[1] in ':[{"':
+        tag = first_char
+        payload_str = remainder[1:]
+    else:
+        payload_str = remainder
+
+    try:
+        payload = orjson.loads(payload_str)
+        return row_id, tag, payload
+    except Exception:
+        # Если это чистая строка или сложный сегмент
+        return row_id, tag, payload_str
+
+
+def extract_rsc_flight(html: str) -> dict[str, Any]:
+    """Извлекает и декодирует потоковые чанки React Server Components (RSC Flight)
+    из тегов `self.__next_f.push` в Next.js App Router (React 19).
+
+    Возвращает словарь вида `{'rowId_tag': payload}`.
+    """
+    # Ищем все вызовы self.__next_f.push([..., "..."])
+    matches = re.findall(
+        r'self\.__next_f\.push\(\[\s*\d+\s*,\s*(".*?(?<!\\)")\s*\]\)',
+        html,
+        re.DOTALL,
+    )
+
+    if not matches:
+        # Альтернативный паттерн без обрамляющих кавычек внутри
+        matches = re.findall(
+            r'self\.__next_f\.push\(\[.*?,\s*"(.*?)"\]\)',
+            html,
+            re.DOTALL,
+        )
+
+    full_flight_text = ""
+    for match in matches:
+        try:
+            # Декодируем экранированную JS-строку
+            decoded = orjson.loads(match if match.startswith('"') else f'"{match}"')
+            full_flight_text += decoded
+        except Exception:
+            try:
+                decoded = match.encode("utf-8").decode("unicode_escape")
+                full_flight_text += decoded
+            except Exception:
+                full_flight_text += match
+
+    state_tree: dict[str, Any] = {}
+    for line in full_flight_text.splitlines():
+        parsed = parse_flight_line(line)
+        if parsed:
+            row_id, tag, payload = parsed
+            state_tree[f"{row_id}_{tag}"] = payload
+
+    return state_tree

fast_scraper/extractors/nuxt.py

@@ -0,0 +1,29 @@
+import re
+from typing import Any
+
+import orjson
+from selectolax.lexbor import LexborHTMLParser
+
+
+def extract_nuxt_data(html: str) -> dict[str, Any] | list[Any]:
+    """Извлекает состояние Nuxt 3 (__NUXT_DATA__) или Nuxt 2 (window.__NUXT__).
+
+    Raises:
+        ValueError: Если данные Nuxt не найдены.
+    """
+    parser = LexborHTMLParser(html)
+
+    # 1. Nuxt 3 JSON-массив данных
+    script_node = parser.css_first("script#__NUXT_DATA__")
+    if script_node and script_node.text():
+        return orjson.loads(script_node.text().strip())
+
+    # 2. Nuxt 2 window.__NUXT__ JS-объект
+    match = re.search(r"window\.__NUXT__\s*=\s*(\{.*?\});", html, re.DOTALL)
+    if match:
+        try:
+            return orjson.loads(match.group(1))
+        except Exception:
+            pass
+
+    raise ValueError("Nuxt state (__NUXT_DATA__ / window.__NUXT__) not found in HTML")

fast_scraper/pipeline/__init__.py

@@ -0,0 +1,3 @@
+from .schema_mapper import map_state_to_model
+
+__all__ = ["map_state_to_model"]

fast_scraper/pipeline/schema_mapper.py

@@ -0,0 +1,55 @@
+from typing import Any, TypeVar
+
+import jmespath
+from pydantic import BaseModel, TypeAdapter
+
+T = TypeVar("T", bound=BaseModel)
+
+
+def map_state_to_model(
+    state: dict[str, Any] | list[Any],
+    query: str,
+    model_cls: type[T],
+    strict: bool = False,
+    default: Any = None,
+) -> list[T] | T | None:
+    """Выполняет поиск по JMESPath-запросу в структуре состояния и валидирует результат в Pydantic v2 модель(и).
+
+    Args:
+        state: Исходный JSON-словарь или массив данных состояния.
+        query: JMESPath-выражение (например, "props.pageProps.items[*].{id: id, name: title}").
+        model_cls: Pydantic v2 класс схемы данных.
+        strict: Если True, выбрасывает ValueError при пустом результате поиска.
+        default: Значение по умолчанию, если ничего не найдено в non-strict режиме.
+
+    Returns:
+        Экземпляр модели T, список list[T], или default.
+    """
+    extracted = jmespath.search(query, state)
+
+    # Проверка на пустой результат
+    if extracted is None or (isinstance(extracted, list) and len(extracted) == 0):
+        if strict:
+            raise ValueError(f"JMESPath query '{query}' returned empty result in strict mode")
+
+        # Если в запросе была проекция списка или default указан как список
+        is_list_query = "[*" in query or query.endswith("]") or query.endswith("}")
+        if default is None and is_list_query:
+            return []
+        return default
+
+    # Если результат - список словарей
+    if isinstance(extracted, list):
+        adapter = TypeAdapter(list[model_cls])
+        return adapter.validate_python(extracted)
+
+    # Если результат - одиночный объект
+    if isinstance(extracted, dict):
+        return model_cls.model_validate(extracted)
+
+    # Примитивное значение не мапится напрямую в модель
+    if strict:
+        raise ValueError(
+            f"Expected dict or list from query '{query}', got {type(extracted).__name__}"
+        )
+    return default

fast_scraper/proxy/__init__.py

@@ -0,0 +1,4 @@
+from .health import ProxyState
+from .manager import ProxyManager
+
+__all__ = ["ProxyManager", "ProxyState"]

fast_scraper/proxy/health.py

@@ -0,0 +1,38 @@
+import time
+from dataclasses import dataclass
+
+
+@dataclass
+class ProxyState:
+    url: str
+    fail_count: int = 0
+    success_count: int = 0
+    last_fail_time: float = 0.0
+    last_success_time: float = 0.0
+    is_in_cooldown: bool = False
+    cooldown_until: float = 0.0
+
+    def mark_success(self) -> None:
+        self.success_count += 1
+        self.fail_count = 0
+        self.last_success_time = time.monotonic()
+        self.is_in_cooldown = False
+        self.cooldown_until = 0.0
+
+    def mark_fail(self, max_fails: int, cooldown_seconds: float) -> None:
+        self.fail_count += 1
+        self.last_fail_time = time.monotonic()
+        if self.fail_count >= max_fails:
+            self.is_in_cooldown = True
+            self.cooldown_until = time.monotonic() + cooldown_seconds
+
+    def is_available(self) -> bool:
+        if not self.is_in_cooldown:
+            return True
+        if time.monotonic() >= self.cooldown_until:
+            # Кулдаун истек - восстанавливаем прокси
+            self.is_in_cooldown = False
+            self.fail_count = 0
+            self.cooldown_until = 0.0
+            return True
+        return False

fast_scraper/proxy/manager.py

@@ -0,0 +1,69 @@
+import random
+import threading
+from typing import Literal
+
+from ..config import ProxyConfig
+from .health import ProxyState
+
+
+class ProxyManager:
+    """Потокобезопасный менеджер пула прокси с поддержкой стратегий и кулдауна."""
+
+    def __init__(self, config: ProxyConfig):
+        self.config = config
+        self._lock = threading.Lock()
+        self._states: dict[str, ProxyState] = {url: ProxyState(url=url) for url in config.urls}
+        self._index = 0
+
+    @property
+    def total_count(self) -> int:
+        return len(self._states)
+
+    def add_proxy(self, url: str) -> None:
+        with self._lock:
+            if url not in self._states:
+                self._states[url] = ProxyState(url=url)
+
+    def remove_proxy(self, url: str) -> None:
+        with self._lock:
+            self._states.pop(url, None)
+
+    def get_proxy(
+        self, strategy: Literal["round_robin", "random", "least_failed"] | None = None
+    ) -> str | None:
+        """Возвращает живой прокси по заданной стратегии или None, если пул пуст."""
+        with self._lock:
+            if not self._states:
+                return None
+
+            available = [state for state in self._states.values() if state.is_available()]
+            if not available:
+                # Если все в кулдауне, берем тот, у которого быстрее всего закончится кулдаун
+                available = sorted(self._states.values(), key=lambda s: s.cooldown_until)
+
+            strat = strategy or self.config.strategy
+
+            if strat == "random":
+                return random.choice(available).url
+
+            if strat == "least_failed":
+                # Сортируем по числу ошибок
+                sorted_by_fails = sorted(available, key=lambda s: (s.fail_count, -s.success_count))
+                return sorted_by_fails[0].url
+
+            # Round-Robin по умолчанию
+            self._index = (self._index + 1) % len(available)
+            return available[self._index].url
+
+    def report_success(self, url: str) -> None:
+        with self._lock:
+            if url in self._states:
+                self._states[url].mark_success()
+
+    def report_fail(self, url: str) -> None:
+        with self._lock:
+            if url in self._states:
+                self._states[url].mark_fail(
+                    max_fails=self.config.max_fails_before_cooldown,
+                    cooldown_seconds=self.config.cooldown_seconds,
+                )

fast_scraper/py.typed

@@ -0,0 +1 @@
+# Marker file for PEP 561

oniscrape/__init__.py

@@ -0,0 +1,49 @@
+from fast_scraper import (
+    BaseCookieStorage,
+    InMemoryCookieStorage,
+    ProxyConfig,
+    ProxyManager,
+    RedisCookieStorage,
+    RetryConfig,
+    ScraperClient,
+    ScraperConfig,
+    ScraperRequestError,
+    css_all_attr,
+    css_all_text,
+    css_attr,
+    css_text,
+    extract_json_ld,
+    extract_json_scripts,
+    extract_meta_relay,
+    extract_meta_tokens,
+    extract_next_data,
+    extract_rsc_flight,
+    extract_nuxt_data,
+    map_state_to_model,
+    parse_html,
+)
+
+__all__ = [
+    "ScraperClient",
+    "ScraperRequestError",
+    "ScraperConfig",
+    "ProxyConfig",
+    "RetryConfig",
+    "ProxyManager",
+    "BaseCookieStorage",
+    "InMemoryCookieStorage",
+    "RedisCookieStorage",
+    "parse_html",
+    "css_text",
+    "css_all_text",
+    "css_attr",
+    "css_all_attr",
+    "extract_next_data",
+    "extract_rsc_flight",
+    "extract_meta_relay",
+    "extract_meta_tokens",
+    "extract_nuxt_data",
+    "extract_json_ld",
+    "extract_json_scripts",
+    "map_state_to_model",
+]

oniscrape/py.typed

@@ -0,0 +1 @@
+# Marker file for PEP 561

oniscrape-0.1.0.dist-info/METADATA

@@ -0,0 +1,261 @@
+Metadata-Version: 2.5
+Name: oniscrape
+Version: 0.1.0
+Summary: High-performance async scraping engine powered by curl_cffi, selectolax, orjson, and Pydantic v2. Extracts Next.js SSR, RSC Flight streams, and Meta Relay states without headless browsers.
+Author: FastScraper Team
+License-Expression: MIT
+License-File: LICENSE
+Keywords: anti-bot,crawler,curl-cffi,ja3,nextjs,pydantic,react-server-components,rsc,scraper,selectolax,tls-fingerprint
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: curl-cffi>=0.7.4
+Requires-Dist: jmespath>=1.0.1
+Requires-Dist: orjson>=3.10.0
+Requires-Dist: pydantic>=2.7.0
+Requires-Dist: selectolax>=0.3.21
+Requires-Dist: tenacity>=8.3.0
+Provides-Extra: dev
+Requires-Dist: pyright>=1.1.350; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23.0; extra == 'dev'
+Requires-Dist: pytest>=8.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.4.0; extra == 'dev'
+Provides-Extra: redis
+Requires-Dist: redis>=5.0.0; extra == 'redis'
+Description-Content-Type: text/markdown
+
+# fast-scraper 🚀
+
+> **Высокопроизводительный асинхронный скрапинг-движок для Python на базе `curl_cffi`, `selectolax` (Lexbor), `orjson` и `Pydantic v2`.**
+
+Специализированный инструмент для сверхбыстрого парсинга современных веб-приложений (Next.js, React Server Components, Meta Threads/Instagram, Nuxt) и статических сайтов **без запуска тяжелых headless-браузеров**.
+
+---
+
+## ⚡ Почему не Playwright / Selenium?
+
+| Параметр | Headless Браузер (Playwright / Puppeteer) | `fast-scraper` (No-JS / State Engine) |
+| :--- | :--- | :--- |
+| **Потребление RAM** | ~300 - 600 МБ на поток/вкладку | **~15 - 30 МБ на процесс** |
+| **Время ответа** | 3.0 - 8.0 секунд (рендеринг DOM + JS) | **0.1 - 0.4 секунды** (чистый сетевой I/O) |
+| **Устойчивость к редизайнам** | Низкая (CSS-классы React меняются при каждом билде) | **Высокая** (структура данных в State/API стабильна годами) |
+| **Обход TLS-проверок** | Зависит от stealth-патчей Chromium | **Нативный JA3/JA4 / HTTP2 спуфинг через `curl_cffi`** |
+| **Утечки IP при смене прокси** | Частая проблема из-за общего пула сокетов | **Гарантированная изоляция сокетов на уровне сессий** |
+
+---
+
+## 📦 Установка
+
+### Базовая установка:
+```bash
+pip install fast-scraper
+```
+или через `uv`:
+```bash
+uv add fast-scraper
+```
+
+### С поддержкой Redis (для распределенного хранения куки):
+```bash
+pip install fast-scraper[redis]
+```
+
+### Локальная разработка:
+```bash
+git clone https://github.com/your-org/fast-scraper.git
+cd fast-scraper
+uv pip install -e .[dev]
+```
+
+---
+
+## 🛠️ Быстрый старт и примеры
+
+### 1. Парсинг Next.js SSR (__NEXT_DATA__) напрямую в Pydantic v2
+
+Вместо того чтобы искать элементы на странице, `fast-scraper` мгновенно забирает сырое JSON-состояние гидратации, вшитое сервером в страницу:
+
+```python
+import asyncio
+from pydantic import BaseModel, Field
+from fast_scraper import ScraperClient, extract_next_data, map_state_to_model
+
+class CryptoMetric(BaseModel):
+    num_cryptos: int = Field(alias="numCryptocurrencies")
+    num_markets: int = Field(alias="numMarkets")
+    active_exchanges: int = Field(alias="activeExchanges")
+
+async def main():
+    async with ScraperClient() as client:
+        response = await client.get("https://coinmarketcap.com/")
+        
+        # 1. Мгновенно достаем JSON-дерево гидратации (без выполнения JS)
+        state = extract_next_data(response.text)
+        
+        # 2. Извлекаем нужные ветки по JMESPath и валидируем через Pydantic v2
+        metrics = map_state_to_model(
+            state=state,
+            query="props.dehydratedState.queries[?queryKey[0]=='global-metric'].state.data | [0]",
+            model_cls=CryptoMetric,
+            strict=False,
+        )
+        print(metrics)
+
+asyncio.run(main())
+```
+
+---
+
+### 2. Парсинг React Server Components (RSC Flight stream) в Next.js 14 / 15 / 19
+
+Next.js App Router не использует `__NEXT_DATA__`, а отдает потоковые чанки `self.__next_f.push` по протоколу React Flight (`id:tag:payload`). `fast-scraper` декодирует этот протокол "из коробки":
+
+```python
+import asyncio
+from fast_scraper import ScraperClient, extract_rsc_flight
+
+async def main():
+    async with ScraperClient() as client:
+        response = await client.get("https://nextjs.org/")
+        
+        # Декодирует все потоковые слоты wire-протокола
+        flight_tree = extract_rsc_flight(response.text)
+        
+        # flight_tree содержит разобранные слоты вида {'0_J': [...], '1_I': [...]}
+        print(f"Декодировано слотов RSC: {len(flight_tree)}")
+
+asyncio.run(main())
+```
+
+---
+
+### 3. Парсинг закрытых данных Threads / Instagram (Meta Relay Cache)
+
+```python
+import asyncio
+from fast_scraper import ScraperClient, extract_meta_relay, extract_meta_tokens
+
+async def main():
+    async with ScraperClient() as client:
+        response = await client.get("https://www.threads.net/@zuck")
+        
+        # 1. Извлечение токенов для последующих прямых POST-запросов к /api/graphql
+        tokens = extract_meta_tokens(response.text)
+        print("LSD Token:", tokens["lsd"])
+        print("App ID:", tokens["app_id"])
+        
+        # 2. Извлечение префетч-кэша GraphQL (RelayPrefetchedStreamCache)
+        relay_data = extract_meta_relay(response.text)
+        print(f"Найдено блоков Relay Cache: {len(relay_data)}")
+
+asyncio.run(main())
+```
+
+---
+
+### 4. C-уровень DOM-парсинга через Selectolax Lexbor
+
+Для сайтов с чистым HTML используется движок Lexbor на чистом Си (в 20 раз быстрее BeautifulSoup и потребляет минимум RAM):
+
+```python
+from fast_scraper import parse_html, css_text, css_all_text, css_all_attr
+
+tree = parse_html(html_content)
+
+# Быстрое извлечение первого найденного текста с авто-strip
+title = css_text(tree, "h1.product-title", default="Без названия")
+
+# Извлечение всех элементов
+items = css_all_text(tree, "ul.features li")
+
+# Извлечение атрибутов
+image_urls = css_all_attr(tree, "div.gallery img", "src")
+```
+
+---
+
+### 5. Пул прокси с авто-кулдауном и предотвращением утечек сокетов
+
+`fast-scraper` изолирует `AsyncSession` под каждый конкретный запрос/прокси, что гарантирует закрытие Keep-Alive сокетов `libcurl` и предотвращает утечки реального IP при ротации:
+
+```python
+from fast_scraper import ScraperClient, ScraperConfig, ProxyConfig
+
+config = ScraperConfig(
+    default_impersonate="chrome124",
+    timeout_seconds=15.0,
+    proxy=ProxyConfig(
+        urls=[
+            "socks5://127.0.0.1:40000", # Например, локальный Cloudflare WARP
+            "socks5://127.0.0.1:40001",
+            "http://user:pass@proxy3.net:8080",
+        ],
+        strategy="least_failed", # "round_robin" | "random" | "least_failed"
+        cooldown_seconds=120.0,  # Время отстоя прокси при получении 403/429
+        max_fails_before_cooldown=2,
+    )
+)
+
+async with ScraperClient(config=config) as client:
+    response = await client.get("https://httpbin.org/ip")
+    print(response.json())
+```
+
+---
+
+## 🏛️ Архитектура пакета
+
+```text
+src/fast_scraper/
+├── __init__.py           # Публичный API
+├── client.py             # ScraperClient с изоляцией сессий и ретраями (tenacity)
+├── config.py             # Pydantic v2 конфигурация (ScraperConfig, ProxyConfig, RetryConfig)
+├── py.typed              # Маркер типизации PEP 561
+├── extractors/           # Движки извлечения состояний гидратации
+│   ├── nextjs.py         # __NEXT_DATA__ и React Server Components (RSC Flight)
+│   ├── meta.py           # Threads / Instagram Relay Cache и токены (lsd, app_id)
+│   ├── nuxt.py           # Nuxt 2 / 3 (__NUXT_DATA__)
+│   └── generic.py        # Schema.org JSON-LD и <script type="application/json">
+├── dom/                  # C-уровень DOM-парсинга
+│   └── parser.py         # Обертки над Selectolax Lexbor
+├── proxy/                # Ротация и мониторинг прокси
+│   ├── manager.py        # ProxyManager (Round-Robin, Random, Least-Failed)
+│   └── health.py         # Отслеживание сбоев и таймеры кулдауна
+├── cookies/              # Управление сессиями и куки
+│   ├── memory.py         # InMemoryCookieStorage
+│   └── redis_storage.py  # RedisCookieStorage
+└── pipeline/             # Трансформация данных
+    └── schema_mapper.py  # JMESPath -> Pydantic v2 TypeAdapter
+```
+
+---
+
+## 🧪 Тестирование и верификация
+
+Все тесты и проверки запускаются одной командой:
+
+```bash
+# Запуск тестов
+uv run --with pytest --with pytest-asyncio pytest -v
+
+# Проверка типов
+uv run --with pyright --with pytest pyright src tests
+
+# Проверка линтером
+uv run --with ruff ruff check src tests
+```
+
+---
+
+## 📄 Лицензия
+
+Проект распространяется под свободной лицензией **MIT**. Подробнее см. в файле [LICENSE](LICENSE).

oniscrape-0.1.0.dist-info/RECORD

@@ -0,0 +1,27 @@
+fast_scraper/__init__.py,sha256=pawATDdVYl1OnCSXEd3rkR5UWibNT4lCTPmIUvejl3E,1214
+fast_scraper/client.py,sha256=txo3A8Hp_gWJ-0CgJ3HrxXVHzWl01KG_-Ume8sgUlqY,6920
+fast_scraper/config.py,sha256=GC_30wIkyOL1QaQNd9ebPqzdauuUQNwyxrv88-jd9NY,2288
+fast_scraper/py.typed,sha256=8PjyZ1aVoQpRVvt71muvuq5qE-jTFZkK-GLHkhdebmc,26
+fast_scraper/cookies/__init__.py,sha256=V6YkMZ7cn8o4v82BzUeGsWKmn4kFmG-DSH6tFAFmqvg,204
+fast_scraper/cookies/base.py,sha256=X7VWiw-kxpnCe7yr8hCoSzJOd-vNuEnTG5EcFO_AxIU,730
+fast_scraper/cookies/memory.py,sha256=S7QvnPw1mZ4TnQXU-mrhMwbFiRNeQo8UTDbJEPIlMrE,949
+fast_scraper/cookies/redis_storage.py,sha256=eNrQUt8mnhGH9RaX8yMqNkpX-wYENAc7y84BThALg-Y,1297
+fast_scraper/dom/__init__.py,sha256=cwglj7RerHDZLMZ44FvoyOizHWQ-51Z9rY0SFJBcur4,209
+fast_scraper/dom/parser.py,sha256=Y3hMM2Cfk18qaiko90BJhHB_6VvfGhRgF2WJRT8tabo,1976
+fast_scraper/extractors/__init__.py,sha256=QfOTRsrzcHjD8KCXF5VP4nneeQIU3M6VRV1GLdS7Y9E,406
+fast_scraper/extractors/base.py,sha256=g5vr5cT52YkDVAxNRwvv7uFcxDO042aj2p3Ta8F9kZc,265
+fast_scraper/extractors/generic.py,sha256=kS9jHrwhtHDkEmRMc4YHXRFDfyRHgI7qxwY_s_j-B4Y,1603
+fast_scraper/extractors/meta.py,sha256=DgZgQi9Dq5vBcjf-eW9IHKsz1o49MrjN1e84DvNCYEs,1913
+fast_scraper/extractors/nextjs.py,sha256=OvE3i0_unEhtSyyxWujtn9kMBsR5czI4UsH178Zz2Xg,3386
+fast_scraper/extractors/nuxt.py,sha256=3NXUBfnAYcngJ39agzp34U-I6donqKCqaSuEPGb8vWc,925
+fast_scraper/pipeline/__init__.py,sha256=hATJPesLcIVZnwEaxEZog_4VQUuD8_TXRPYICloTjGg,80
+fast_scraper/pipeline/schema_mapper.py,sha256=NKlISbgQDB9QSUxr9_K3ubxeQginGCq01IiyBiuD0LQ,2360
+fast_scraper/proxy/__init__.py,sha256=vOspUXm6h6p5xPgF7saupWv291Cs-d8jTsq4QKlRgEQ,107
+fast_scraper/proxy/health.py,sha256=Rek0wJFcNkoQwSiNzN8D2ZAd3nho0-qr9y9fhKk1rDI,1181
+fast_scraper/proxy/manager.py,sha256=YWphLyojAcBWHitHiiADb_QyOTHWNJOXR0ZrWPlTLyk,2621
+oniscrape/__init__.py,sha256=kaaSs-jDcwkcHnPEsv46evIYmMshvT1w4AX5bgJ7gQw,1006
+oniscrape/py.typed,sha256=8PjyZ1aVoQpRVvt71muvuq5qE-jTFZkK-GLHkhdebmc,26
+oniscrape-0.1.0.dist-info/METADATA,sha256=eAeRNvvXX88gniZZ_Q2dGxmg6ZmN0ehqnkEe5NiH7b4,11132
+oniscrape-0.1.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+oniscrape-0.1.0.dist-info/licenses/LICENSE,sha256=3OYHIaaKX4UZJLdLHtwjLjDPFz0KH-kmRtEVi_AITWs,1076
+oniscrape-0.1.0.dist-info/RECORD,,

oniscrape-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

oniscrape-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 FastScraper Authors
+
+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.