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

scrapely_python-0.1.9/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-2026 TeraShift GmbH (Scrape.ly)
+
+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.

scrapely_python-0.1.9/LICENSE-APACHE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2018 Apify Technologies s.r.o.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

scrapely_python-0.1.9/NOTICE

@@ -0,0 +1,27 @@
+Scrapely Python SDK
+===================
+
+Copyright (c) 2025-2026 TeraShift GmbH (Scrape.ly).
+
+This package is licensed under the MIT License (see LICENSE), except for
+the files listed below, which are derived from apify-sdk-python
+(https://github.com/apify/apify-sdk-python),
+Copyright Apify Technologies s.r.o., licensed under the Apache License,
+Version 2.0 (see LICENSE-APACHE). Those files have been modified by
+TeraShift GmbH and remain under the Apache License, Version 2.0:
+
+  - src/scrapely/events/_types.py (from src/apify/events/_types.py)
+  - src/scrapely/events/event_manager.py (from src/apify/events/_apify_event_manager.py)
+  - src/scrapely/request_loaders/_scrapely_request_list.py
+    (from src/apify/request_loaders/_apify_request_list.py)
+
+You may obtain a copy of the Apache License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+This product includes software developed by Apify Technologies s.r.o.
+(https://apify.com/). The original source code is available at
+https://github.com/apify/apify-sdk-python.
+
+Scrape.ly is not affiliated with Apify. Apify is a trademark of
+Apify Technologies s.r.o.

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

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: scrapely-python
-Version: 0.1.6
+Version: 0.1.9
 Summary: Scrapely Python SDK - A toolkit for building Actors on the Scrapely platform
 Author-email: Scrapely <support@scrape.ly>
-License-Expression: MIT
+License-Expression: MIT AND Apache-2.0
 Project-URL: Homepage, https://scrape.ly
 Project-URL: Documentation, https://docs.scrape.ly
 Project-URL: Repository, https://github.com/SandeepDev1/scrapely
@@ -18,6 +18,9 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: LICENSE-APACHE
+License-File: NOTICE
 Requires-Dist: httpx>=0.25.0
 Requires-Dist: crawlee<2.0.0,>=1.8.0
 Requires-Dist: websockets>=12.0
@@ -32,6 +35,7 @@ Requires-Dist: isort>=5.12.0; extra == "dev"
 Requires-Dist: mypy>=1.0.0; extra == "dev"
 Requires-Dist: playwright>=1.40.0; extra == "dev"
 Requires-Dist: browserforge>=1.2.0; extra == "dev"
+Dynamic: license-file
 
 # Scrapely Python SDK
 
@@ -80,3 +84,9 @@ if __name__ == "__main__":
 - Apify-compatible environment aliases and asynchronous client access
 
 See the [complete Python SDK guide](../docs/sdk-python.md) for lifecycle details, option objects, storage selection, events, CDP behavior, run control, environment variables, errors, and the full public export list.
+
+## License
+
+MIT (see [LICENSE](./LICENSE)), except for three files derived from the Apache-2.0 licensed
+[apify-sdk-python](https://github.com/apify/apify-sdk-python), which stay under the Apache License 2.0
+(see [LICENSE-APACHE](./LICENSE-APACHE) and [NOTICE](./NOTICE)).

{scrapely_python-0.1.6 → scrapely_python-0.1.9}/README.md

@@ -45,3 +45,9 @@ if __name__ == "__main__":
 - Apify-compatible environment aliases and asynchronous client access
 
 See the [complete Python SDK guide](../docs/sdk-python.md) for lifecycle details, option objects, storage selection, events, CDP behavior, run control, environment variables, errors, and the full public export list.
+
+## License
+
+MIT (see [LICENSE](./LICENSE)), except for three files derived from the Apache-2.0 licensed
+[apify-sdk-python](https://github.com/apify/apify-sdk-python), which stay under the Apache License 2.0
+(see [LICENSE-APACHE](./LICENSE-APACHE) and [NOTICE](./NOTICE)).

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

@@ -4,10 +4,11 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "scrapely-python"
-version = "0.1.6"
+version = "0.1.9"
 description = "Scrapely Python SDK - A toolkit for building Actors on the Scrapely platform"
 readme = "README.md"
-license = "MIT"
+license = "MIT AND Apache-2.0"
+license-files = ["LICENSE", "LICENSE-APACHE", "NOTICE"]
 authors = [
     {name = "Scrapely", email = "support@scrape.ly"}
 ]

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

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

{scrapely_python-0.1.6 → scrapely_python-0.1.9}/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:
@@ -604,11 +607,14 @@ class Actor(metaclass=_ActorMeta):
         *,
         status_message: Optional[str] = None,
         exit_code: Optional[int] = None,
+        exception: Optional[BaseException] = None,
     ) -> None:
         """Fail the Actor run (exit code defaults to ``1``).
 
-        Apify-Python parity: supports keyword-only ``status_message`` and
-        ``exit_code`` arguments (``await Actor.fail(status_message="Boom")``).
+        Apify-Python parity: supports keyword-only ``status_message``,
+        ``exit_code`` and ``exception`` arguments
+        (``await Actor.fail(status_message="Boom", exception=e)``). When
+        ``exception`` is given its traceback is logged.
         The pre-existing positional forms (``Actor.fail("message")`` /
         ``Actor.fail(ExitOptions(...))``) remain supported; explicit keyword
         arguments take precedence over the positional values when provided.
@@ -632,7 +638,10 @@ class Actor(metaclass=_ActorMeta):
         if exit_code is not None:
             opts.exit_code = exit_code
 
-        logger.error(f'[Scrapely] Actor failed: {opts.status_message or "Unknown error"}')
+        logger.error(
+            f'[Scrapely] Actor failed: {opts.status_message or "Unknown error"}',
+            exc_info=exception,
+        )
         await cls.exit(opts)
 
     @classmethod
@@ -687,8 +696,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 +710,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 +719,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 +749,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 +1182,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.9}/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.9}/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.9}/src/scrapely/events/_types.py

@@ -1,3 +1,7 @@
+# SPDX-License-Identifier: Apache-2.0
+# Derived from apify-sdk-python (src/apify/events/_types.py),
+# Copyright Apify Technologies s.r.o., licensed under the Apache License 2.0.
+# Modified by TeraShift GmbH. See LICENSE-APACHE and NOTICE.
 """Scrapely event types - extends Crawlee's event types with Scrapely-specific data models."""
 
 from __future__ import annotations

{scrapely_python-0.1.6 → scrapely_python-0.1.9}/src/scrapely/events/event_manager.py

@@ -1,3 +1,7 @@
+# SPDX-License-Identifier: Apache-2.0
+# Derived from apify-sdk-python (src/apify/events/_apify_event_manager.py),
+# Copyright Apify Technologies s.r.o., licensed under the Apache License 2.0.
+# Modified by TeraShift GmbH. See LICENSE-APACHE and NOTICE.
 """Event manager for Scrapely Actors.
 
 Extends Crawlee's EventManager with WebSocket connectivity to the Scrapely platform