scrapely-python 0.1.34__tar.gz → 0.1.36__tar.gz

{scrapely_python-0.1.34 → scrapely_python-0.1.36}/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 All notable changes to this project will be documented in this file.
 
+## [Unreleased]
+
+## [0.1.36] - 2026-10-26
+
+- Opening a named dataset, key-value store or request queue (`Actor.open_dataset('name')` and the like) retries when the API answers `503 storage-name-busy`. The API sends it when another request kept creating or renaming a storage of that name for over 15 s; nothing was changed, so the open is simply repeated. It used to fail the open.
+
+## [0.1.35] - 2026-10-26
+
+- Once `Actor.fail()` has run, the run stays failed. A later `Actor.exit()` keeps the failure's exit code and status message, so the usual `try: ... await Actor.fail(...) finally: await Actor.exit()` pattern now ends the run as FAILED. Before, the `exit()` in `finally` replaced the failure's exit code 1 with 0 and the run ended as SUCCEEDED with the failure message as its status. The same holds after `fail()` whose `SystemExit` was caught, after `fail(ExitOptions(exit=False))` (also inside `async with Actor(...)` and `Actor.main()`), and for a second `fail()`, which keeps the first failure's code and message.
+- `Actor.fail(ExitOptions(...))` without an exit code exits with 1. `ExitOptions` defaults `exit_code` to 0, which made such a failure exit with 0. A non-zero `exit_code` in the options, or an explicit `exit_code=` keyword, still wins.
+
 ## [0.1.34] - 2026-10-23
 
 - Debug captures (`Actor.debug_capture`, `Actor.debug_capture_sync`) store parsed XML/HTML elements as their markup instead of a repr such as `<Element 'change' at 0x...>`: `xml.etree.ElementTree` elements and trees, lxml elements and trees, BeautifulSoup tags, selectolax nodes and parsel / Scrapy selectors, passed alone or inside a dict or list. The text after an element (its tail) is not included. Other objects are still stored as their `str()`. Captures are only active on the platform's own diagnostic runs (`SCRAPELY_DEBUG_CAPTURE=1`).

{scrapely_python-0.1.34 → scrapely_python-0.1.36}/PKG-INFO

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

{scrapely_python-0.1.34 → scrapely_python-0.1.36}/pyproject.toml

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

{scrapely_python-0.1.34 → scrapely_python-0.1.36}/src/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.34'
+__version__ = '0.1.36'
 __all__ = [
     # Core
     'Actor',

{scrapely_python-0.1.34 → scrapely_python-0.1.36}/src/scrapely/actor.py

@@ -349,6 +349,10 @@ class Actor(metaclass=_ActorMeta):
     _cached_input: Optional[Dict[str, Any]] = None
     _exit_code: int = 0
     _status_message: Optional[str] = None
+    # Set by fail() for the rest of the lifecycle: (exit code, status message).
+    # A later exit() keeps them, so `fail()` followed by the usual `exit()` in a
+    # `finally:` block still ends the run as FAILED (it used to exit with 0).
+    _failure: Optional[Tuple[int, Optional[str]]] = None
     _charging_manager: Optional[ChargingManager] = None
     _use_state_stores: set = set()
     # Lifecycle bookkeeping set in init() / cleared in _shutdown().
@@ -392,9 +396,11 @@ class Actor(metaclass=_ActorMeta):
         elif exc_type is not None:
             cls._exit_code = 1
             logger.error(f'Actor failed: {exc_val}')
+        elif cls._failure is not None:
+            cls._exit_code = cls._failure[0]  # fail(exit=False) earlier: the run stays failed
         else:
             cls._exit_code = self._instance_exit_code
-        if self._instance_status_message:
+        if self._instance_status_message and cls._failure is None:
             cls._status_message = self._instance_status_message
             await cls._persist_terminal_status_message(self._instance_status_message)
         await cls._shutdown(timeout_secs=int(self._cleanup_timeout.total_seconds()))
@@ -410,6 +416,7 @@ class Actor(metaclass=_ActorMeta):
         cls._main_loop = asyncio.get_running_loop()  # for debug_capture_sync from worker threads
         if cls._initialized:
             return
+        cls._failure = None  # a new lifecycle starts unfailed
 
         if options is None or options.configure_logging:
             _lazy('_configure_logging')()
@@ -701,13 +708,33 @@ class Actor(metaclass=_ActorMeta):
         if exit_code is not None:
             opts.exit_code = exit_code
 
-        if opts.status_message:
+        if cls._failure is not None:
+            # Actor.fail() already ran: the run stays failed. Keep its exit code and
+            # status message; a later exit() (e.g. in a `finally:` block) only
+            # finishes the shutdown and exits with the failure's code.
+            if opts.status_message:
+                logger.info(f'[Scrapely] {opts.status_message}')
+            logger.info(
+                '[Scrapely] Actor.exit() after Actor.fail(): the run stays failed (exit code %s).',
+                cls._failure[0],
+            )
+            opts = ExitOptions(**{**opts.__dict__})
+            opts.exit_code, opts.status_message = cls._failure
+            await cls._exit_with(opts, persist_message=False)
+            return
+
+        await cls._exit_with(opts)
+
+    @classmethod
+    async def _exit_with(cls, opts: ExitOptions, persist_message: bool = True) -> None:
+        if opts.status_message and persist_message:
             logger.info(f'[Scrapely] {opts.status_message}')
 
         cls._exit_code = opts.exit_code
         cls._status_message = opts.status_message
 
-        await cls._persist_terminal_status_message(opts.status_message)
+        if persist_message:
+            await cls._persist_terminal_status_message(opts.status_message)
         await cls._shutdown(timeout_secs=opts.timeout_secs)
 
         if opts.exit:
@@ -736,7 +763,7 @@ class Actor(metaclass=_ActorMeta):
         if isinstance(message_or_options, str):
             opts = ExitOptions(exit_code=1, status_message=message_or_options)
         else:
-            # Options-object form: an explicit exit_code in the object wins over
+            # Options-object form: a non-zero exit_code in the object wins over
             # the fail() default of 1 (JS SDK semantics). Build the dict first —
             # passing it alongside exit_code=1 as kwargs raises
             # "got multiple values for keyword argument 'exit_code'".
@@ -751,12 +778,24 @@ class Actor(metaclass=_ActorMeta):
             opts.status_message = status_message
         if exit_code is not None:
             opts.exit_code = exit_code
+        elif not opts.exit_code:
+            # ExitOptions always carries exit_code (default 0), so 0 from an options
+            # object means "not set": a failed run must not exit with 0. Only an
+            # explicit exit_code=0 keyword keeps 0.
+            opts.exit_code = 1
 
         logger.error(
             f'[Scrapely] Actor failed: {opts.status_message or "Unknown error"}',
             exc_info=exception,
         )
-        await cls.exit(opts)
+        if cls._failure is not None:
+            # Failed already: the first failure's code and message stay.
+            opts = ExitOptions(**{**opts.__dict__})
+            opts.exit_code, opts.status_message = cls._failure
+            await cls._exit_with(opts, persist_message=False)
+            return
+        cls._failure = (opts.exit_code, opts.status_message)
+        await cls._exit_with(opts)
 
     @classmethod
     def is_at_home(cls) -> bool:

{scrapely_python-0.1.34 → scrapely_python-0.1.36}/src/scrapely/storage/api_client.py

@@ -40,11 +40,13 @@ def is_retryable_response(
 
     429 always: the run API limiter and dataset backpressure refuse it before
     anything is written. Idempotent methods: also 500/502/503/504. Others
-    (dataset push, KV PUT) only on a 503 that certainly was not processed: the
-    rate limiter refused it ("rate-limit-unavailable", before the handler), or
-    HAProxy had no backend (its own page, nothing forwarded). Any other 503 may
-    mean "outcome unknown" (a direct dataset write whose commit was not
-    confirmed), and re-sending could store the items twice.
+    (dataset push, KV PUT, named storage create) only on a 503 that certainly
+    was not processed: the rate limiter refused it ("rate-limit-unavailable",
+    before the handler), another request held the storage name
+    ("storage-name-busy", nothing changed), or HAProxy had no backend (its own
+    page, nothing forwarded). Any other 503 may mean "outcome unknown" (a
+    direct dataset write whose commit was not confirmed), and re-sending could
+    store the items twice.
     """
     if status == 429:
         return True
@@ -52,7 +54,7 @@ def is_retryable_response(
         return status in (500, 502, 503, 504)
     if status != 503:
         return False
-    return error_type == 'rate-limit-unavailable' or NO_BACKEND_MARKER in (body_text or '')
+    return error_type in ('rate-limit-unavailable', 'storage-name-busy') or NO_BACKEND_MARKER in (body_text or '')
 
 
 def unwrap_data(value: Any) -> Any:

{scrapely_python-0.1.34 → scrapely_python-0.1.36}/src/scrapely_python.egg-info/PKG-INFO

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