scrapely-python 0.1.6__tar.gz → 0.1.7__tar.gz

{scrapely_python-0.1.6 → scrapely_python-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scrapely-python
-Version: 0.1.6
+Version: 0.1.7
 Summary: Scrapely Python SDK - A toolkit for building Actors on the Scrapely platform
 Author-email: Scrapely <support@scrape.ly>
 License-Expression: MIT

{scrapely_python-0.1.6 → scrapely_python-0.1.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "scrapely-python"
-version = "0.1.6"
+version = "0.1.7"
 description = "Scrapely Python SDK - A toolkit for building Actors on the Scrapely platform"
 readme = "README.md"
 license = "MIT"

{scrapely_python-0.1.6 → scrapely_python-0.1.7}/src/scrapely/__init__.py

@@ -132,7 +132,7 @@ from .errors import (
     raise_for_status,
 )
 
-__version__ = '0.1.6'
+__version__ = '0.1.7'
 __all__ = [
     # Core
     'Actor',

{scrapely_python-0.1.6 → scrapely_python-0.1.7}/src/scrapely/actor.py

@@ -27,6 +27,7 @@ from crawlee.storages import Dataset, KeyValueStore, RequestQueue
 from .charging import ChargingManager, is_default_dataset_item_event, push_data_and_charge
 from .configuration import Configuration
 from .crypto import decrypt_secret_inputs
+from .proxy_configuration import with_proxy_key_aliases
 from crawlee.events import EventManager
 
 from .events import Event, LocalEventManager, ScrapelyEventManager
@@ -484,8 +485,10 @@ class Actor(metaclass=_ActorMeta):
                     flush = getattr(cls._charging_manager, 'flush_pending', None)
                     if flush is not None:
                         deadline_ms = min(max(1, timeout_secs) * 1000, 30_000)
+                        # The flush's own deadline ends its retries (charge POSTs back off
+                        # for up to ~45 s) a little before wait_for would cancel it.
                         await asyncio.wait_for(
-                            flush(max_intents=64, deadline_ms=deadline_ms),
+                            flush(max_intents=64, deadline_ms=max(500, deadline_ms - 2_000)),
                             timeout=max(1.0, deadline_ms / 1000.0),
                         )
                 except BaseException as e:
@@ -687,8 +690,8 @@ class Actor(metaclass=_ActorMeta):
                 kvs = await cls.open_key_value_store()
                 metamorph_input = await kvs.get_value(f'INPUT-METAMORPH-{count}')
                 if metamorph_input is not None:
-                    cls._cached_input = metamorph_input
-                    return cast(Dict[str, Any], metamorph_input)
+                    cls._cached_input = with_proxy_key_aliases(metamorph_input)
+                    return cast(Dict[str, Any], cls._cached_input)
 
         raw_input = os.environ.get('ACTOR_INPUT')
         if raw_input:
@@ -701,7 +704,8 @@ class Actor(metaclass=_ActorMeta):
             # path is decrypted, mirroring Actor.getInput() in the Node SDK)
             if isinstance(parsed, dict):
                 parsed = decrypt_secret_inputs(parsed)
-            cls._cached_input = parsed
+            # Proxy objects carry both namings (scrapelyProxy* and apifyProxy*).
+            cls._cached_input = with_proxy_key_aliases(parsed)
             return cast(Dict[str, Any], cls._cached_input)
 
         kvs = await cls.open_key_value_store()
@@ -709,8 +713,8 @@ class Actor(metaclass=_ActorMeta):
         result = await kvs.get_value(input_key)
         if isinstance(result, dict):
             result = decrypt_secret_inputs(result)
-        cls._cached_input = result
-        return cast(Optional[Dict[str, Any]], result)
+        cls._cached_input = with_proxy_key_aliases(result)
+        return cast(Optional[Dict[str, Any]], cls._cached_input)
 
     @classmethod
     async def get_input_or_throw(cls) -> Dict[str, Any]:
@@ -739,7 +743,7 @@ class Actor(metaclass=_ActorMeta):
 
         # Decrypt secret inputs after loading (JS parity with Actor.input getter)
         if isinstance(cls._cached_input, dict):
-            cls._cached_input = decrypt_secret_inputs(cls._cached_input)
+            cls._cached_input = with_proxy_key_aliases(decrypt_secret_inputs(cls._cached_input))
 
         return cls._cached_input
 
@@ -1172,6 +1176,11 @@ class Actor(metaclass=_ActorMeta):
         """Return the Configuration instance."""
         return cls.get_config()
 
+    @_ClassProperty
+    def config(cls) -> Configuration:
+        """Return the Configuration instance (Apify SDK ``Actor.config`` parity)."""
+        return cls.get_config()
+
     @_ClassProperty
     def event_manager(cls) -> Optional[EventManager]:
         """Return the EventManager instance."""

{scrapely_python-0.1.6 → scrapely_python-0.1.7}/src/scrapely/charging.py

@@ -47,8 +47,16 @@ CHARGE_IDEMPOTENCY_SAFE_AGE_SECS = 30 * 24 * 60 * 60
 # Soft cap on open unresolved intents. Refuse NEW billable charges when full.
 _PENDING_MAX_ENTRIES = 1024
 
-# Immediate same-key POST attempts before leaving intent pending / raising.
-_POST_ATTEMPTS = 3
+# Same-key POST attempts before leaving an intent pending / raising. The API
+# client itself retries 5xx answers and refused or reset connections of these
+# POSTs with its long backoff (0.5 s doubling to 8 s, about 45 s): re-sending
+# is safe because every attempt carries the same Idempotency-Key. These outer
+# attempts cover what the client gives up on quickly (timeouts, other
+# transport errors), with the same backoff, within _RETRY_BUDGET_SECS.
+_POST_ATTEMPTS = 8
+
+# Outer retries stop once this much time has passed since the first attempt.
+_RETRY_BUDGET_SECS = 60.0
 
 # Local-only dataset collecting one entry per logical charge operation
 # (JS ChargingManager LOCAL_CHARGING_LOG_DATASET_NAME parity).
@@ -160,6 +168,7 @@ class ChargingManager:
     _PENDING_MAX_ENTRIES = _PENDING_MAX_ENTRIES
     _IDEMPOTENCY_SAFE_AGE_SECS = CHARGE_IDEMPOTENCY_SAFE_AGE_SECS
     _POST_ATTEMPTS = _POST_ATTEMPTS
+    _RETRY_BUDGET_SECS = _RETRY_BUDGET_SECS
 
     def __init__(self, config: 'Configuration', client: 'ApiClient'):
         """Initialize the charging manager.
@@ -458,12 +467,14 @@ class ChargingManager:
         """
         if self._client is None or not self._is_at_home or not self._actor_run_id:
             return False
+        started = time.monotonic()
         for attempt in range(self._POST_ATTEMPTS):
             try:
                 await self._client.post(
                     f'/v2/actor-runs/{self._actor_run_id}/charge/void',
                     json_data={},
                     headers={'Idempotency-Key': operation_id},
+                    idempotent=True,
                 )
                 self._unwind_reservation(event_name, reserved)
                 return True
@@ -478,8 +489,8 @@ class ChargingManager:
                 # 404: nothing to void; 409: already settled; 4xx auth: permanent.
                 if status is not None and 400 <= status < 500:
                     return False
-                if attempt + 1 < self._POST_ATTEMPTS:
-                    await asyncio.sleep(0.25 * (attempt + 1))
+                if not await self._backoff_before_retry(attempt, started, err):
+                    break
         # Outcome unknown: keep the reservation and retry before the next push / at exit.
         self._pending_voids.append((event_name, operation_id, reserved, not_found_means_voided))
         logger.error('Void of charge %s (%r) not confirmed yet; will retry', operation_id, event_name)
@@ -528,6 +539,7 @@ class ChargingManager:
         event_name: str,
         count: int,
         idempotency_key: str,
+        deadline: Optional[float] = None,
     ) -> Dict[str, Any]:
         if self._client is None:
             raise RuntimeError('ChargingManager has no API client; cannot post charge intent')
@@ -538,6 +550,8 @@ class ChargingManager:
                 'count': count,
             },
             headers={'Idempotency-Key': idempotency_key},
+            idempotent=True,
+            **({'retry_deadline': deadline} if deadline is not None else {}),
         )
         if isinstance(response, dict):
             return response
@@ -550,25 +564,58 @@ class ChargingManager:
             pass
         return {}
 
+    async def _backoff_before_retry(
+        self, attempt: int, started: float, err: BaseException, deadline: Optional[float] = None
+    ) -> bool:
+        """Sleep before the next same-key attempt; False when no attempt is left.
+
+        A 5xx answer reaching this point was already retried by the API client
+        with its long backoff, so it ends the attempts. Timeouts and other
+        errors without an answer back off the same way (0.5 s doubling to 8 s)
+        while attempts and the retry budget last.
+        """
+        from .storage.api_client import server_retry_delay
+
+        if attempt + 1 >= self._POST_ATTEMPTS:
+            return False
+        status = _http_status_of(err)
+        if status is not None and status >= 500:
+            return False
+        delay = server_retry_delay(attempt, None)
+        if time.monotonic() - started + delay > self._RETRY_BUDGET_SECS:
+            return False
+        if deadline is not None and time.monotonic() + delay > deadline:
+            return False
+        logger.warning('Charge request failed (%s); retrying in %.1fs', type(err).__name__, delay)
+        await asyncio.sleep(delay)
+        return True
+
     async def _post_charge_with_retries(
         self,
         *,
         event_name: str,
         count: int,
         idempotency_key: str,
+        deadline: Optional[float] = None,
     ) -> Optional[int]:
         """POST charge; return acceptedCount on success, None if uncertain.
 
+        ``deadline`` (``time.monotonic()``) bounds every retry, the API
+        client's included, so a flush with a time budget ends with the intent
+        still pending instead of being cancelled mid-request.
+
         Raises ChargeRejectedError for definitive platform rejections.
         Same idempotency key on every attempt.
         """
         last_error: Optional[BaseException] = None
+        started = time.monotonic()
         for attempt in range(self._POST_ATTEMPTS):
             try:
                 body = await self._post_charge_once(
                     event_name=event_name,
                     count=count,
                     idempotency_key=idempotency_key,
+                    deadline=deadline,
                 )
                 return _read_accepted_count(body, count)
             except Exception as e:
@@ -581,8 +628,8 @@ class ChargingManager:
                 )
                 if rejected is not None:
                     raise rejected from e
-                if attempt + 1 < self._POST_ATTEMPTS:
-                    await asyncio.sleep(0.25 * (attempt + 1))
+                if not await self._backoff_before_retry(attempt, started, e, deadline):
+                    break
         if last_error is not None:
             logger.warning(
                 'Failed to record charge for event %s (count=%s, key=%s): %s',
@@ -638,6 +685,7 @@ class ChargingManager:
                             event_name=event_name,
                             count=count,
                             idempotency_key=idempotency_key,
+                            deadline=deadline,
                         )
                     except ChargeRejectedError as err:
                         self._unwind_reservation(event_name, count)

{scrapely_python-0.1.6 → scrapely_python-0.1.7}/src/scrapely/configuration.py

@@ -145,6 +145,8 @@ class Configuration:
         'proxy_hostname': 'proxy.scrape.ly',
         'proxy_port': 8000,
         'container_port': 4321,
+        # Apify parity: standby runs listen on ACTOR_STANDBY_PORT (4321 unless set).
+        'standby_port': 4321,
         'container_url': 'http://localhost:4321',
         'metamorph_after_sleep_millis': 300000,
         'persist_state_interval_millis': 60000,
@@ -245,6 +247,25 @@ class Configuration:
         """
         self._config[key] = value
     
+    def __getattr__(self, name: str) -> Any:
+        """Attribute access to any known setting (Apify ``Actor.config.<field>`` parity).
+
+        ``Actor.config.standby_port``, ``Actor.config.meta_origin`` and the other
+        keys this class reads from the environment resolve like ``get(name)``.
+        """
+        if name.startswith('_'):
+            raise AttributeError(name)
+        known = name in self.DEFAULTS or name in self.ENV_MAP.values() or name in self.__dict__.get('_config', {})
+        if not known:
+            raise AttributeError(f'{type(self).__name__!r} object has no attribute {name!r}')
+        return self.get(name)
+
+    @property
+    def standby_port(self) -> int:
+        """Port a standby run serves HTTP on (ACTOR_STANDBY_PORT, default 4321)."""
+        value = self.get('standby_port')
+        return value if isinstance(value, int) else 4321
+
     @property
     def token(self) -> Optional[str]:
         """Get the authentication token."""

{scrapely_python-0.1.6 → scrapely_python-0.1.7}/src/scrapely/proxy_configuration.py

@@ -127,6 +127,53 @@ def _input_proxy_option(actor_proxy_input: Dict[str, Any], name: str) -> Any:
     return value if value is not None else actor_proxy_input.get(f'apifyProxy{name}')
 
 
+_PROXY_OPTION_NAMES = ('Groups', 'Country', 'Subdivision')
+
+
+def _is_proxy_input_object(value: Any) -> bool:
+    if not isinstance(value, dict):
+        return False
+    keys = ['useScrapelyProxy', 'useApifyProxy']
+    for name in _PROXY_OPTION_NAMES:
+        keys += [f'scrapelyProxy{name}', f'apifyProxy{name}']
+    return any(key in value for key in keys)
+
+
+def with_proxy_key_aliases(actor_input: Any) -> Any:
+    """Actor input with every proxy option under both its Scrapely and Apify name.
+
+    For each top-level object that has a proxy key of either naming
+    (``useScrapelyProxy`` / ``useApifyProxy``, ``scrapelyProxyGroups`` /
+    ``apifyProxyGroups``, ``...Country``, ``...Subdivision``), every set value
+    is written under both names, so code that reads either naming sees the
+    user's choice. A boolean ``useScrapelyProxy`` and a set ``scrapelyProxy*``
+    value win over their Apify counterparts. Nothing is removed: keys with
+    unset or non-boolean values stay as sent. Returns ``actor_input`` itself
+    when nothing changes; never mutates it.
+    """
+    if not isinstance(actor_input, dict):
+        return actor_input
+    result: Optional[Dict[str, Any]] = None
+    for key, value in actor_input.items():
+        if not _is_proxy_input_object(value):
+            continue
+        aliased = dict(value)
+        use = _input_use_platform_proxy(value)
+        if use is not None:
+            aliased['useScrapelyProxy'] = use
+            aliased['useApifyProxy'] = use
+        for name in _PROXY_OPTION_NAMES:
+            option = _input_proxy_option(value, name)
+            if option is not None:
+                aliased[f'scrapelyProxy{name}'] = option
+                aliased[f'apifyProxy{name}'] = option
+        if aliased != value:
+            if result is None:
+                result = dict(actor_input)
+            result[key] = aliased
+    return result if result is not None else actor_input
+
+
 def _platform_env() -> Optional[Dict[str, Any]]:
     """Read platform proxy credentials from the environment (or None)."""
     hostname = os.environ.get('SCRAPELY_PROXY_HOSTNAME') or os.environ.get('APIFY_PROXY_HOSTNAME')

{scrapely_python-0.1.6 → scrapely_python-0.1.7}/src/scrapely/storage/api_client.py

@@ -258,8 +258,15 @@ class ApiClient:
         raise_for_status: bool = True,
         do_not_retry_timeouts: bool = False,
         idempotent: Optional[bool] = None,
+        retry_deadline: Optional[float] = None,
     ) -> httpx.Response:
-        """Make an HTTP request with adaptive rate limiting and 429 retries."""
+        """Make an HTTP request with adaptive rate limiting and 429 retries.
+
+        ``retry_deadline`` (a ``time.monotonic()`` value) stops the 5xx /
+        connection retries once the next backoff would end after it, so a
+        caller with a time budget (e.g. the exit flush) gets an answer instead
+        of being cancelled mid-retry.
+        """
         client = await self._ensure_client()
         url = self._url(path)
         logger.debug('%s %s params=%s', method, url, params)
@@ -293,8 +300,12 @@ class ApiClient:
                 # No response. A refused/unresolvable connection never reached
                 # the API, so it is safe for every method; anything else (reset
                 # mid-request) only for idempotent ones.
-                if (idempotent or isinstance(exc, httpx.ConnectError)) and server_attempt < self._max_server_retries:
-                    wait = server_retry_delay(server_attempt, None)
+                wait = server_retry_delay(server_attempt, None)
+                if (
+                    (idempotent or isinstance(exc, httpx.ConnectError))
+                    and server_attempt < self._max_server_retries
+                    and (retry_deadline is None or time.monotonic() + wait <= retry_deadline)
+                ):
                     server_attempt += 1
                     logger.warning(
                         '%s %s failed (%s); retry %d/%d in %.1fs',
@@ -316,6 +327,10 @@ class ApiClient:
             if (
                 not response.is_success
                 and server_attempt < self._max_server_retries
+                and (
+                    retry_deadline is None
+                    or time.monotonic() + server_retry_delay(server_attempt, response.headers.get('Retry-After')) <= retry_deadline
+                )
                 and is_retryable_response(
                     response.status_code,
                     idempotent,
@@ -364,6 +379,7 @@ class ApiClient:
         *,
         raise_for_status: bool = True,
         idempotent: Optional[bool] = None,
+        retry_deadline: Optional[float] = None,
     ) -> httpx.Response:
         return await self.request(
             'POST',
@@ -374,6 +390,7 @@ class ApiClient:
             headers=headers,
             raise_for_status=raise_for_status,
             idempotent=idempotent,
+            retry_deadline=retry_deadline,
         )
 
     async def put(

{scrapely_python-0.1.6 → scrapely_python-0.1.7}/src/scrapely/storage/client.py

@@ -293,8 +293,13 @@ class ApiStorageClient:
         value: Any,
         content_type: Optional[str] = None,
     ) -> None:
+        if isinstance(value, (bytearray, memoryview)):
+            value = bytes(value)
         if content_type is None:
-            if isinstance(value, (str, bytes)):
+            # Same defaults as Apify: bytes are binary, str is text, anything else JSON.
+            if isinstance(value, bytes):
+                content_type = 'application/octet-stream'
+            elif isinstance(value, str):
                 content_type = 'text/plain'
             else:
                 content_type = 'application/json'

{scrapely_python-0.1.6 → scrapely_python-0.1.7}/src/scrapely_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scrapely-python
-Version: 0.1.6
+Version: 0.1.7
 Summary: Scrapely Python SDK - A toolkit for building Actors on the Scrapely platform
 Author-email: Scrapely <support@scrape.ly>
 License-Expression: MIT

{scrapely_python-0.1.6 → scrapely_python-0.1.7}/src/scrapely_python.egg-info/SOURCES.txt

@@ -49,8 +49,10 @@ tests/test_api_client_retries.py
 tests/test_apify_parity.py
 tests/test_browser_configuration.py
 tests/test_cdp_retry.py
+tests/test_charge_retries.py
 tests/test_charging_parity.py
 tests/test_charging_pending.py
+tests/test_input_proxy_aliases.py
 tests/test_parity.py
 tests/test_patch_browser_pool.py
 tests/test_proxy_configuration.py

scrapely_python-0.1.7/tests/test_charge_retries.py

@@ -0,0 +1,141 @@
+"""Charge and void POSTs ride out 5xx answers and timeouts with the long backoff.
+
+Staging 2026-10-14: about 3 of 40 pay-per-event runs logged "Failed to record
+charge" three times within 1.5 s and raised ChargeUncertainError, because the
+charge POST retried 3 times with 0.25 s / 0.5 s sleeps and the API client did
+not retry 500/502/504 for POST. Every attempt carries the same
+Idempotency-Key, so re-sending is safe: the client now retries any 5xx (and
+reset connections) with its 0.5 s → 8 s backoff, and timeouts get the same
+backoff from the charging manager.
+"""
+
+from __future__ import annotations
+
+from decimal import Decimal
+from typing import List
+from unittest.mock import MagicMock
+
+import httpx
+import pytest
+
+from scrapely import charging as charging_mod
+from scrapely.charging import ChargeRejectedError, ChargingManager
+from scrapely.pricing_types import PayPerEventActorPricingInfo, PricingPerEvent
+from scrapely.storage import api_client as client_mod
+from scrapely.storage.api_client import ApiClient
+
+
+@pytest.fixture(autouse=True)
+def no_sleep(monkeypatch: pytest.MonkeyPatch) -> List[float]:
+    slept: List[float] = []
+
+    async def fake_sleep(secs: float) -> None:
+        slept.append(secs)
+
+    monkeypatch.setattr(client_mod.asyncio, 'sleep', fake_sleep)
+    monkeypatch.setattr(charging_mod.asyncio, 'sleep', fake_sleep)
+    return slept
+
+
+def manager_for(responses: list) -> tuple[ChargingManager, list]:
+    calls: list = []
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        calls.append((request.url.path, request.headers.get('Idempotency-Key')))
+        r = responses.pop(0) if len(responses) > 1 else responses[0]
+        if isinstance(r, Exception):
+            raise r
+        return r
+
+    client = ApiClient('http://api.test', 'st_x', 'run-1', transport=httpx.MockTransport(handler))
+    config = MagicMock()
+    config.get = MagicMock(side_effect=lambda key, default=None: {
+        'is_at_home': True, 'actor_run_id': 'run-1', 'max_total_charge_usd': '100',
+    }.get(key, default))
+    mgr = ChargingManager(config, client)
+    mgr._pricing_info = PayPerEventActorPricingInfo(pricing_per_event={'page-open': PricingPerEvent(event_price_usd=Decimal('0.01'))})
+    mgr._per_event_prices = {'page-open': Decimal('0.01')}
+    mgr._initialized = True
+    mgr._actor_run_id = 'run-1'
+    mgr._max_total_charge_usd = Decimal('100')
+    return mgr, calls
+
+
+def ok(count: int = 1) -> httpx.Response:
+    return httpx.Response(201, json={'acceptedCount': count, 'requestedCount': count})
+
+
+@pytest.mark.parametrize('status', [500, 502, 503, 504])
+async def test_charge_5xx_is_retried_with_the_same_key(status: int, no_sleep: List[float]) -> None:
+    mgr, calls = manager_for([httpx.Response(status, json={'error': {'type': 'internal-error'}})] * 5 + [ok(2)])
+    result = await mgr.charge('page-open', 2)
+    assert result.charged_count == 2
+    assert len(calls) == 6 and len({key for _, key in calls}) == 1, 'one operation, one Idempotency-Key'
+    assert sum(no_sleep) > 7, f'long backoff, not 1.5 s: {no_sleep}'
+    assert not mgr._pending_charge_keys
+
+
+async def test_charge_timeouts_back_off_until_confirmed(no_sleep: List[float]) -> None:
+    timeout = httpx.ReadTimeout('timed out')
+    mgr, calls = manager_for([timeout] * 9 + [ok()])
+    result = await mgr.charge('page-open', 1)
+    assert result.charged_count == 1
+    assert len({key for _, key in calls}) == 1
+    assert any(s >= 1.0 for s in no_sleep), f'timeouts get the growing backoff too: {no_sleep}'
+
+
+async def test_charge_reset_connection_is_retried() -> None:
+    mgr, calls = manager_for([httpx.RemoteProtocolError('reset'), ok()])
+    assert (await mgr.charge('page-open', 1)).charged_count == 1
+    assert len(calls) == 2
+
+
+async def test_rejection_is_not_retried() -> None:
+    mgr, calls = manager_for([httpx.Response(402, json={'error': {'type': 'charge-limit-exceeded', 'message': 'limit'}})])
+    with pytest.raises(ChargeRejectedError):
+        await mgr._post_charge_with_retries(event_name='page-open', count=1, idempotency_key='k1')
+    assert len(calls) == 1
+
+
+async def test_retries_stop_within_the_budget(no_sleep: List[float]) -> None:
+    mgr, calls = manager_for([httpx.ReadTimeout('timed out')])
+    assert await mgr._post_charge_with_retries(event_name='page-open', count=1, idempotency_key='k1') is None
+    assert sum(s for s in no_sleep if s >= 0.5) <= ChargingManager._RETRY_BUDGET_SECS + 1
+    assert len({key for _, key in calls}) == 1
+
+
+async def test_void_5xx_is_retried() -> None:
+    mgr, calls = manager_for([httpx.Response(503, json={'error': {'type': 'service-unavailable'}}), httpx.Response(200, json={})])
+    assert await mgr._void_charge('page-open', 'op-1', 1) is True
+    assert [path for path, _ in calls] == ['/v2/actor-runs/run-1/charge/void'] * 2
+
+
+async def test_flush_deadline_bounds_the_client_retries(no_sleep: List[float]) -> None:
+    """A flush with a time budget stops retrying in time; the intent stays pending."""
+    import time as _time
+
+    mgr, calls = manager_for([httpx.Response(503, json={'error': {'type': 'service-unavailable'}})])
+    mgr._pending_charge_keys['k1'] = {'event_name': 'page-open', 'count': 1, 'created_at': _time.monotonic()}
+    clock = [1000.0]
+
+    def fake_monotonic() -> float:
+        return clock[0]
+
+    async def advancing_sleep(secs: float) -> None:
+        no_sleep.append(secs)
+        clock[0] += secs
+
+    import pytest as _pytest
+    mp = _pytest.MonkeyPatch()
+    try:
+        mp.setattr(client_mod.time, 'monotonic', fake_monotonic)
+        mp.setattr(charging_mod.time, 'monotonic', fake_monotonic)
+        mp.setattr(client_mod.asyncio, 'sleep', advancing_sleep)
+        mp.setattr(charging_mod.asyncio, 'sleep', advancing_sleep)
+        confirmed = await mgr.flush_pending(deadline_ms=3000)
+    finally:
+        mp.undo()
+    assert confirmed == 0
+    assert 'k1' in mgr._pending_charge_keys, 'still pending for a later flush'
+    assert sum(no_sleep) <= 3.0, f'no retry sleeps past the deadline: {no_sleep}'
+    assert len(calls) >= 2, 'it did retry within the budget'

scrapely_python-0.1.7/tests/test_input_proxy_aliases.py

@@ -0,0 +1,98 @@
+"""Proxy input objects carry both namings; Actor.config exposes standby_port.
+
+Actors read the proxy choice either as useScrapelyProxy / scrapelyProxyGroups /
+scrapelyProxyCountry / scrapelyProxySubdivision or under the Apify names.
+Actor.get_input() and Actor.input fill in whichever naming is missing, so both
+reads see the user's choice whatever naming the input was written with.
+"""
+
+from __future__ import annotations
+
+import base64
+import json
+from typing import Any
+
+import pytest
+
+from scrapely import Actor
+from scrapely.configuration import Configuration
+from scrapely.proxy_configuration import with_proxy_key_aliases
+
+
+BOTH_RESIDENTIAL_CN = {
+    'useScrapelyProxy': True, 'useApifyProxy': True,
+    'scrapelyProxyGroups': ['RESIDENTIAL'], 'apifyProxyGroups': ['RESIDENTIAL'],
+    'scrapelyProxyCountry': 'CN', 'apifyProxyCountry': 'CN',
+}
+
+
+def test_scrapely_names_get_apify_aliases() -> None:
+    sent = {'proxy': {'useScrapelyProxy': True, 'scrapelyProxyGroups': ['RESIDENTIAL'], 'scrapelyProxyCountry': 'CN'}, 'q': 'x'}
+    out = with_proxy_key_aliases(sent)
+    assert out == {'proxy': BOTH_RESIDENTIAL_CN, 'q': 'x'}
+    assert sent['proxy'] == {'useScrapelyProxy': True, 'scrapelyProxyGroups': ['RESIDENTIAL'], 'scrapelyProxyCountry': 'CN'}, 'not mutated'
+
+
+def test_apify_names_get_scrapely_aliases() -> None:
+    out = with_proxy_key_aliases({'proxy': {'useApifyProxy': True, 'apifyProxyGroups': ['RESIDENTIAL'], 'apifyProxyCountry': 'CN'}})
+    assert out == {'proxy': BOTH_RESIDENTIAL_CN}
+
+
+def test_proxy_off_and_custom_urls() -> None:
+    assert with_proxy_key_aliases({'p': {'useScrapelyProxy': False}}) == {'p': {'useScrapelyProxy': False, 'useApifyProxy': False}}
+    out = with_proxy_key_aliases({'p': {'useApifyProxy': False, 'proxyUrls': ['http://u:p@1.2.3.4:8080']}})
+    assert out == {'p': {'useScrapelyProxy': False, 'useApifyProxy': False, 'proxyUrls': ['http://u:p@1.2.3.4:8080']}}
+
+
+def test_scrapely_value_wins_and_unset_values_stay() -> None:
+    out = with_proxy_key_aliases({'p': {
+        'useScrapelyProxy': False, 'useApifyProxy': True,
+        'scrapelyProxyGroups': None, 'apifyProxyGroups': ['DATACENTER'],
+        'scrapelyProxyCountry': 'DE', 'apifyProxyCountry': 'US', 'apifyProxySubdivision': None,
+    }})
+    assert out == {'p': {
+        'useScrapelyProxy': False, 'useApifyProxy': False,
+        'scrapelyProxyGroups': ['DATACENTER'], 'apifyProxyGroups': ['DATACENTER'],
+        'scrapelyProxyCountry': 'DE', 'apifyProxyCountry': 'DE', 'apifyProxySubdivision': None,
+    }}
+
+
+def test_unrelated_fields_are_never_removed() -> None:
+    sent = {'settings': {'useApifyProxy': 'false', 'label': 'x'}}
+    assert with_proxy_key_aliases(sent) is sent, 'a non-boolean switch is kept as sent'
+
+
+@pytest.mark.parametrize('value', [None, 'x', 1, [], [{'useScrapelyProxy': True}], {'a': 1}, {'p': {'x': 1}}])
+def test_other_values_unchanged(value: Any) -> None:
+    assert with_proxy_key_aliases(value) is value
+
+
+def test_complete_input_is_returned_as_is() -> None:
+    sent = {'p': dict(BOTH_RESIDENTIAL_CN)}
+    assert with_proxy_key_aliases(sent) is sent
+
+
+async def test_get_input_and_input_getter_alias(monkeypatch: pytest.MonkeyPatch) -> None:
+    raw = {'proxyConfiguration': {'useApifyProxy': True, 'apifyProxyGroups': ['RESIDENTIAL'], 'apifyProxyCountry': 'CN'}}
+    monkeypatch.setenv('ACTOR_INPUT', base64.b64encode(json.dumps(raw).encode()).decode())
+    monkeypatch.delenv('ACTOR_METAMORPH_COUNT', raising=False)
+    monkeypatch.setattr(Actor, '_cached_input', None)
+    monkeypatch.setattr(Actor, '_initialized', True, raising=False)
+    monkeypatch.setattr(Actor, '_ensure_initialized', classmethod(lambda cls, name: None))
+    got = await Actor.get_input()
+    assert got['proxyConfiguration'] == BOTH_RESIDENTIAL_CN
+    monkeypatch.setattr(Actor, '_cached_input', None)
+    assert Actor.input['proxyConfiguration'] == BOTH_RESIDENTIAL_CN
+
+
+def test_config_standby_port(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.delenv('ACTOR_STANDBY_PORT', raising=False)
+    assert Configuration().standby_port == 4321
+    monkeypatch.setenv('ACTOR_STANDBY_PORT', '5000')
+    monkeypatch.setenv('ACTOR_META_ORIGIN', 'STANDBY')
+    config = Configuration()
+    assert config.standby_port == 5000
+    assert config.meta_origin == 'STANDBY', 'known settings are attributes too'
+    with pytest.raises(AttributeError):
+        config.not_a_setting  # noqa: B018
+    assert Actor.config is Actor.configuration