apify 3.4.2b22__tar.gz → 3.4.2b24__tar.gz

{apify-3.4.2b22 → apify-3.4.2b24}/CHANGELOG.md

@@ -26,6 +26,8 @@ All notable changes to this project will be documented in this file.
 - **scrapy:** Drop deprecated spider arg from Scrapy proxy middleware methods ([#977](https://github.com/apify/apify-sdk-python/pull/977)) ([49dd836](https://github.com/apify/apify-sdk-python/commit/49dd836c986b0e3bda4bb6485be8ad95d286cd82)) by [@vdusek](https://github.com/vdusek)
 - Redirect input key in all file-system key-value store operations ([#976](https://github.com/apify/apify-sdk-python/pull/976)) ([1fbdce2](https://github.com/apify/apify-sdk-python/commit/1fbdce27452f1cdc9580a53edd6de3ce9fe36a1d)) by [@vdusek](https://github.com/vdusek)
 - Respect explicit zero custom_after_sleep in metamorph and reboot ([#971](https://github.com/apify/apify-sdk-python/pull/971)) ([e8cda0a](https://github.com/apify/apify-sdk-python/commit/e8cda0a80339a21ce94cc382bd042509052ce1bf)) by [@vdusek](https://github.com/vdusek)
+- Reconnect to platform events websocket after connection drop ([#967](https://github.com/apify/apify-sdk-python/pull/967)) ([5653a22](https://github.com/apify/apify-sdk-python/commit/5653a222d976919cc7388a88242a488ba503647e)) by [@vdusek](https://github.com/vdusek)
+- Forward all `Webhook` fields to ad-hoc webhooks ([#963](https://github.com/apify/apify-sdk-python/pull/963)) ([726620b](https://github.com/apify/apify-sdk-python/commit/726620be25da85b74b3f0d1e4f8c1f8f1b29d9b1)) by [@vdusek](https://github.com/vdusek)
 
 ### 🚜 Refactor
 

{apify-3.4.2b22 → apify-3.4.2b24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: apify
-Version: 3.4.2b22
+Version: 3.4.2b24
 Summary: Apify SDK for Python
 Project-URL: Apify Homepage, https://apify.com
 Project-URL: Changelog, https://docs.apify.com/sdk/python/docs/changelog

{apify-3.4.2b22 → apify-3.4.2b24}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "apify"
-version = "3.4.2b22"
+version = "3.4.2b24"
 description = "Apify SDK for Python"
 authors = [{ name = "Apify Technologies s.r.o.", email = "support@apify.com" }]
 license = { file = "LICENSE" }

{apify-3.4.2b22 → apify-3.4.2b24}/src/apify/_actor.py

@@ -4,6 +4,7 @@ import asyncio
 import sys
 import warnings
 from contextlib import suppress
+from dataclasses import asdict
 from datetime import UTC, datetime, timedelta
 from functools import cached_property
 from typing import TYPE_CHECKING, Any, Literal, TypeVar, cast, overload
@@ -1283,15 +1284,16 @@ class _ActorType:
         if not self.configuration.actor_run_id:
             raise RuntimeError('actor_run_id cannot be None when running on the Apify platform.')
 
+        # `Webhook`'s field names match `webhooks().create()`'s parameters, so we forward them by name rather
+        # than listing each one.
+        webhook_fields = asdict(webhook)
+
+        if idempotency_key is not None:
+            webhook_fields['idempotency_key'] = idempotency_key
+
         await self.apify_client.webhooks().create(
+            **webhook_fields,
             actor_run_id=self.configuration.actor_run_id,
-            event_types=webhook.event_types,
-            request_url=webhook.request_url,
-            payload_template=webhook.payload_template,
-            headers_template=webhook.headers_template,
-            ignore_ssl_errors=webhook.ignore_ssl_errors,
-            do_not_retry=webhook.do_not_retry,
-            idempotency_key=idempotency_key if idempotency_key is not None else webhook.idempotency_key,
             is_ad_hoc=True,
         )
 

{apify-3.4.2b22 → apify-3.4.2b24}/src/apify/_webhook.py

@@ -48,15 +48,13 @@ class Webhook:
 
 
 def to_client_representations(webhooks: list[Webhook] | None) -> list[WebhookRepresentation] | None:
-    """Project SDK webhooks to the minimal ad-hoc representation accepted by the client's `start()` / `call()`."""
+    """Convert SDK webhooks to the ad-hoc representation accepted by the client's `start()` / `call()`.
+
+    `Webhook`'s field names match `WebhookRepresentation`'s, so we let pydantic read them straight off the
+    instance rather than listing each one. This forwards any field the representation declares without changes
+    here, and never emits an undeclared field as a malformed snake_case extra.
+    """
     if not webhooks:
         return None
-    return [
-        WebhookRepresentation(
-            event_types=w.event_types,
-            request_url=w.request_url,
-            payload_template=w.payload_template,
-            headers_template=w.headers_template,
-        )
-        for w in webhooks
-    ]
+
+    return [WebhookRepresentation.model_validate(webhook, from_attributes=True) for webhook in webhooks]

apify-3.4.2b24/src/apify/events/_apify_event_manager.py

@@ -0,0 +1,242 @@
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import time
+from typing import TYPE_CHECKING, Annotated, Self
+
+import websockets.asyncio.client
+import websockets.client
+import websockets.exceptions
+from pydantic import Discriminator, TypeAdapter
+from typing_extensions import Unpack, override
+from websockets.frames import CloseCode
+
+from crawlee.events import EventManager
+from crawlee.events._types import Event, EventPersistStateData
+
+from apify._utils import docs_group
+from apify.events._types import DeprecatedEvent, EventMessage, SystemInfoEventData, UnknownEvent
+from apify.log import logger
+
+if TYPE_CHECKING:
+    from collections.abc import Generator
+    from types import TracebackType
+
+    from crawlee.events._event_manager import EventManagerOptions
+
+    from apify._configuration import Configuration
+
+
+event_data_adapter = TypeAdapter[EventMessage | DeprecatedEvent | UnknownEvent](
+    Annotated[EventMessage, Discriminator('name')] | DeprecatedEvent | UnknownEvent
+)
+
+
+@docs_group('Event managers')
+class ApifyEventManager(EventManager):
+    """Event manager for the Apify platform.
+
+    This class extends Crawlee's `EventManager` to provide Apify-specific functionality, including websocket
+    connectivity to the Apify platform for receiving platform events.
+
+    The event manager handles:
+    - Registration and emission of events and their listeners.
+    - Websocket connection to Apify platform events.
+    - Processing and validation of platform messages.
+    - Automatic event forwarding from the platform to local event listeners.
+
+    This class should not be used directly. Use the `Actor.on` and `Actor.off` methods to interact
+    with the event system.
+    """
+
+    _NON_RETRYABLE_CLOSE_CODES = frozenset(
+        {
+            CloseCode.PROTOCOL_ERROR,
+            CloseCode.UNSUPPORTED_DATA,
+            CloseCode.INVALID_DATA,
+            CloseCode.POLICY_VIOLATION,
+            CloseCode.MANDATORY_EXTENSION,
+        }
+    )
+    """WebSocket close codes for a permanent condition, on which the connection is not re-established.
+
+    The platform sends `POLICY_VIOLATION` (1008) for an unknown/missing run ID or an exceeded per-run
+    connection limit. The rest are protocol, data, or mandatory-extension failures that reconnecting
+    cannot resolve.
+    """
+
+    _HEALTHY_CONNECTION_MIN_DURATION = 1.0
+    """Seconds a connection must stay open to count as healthy, after which a drop reconnects without backoff."""
+
+    def __init__(self, configuration: Configuration, **kwargs: Unpack[EventManagerOptions]) -> None:
+        """Initialize a new instance.
+
+        Args:
+            configuration: The Actor configuration for the event manager.
+            **kwargs: Additional event manager options passed to the parent class.
+        """
+        super().__init__(**kwargs)
+
+        self._configuration = configuration
+        """The Actor configuration for the event manager."""
+
+        self._platform_events_websocket: websockets.asyncio.client.ClientConnection | None = None
+        """WebSocket connection to the platform events."""
+
+        self._process_platform_messages_task: asyncio.Task | None = None
+        """Task for processing messages from the platform websocket."""
+
+        self._connected_to_platform_websocket: asyncio.Future[bool] | None = None
+        """Future that resolves when the connection to the platform websocket is established."""
+
+    @override
+    async def __aenter__(self) -> Self:
+        await super().__aenter__()
+        self._connected_to_platform_websocket = asyncio.Future()
+
+        # Run tasks but don't await them
+        if self._configuration.actor_events_ws_url:
+            self._process_platform_messages_task = asyncio.create_task(
+                self._process_platform_messages(self._configuration.actor_events_ws_url)
+            )
+            is_connected = await self._connected_to_platform_websocket
+            if not is_connected:
+                # Exit the already-entered parent so the recurring persist state task does not leak.
+                await self.__aexit__(None, None, None)
+                raise RuntimeError('Error connecting to platform events websocket!')
+        else:
+            logger.debug('APIFY_ACTOR_EVENTS_WS_URL env var not set, no events from Apify platform will be emitted.')
+
+        return self
+
+    @override
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        exc_traceback: TracebackType | None,
+    ) -> None:
+        # Cancel the task before closing the websocket so that the closed connection is not treated as a drop
+        # and followed by a reconnect attempt.
+        if self._process_platform_messages_task and not self._process_platform_messages_task.done():
+            self._process_platform_messages_task.cancel()
+            with contextlib.suppress(asyncio.CancelledError):
+                await self._process_platform_messages_task
+
+        if self._platform_events_websocket:
+            await self._platform_events_websocket.close()
+
+        await super().__aexit__(exc_type, exc_value, exc_traceback)
+
+    def _process_connection_exception(self, exc: Exception) -> Exception | None:
+        """Decide whether a failed connection attempt to the platform websocket should be retried.
+
+        Before the first successful connection, every error is fatal so that `__aenter__` fails fast. After that,
+        the default `websockets` behavior decides which errors are transient and retried with exponential backoff.
+        """
+        if self._connected_to_platform_websocket and self._connected_to_platform_websocket.done():
+            return websockets.asyncio.client.process_exception(exc)
+        return exc
+
+    async def _process_platform_messages(self, ws_url: str) -> None:
+        # The `websockets` reconnect iterator only backs off on failed connection *attempts*, not on a connection
+        # that opens and is then closed. Track our own backoff here so a server that keeps accepting and immediately
+        # closing is not hammered; it is reset after a healthy connection so a healthy drop reconnects immediately.
+        backoff_delays: Generator[float] | None = None
+
+        try:
+            # Used as an async iterator, `connect` reconnects with exponential backoff on failed connection attempts.
+            async for websocket in websockets.asyncio.client.connect(
+                ws_url, process_exception=self._process_connection_exception
+            ):
+                self._platform_events_websocket = websocket
+                if self._connected_to_platform_websocket and not self._connected_to_platform_websocket.done():
+                    self._connected_to_platform_websocket.set_result(True)
+                else:
+                    logger.info('Reconnected to the platform events websocket.')
+
+                connection_opened_at = time.monotonic()
+                connection_lost = await self._consume_messages(websocket)
+
+                if not self._should_reconnect_after_close(websocket, connection_lost=connection_lost):
+                    break
+
+                # Reconnect a healthy connection immediately; back off only on repeated rapid drops. The first
+                # rapid drop reconnects once without delay (it only primes the backoff generator), and each
+                # subsequent consecutive rapid drop then sleeps for the next backoff interval. A healthy
+                # connection resets the generator, so the next rapid drop again gets that one free retry.
+                if time.monotonic() - connection_opened_at >= self._HEALTHY_CONNECTION_MIN_DURATION:
+                    backoff_delays = None
+                elif backoff_delays is None:
+                    backoff_delays = websockets.client.backoff()
+                else:
+                    await asyncio.sleep(next(backoff_delays))
+        except Exception:
+            logger.exception('Error in websocket connection')
+            if self._connected_to_platform_websocket is not None and not self._connected_to_platform_websocket.done():
+                self._connected_to_platform_websocket.set_result(False)
+
+    async def _consume_messages(self, websocket: websockets.asyncio.client.ClientConnection) -> bool:
+        """Handle platform messages until the connection closes; return whether it was lost vs. closed cleanly."""
+        try:
+            async for message in websocket:
+                await self._handle_platform_message(message)
+        except websockets.exceptions.ConnectionClosed:
+            return True
+        return False
+
+    async def _handle_platform_message(self, message: str | bytes) -> None:
+        """Parse a single platform message and emit the matching local event."""
+        try:
+            parsed_message = event_data_adapter.validate_json(message)
+
+            if isinstance(parsed_message, DeprecatedEvent):
+                return
+
+            if isinstance(parsed_message, UnknownEvent):
+                logger.info(
+                    f'Unknown message received: event_name={parsed_message.name}, event_data={parsed_message.data}'
+                )
+                return
+
+            self.emit(
+                event=parsed_message.name,
+                event_data=parsed_message.data
+                if not isinstance(parsed_message.data, SystemInfoEventData)
+                else parsed_message.data.to_crawlee_format(self._configuration.dedicated_cpus or 1),
+            )
+
+            if parsed_message.name == Event.MIGRATING:
+                await self._emit_persist_state_event_rec_task.stop()
+                self.emit(event=Event.PERSIST_STATE, event_data=EventPersistStateData(is_migrating=True))
+        except Exception:
+            logger.exception('Cannot parse Actor event', extra={'raw_message': message})
+
+    def _should_reconnect_after_close(
+        self,
+        websocket: websockets.asyncio.client.ClientConnection,
+        *,
+        connection_lost: bool,
+    ) -> bool:
+        """Log the websocket close and report whether to reconnect (`False` on a non-retryable close code)."""
+        if websocket.close_code in self._NON_RETRYABLE_CLOSE_CODES:
+            logger.error(
+                f'Connection to platform events websocket was closed with a non-retryable code '
+                f'(code={websocket.close_code}, reason={websocket.close_reason!r}); not reconnecting. '
+                f'No further platform events will be received for the rest of this run, so migration and '
+                f'abort handling (e.g. persisting state before a migration) is now disabled.'
+            )
+            return False
+
+        if connection_lost:
+            logger.warning(
+                f'Connection to platform events websocket was lost '
+                f'(code={websocket.close_code}, reason={websocket.close_reason!r}), reconnecting...'
+            )
+        else:
+            logger.info(
+                f'Connection to platform events websocket was closed '
+                f'(code={websocket.close_code}, reason={websocket.close_reason!r}), reconnecting...'
+            )
+        return True

{apify-3.4.2b22 → apify-3.4.2b24}/src/apify/storage_clients/_apify/_alias_resolving.py

@@ -6,14 +6,13 @@ from functools import cached_property
 from logging import getLogger
 from typing import TYPE_CHECKING, ClassVar, Literal, overload
 
-from apify_client import ApifyClientAsync
-
 from ._utils import hash_api_public_base_url_and_token
 
 if TYPE_CHECKING:
     from collections.abc import Callable
     from types import TracebackType
 
+    from apify_client import ApifyClientAsync
     from apify_client._resource_clients import (
         DatasetClientAsync,
         DatasetCollectionClientAsync,
@@ -35,6 +34,7 @@ async def open_by_alias(
     storage_type: Literal['Dataset'],
     collection_client: DatasetCollectionClientAsync,
     get_resource_client_by_id: Callable[[str], DatasetClientAsync],
+    api_client: ApifyClientAsync,
     configuration: Configuration,
 ) -> DatasetClientAsync: ...
 
@@ -46,6 +46,7 @@ async def open_by_alias(
     storage_type: Literal['KeyValueStore'],
     collection_client: KeyValueStoreCollectionClientAsync,
     get_resource_client_by_id: Callable[[str], KeyValueStoreClientAsync],
+    api_client: ApifyClientAsync,
     configuration: Configuration,
 ) -> KeyValueStoreClientAsync: ...
 
@@ -57,6 +58,7 @@ async def open_by_alias(
     storage_type: Literal['RequestQueue'],
     collection_client: RequestQueueCollectionClientAsync,
     get_resource_client_by_id: Callable[[str], RequestQueueClientAsync],
+    api_client: ApifyClientAsync,
     configuration: Configuration,
 ) -> RequestQueueClientAsync: ...
 
@@ -69,6 +71,7 @@ async def open_by_alias(
         KeyValueStoreCollectionClientAsync | RequestQueueCollectionClientAsync | DatasetCollectionClientAsync
     ),
     get_resource_client_by_id: Callable[[str], KeyValueStoreClientAsync | RequestQueueClientAsync | DatasetClientAsync],
+    api_client: ApifyClientAsync,
     configuration: Configuration,
 ) -> KeyValueStoreClientAsync | RequestQueueClientAsync | DatasetClientAsync:
     """Open storage by alias, creating it if necessary.
@@ -81,6 +84,8 @@ async def open_by_alias(
         storage_type: The type of storage to open.
         collection_client: The Apify API collection client for the storage type.
         get_resource_client_by_id: A callable that takes a storage ID and returns the resource client.
+        api_client: The Apify API client used for the storage operation. Reused to access the default KVS that
+            holds the alias mapping, so alias resolution does not spin up its own client.
         configuration: Configuration object containing API credentials and settings.
 
     Returns:
@@ -94,6 +99,7 @@ async def open_by_alias(
         storage_type=storage_type,
         alias=alias,
         configuration=configuration,
+        api_client=api_client,
     ) as alias_resolver:
         storage_id = await alias_resolver.resolve_id()
 
@@ -142,10 +148,12 @@ class AliasResolver:
         storage_type: Literal['Dataset', 'KeyValueStore', 'RequestQueue'],
         alias: str,
         configuration: Configuration,
+        api_client: ApifyClientAsync,
     ) -> None:
         self._storage_type = storage_type
         self._alias = alias
         self._configuration = configuration
+        self._api_client = api_client
 
     async def __aenter__(self) -> AliasResolver:
         """Context manager to prevent race condition in alias creation."""
@@ -173,26 +181,22 @@ class AliasResolver:
             cls._alias_init_lock = Lock()
         return cls._alias_init_lock
 
-    @classmethod
-    async def _get_alias_map(cls, configuration: Configuration) -> dict[str, str]:
+    async def _get_alias_map(self) -> dict[str, str]:
         """Get the aliases and storage ids mapping from the default kvs.
 
-        Mapping is loaded from kvs only once and is shared for all instances of the AliasResolver class.
-
-        Args:
-            configuration: Configuration object to use for accessing the default KVS.
+        Mapping is loaded from kvs only once and is shared for all instances of the `AliasResolver` class.
 
         Returns:
             Map of aliases and storage ids.
         """
-        if not cls._alias_map_loaded and configuration.is_at_home:
-            default_kvs_client = await cls._get_default_kvs_client(configuration)
+        if not AliasResolver._alias_map_loaded and self._configuration.is_at_home:
+            default_kvs_client = self._get_default_kvs_client()
 
-            record = await default_kvs_client.get_record(cls._ALIAS_MAPPING_KEY)
-            cls._alias_map = record.get('value', {}) if record else {}
-            cls._alias_map_loaded = True
+            record = await default_kvs_client.get_record(self._ALIAS_MAPPING_KEY)
+            AliasResolver._alias_map = record.get('value', {}) if record else {}
+            AliasResolver._alias_map_loaded = True
 
-        return cls._alias_map
+        return AliasResolver._alias_map
 
     async def resolve_id(self) -> str | None:
         """Get id of the aliased storage.
@@ -212,12 +216,12 @@ class AliasResolver:
                 return storage_id
 
         # Fallback to the mapping saved in the default KVS
-        return (await self._get_alias_map(self._configuration)).get(self._storage_key, None)
+        return (await self._get_alias_map()).get(self._storage_key, None)
 
     async def store_mapping(self, storage_id: str) -> None:
         """Add alias and related storage id to the mapping in default kvs and local in-memory mapping."""
         # Update in-memory mapping
-        alias_map = await self._get_alias_map(self._configuration)
+        alias_map = await self._get_alias_map()
         alias_map[self._storage_key] = storage_id
 
         if not self._configuration.is_at_home:
@@ -226,7 +230,7 @@ class AliasResolver:
             )
             return
 
-        default_kvs_client = await self._get_default_kvs_client(self._configuration)
+        default_kvs_client = self._get_default_kvs_client()
 
         try:
             record = await default_kvs_client.get_record(self._ALIAS_MAPPING_KEY)
@@ -249,16 +253,14 @@ class AliasResolver:
             ]
         )
 
-    @staticmethod
-    async def _get_default_kvs_client(configuration: Configuration) -> KeyValueStoreClientAsync:
-        """Get a client for the default key-value store."""
-        apify_client_async = ApifyClientAsync(
-            token=configuration.token,
-            api_url=configuration.api_base_url,
-            max_retries=8,
-        )
+    def _get_default_kvs_client(self) -> KeyValueStoreClientAsync:
+        """Get a client for the default key-value store.
 
-        if not configuration.default_key_value_store_id:
+        Derived from the injected `ApifyClientAsync`, so alias resolution shares the same HTTP client (and its
+        connection pool and event loop affinity) as the storage operation that triggered it, instead of creating
+        and leaking its own.
+        """
+        if not self._configuration.default_key_value_store_id:
             raise ValueError("'Configuration.default_key_value_store_id' must be set.")
 
-        return apify_client_async.key_value_store(key_value_store_id=configuration.default_key_value_store_id)
+        return self._api_client.key_value_store(key_value_store_id=self._configuration.default_key_value_store_id)

{apify-3.4.2b22 → apify-3.4.2b24}/src/apify/storage_clients/_apify/_api_client_creation.py

@@ -117,6 +117,7 @@ async def create_storage_api_client(
                 storage_type=storage_type,
                 collection_client=collection_client,
                 get_resource_client_by_id=get_resource_client,
+                api_client=apify_client,
                 configuration=configuration,
             )  # ty:ignore[no-matching-overload]
 
@@ -127,6 +128,7 @@ async def create_storage_api_client(
                 storage_type=storage_type,
                 collection_client=collection_client,
                 get_resource_client_by_id=get_resource_client,
+                api_client=apify_client,
                 configuration=configuration,
             )  # ty:ignore[no-matching-overload]
 

apify-3.4.2b22/src/apify/events/_apify_event_manager.py

@@ -1,142 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import contextlib
-from typing import TYPE_CHECKING, Annotated, Self
-
-import websockets.asyncio.client
-from pydantic import Discriminator, TypeAdapter
-from typing_extensions import Unpack, override
-
-from crawlee.events import EventManager
-from crawlee.events._types import Event, EventPersistStateData
-
-from apify._utils import docs_group
-from apify.events._types import DeprecatedEvent, EventMessage, SystemInfoEventData, UnknownEvent
-from apify.log import logger
-
-if TYPE_CHECKING:
-    from types import TracebackType
-
-    from crawlee.events._event_manager import EventManagerOptions
-
-    from apify._configuration import Configuration
-
-
-event_data_adapter = TypeAdapter[EventMessage | DeprecatedEvent | UnknownEvent](
-    Annotated[EventMessage, Discriminator('name')] | DeprecatedEvent | UnknownEvent
-)
-
-
-@docs_group('Event managers')
-class ApifyEventManager(EventManager):
-    """Event manager for the Apify platform.
-
-    This class extends Crawlee's `EventManager` to provide Apify-specific functionality, including websocket
-    connectivity to the Apify platform for receiving platform events.
-
-    The event manager handles:
-    - Registration and emission of events and their listeners.
-    - Websocket connection to Apify platform events.
-    - Processing and validation of platform messages.
-    - Automatic event forwarding from the platform to local event listeners.
-
-    This class should not be used directly. Use the `Actor.on` and `Actor.off` methods to interact
-    with the event system.
-    """
-
-    def __init__(self, configuration: Configuration, **kwargs: Unpack[EventManagerOptions]) -> None:
-        """Initialize a new instance.
-
-        Args:
-            configuration: The Actor configuration for the event manager.
-            **kwargs: Additional event manager options passed to the parent class.
-        """
-        super().__init__(**kwargs)
-
-        self._configuration = configuration
-        """The Actor configuration for the event manager."""
-
-        self._platform_events_websocket: websockets.asyncio.client.ClientConnection | None = None
-        """WebSocket connection to the platform events."""
-
-        self._process_platform_messages_task: asyncio.Task | None = None
-        """Task for processing messages from the platform websocket."""
-
-        self._connected_to_platform_websocket: asyncio.Future[bool] | None = None
-        """Future that resolves when the connection to the platform websocket is established."""
-
-    @override
-    async def __aenter__(self) -> Self:
-        await super().__aenter__()
-        self._connected_to_platform_websocket = asyncio.Future()
-
-        # Run tasks but don't await them
-        if self._configuration.actor_events_ws_url:
-            self._process_platform_messages_task = asyncio.create_task(
-                self._process_platform_messages(self._configuration.actor_events_ws_url)
-            )
-            is_connected = await self._connected_to_platform_websocket
-            if not is_connected:
-                # Exit the already-entered parent so the recurring persist state task does not leak.
-                await self.__aexit__(None, None, None)
-                raise RuntimeError('Error connecting to platform events websocket!')
-        else:
-            logger.debug('APIFY_ACTOR_EVENTS_WS_URL env var not set, no events from Apify platform will be emitted.')
-
-        return self
-
-    @override
-    async def __aexit__(
-        self,
-        exc_type: type[BaseException] | None,
-        exc_value: BaseException | None,
-        exc_traceback: TracebackType | None,
-    ) -> None:
-        if self._platform_events_websocket:
-            await self._platform_events_websocket.close()
-
-        if self._process_platform_messages_task and not self._process_platform_messages_task.done():
-            self._process_platform_messages_task.cancel()
-            with contextlib.suppress(asyncio.CancelledError):
-                await self._process_platform_messages_task
-
-        await super().__aexit__(exc_type, exc_value, exc_traceback)
-
-    async def _process_platform_messages(self, ws_url: str) -> None:
-        try:
-            async with websockets.asyncio.client.connect(ws_url) as websocket:
-                self._platform_events_websocket = websocket
-                if self._connected_to_platform_websocket is not None:
-                    self._connected_to_platform_websocket.set_result(True)
-
-                async for message in websocket:
-                    try:
-                        parsed_message = event_data_adapter.validate_json(message)
-
-                        if isinstance(parsed_message, DeprecatedEvent):
-                            continue
-
-                        if isinstance(parsed_message, UnknownEvent):
-                            logger.info(
-                                f'Unknown message received: event_name={parsed_message.name}, '
-                                f'event_data={parsed_message.data}'
-                            )
-                            continue
-
-                        self.emit(
-                            event=parsed_message.name,
-                            event_data=parsed_message.data
-                            if not isinstance(parsed_message.data, SystemInfoEventData)
-                            else parsed_message.data.to_crawlee_format(self._configuration.dedicated_cpus or 1),
-                        )
-
-                        if parsed_message.name == Event.MIGRATING:
-                            await self._emit_persist_state_event_rec_task.stop()
-                            self.emit(event=Event.PERSIST_STATE, event_data=EventPersistStateData(is_migrating=True))
-                    except Exception:
-                        logger.exception('Cannot parse Actor event', extra={'raw_message': message})
-        except Exception:
-            logger.exception('Error in websocket connection')
-            if self._connected_to_platform_websocket is not None and not self._connected_to_platform_websocket.done():
-                self._connected_to_platform_websocket.set_result(False)