scrapely-python 0.1.40__py3-none-any.whl → 0.1.42__py3-none-any.whl

scrapely/__init__.py

@@ -227,7 +227,7 @@ if TYPE_CHECKING:  # Static analysers and IDEs see the lazy names as plain impor
         set_api_storage,
     )
 
-__version__ = '0.1.40'
+__version__ = '0.1.41'
 __all__ = [
     # Core
     'Actor',

scrapely/actor.py

@@ -725,8 +725,23 @@ class Actor(metaclass=_ActorMeta):
 
         await cls._exit_with(opts)
 
+    @classmethod
+    def _truthful_status_message(cls, message: Optional[str]) -> Optional[str]:
+        """Name the limit that really stopped the run in a status message.
+
+        Actors word a refused charge as "the maximum charge for this run was
+        reached" whatever refused it. Once the run hit a limit, the charging
+        manager knows which one (the item limit, the maximum charge, the
+        balance), and that clause is replaced by its stop message.
+        """
+        rewrite = getattr(cls._charging_manager, 'rewrite_status_message', None)
+        if not message or rewrite is None:
+            return message
+        return rewrite(message)
+
     @classmethod
     async def _exit_with(cls, opts: ExitOptions, persist_message: bool = True) -> None:
+        opts.status_message = cls._truthful_status_message(opts.status_message)
         if opts.status_message and persist_message:
             logger.info(f'[Scrapely] {opts.status_message}')
 
@@ -1289,6 +1304,7 @@ class Actor(metaclass=_ActorMeta):
             The updated ActorRun object, or an empty ActorRun when running locally.
         """
         cls._ensure_initialized('set_status_message')
+        message = cls._truthful_status_message(message) or message
         opts = options or SetStatusMessageOptions()
         level = (getattr(opts, 'level', None) or 'INFO').upper()
         if is_terminal is None:
@@ -1371,6 +1387,7 @@ class Actor(metaclass=_ActorMeta):
         if not api_url or not token or not run_id:
             return None
 
+        message = cls._truthful_status_message(message) or message
         client = cls.new_client(token=token, base_url=api_url)
         # Setting the message is idempotent: a 429 (run API rate limit), 5xx or
         # dropped connection is retried with backoff instead of failing the run.

scrapely/charging.py

@@ -13,6 +13,7 @@ import contextvars
 import json
 import os
 import logging
+import re
 import time
 import uuid
 from datetime import datetime, timezone
@@ -75,6 +76,87 @@ def _is_transient_status(status: Optional[int]) -> bool:
 LOCAL_CHARGING_LOG_DATASET_NAME = 'charging_log'
 
 
+# Which run limit refused or cut down a charge (the platform's ``error.reason``
+# on HTTP 402 and ``limitedBy`` on a partial acceptance). The run's stop
+# message names it, so an item limit is never called a spending limit.
+CHARGE_LIMIT_MAX_ITEMS = 'max-items'
+CHARGE_LIMIT_MAX_CHARGE = 'max-charge'
+CHARGE_LIMIT_INSUFFICIENT_FUNDS = 'insufficient-funds'
+_CHARGE_LIMIT_REASONS = frozenset({CHARGE_LIMIT_MAX_ITEMS, CHARGE_LIMIT_MAX_CHARGE, CHARGE_LIMIT_INSUFFICIENT_FUNDS})
+
+
+def _format_usd(value: Any) -> str:
+    """$3.00, $0.005: two decimals unless the amount needs more."""
+    try:
+        amount = Decimal(str(value))
+    except Exception:
+        return f'${value}'
+    if amount == amount.quantize(Decimal('0.01')):
+        return f'${amount:.2f}'
+    return f"${format(amount.normalize(), 'f')}"
+
+
+def charge_limit_stop_message(
+    reason: Optional[str], *, max_items: Optional[int] = None, max_total_charge_usd: Any = None
+) -> Optional[str]:
+    """The run's stop message for a charge limit, or None when the reason is unknown."""
+    if reason == CHARGE_LIMIT_MAX_ITEMS:
+        if max_items is not None and max_items > 0:
+            unit = 'item' if max_items == 1 else 'items'
+            return f'Stopped: reached the item limit you set ({max_items} {unit})'
+        return 'Stopped: reached the item limit you set'
+    if reason == CHARGE_LIMIT_MAX_CHARGE:
+        if max_total_charge_usd is not None:
+            return f'Stopped: reached the maximum charge you set ({_format_usd(max_total_charge_usd)})'
+        return 'Stopped: reached the maximum charge you set'
+    if reason == CHARGE_LIMIT_INSUFFICIENT_FUNDS:
+        return 'Stopped: your account has no credit left for this run'
+    return None
+
+
+# A status-message clause that blames the spending limit ("stopped because the
+# maximum charge for this run was reached", "The run reached its maximum total
+# charge. Stopping.", ...). Actors written before the platform said which limit
+# was hit use such texts for every refused charge.
+_CHARGE_CLAIM_RE = re.compile(r'\bmax(?:imum)?\s+(?:total\s+)?charge|\bspending\s+limit', re.IGNORECASE)
+_CLAUSE_SEPARATOR_RE = re.compile(r'(;\s*|[.!?](?:\s+|$))')
+
+
+def rewrite_charge_limit_claims(message: str, stop_message: Optional[str]) -> str:
+    """Replace the clause of ``message`` that blames the spending limit with ``stop_message``.
+
+    "Saved 800 results; stopped because the maximum charge for this run was
+    reached" becomes "Saved 800 results. Stopped: reached the item limit you set
+    (800 items)". Only the first such clause is replaced (later ones are
+    dropped); a message without one is returned as is.
+    """
+    if not message or not stop_message or stop_message in message or not _CHARGE_CLAIM_RE.search(message):
+        return message
+    parts = _CLAUSE_SEPARATOR_RE.split(message)
+    out: List[str] = []
+    replaced = False
+    for i in range(0, len(parts), 2):
+        clause = parts[i]
+        sep = parts[i + 1] if i + 1 < len(parts) else ''
+        if not _CHARGE_CLAIM_RE.search(clause):
+            out.append(clause + sep)
+            continue
+        if replaced:
+            continue
+        replaced = True
+        if out and out[-1].rstrip().endswith(';'):
+            out[-1] = out[-1].rstrip()[:-1].rstrip() + '. '
+        lead = clause[: len(clause) - len(clause.lstrip())]
+        tail = ''
+        if sep:
+            tail = '.' + sep[len(sep.rstrip()):] if sep.strip() in (';', '.', '!', '?') else sep
+        out.append(lead + stop_message + tail)
+    result = ''.join(out).rstrip()
+    if message.rstrip().endswith('.') and not result.endswith('.'):
+        result += '.'
+    return result
+
+
 # Charge-limit safety net for the default dataset.
 #
 # Once a pay-per-event run has used up its spending limit (maxTotalChargeUsd),
@@ -205,6 +287,8 @@ class ChargeRejectedError(Exception):
         count: int,
         status_code: Optional[int] = None,
         reason: str = 'rejected',
+        limit_reason: Optional[str] = None,
+        max_items: Optional[int] = None,
     ) -> None:
         super().__init__(message)
         self.operation_id = operation_id
@@ -212,6 +296,9 @@ class ChargeRejectedError(Exception):
         self.count = count
         self.status_code = status_code
         self.reason = reason
+        # Which run limit refused the charge (CHARGE_LIMIT_*), when the platform said.
+        self.limit_reason = limit_reason
+        self.max_items = max_items
 
 
 class ChargingManager:
@@ -282,6 +369,13 @@ class ChargingManager:
         # Sticky: the platform refused or capped a charge (HTTP 402 / fewer
         # events accepted) or the local budget gate trimmed one.
         self._charge_limit_hit = False
+        # Which limit that was (CHARGE_LIMIT_*; the first one known wins) and the
+        # run's item limit as the platform reported it.
+        self._charge_limit_reason: Optional[str] = None
+        self._charge_limit_max_items: Optional[int] = None
+        # limitedBy / maxItems of the last partially accepted charge response.
+        self._last_limited_by: Optional[str] = None
+        self._last_limit_max_items: Optional[int] = None
         # Default-dataset rows refused after the limit (one warning, then a count).
         self._refused_default_dataset_items = 0
         # Prepaid-row balance: priced events charged through charge() minus rows
@@ -301,9 +395,9 @@ class ChargingManager:
         self._closed = True
         if self._refused_default_dataset_items:
             logger.warning(
-                '%s result(s) pushed to the default dataset after the spending limit was '
-                'reached were not saved',
+                '%s result(s) pushed to the default dataset after %s was reached were not saved',
                 self._refused_default_dataset_items,
+                self._limit_name(),
             )
 
     def _remaining_budget_usd(self) -> Decimal:
@@ -350,24 +444,107 @@ class ChargingManager:
             return False
         return self._remaining_budget_usd() < min(prices)
 
-    def _mark_charge_limit_hit(self) -> None:
+    def _mark_charge_limit_hit(self, reason: Optional[str] = None, max_items: Optional[int] = None) -> None:
         if self._pricing_info is not None:
             self._charge_limit_hit = True
+            if reason in _CHARGE_LIMIT_REASONS and self._charge_limit_reason is None:
+                self._charge_limit_reason = reason
+            if reason == CHARGE_LIMIT_MAX_ITEMS and max_items is not None and max_items > 0:
+                self._charge_limit_max_items = max_items
+
+    def _mark_rejected_charge(self, err: 'ChargeRejectedError') -> None:
+        """Record a definitive platform refusal that means the run's limit is used up."""
+        if _is_charge_limit_rejection(err):
+            self._mark_charge_limit_hit(err.limit_reason, err.max_items)
+
+    def _mark_partial_charge(self) -> None:
+        """The platform accepted fewer events than asked: record which limit cut it."""
+        self._mark_charge_limit_hit(self._last_limited_by, self._last_limit_max_items)
+
+    def _max_items_setting(self) -> Optional[int]:
+        """The run's item limit: as the platform reported it, else ACTOR_MAX_PAID_DATASET_ITEMS."""
+        if self._charge_limit_max_items is not None:
+            return self._charge_limit_max_items
+        try:
+            raw = self._config.get('actor_max_paid_dataset_items')
+            value = int(raw) if raw not in (None, '') else None
+        except (TypeError, ValueError):
+            value = None
+        return value if value is not None and value > 0 else None
+
+    def get_charge_limit_reason(self) -> Optional[str]:
+        """Why this run's charges stopped being accepted, or None while they still are.
+
+        One of ``'max-items'`` (the item limit the user set, maxItems),
+        ``'max-charge'`` (the maximum total charge, maxTotalChargeUsd) or
+        ``'insufficient-funds'`` (the account balance). Platforms that do not
+        say which limit it was: inferred from the run's settings.
+        """
+        if not self.is_charge_limit_reached():
+            return None
+        if self._charge_limit_reason is not None:
+            return self._charge_limit_reason
+        max_items = self._max_items_setting()
+        if max_items is not None and any(
+            count >= max_items
+            for name, count in self._charged_events.items()
+            if not is_default_dataset_item_event(name) and self._per_event_prices.get(name, 0) > 0
+        ):
+            return CHARGE_LIMIT_MAX_ITEMS
+        if self._max_total_charge_usd is not None:
+            prices = [price for price in self._per_event_prices.values() if price > 0]
+            if prices and self._remaining_budget_usd() < min(prices):
+                return CHARGE_LIMIT_MAX_CHARGE
+        return None
+
+    def get_charge_limit_message(self) -> Optional[str]:
+        """The run's stop message for the limit that was reached, or None.
+
+        "Stopped: reached the item limit you set (800 items)", "Stopped: reached
+        the maximum charge you set ($3.00)", ... Use it as (part of) the final
+        status message when the Actor stops because a charge was refused.
+        """
+        return charge_limit_stop_message(
+            self.get_charge_limit_reason(),
+            max_items=self._max_items_setting(),
+            max_total_charge_usd=self._max_total_charge_usd,
+        )
+
+    def rewrite_status_message(self, message: str) -> str:
+        """``message`` with a clause blaming the spending limit replaced by the real reason.
+
+        Only once a limit was reached; any other message is returned as is.
+        """
+        try:
+            return rewrite_charge_limit_claims(message, self.get_charge_limit_message())
+        except Exception:  # noqa: BLE001 - a status message must never break the run
+            return message
+
+    def _limit_name(self) -> str:
+        """'the item limit of this run (maxItems = 800)', ... for log lines."""
+        reason = self.get_charge_limit_reason()
+        if reason == CHARGE_LIMIT_MAX_ITEMS:
+            max_items = self._max_items_setting()
+            return f'the item limit of this run (maxItems = {max_items})' if max_items else 'the item limit of this run (maxItems)'
+        if reason == CHARGE_LIMIT_INSUFFICIENT_FUNDS:
+            return 'the end of the account balance'
+        if reason == CHARGE_LIMIT_MAX_CHARGE or self._max_total_charge_usd is not None:
+            limit = f'${self._max_total_charge_usd}' if self._max_total_charge_usd is not None else 'the limit'
+            return f'the spending limit of this run (maxTotalChargeUsd = {limit})'
+        return 'the limit of this run'
 
     def _note_refused_default_dataset_items(self, count: int) -> None:
         """Count rows dropped because of the limit; warn on the first one only."""
         if count <= 0:
             return
         if not self._refused_default_dataset_items:
-            limit = (
-                f'${self._max_total_charge_usd}' if self._max_total_charge_usd is not None else 'the limit'
-            )
+            name = self._limit_name()
             logger.warning(
-                'The spending limit of this run (maxTotalChargeUsd = %s) has been reached: '
+                '%s has been reached: '
                 'results pushed to the default dataset are no longer saved. The Actor should '
                 'stop now (check ChargeResult.event_charge_limit_reached or '
                 'Actor.get_charging_manager().is_charge_limit_reached()).',
-                limit,
+                name[0].upper() + name[1:],
             )
         self._refused_default_dataset_items += count
 
@@ -927,6 +1104,7 @@ class ChargingManager:
                     deadline=deadline,
                 )
                 self._last_remaining_budget_nd = _read_remaining_budget_nd(body)
+                self._last_limited_by, self._last_limit_max_items = _read_limited_by(body)
                 return _read_accepted_count(body, count)
             except Exception as e:
                 last_error = e
@@ -997,8 +1175,7 @@ class ChargingManager:
                             deadline=deadline,
                         )
                     except ChargeRejectedError as err:
-                        if _is_charge_limit_rejection(err):
-                            self._mark_charge_limit_hit()
+                        self._mark_rejected_charge(err)
                         self._unwind_reservation(event_name, count)
                         self._drop_pending(idempotency_key)
                         logger.warning(
@@ -1010,7 +1187,7 @@ class ChargingManager:
                         continue
                     if accepted is not None:
                         if accepted < count:
-                            self._mark_charge_limit_hit()
+                            self._mark_partial_charge()
                             self._unwind_reservation(event_name, count - accepted)
                         self._drop_pending(idempotency_key)
                         confirmed += 1
@@ -1100,7 +1277,8 @@ class ChargingManager:
                     )
 
             if chargeable_count < count:
-                self._mark_charge_limit_hit()
+                # The local budget gate: only maxTotalChargeUsd trims here.
+                self._mark_charge_limit_hit(CHARGE_LIMIT_MAX_CHARGE)
 
             if chargeable_count <= 0:
                 return ChargeResult(
@@ -1155,8 +1333,7 @@ class ChargingManager:
                     idempotency_key=idempotency_key,
                 )
             except ChargeRejectedError as rejected:
-                if _is_charge_limit_rejection(rejected):
-                    self._mark_charge_limit_hit()
+                self._mark_rejected_charge(rejected)
                 # Server definitively rejected: unwind local reservation.
                 self._drop_pending(idempotency_key)
                 self._unwind_reservation(event_name, chargeable_count)
@@ -1171,7 +1348,7 @@ class ChargingManager:
                     self._last_accepted_operation_id = idempotency_key
                 if accepted < chargeable_count:
                     # The platform capped the charge at the run's limit.
-                    self._mark_charge_limit_hit()
+                    self._mark_partial_charge()
                     self._unwind_reservation(event_name, chargeable_count - accepted)
                     chargeable_count = accepted
                     result = ChargeResult(
@@ -1223,11 +1400,12 @@ class ChargingManager:
         if chargeable_count < count:
             subject = 'instance' if count == 1 else 'instances'
             logger.info(
-                "Charging %s %s of '%s' event would exceed maxTotalChargeUsd - "
+                "Charging %s %s of '%s' event would exceed %s - "
                 'only %s events were charged',
                 count,
                 subject,
                 event_name,
+                self._limit_name(),
                 chargeable_count,
             )
 
@@ -1421,6 +1599,43 @@ def _read_remaining_budget_nd(body: Any) -> Optional[int]:
     return None
 
 
+def _positive_int(raw: Any) -> Optional[int]:
+    if isinstance(raw, (int, float)) and not isinstance(raw, bool) and raw > 0:
+        return int(raw)
+    return None
+
+
+def _read_limited_by(body: Any) -> tuple[Optional[str], Optional[int]]:
+    """limitedBy and maxItems of a partially accepted charge (platforms that send them)."""
+    if not isinstance(body, dict):
+        return None, None
+    data = body.get('data') if isinstance(body.get('data'), dict) else body
+    if not isinstance(data, dict):
+        return None, None
+    reason = data.get('limitedBy')
+    return (reason if reason in _CHARGE_LIMIT_REASONS else None), _positive_int(data.get('maxItems'))
+
+
+def _rejection_limit(body: Any, message: str) -> tuple[Optional[str], Optional[int]]:
+    """Which limit a 402 names: error.reason, else its message (older platforms)."""
+    reason: Optional[str] = None
+    max_items: Optional[int] = None
+    if isinstance(body, dict):
+        error = body.get('error')
+        if isinstance(error, dict) and error.get('reason') in _CHARGE_LIMIT_REASONS:
+            reason = error['reason']
+        max_items = _positive_int(body.get('maxItems'))
+    if reason is None:
+        text = message.lower()
+        if 'maxitems' in text or 'maximum number of results' in text:
+            reason = CHARGE_LIMIT_MAX_ITEMS
+        elif 'insufficient balance' in text:
+            reason = CHARGE_LIMIT_INSUFFICIENT_FUNDS
+        elif 'maximum total charge' in text:
+            reason = CHARGE_LIMIT_MAX_CHARGE
+    return reason, max_items
+
+
 def _read_accepted_count(body: Any, fallback: int) -> int:
     if not isinstance(body, dict):
         return fallback
@@ -1446,6 +1661,9 @@ def _classify_charge_http_error(
 
     # 401/403: ownership or scoped-run authorization failures are permanent.
     if status in (400, 401, 402, 403, 404, 405, 409):
+        limit_reason, max_items = (
+            _rejection_limit(getattr(err, 'body', None), str(err)) if status == 402 else (None, None)
+        )
         return ChargeRejectedError(
             f'Charge rejected by platform (HTTP {status}) for event {event_name!r}',
             operation_id=operation_id,
@@ -1453,6 +1671,8 @@ def _classify_charge_http_error(
             count=count,
             status_code=int(status) if status is not None else None,
             reason='charge-limit-exceeded' if status == 402 else f'http-{status}',
+            limit_reason=limit_reason,
+            max_items=max_items,
         )
 
     # A 5xx / 408 / 429 answer is never a definitive rejection, whatever its text
@@ -1472,6 +1692,11 @@ def _classify_charge_http_error(
             'conflict',
         )
     ):
+        limit_reason, max_items = (
+            _rejection_limit(getattr(err, 'body', None), message)
+            if 'charge-limit-exceeded' in message.lower()
+            else (None, None)
+        )
         return ChargeRejectedError(
             message,
             operation_id=operation_id,
@@ -1479,6 +1704,8 @@ def _classify_charge_http_error(
             count=count,
             status_code=int(status) if isinstance(status, int) else None,
             reason='message-match',
+            limit_reason=limit_reason,
+            max_items=max_items,
         )
     return None
 
@@ -1580,7 +1807,7 @@ async def push_data_and_charge(
         limited_items = items[:limited_count] if limited_count < len(items) else items
         if is_ppe and is_default_dataset and limited_count < len(items):
             # Rows beyond what the budget can pay for are dropped.
-            charging_manager._mark_charge_limit_hit()
+            charging_manager._mark_charge_limit_hit(CHARGE_LIMIT_MAX_CHARGE)
             charging_manager._note_refused_default_dataset_items(len(items) - limited_count)
 
         if not limited_items:

scrapely/http/_client.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import asyncio
+import dataclasses
 import logging
 import random
 import threading
@@ -102,14 +103,30 @@ def _proxy_from_proxies(proxies: Any) -> Optional[str]:
 
 
 class _Pin:
-    """Holder of a pinned identity (a session)."""
+    """Holder of a pinned identity (a session).
 
-    __slots__ = ('identity', 'alock', 'tlock')
+    ``keep``: the identity is never retired or swapped by the client (no
+    rotation on a block or error, no usage/age expiry); only ``rotate()`` or
+    closing the session moves it to a new one.
+    """
+
+    __slots__ = ('identity', 'alock', 'tlock', 'keep')
 
-    def __init__(self) -> None:
+    def __init__(self, keep: bool = False) -> None:
         self.identity: Optional[Identity] = None
         self.alock: Optional[asyncio.Lock] = None
         self.tlock = threading.Lock()
+        self.keep = keep
+
+
+def _no_rotation(decision: Any) -> Any:
+    """The policy's decision with the rotation taken out (kept identities): stop here, retire nothing."""
+    try:
+        return dataclasses.replace(decision, retry=False, retire=False, delay=0.0)
+    except TypeError:
+        decision.retry = False
+        decision.retire = False
+        return decision
 
 
 class CookieStore:
@@ -522,7 +539,7 @@ class AsyncClient(_Base):
                 pin.alock = asyncio.Lock()
             async with pin.alock:
                 ident = pin.identity
-                if ident is not None and ident.expired(self._clock(), self.max_usage, self.max_age):
+                if ident is not None and not pin.keep and ident.expired(self._clock(), self.max_usage, self.max_age):
                     pin.identity = None
                     await self._retire(ident)
                     ident = None
@@ -558,6 +575,8 @@ class AsyncClient(_Base):
     async def _release(self, pin: Optional[_Pin], ident: Identity, retire: bool) -> None:
         ident.in_flight -= 1
         if pin is not None:
+            if pin.keep and pin.identity is ident:
+                return
             if retire or not self.sticky:
                 if pin.identity is ident:
                     pin.identity = None
@@ -658,12 +677,16 @@ class AsyncClient(_Base):
                 # Cancelled or failed in our own code: nothing says the identity is burnt.
                 await self._release(_pin, ident, retire=False)
                 raise
+            if decision.retry and not decision.same_identity and _pin is not None and _pin.keep:
+                # A kept identity is never swapped: the block or error goes back to the caller as is.
+                decision = _no_rotation(decision)
             if not decision.retry:
                 await self._release(_pin, ident, retire=decision.retire)
                 ok = resp is not None and reason is None and resp.status_code < 500
                 self._stats.record_request(ok)
                 if resp is None:
-                    assert error is not None
+                    if error is None:
+                        raise RuntimeError('scrapely.http: request ended with no response and no error')
                     raise error
                 resp.blocked = reason
                 return resp
@@ -703,14 +726,21 @@ class AsyncClient(_Base):
     async def options(self, url: str, **kwargs: Any) -> Response:
         return await self.request('OPTIONS', url, **kwargs)
 
-    def session(self) -> 'AsyncHttpSession':
+    def session(self, keep_identity: bool = False) -> 'AsyncHttpSession':
         """A pinned identity for multi-step flows (homepage → API with its cookies).
 
         All requests of the session use one profile, proxy session and cookie
         jar. On a block the whole identity is retired and the session continues
         on a fresh one (new IP, new profile, empty jar).
+
+        ``keep_identity=True`` keeps the identity and its jar on a block or an
+        error too: the blocked response comes back (``response.blocked`` names
+        the block) and the next request goes out on the same profile, exit and
+        cookies. That is what a challenge solve needs (the SBSD bundle, the
+        sensor submissions and the page fetches must share one identity).
+        ``rotate()`` moves the session to a fresh identity when you decide to.
         """
-        return AsyncHttpSession(self)
+        return AsyncHttpSession(self, keep_identity=keep_identity)
 
     async def aclose(self) -> None:
         if self._closed:
@@ -733,11 +763,21 @@ class AsyncClient(_Base):
 class AsyncHttpSession:
     """A pinned identity on an ``AsyncClient`` (see ``AsyncClient.session()``)."""
 
-    def __init__(self, client: AsyncClient) -> None:
+    def __init__(self, client: AsyncClient, keep_identity: bool = False) -> None:
         self._client = client
-        self._pin = _Pin()
+        self._pin = _Pin(keep=keep_identity)
         self.cookies = _SessionCookies(self)
 
+    @property
+    def keep_identity(self) -> bool:
+        return self._pin.keep
+
+    async def rotate(self) -> None:
+        """Retire the current identity; the next request opens a fresh one (new exit, profile and jar)."""
+        if self._pin.identity is not None:
+            ident, self._pin.identity = self._pin.identity, None
+            await self._client._retire(ident, force=ident.in_flight <= 0)
+
     @property
     def profile(self) -> Optional[str]:
         return self._pin.identity.profile.label if self._pin.identity else None
@@ -873,7 +913,7 @@ class Client(_Base):
         if pin is not None:
             with pin.tlock:
                 ident = pin.identity
-                if ident is not None and ident.expired(self._clock(), self.max_usage, self.max_age):
+                if ident is not None and not pin.keep and ident.expired(self._clock(), self.max_usage, self.max_age):
                     pin.identity = None
                     self._retire(ident)
                     ident = None
@@ -918,6 +958,8 @@ class Client(_Base):
         with self._lock:
             ident.in_flight -= 1
         if pin is not None:
+            if pin.keep and pin.identity is ident:
+                return
             if retire or not self.sticky:
                 with pin.tlock:
                     if pin.identity is ident:
@@ -1023,12 +1065,15 @@ class Client(_Base):
                 # Failed in our own code: nothing says the identity is burnt.
                 self._release(_pin, ident, retire=False)
                 raise
+            if decision.retry and not decision.same_identity and _pin is not None and _pin.keep:
+                decision = _no_rotation(decision)
             if not decision.retry:
                 self._release(_pin, ident, retire=decision.retire)
                 ok = resp is not None and reason is None and resp.status_code < 500
                 self._stats.record_request(ok)
                 if resp is None:
-                    assert error is not None
+                    if error is None:
+                        raise RuntimeError('scrapely.http: request ended with no response and no error')
                     raise error
                 resp.blocked = reason
                 return resp
@@ -1067,9 +1112,9 @@ class Client(_Base):
     def options(self, url: str, **kwargs: Any) -> Response:
         return self.request('OPTIONS', url, **kwargs)
 
-    def session(self) -> 'HttpSession':
+    def session(self, keep_identity: bool = False) -> 'HttpSession':
         """A pinned identity for multi-step flows (see ``AsyncClient.session``)."""
-        return HttpSession(self)
+        return HttpSession(self, keep_identity=keep_identity)
 
     def close(self) -> None:
         if self._closed:
@@ -1090,11 +1135,22 @@ class Client(_Base):
 class HttpSession:
     """A pinned identity on a sync ``Client`` (see ``Client.session()``)."""
 
-    def __init__(self, client: Client) -> None:
+    def __init__(self, client: Client, keep_identity: bool = False) -> None:
         self._client = client
-        self._pin = _Pin()
+        self._pin = _Pin(keep=keep_identity)
         self.cookies = _SessionCookies(self)
 
+    @property
+    def keep_identity(self) -> bool:
+        return self._pin.keep
+
+    def rotate(self) -> None:
+        """Retire the current identity; the next request opens a fresh one (new exit, profile and jar)."""
+        with self._pin.tlock:
+            ident, self._pin.identity = self._pin.identity, None
+        if ident is not None:
+            self._client._retire(ident, force=ident.in_flight <= 0)
+
     @property
     def profile(self) -> Optional[str]:
         return self._pin.identity.profile.label if self._pin.identity else None

scrapely/solver.py

@@ -62,6 +62,7 @@ from typing import Any, Awaitable, Callable, Optional
 import httpx
 
 __all__ = [
+    "AkamaiSensor",
     "Clearance",
     "DEGRADED_STATUS_MESSAGE",
     "IpBanned",
@@ -72,11 +73,16 @@ __all__ = [
     "SolverAuthError",
     "SolverRateLimited",
     "SolverRequestInvalid",
+    "SensorResult",
     "SolverUnavailable",
     "VendorUnavailable",
+    "abck_state",
     "check_solver_response",
     "degraded_status_message",
     "detect_vendor",
+    "find_pixel_collector",
+    "find_sbsd_bundle",
+    "find_sensor_script",
     "is_blocked",
     "solver_env",
     "solver_status",
@@ -874,3 +880,361 @@ class Solver:
         if not ok:
             raise SolveAttemptError("still blocked after the clearance was applied")
         return clearance
+
+
+# ─── Akamai Bot Manager on your own session (sensor WebSocket lane + SBSD) ──
+
+
+_SCRIPT_SRC_RE = re.compile(r"<script[^>]+src=[\"']([^\"']+)[\"']", re.I)
+_SBSD_NONCE_RE = re.compile(r"(?:^|&)v=[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}(?:&|$)", re.I)
+_PIXEL_PATH_RE = re.compile(r"^/akam/\d+/")
+_LONG_PATH_RE = re.compile(r"<script[^>]+src=[\"']((?:/[a-zA-Z0-9\-_]+){5,10}(?:\?v=[^\"']*)?)[\"']", re.I)
+_AKAM_PIXEL_TAG_RE = re.compile(r"akam/13.*?top:\s?-999px.*?src=\"(.*?)\"", re.S)
+_AKAM_KEYWORD_RE = re.compile(r"<script[^>]+src=[\"']([^\"']*/(?:akam|_abck|bm-)[^\"']+)[\"']", re.I)
+_STRIP_SCRIPTS_RE = re.compile(r"<script\b[^<]*(?:(?!</script>)<[^<]*)*</script>", re.I)
+# Headers the submission must carry from YOUR client (its fingerprint), never the solver's copy.
+_OWN_HEADERS = {"user-agent", "cookie", "host", "content-length", "accept-language", "accept-encoding", "connection",
+                "sec-ch-ua", "sec-ch-ua-mobile", "sec-ch-ua-platform"}
+
+
+def _urljoin(base: str, ref: str) -> str:
+    from urllib.parse import urljoin
+
+    return urljoin(base, ref)
+
+
+def _is_sbsd_bundle(url: str) -> bool:
+    u = httpx.URL(url)
+    return u.path.startswith("/.well-known/sbsd") or bool(_SBSD_NONCE_RE.search(u.query.decode() if isinstance(u.query, bytes) else str(u.query or "")))
+
+
+def _is_sensor_candidate(url: str) -> bool:
+    return not _is_sbsd_bundle(url) and not _PIXEL_PATH_RE.match(httpx.URL(url).path)
+
+
+def _sbsd_src(html: str, base_url: str) -> tuple[str, str] | None:
+    for m in _SCRIPT_SRC_RE.finditer(html or ""):
+        u = _urljoin(base_url, m.group(1))
+        if _is_sbsd_bundle(u):
+            return m.group(1), u
+    return None
+
+
+def find_sbsd_bundle(html: str, base_url: str) -> str | None:
+    """URL of the SBSD bundle script a page loads (``src`` with a UUID ``v=``, or ``/.well-known/sbsd``), or None."""
+    found = _sbsd_src(html, base_url)
+    return found[1] if found else None
+
+
+def find_sensor_script(html: str, base_url: str) -> str | None:
+    """URL of the Akamai ``_abck`` sensor script in a page, or None (the provider examples' three patterns)."""
+    html = html or ""
+    m = _AKAM_PIXEL_TAG_RE.search(html)
+    if m:
+        u = _urljoin(base_url, m.group(1))
+        if _is_sensor_candidate(u):
+            return u
+    for m in _LONG_PATH_RE.finditer(html):
+        u = _urljoin(base_url, m.group(1))
+        if _is_sensor_candidate(u):
+            return u
+    m = _AKAM_KEYWORD_RE.search(html)
+    if m:
+        u = _urljoin(base_url, m.group(1))
+        if _is_sensor_candidate(u):
+            return u
+    return None
+
+
+_PIXEL_COLLECTOR_RE = re.compile(r"<script[^>]+src=[\"']([^\"']*/akam/\d+/[0-9a-f]{6,})[\"']", re.I)
+
+
+def find_pixel_collector(html: str, base_url: str) -> str | None:
+    """URL of Akamai's pixel collector script (``/akam/<n>/<hex>``, it POSTs to ``/akam/<n>/pixel_<hex>``), or None."""
+    m = _PIXEL_COLLECTOR_RE.search(html or "")
+    return _urljoin(base_url, m.group(1)) if m else None
+
+
+def pixel_target(collector_url: str) -> str:
+    """The endpoint a pixel collector POSTs to: its own directory, ``pixel_`` + its basename, no query."""
+    u = httpx.URL(collector_url)
+    head, _, name = u.path.rpartition("/")
+    return f"{u.scheme}://{u.host}{head}/pixel_{name}"
+
+
+def abck_state(value: str | None) -> str | None:
+    """The state field of an ``_abck`` cookie: ``'0'`` accepted, ``'-1'`` keep going, None when absent."""
+    parts = (value or "").split("~")
+    return parts[1] if len(parts) > 1 else None
+
+
+def _cookie_dict(session: Any) -> dict[str, str]:
+    jar = getattr(session, "cookies", None)
+    if jar is None:
+        return {}
+    try:
+        if hasattr(jar, "jar"):
+            return {c.name: c.value for c in jar.jar}
+        return dict(jar.items())
+    except Exception:  # noqa: BLE001
+        return {}
+
+
+def _ws_connect(url: str, headers: dict[str, str]) -> Any:
+    """websockets.connect with request headers (``additional_headers`` from 13, ``extra_headers`` before)."""
+    import websockets
+
+    try:
+        return websockets.connect(url, additional_headers=headers, max_size=32 * 1024 * 1024, open_timeout=30)
+    except TypeError:
+        return websockets.connect(url, extra_headers=headers, max_size=32 * 1024 * 1024, open_timeout=30)
+
+
+def _refused_upgrade(exc: BaseException) -> tuple[int, str, str | None]:
+    """(status, body, Retry-After) of a refused WebSocket upgrade, across websockets versions."""
+    response = getattr(exc, "response", None)
+    if response is not None:
+        status = int(getattr(response, "status_code", 0) or 0)
+        raw = getattr(response, "body", b"") or b""
+        headers = getattr(response, "headers", None)
+        return status, raw.decode("utf-8", "replace") if isinstance(raw, (bytes, bytearray)) else str(raw), headers.get("retry-after") if headers is not None else None
+    status = int(getattr(exc, "status_code", 0) or 0)
+    headers = getattr(exc, "headers", None)
+    return status, "", headers.get("retry-after") if headers is not None else None
+
+
+def _is_scrapely_http(session: Any) -> bool:
+    return type(session).__module__.startswith("scrapely.http")
+
+
+async def _session_send(session: Any, method: str, url: str, *, headers: dict, body: str | bytes | None, kind: str, timeout: float) -> tuple[int, str]:
+    kwargs: dict[str, Any] = {"headers": headers, "timeout": timeout}
+    if body is not None:
+        data = body.encode() if isinstance(body, str) else body
+        kwargs["content" if (_is_httpx(session) or _is_scrapely_http(session)) else "data"] = data
+    if _is_scrapely_http(session):
+        # One identity for the whole solve: no rotation, and a 403 is an answer, not a block to route around.
+        kwargs.update(kind=kind, max_rotations=0, is_blocked=lambda r: None)
+    r = await session.request(method, url, **kwargs)
+    return _status_body(r)
+
+
+@dataclass
+class SensorResult:
+    """Outcome of ``AkamaiSensor.solve_abck``: whether the provider reported ``_abck`` accepted."""
+
+    accepted: bool
+    rounds: int = 0
+    submissions: int = 0
+    abck: str | None = None
+    error: str | None = None
+
+
+class AkamaiSensor:
+    """Akamai Bot Manager solved on YOUR HTTP session, the way the provider's own examples do it.
+
+    Two independent channels, both answered through the session you pass, so
+    every request carries your client's fingerprint, exit IP and cookie jar:
+
+    * ``solve_sbsd(session, url, html)``: the page loads an SBSD bundle (a
+      script whose ``src`` has a UUID ``v=``, often a ~440-byte "Access Denied"
+      bootstrap). The bundle is fetched on your session, the provider computes
+      the ledger (``/akamai/sbsd/generate-session``), and its rows are POSTed to
+      the bundle path on your session.
+    * ``solve_abck(session, url, html)``: the classic ``_abck`` sensor over the
+      provider's stateful WebSocket (``/akamai/session``, relayed by the
+      platform for runs). The provider generates each sensor; it is POSTed on
+      your session; rounds continue until ``_abck`` is ``~0~``.
+
+    ``solve(session, url, html)`` does SBSD when the page carries a bundle, then ``_abck``.
+
+    Use a session that keeps its identity on a block (``http.session(keep_identity=True)``
+    of ``scrapely.http``, or one curl_cffi / httpx client): the solve, the
+    retries and the page fetches must share one identity, jar and exit. The
+    ``profile_id`` must be the browser your client claims (``chrome-154-macos``
+    for scrapely.http Chrome 154 on macOS, ``chrome-146-macos`` for curl_cffi
+    ``impersonate="chrome146"``); a mismatch shows as ``_abck`` stuck at ``~-1~``.
+
+    Example::
+
+        http = AsyncClient(proxy_configuration=proxy, fingerprint_options=FingerprintOptions(
+            browsers=[{"name": "chrome", "min_version": 154, "max_version": 154}], operating_systems=["macos"]))
+        session = http.session(keep_identity=True)
+        akamai = AkamaiSensor(profile_id="chrome-154-macos")
+        home = await session.get("https://www.example.com/")
+        result = await akamai.solve(session, "https://www.example.com/", home.text)
+        page = await session.get("https://www.example.com/item/1")
+    """
+
+    def __init__(
+        self,
+        profile_id: str = "chrome-154-macos",
+        *,
+        telemetry: dict | None = None,
+        timeout: float = 90.0,
+        request_timeout: float = 30.0,
+        max_rounds: int = 12,
+    ) -> None:
+        self.profile_id = profile_id
+        self.telemetry = telemetry
+        self.timeout = timeout
+        self.request_timeout = request_timeout
+        self.max_rounds = max_rounds
+        self.sessions = 0
+        self.accepted = 0
+
+    @staticmethod
+    def _endpoint() -> tuple[str, str]:
+        env = solver_env()
+        if env is None:
+            raise VendorUnavailable("solver_not_enabled", "akamai", None, "the platform solver is not available to this run")
+        return env
+
+    # -- SBSD --------------------------------------------------------------------
+
+    async def solve_sbsd(self, session: Any, url: str, html: str) -> bool:
+        """Answers the SBSD bundle of `html` (the page `url` as your session got it). False when there is none."""
+        found = _sbsd_src(html, url)
+        if not found:
+            return False
+        src_attr, bundle_url = found
+        base, key = self._endpoint()
+        origin = f"{httpx.URL(url).scheme}://{httpx.URL(url).host}"
+        _, source = await _session_send(session, "GET", bundle_url, headers={"referer": url, "sec-fetch-dest": "script", "sec-fetch-mode": "no-cors", "sec-fetch-site": "same-origin", "accept": "*/*"}, body=None, kind="xhr", timeout=self.request_timeout)
+        cookie_header = "; ".join(f"{k}={v}" for k, v in _cookie_dict(session).items())
+        async with httpx.AsyncClient(timeout=self.timeout) as api:
+            r = await api.post(
+                f"{base}/akamai/sbsd/generate-session",
+                headers={"x-api-key": key},
+                json={"bundle": {"scriptSrc": src_attr, "source": source}, "document": {"url": url, "html": html, "cookieHeader": cookie_header}, "profile": {"id": self.profile_id}},
+            )
+        check_solver_response(r.status_code, r.text, r.headers.get("retry-after"))
+        data = _json(r.text)
+        rows = sorted([s for s in data.get("submissions") or [] if isinstance(s, dict) and s.get("resolvedUrl")], key=lambda s: s.get("index", 0))
+        if not rows:
+            raise SolveAttemptError(f"the SBSD ledger had no rows ({str(data.get('error') or data.get('outcome') or 'no reason')[:120]})")
+        for row in rows:
+            target = _urljoin(url, row["resolvedUrl"])
+            if not _step_allowed(target, url):
+                raise SolveAttemptError("the SBSD ledger pointed outside the target site; refused")
+            await _session_send(session, "POST", target, headers={"content-type": "text/plain;charset=UTF-8", "origin": origin, "referer": url, "sec-fetch-dest": "empty", "sec-fetch-mode": "cors", "sec-fetch-site": "same-origin", "accept": "*/*"}, body=row.get("body") or "", kind="xhr", timeout=self.request_timeout)
+        return True
+
+    # -- pixel channel (/akam/<n>/<hex> collector) -----------------------------------
+
+    async def solve_pixel(self, session: Any, url: str, html: str) -> bool:
+        """Answers Akamai's pixel channel of `html`: the collector script is fetched on your session, the solver
+        writes the POST the collector would send (``/akamai/pixel/generate``), and it is POSTed to the collector's
+        ``pixel_`` endpoint on your session. False when the page has no collector."""
+        collector = find_pixel_collector(html, url)
+        if not collector:
+            return False
+        base, key = self._endpoint()
+        origin = f"{httpx.URL(url).scheme}://{httpx.URL(url).host}"
+        _, source = await _session_send(session, "GET", collector, headers={"referer": url, "sec-fetch-dest": "script", "sec-fetch-mode": "no-cors", "sec-fetch-site": "same-origin", "accept": "*/*"}, body=None, kind="xhr", timeout=self.request_timeout)
+        cookie_header = "; ".join(f"{k}={v}" for k, v in _cookie_dict(session).items())
+        async with httpx.AsyncClient(timeout=self.timeout) as api:
+            r = await api.post(
+                f"{base}/akamai/pixel/generate",
+                headers={"x-api-key": key, "accept": "application/json"},
+                json={"document": {"url": url, "html": html, **({"cookieHeader": cookie_header} if cookie_header else {})},
+                      "profile": {"id": self.profile_id}, "script": {"source": source, "url": collector}},
+            )
+        check_solver_response(r.status_code, r.text, r.headers.get("retry-after"))
+        data = _json(r.text)
+        request = data.get("request") if isinstance(data.get("request"), dict) else {}
+        if not data.get("ok") or not isinstance(request.get("body"), str):
+            err = data.get("error") if isinstance(data.get("error"), dict) else {}
+            raise SolveAttemptError(f"the pixel route refused ({err.get('code') or r.status_code})")
+        # The collector's own endpoint, not the solver's reconstruction of it (the provider examples do the same).
+        target = pixel_target(collector)
+        await _session_send(session, "POST", target, headers={"content-type": request.get("contentType") or "application/x-www-form-urlencoded", "origin": origin, "referer": url, "sec-fetch-dest": "empty", "sec-fetch-mode": "cors", "sec-fetch-site": "same-origin", "accept": "*/*"}, body=request["body"], kind="xhr", timeout=self.request_timeout)
+        return True
+
+    # -- _abck sensor (WebSocket) ---------------------------------------------------
+
+    async def solve_abck(self, session: Any, url: str, html: str, *, script_url: str | None = None) -> SensorResult:
+        """Runs the ``_abck`` sensor rounds for the page `url` (its `html` as your session got it)."""
+        import websockets
+
+        script_url = script_url or find_sensor_script(html, url)
+        if not script_url:
+            return SensorResult(accepted=False, error="no Akamai sensor script in the page")
+        base, key = self._endpoint()
+        origin = f"{httpx.URL(url).scheme}://{httpx.URL(url).host}"
+        _, script = await _session_send(session, "GET", script_url, headers={"referer": url, "sec-fetch-dest": "script", "sec-fetch-mode": "no-cors", "sec-fetch-site": "same-origin", "accept": "*/*"}, body=None, kind="xhr", timeout=self.request_timeout)
+        init: dict[str, Any] = {
+            "type": "init", "url": url, "script": script, "scriptUrl": script_url, "html": _STRIP_SCRIPTS_RE.sub("", html or ""),
+            "cookies": _cookie_dict(session), "profileId": self.profile_id,
+        }
+        if self.telemetry:
+            init["profile"] = self.telemetry
+        ws_url = re.sub(r"^http", "ws", base, flags=re.I) + "/akamai/session"
+        result = SensorResult(accepted=False)
+        self.sessions += 1
+        deadline = time.monotonic() + self.timeout
+        try:
+            async with _ws_connect(ws_url, {"x-api-key": key}) as ws:
+                await ws.send(json.dumps(init))
+                while True:
+                    left = deadline - time.monotonic()
+                    if left <= 0:
+                        result.error = f"not accepted within {self.timeout:g}s"
+                        break
+                    try:
+                        raw = await asyncio.wait_for(ws.recv(), timeout=left)
+                    except asyncio.TimeoutError:
+                        result.error = f"not accepted within {self.timeout:g}s"
+                        break
+                    msg = _json(raw if isinstance(raw, str) else raw.decode("utf-8", "replace"))
+                    kind = msg.get("type")
+                    if kind == "submission":
+                        result.submissions += 1
+                        if result.submissions > self.max_rounds:
+                            result.error = f"not accepted after {self.max_rounds} rounds"
+                            break
+                        target = str(msg.get("url") or "")
+                        headers = {k: v for k, v in (msg.get("headers") or {}).items() if k.lower() not in _OWN_HEADERS}
+                        headers.setdefault("origin", origin)
+                        headers.setdefault("referer", url)
+                        if not _step_allowed(target, url):
+                            await ws.send(json.dumps({"type": "submission_response", "id": msg.get("id"), "status": 0, "body": "Client error: refused a submission outside the target site"}))
+                            continue
+                        try:
+                            status, body = await _session_send(session, str(msg.get("method") or "POST"), target, headers=headers, body=msg.get("body") or "", kind="xhr", timeout=self.request_timeout)
+                        except Exception as exc:  # noqa: BLE001
+                            status, body = 0, f"Client error: {type(exc).__name__}"
+                        await ws.send(json.dumps({"type": "submission_response", "id": msg.get("id"), "status": status, "body": body, "cookies": _cookie_dict(session)}))
+                    elif kind == "cookie_update":
+                        result.rounds = int(msg.get("round") or result.rounds + 1)
+                        result.abck = abck_state((msg.get("cookies") or {}).get("_abck")) or result.abck
+                        if msg.get("accepted"):
+                            result.accepted = True
+                            break
+                    elif kind == "status" and str(msg.get("state") or "") == "accepted":
+                        result.accepted = True
+                        break
+                    elif kind == "error":
+                        result.error = str(msg.get("message") or msg.get("code") or "solver error")[:300]
+                        if msg.get("code") == "invalid_request":
+                            raise SolverRequestInvalid(result.error)
+        except websockets.exceptions.InvalidHandshake as exc:  # a refused upgrade carries the gateway's JSON error
+            status, body, retry_after = _refused_upgrade(exc)
+            if status:
+                check_solver_response(status, body, retry_after)
+            raise SolveAttemptError(f"solver session refused ({status or type(exc).__name__})") from exc
+        except (OSError, asyncio.TimeoutError, websockets.exceptions.WebSocketException) as exc:
+            if not result.accepted:
+                result.error = result.error or f"solver session failed: {type(exc).__name__}"
+        result.abck = abck_state(_cookie_dict(session).get("_abck")) or result.abck
+        if result.accepted:
+            self.accepted += 1
+        return result
+
+    async def solve(self, session: Any, url: str, html: str) -> SensorResult:
+        """SBSD when the page carries a bundle, then the ``_abck`` sensor (on the page as it is after SBSD)."""
+        if find_sbsd_bundle(html, url):
+            await self.solve_sbsd(session, url, html)
+            if not find_sensor_script(html, url) or len(html) < 5000:
+                _, html = await _session_send(session, "GET", url, headers={"referer": url}, body=None, kind="navigate", timeout=self.request_timeout)
+        return await self.solve_abck(session, url, html)

{scrapely_python-0.1.40.dist-info → scrapely_python-0.1.42.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scrapely-python
-Version: 0.1.40
+Version: 0.1.42
 Summary: Scrapely Python SDK - A toolkit for building Actors on the Scrapely platform
 Author-email: Scrapely <hello@scrape.ly>
 License-Expression: MIT AND Apache-2.0

{scrapely_python-0.1.40.dist-info → scrapely_python-0.1.42.dist-info}/RECORD

@@ -1,9 +1,9 @@
-scrapely/__init__.py,sha256=cTs0rZD-AnrB6WLOzrhgGkh9XqmYj8Ihvqk80JFPjsM,9668
+scrapely/__init__.py,sha256=5ifQCxUm8btxkp_9q1u6UPSgimx-D63FCey6Nydp6SM,9668
 scrapely/_browser_locations.py,sha256=8QVVnkms2bDn3_LDYgYDR59MvFx8757l_JYnZ7xb3oI,145269
-scrapely/actor.py,sha256=z-kL24Y6m98v6lKLOxGYCnFmhVhaHJ6c0uOdYZW_4ak,93514
+scrapely/actor.py,sha256=nT-4xWfqx2Cd8swQ6DFkT8n8xYCoPy9a4dbA1bB-1GI,94391
 scrapely/browser_configuration.py,sha256=jAZapNSHLFW05B96df4wNBtcyiiU9DA3ml0yTL1FwfA,5770
 scrapely/cdp_retry.py,sha256=hdTJEAIKhApM7IOk1DrQEl8NoflSJSmqd4RbNJ2IsgI,8540
-scrapely/charging.py,sha256=xWYBFSr20UN5ySW0Vp1g0Dl6SppXN1y9qvMPQ1B0F1M,95615
+scrapely/charging.py,sha256=qnlqSjKeaJnWepUl9alLytHooihRIVU2CruIYGlFcnk,106445
 scrapely/charging_client.py,sha256=-4q-Ww7gu9EZXpM9QIn1Vd4vwAXmgL_WEKqaQIx3ViA,3961
 scrapely/configuration.py,sha256=ONnzw4mhtrY2jVvoVUQ48dMgmMWnx3Gv7fXrT4pY9z8,16919
 scrapely/errors.py,sha256=V8JBCGSyqrbwMD9GDv6ahWhZ92n2cb8AWxkxth6mcI8,4062
@@ -12,7 +12,7 @@ scrapely/patch_browser_pool.py,sha256=eZck-JSOvCuXdoGQaX6xUsKVGzolDlB4uKiBSBrFyr
 scrapely/pricing_types.py,sha256=yy2nXmCxL0BvUXRtWnznwhoInYeVdWObMRT5Fo0fc4I,5083
 scrapely/proxy_configuration.py,sha256=YAg2xm8eK4B14vCRWsSJxgtMIxdDJXbM66pZDx-HShk,39018
 scrapely/py.typed,sha256=XtWlywqUjc6x_M2gAXlDtYXbAsYkCjKZEjFyJvaHvm4,105
-scrapely/solver.py,sha256=RVoLNJTxniTI5SzDRpUdxe0ajzy4qqjuEmToTL1GRzA,35863
+scrapely/solver.py,sha256=9wVldJmye1P1f4c4bfZAMoRMRYB_CzmGY0Y2ZkI1nLI,55358
 scrapely/types.py,sha256=2yGedPfb5786UNqnlnRG5Cw4Pbyc4EPBiYeoU2kix3I,8812
 scrapely/webhook.py,sha256=GUpQXQ1UYCKi3WZPJ9reztpilBXvwqYInXJxUax36M8,2823
 scrapely/crypto/__init__.py,sha256=MbMPs7Eq_fGSVjOZxNts_JckDCUtxCVqdkHU0VCfN4M,481
@@ -22,7 +22,7 @@ scrapely/events/_types.py,sha256=XslMIEAQOe7othqevnxO86c7i7AysbvDLHH0lep64QU,599
 scrapely/events/event_manager.py,sha256=svqrMb3KtSLvWBBoDrL6ozXaBE-IlHrdrh-rFPDnveM,12988
 scrapely/http/__init__.py,sha256=KGbINWi2WY6tN4CTM6c4-RIOQGL6iV3giNCYoGYJfWU,1949
 scrapely/http/_capture.py,sha256=wtS3bl_hNjICgxg3Iu_aL4uniQ_6xzXk_XsxGzpoBLE,3024
-scrapely/http/_client.py,sha256=_JoW2u3NCpmBdfZbGyJAqrCTIkCBcxvnLPO1Cw0yeKc,48651
+scrapely/http/_client.py,sha256=VccwfsgOlzUQeRMaFVP7oBOw32Fcp89MIUePpinEWCQ,51547
 scrapely/http/_compat.py,sha256=si8V3SAb-FDBcdUKuQHMCthRjNR6_oFlg8rpIKyEv2g,4082
 scrapely/http/_detect.py,sha256=NXMonGYv0jFwG7ONY6MPdhJadTRL2LbyPss-HVbE5J4,5433
 scrapely/http/_headers.py,sha256=jJMYYb6SpcMmIQ5ETTLVZi2xSA40wW_pt8UxzP2EMMQ,16633
@@ -68,10 +68,10 @@ scrapely/storage/_file_system/_key_value_store_client.py,sha256=1C22qY-RWlARzMyW
 scrapely/storage/_file_system/_storage_client.py,sha256=QHa3IULEb6AmgRFwpBqHD2OUTmtA_gl3lId-j6QdSFo,2027
 scrapely/storage_clients/__init__.py,sha256=q2pC-Rwe-BfHl018OyN_P0EDSx4-hNdxbk3pOCLLd4U,618
 scrapely/storages/__init__.py,sha256=kDNtd9VodjdHd4u7GzruJo0aB2HeiBN2_-HrkeqjmFg,139
-scrapely_python-0.1.40.dist-info/licenses/LICENSE,sha256=pQGY0XwjIYh-a2HfawxHq1en53bXkFkDj2Q70jKWHr4,1088
-scrapely_python-0.1.40.dist-info/licenses/LICENSE-APACHE,sha256=N8m0FzMq8i4UbTgXZvKEZJSD-27OF8pWZYS_atz4kTU,11355
-scrapely_python-0.1.40.dist-info/licenses/NOTICE,sha256=1ltrzKk2ez7x2BPNpXeyvOlTty5AfABYDBlwNilpORk,788
-scrapely_python-0.1.40.dist-info/METADATA,sha256=Dqdbn37BPsue4GTs3scUAmHGJUjmHGRDOX9ByjWuah8,4914
-scrapely_python-0.1.40.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
-scrapely_python-0.1.40.dist-info/top_level.txt,sha256=T4B9UMrs4q99QSAFyD1zdXhl40KnLhBKqrDkPhOTsmY,9
-scrapely_python-0.1.40.dist-info/RECORD,,
+scrapely_python-0.1.42.dist-info/licenses/LICENSE,sha256=pQGY0XwjIYh-a2HfawxHq1en53bXkFkDj2Q70jKWHr4,1088
+scrapely_python-0.1.42.dist-info/licenses/LICENSE-APACHE,sha256=N8m0FzMq8i4UbTgXZvKEZJSD-27OF8pWZYS_atz4kTU,11355
+scrapely_python-0.1.42.dist-info/licenses/NOTICE,sha256=1ltrzKk2ez7x2BPNpXeyvOlTty5AfABYDBlwNilpORk,788
+scrapely_python-0.1.42.dist-info/METADATA,sha256=sZW9HkpiYLFvgRsQ-DVb-ZcfqUSH5zodw9nNMMw8wgM,4914
+scrapely_python-0.1.42.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+scrapely_python-0.1.42.dist-info/top_level.txt,sha256=T4B9UMrs4q99QSAFyD1zdXhl40KnLhBKqrDkPhOTsmY,9
+scrapely_python-0.1.42.dist-info/RECORD,,