scrapely-python 0.1.21__tar.gz → 0.1.23__tar.gz

{scrapely_python-0.1.21/src/scrapely_python.egg-info → scrapely_python-0.1.23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scrapely-python
-Version: 0.1.21
+Version: 0.1.23
 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.21 → scrapely_python-0.1.23}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "scrapely-python"
-version = "0.1.21"
+version = "0.1.23"
 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.23/src/scrapely/__init__.py

@@ -0,0 +1,341 @@
+"""
+Scrapely Python SDK - A toolkit for building Actors on the Scrapely platform.
+
+Usage:
+    from scrapely import Actor, Dataset
+
+    async def main():
+        async with Actor:
+            actor_input = await Actor.get_input()
+            await Actor.push_data({'url': actor_input['url']})
+"""
+
+from typing import TYPE_CHECKING, Any
+
+# Side-effect: patch browser launches (Crawlee BrowserPool, PlaywrightCrawler,
+# raw Playwright, Camoufox, pyppeteer) to use the remote CDP browser (CDP_URL).
+# Must run on package import so `from scrapely import Actor` enables the patch
+# before any browser is launched (Node SDK parity). It does not import Crawlee:
+# the Crawlee patches are applied when Crawlee's browser modules load.
+from .patch_browser_pool import set_cdp_url  # noqa: F401
+
+# Crawlee is NOT imported here: it costs ~1 s per run under gVisor and many
+# actors never touch it. Everything that needs Crawlee (the re-exported Crawlee
+# classes, storage clients, events, request loaders) is resolved on first
+# attribute access by ``__getattr__`` below; ``Actor`` imports what it needs on
+# first use. Every ``from scrapely import X`` that worked before still works.
+from .actor import Actor
+from .configuration import Configuration
+from .charging_client import (
+    USES_PUSH_DATA_INTERCEPTION,
+    create_charging_client,
+    push_data_charging_context,
+)
+from .proxy_configuration import ProxyConfiguration
+from .browser_configuration import BrowserConfiguration
+from .charging import (
+    ChargingManager,
+    ChargeUncertainError,
+    ChargeRejectedError,
+    has_default_dataset_item_event_in_pricing,
+    is_default_dataset_item_event,
+    merge_charge_results,
+    push_data_and_charge,
+    resolve_default_dataset_item_event_name,
+    APIFY_DEFAULT_DATASET_ITEM_EVENT,
+    SCRAPELY_DEFAULT_DATASET_ITEM_EVENT,
+    DEFAULT_DATASET_ITEM_EVENT,
+)
+
+from .types import (
+    ActorInput,
+    ActorPermissionLevel,
+    ActorRun,
+    ApifyEnv,
+    AbortOptions,
+    CallOptions,
+    ExitOptions,
+    InitOptions,
+    MetamorphOptions,
+    OpenStorageOptions,
+    ProxyInfo,
+    RebootOptions,
+    RecordOptions,
+    SetStatusMessageOptions,
+    StartOptions,
+    WebhookOptions,
+)
+
+from .webhook import (
+    Webhook,
+    WebhookEventType,
+)
+from .pricing_types import (
+    PricingModel,
+    FreeActorPricingInfo,
+    FlatPricePerMonthActorPricingInfo,
+    PricePerDatasetItemActorPricingInfo,
+    PayPerEventActorPricingInfo,
+    PricingPerEvent,
+    ActorPricingInfo,
+    ActorChargeEvent,
+    ChargeResult,
+    ActorPricingInfoResult,
+)
+from .errors import (
+    ScrapelyClientError,
+    ScrapelyApiError,
+    InvalidResponseBodyError,
+    InvalidRequestError,
+    UnauthorizedError,
+    ForbiddenError,
+    NotFoundError,
+    ConflictError,
+    RateLimitError,
+    ServerError,
+    raise_for_status,
+)
+
+# Public name -> (module, attribute) for names that need Crawlee. Loaded on
+# first access and cached in the module namespace.
+_LAZY_ATTRS = {
+    # Crawlee re-exports
+    'Request': ('crawlee', 'Request'),
+    'RequestLoader': ('crawlee.request_loaders', 'RequestLoader'),
+    'RequestManager': ('crawlee.request_loaders', 'RequestManager'),
+    'RequestManagerTandem': ('crawlee.request_loaders', 'RequestManagerTandem'),
+    'SitemapRequestLoader': ('crawlee.request_loaders', 'SitemapRequestLoader'),
+    'Dataset': ('crawlee.storages', 'Dataset'),
+    'KeyValueStore': ('crawlee.storages', 'KeyValueStore'),
+    'RequestQueue': ('crawlee.storages', 'RequestQueue'),
+    'DatasetItemsListPage': ('crawlee.storage_clients.models', 'DatasetItemsListPage'),
+    'EventListener': ('crawlee.events', 'EventListener'),
+    # Storage clients
+    'ApiStorageClient': ('scrapely.storage', 'ApiStorageClient'),
+    'FileSystemStorageClient': ('scrapely.storage', 'FileSystemStorageClient'),
+    'MemoryStorageClient': ('scrapely.storage', 'MemoryStorageClient'),
+    'ScrapelyStorageClient': ('scrapely.storage', 'ScrapelyStorageClient'),
+    'SmartScrapelyStorageClient': ('scrapely.storage', 'SmartScrapelyStorageClient'),
+    'StorageClient': ('scrapely.storage', 'StorageClient'),
+    'set_api_storage': ('scrapely.storage', 'set_api_storage'),
+    # Request loaders
+    'ScrapelyRequestList': ('scrapely.request_loaders', 'ScrapelyRequestList'),
+    # Events
+    **{
+        name: ('scrapely.events', name)
+        for name in (
+            'AbortingEvent',
+            'ActorEventTypes',
+            'CrawleeEventManager',
+            'DeprecatedEvent',
+            'Event',
+            'EventAbortingData',
+            'EventExitData',
+            'EventManager',
+            'EventMessage',
+            'EventMigratingData',
+            'EventPersistStateData',
+            'EventSystemInfoData',
+            'EventWithoutData',
+            'ExitEvent',
+            'LocalEventManager',
+            'MigratingEvent',
+            'PersistStateEvent',
+            'ScrapelyEventManager',
+            'SystemInfoEvent',
+            'SystemInfoEventData',
+            'UnknownEvent',
+        )
+    },
+}
+
+# Submodules that used to be loaded (and so bound as attributes) by this
+# package's eager imports; ``scrapely.events`` etc. keep working without an
+# explicit ``import scrapely.events``.
+_LAZY_SUBMODULES = frozenset({
+    'events',
+    'log',
+    'request_loaders',
+    'storage',
+    'storage_clients',
+    'storages',
+})
+
+
+def __getattr__(name: str) -> Any:
+    target = _LAZY_ATTRS.get(name)
+    if target is not None:
+        import importlib
+
+        value = getattr(importlib.import_module(target[0]), target[1])
+        globals()[name] = value
+        return value
+    if name in _LAZY_SUBMODULES:
+        import importlib
+
+        return importlib.import_module(f'{__name__}.{name}')
+    raise AttributeError(f'module {__name__!r} has no attribute {name!r}')
+
+
+def __dir__() -> list:
+    return sorted(set(globals()) | set(_LAZY_ATTRS) | _LAZY_SUBMODULES)
+
+
+if TYPE_CHECKING:  # Static analysers and IDEs see the lazy names as plain imports.
+    from crawlee import Request
+    from crawlee.events import EventListener
+    from crawlee.request_loaders import (
+        RequestLoader,
+        RequestManager,
+        RequestManagerTandem,
+        SitemapRequestLoader,
+    )
+    from crawlee.storage_clients.models import DatasetItemsListPage
+    from crawlee.storages import Dataset, KeyValueStore, RequestQueue
+
+    from .events import (
+        AbortingEvent,
+        ActorEventTypes,
+        CrawleeEventManager,
+        DeprecatedEvent,
+        Event,
+        EventAbortingData,
+        EventExitData,
+        EventManager,
+        EventMessage,
+        EventMigratingData,
+        EventPersistStateData,
+        EventSystemInfoData,
+        EventWithoutData,
+        ExitEvent,
+        LocalEventManager,
+        MigratingEvent,
+        PersistStateEvent,
+        ScrapelyEventManager,
+        SystemInfoEvent,
+        SystemInfoEventData,
+        UnknownEvent,
+    )
+    from .request_loaders import ScrapelyRequestList
+    from .storage import (
+        ApiStorageClient,
+        FileSystemStorageClient,
+        MemoryStorageClient,
+        ScrapelyStorageClient,
+        SmartScrapelyStorageClient,
+        StorageClient,
+        set_api_storage,
+    )
+
+__version__ = '0.1.23'
+__all__ = [
+    # Core
+    'Actor',
+    'Configuration',
+    'set_cdp_url',
+    # ApifyClient
+    'create_charging_client',
+    'USES_PUSH_DATA_INTERCEPTION',
+    'push_data_charging_context',
+
+    # Storage
+    'Dataset',
+    'KeyValueStore',
+    'RequestQueue',
+    'Request',
+    'DatasetItemsListPage',
+    # Storage clients
+    'ApiStorageClient',
+    'ScrapelyStorageClient',
+    'SmartScrapelyStorageClient',
+    'FileSystemStorageClient',
+    'MemoryStorageClient',
+    'StorageClient',
+    'set_api_storage',
+    # Request loaders
+    'ScrapelyRequestList',
+    'RequestLoader',
+    'RequestManager',
+    'RequestManagerTandem',
+    'SitemapRequestLoader',
+    # Events
+    'Event',
+    'EventManager',
+    'ScrapelyEventManager',
+    'CrawleeEventManager',
+    'LocalEventManager',
+    # Event data types
+    'SystemInfoEventData',
+    'EventAbortingData',
+    'EventExitData',
+    'EventListener',
+    'EventMigratingData',
+    'EventPersistStateData',
+    'EventSystemInfoData',
+    # Event types
+    'PersistStateEvent',
+    'SystemInfoEvent',
+    'MigratingEvent',
+    'AbortingEvent',
+    'ExitEvent',
+    'EventWithoutData',
+    'DeprecatedEvent',
+    'UnknownEvent',
+    'EventMessage',
+    'ActorEventTypes',
+    # Proxy
+    'ProxyConfiguration',
+    'ProxyInfo',
+    # Remote browser
+    'BrowserConfiguration',
+    # Charging
+    'ChargingManager',
+    'ChargeResult',
+    'ChargeUncertainError',
+    'ChargeRejectedError',
+    'merge_charge_results',
+    'push_data_and_charge',
+
+    # Types
+    'ActorInput',
+    'ActorPermissionLevel',
+    'ActorRun',
+    'ApifyEnv',
+    'AbortOptions',
+    'CallOptions',
+    'ExitOptions',
+    'InitOptions',
+    'MetamorphOptions',
+    'OpenStorageOptions',
+    'RebootOptions',
+    'RecordOptions',
+    'SetStatusMessageOptions',
+    'StartOptions',
+    'WebhookOptions',
+
+    # Webhook
+    'Webhook',
+    'WebhookEventType',
+    # Pricing
+    'PricingModel',
+    'FreeActorPricingInfo',
+    'FlatPricePerMonthActorPricingInfo',
+    'PricePerDatasetItemActorPricingInfo',
+    'PayPerEventActorPricingInfo',
+    'PricingPerEvent',
+    'ActorPricingInfo',
+    'ActorChargeEvent',
+    'ActorPricingInfoResult',
+    # Errors
+    'ScrapelyClientError',
+    'ScrapelyApiError',
+    'InvalidResponseBodyError',
+    'InvalidRequestError',
+    'UnauthorizedError',
+    'ForbiddenError',
+    'NotFoundError',
+    'ConflictError',
+    'RateLimitError',
+    'ServerError',
+    'raise_for_status',
+]

{scrapely_python-0.1.21 → scrapely_python-0.1.23}/src/scrapely/actor.py

@@ -20,10 +20,6 @@ from datetime import datetime, timedelta
 from decimal import Decimal
 from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Tuple, Union, cast
 
-from crawlee.configuration import Configuration as CrawleeConfiguration
-from crawlee.storage_clients._base import StorageClient
-from crawlee.storages import Dataset, KeyValueStore, RequestQueue
-
 from .charging import (
     ChargingManager,
     is_default_dataset_item_event,
@@ -34,23 +30,10 @@ from .charging import (
 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
 from .charging_client import create_charging_client
 from .errors import ForbiddenError
 from .storage.api_client import ApiClient, ApiClientError
 from .storage.client import is_storage_uuid
-from .storage._metadata import StorageType, resolve_alias_from_storages_json
-from .storage.patch_storage import (
-    disconnect_storage,
-    get_api_storage_factory,
-    get_smart_storage_client,
-    set_api_storage,
-    set_storage_client,
-)
-from .storage.scrapely_storage_client import ScrapelyStorageClient
-from .storage.smart_scrapely_storage_client import SmartScrapelyStorageClient
 from .types import (
     AbortOptions,
     ActorRun,
@@ -66,17 +49,74 @@ from .types import (
     StartOptions,
     WebhookOptions,
 )
-from .log import _configure_logging
 from .webhook import Webhook
 
 if TYPE_CHECKING:
+    from crawlee.events import EventManager
+    from crawlee.storage_clients._base import StorageClient
+    from crawlee.storages import Dataset, KeyValueStore, RequestQueue
     from scrapely_client import ApifyClientAsync
 
+    from .events import Event
+    from .storage._metadata import StorageType
+    from .storage.scrapely_storage_client import ScrapelyStorageClient
+    from .storage.smart_scrapely_storage_client import SmartScrapelyStorageClient
+
     from .browser_configuration import BrowserConfiguration
     from .proxy_configuration import ProxyConfiguration
 
 logger = logging.getLogger(__name__)
 
+# Names that need Crawlee, resolved on first use instead of at import: importing
+# Crawlee costs ~1 s per run under gVisor. They stay module attributes
+# (``scrapely.actor.Dataset`` works and can be monkeypatched): ``_lazy`` returns
+# the module-global value when one is set, else imports and caches it.
+_LAZY_ATTRS: Dict[str, Tuple[str, str]] = {
+    'CrawleeConfiguration': ('crawlee.configuration', 'Configuration'),
+    'StorageClient': ('crawlee.storage_clients._base', 'StorageClient'),
+    'Dataset': ('crawlee.storages', 'Dataset'),
+    'KeyValueStore': ('crawlee.storages', 'KeyValueStore'),
+    'RequestQueue': ('crawlee.storages', 'RequestQueue'),
+    'EventManager': ('crawlee.events', 'EventManager'),
+    'Event': ('scrapely.events', 'Event'),
+    'LocalEventManager': ('scrapely.events', 'LocalEventManager'),
+    'ScrapelyEventManager': ('scrapely.events', 'ScrapelyEventManager'),
+    'StorageType': ('scrapely.storage._metadata', 'StorageType'),
+    'resolve_alias_from_storages_json': ('scrapely.storage._metadata', 'resolve_alias_from_storages_json'),
+    'disconnect_storage': ('scrapely.storage.patch_storage', 'disconnect_storage'),
+    'get_api_storage_factory': ('scrapely.storage.patch_storage', 'get_api_storage_factory'),
+    'get_smart_storage_client': ('scrapely.storage.patch_storage', 'get_smart_storage_client'),
+    'set_api_storage': ('scrapely.storage.patch_storage', 'set_api_storage'),
+    'set_storage_client': ('scrapely.storage.patch_storage', 'set_storage_client'),
+    'ScrapelyStorageClient': ('scrapely.storage.scrapely_storage_client', 'ScrapelyStorageClient'),
+    'SmartScrapelyStorageClient': (
+        'scrapely.storage.smart_scrapely_storage_client',
+        'SmartScrapelyStorageClient',
+    ),
+    '_configure_logging': ('scrapely.log', '_configure_logging'),
+}
+
+
+def _lazy(name: str) -> Any:
+    """Return a Crawlee-dependent module attribute, importing it on first use."""
+    value = globals().get(name, _MISSING)
+    if value is _MISSING:
+        import importlib
+
+        module_name, attr = _LAZY_ATTRS[name]
+        value = getattr(importlib.import_module(module_name), attr)
+        globals()[name] = value
+    return value
+
+
+_MISSING = object()
+
+
+def __getattr__(name: str) -> Any:
+    if name in _LAZY_ATTRS:
+        return _lazy(name)
+    raise AttributeError(f'module {__name__!r} has no attribute {name!r}')
+
 # Terminal run statuses used by the run-control polling loops (call/call_task).
 _RUN_TERMINAL_STATUSES = frozenset({'SUCCEEDED', 'FAILED', 'ABORTED', 'TIMED-OUT'})
 
@@ -324,7 +364,7 @@ class Actor(metaclass=_ActorMeta):
             return
 
         if options is None or options.configure_logging:
-            _configure_logging()
+            _lazy('_configure_logging')()
 
         # Do NOT set _initialized until everything succeeds (failed init must be retryable).
         cls._config = Configuration.get_global_config()
@@ -338,7 +378,7 @@ class Actor(metaclass=_ActorMeta):
             for key, value in options.configuration.items():
                 cls._config.set(key, value)
 
-        crawlee_config = CrawleeConfiguration.get_global_configuration()
+        crawlee_config = _lazy('CrawleeConfiguration').get_global_configuration()
         if cls._config.get('is_at_home'):
             crawlee_config.purge_on_start = False
 
@@ -361,9 +401,9 @@ class Actor(metaclass=_ActorMeta):
                         '[Scrapely] Initializing API storage for run %s',
                         storage_opt['run_id'],
                     )
-                    smart = set_api_storage(storage_opt)
-                elif isinstance(storage_opt, StorageClient):
-                    smart = set_storage_client(storage_opt)
+                    smart = _lazy('set_api_storage')(storage_opt)
+                elif isinstance(storage_opt, _lazy('StorageClient')):
+                    smart = _lazy('set_storage_client')(storage_opt)
                 else:
                     raise TypeError(
                         'Actor.init() storage option must be ApiStorageConfig or StorageClient'
@@ -375,7 +415,7 @@ class Actor(metaclass=_ActorMeta):
 
                 if api_url and token and run_id:
                     logger.info('[Scrapely] Initializing API storage for run %s', run_id)
-                    smart = set_api_storage({
+                    smart = _lazy('set_api_storage')({
                         'api_url': api_url,
                         'token': token,
                         'run_id': run_id,
@@ -383,7 +423,7 @@ class Actor(metaclass=_ActorMeta):
                 elif not cls._config.get('is_at_home'):
                     # Local development without credentials: Smart → FS (Apify docs shape)
                     logger.info('[Scrapely] Initializing local file-system storage')
-                    smart = set_api_storage()
+                    smart = _lazy('set_api_storage')()
                 else:
                     raise RuntimeError(
                         'Missing required configuration for secure storage. '
@@ -392,8 +432,12 @@ class Actor(metaclass=_ActorMeta):
                         'or pass storage in Actor.init().'
                     )
 
-            cls._smart_storage = smart if isinstance(smart, SmartScrapelyStorageClient) else get_smart_storage_client()
-            factory = get_api_storage_factory()
+            cls._smart_storage = (
+                smart
+                if isinstance(smart, _lazy('SmartScrapelyStorageClient'))
+                else _lazy('get_smart_storage_client')()
+            )
+            factory = _lazy('get_api_storage_factory')()
             cls._scrapely_storage = factory
             if factory is not None and factory.has_credentials():
                 cls._client = factory.api_client
@@ -408,12 +452,12 @@ class Actor(metaclass=_ActorMeta):
 
             event_manager: EventManager
             if ws_url:
-                event_manager = ScrapelyEventManager(
+                event_manager = _lazy('ScrapelyEventManager')(
                     configuration=cls._config,
                     persist_state_interval=persist_interval,
                 )
             else:
-                event_manager = LocalEventManager(
+                event_manager = _lazy('LocalEventManager')(
                     system_info_interval=timedelta(seconds=1),
                     persist_state_interval=persist_interval,
                 )
@@ -544,7 +588,7 @@ class Actor(metaclass=_ActorMeta):
             cls._default_rq = None
             cls._cached_input = None
             try:
-                disconnect_storage()
+                _lazy('disconnect_storage')()
             except BaseException as e:
                 cleanup_error = cleanup_error or e
                 logger.warning('disconnect_storage failed during shutdown: %s', e)
@@ -784,6 +828,7 @@ class Actor(metaclass=_ActorMeta):
         event_name: Optional[str] = None,
         charges: Optional[Dict[str, int]] = None,
         charge_per: str = 'row',
+        dataset: Optional[Union[str, Dataset]] = None,
     ) -> ChargeResult:
         """Push data to the default dataset, charging pay-per-event items.
 
@@ -807,6 +852,12 @@ class Actor(metaclass=_ActorMeta):
                 charges them once for the whole push, e.g.
                 ``push_data(page_rows, charges={'document': 1}, charge_per='batch')``:
                 all rows are stored if the charge is accepted, none if it is refused.
+            dataset: Push to this named dataset (name, or a Dataset from ``open_dataset``)
+                instead of the default one, with the same charge-first semantics:
+                ``push_data(rows, charged_event_name='comment', dataset=f'comments-{run_id}')``.
+                Rows of a named dataset carry no implicit default-dataset-item event and are
+                not gated by the default dataset's spending-limit safety net; charged pushes
+                store only the rows that were charged.
 
         Returns:
             ChargeResult describing how many items were charged and pushed.
@@ -827,6 +878,13 @@ class Actor(metaclass=_ActorMeta):
         if cls._default_dataset is None:
             cls._default_dataset = await cls.open_dataset()
 
+        target = cls._default_dataset
+        if dataset is not None:
+            target = dataset if isinstance(dataset, _lazy('Dataset')) else await cls.open_dataset(name=dataset)
+        is_default = target is cls._default_dataset or (
+            getattr(target, 'id', None) is not None and target.id == getattr(cls._default_dataset, 'id', None)
+        )
+
         items = data if isinstance(data, list) else [data]
         charging_manager = cls.get_charging_manager()
         if charges is not None:
@@ -836,8 +894,8 @@ class Actor(metaclass=_ActorMeta):
                 charging_manager,
                 items,
                 charges,
-                True,  # Actor.push_data always targets the default dataset
-                cls._default_dataset.push_data,
+                is_default,
+                target.push_data,
                 charge_per=charge_per,
             )
         if charge_per != 'row':
@@ -846,8 +904,8 @@ class Actor(metaclass=_ActorMeta):
             charging_manager,
             items,
             event_name,
-            True,  # Actor.push_data always targets the default dataset
-            cls._default_dataset.push_data,
+            is_default,
+            target.push_data,
         )
 
     @classmethod
@@ -888,7 +946,7 @@ class Actor(metaclass=_ActorMeta):
 
         if alias is not None:
             storages_json = cls._env_config().get('actor_storages_json')
-            resolved = resolve_alias_from_storages_json(alias, storage_type, storages_json)
+            resolved = _lazy('resolve_alias_from_storages_json')(alias, storage_type, storages_json)
             if resolved is not None:
                 id = resolved
                 alias = None
@@ -901,12 +959,12 @@ class Actor(metaclass=_ActorMeta):
 
     @classmethod
     def _storage_client_for_open(cls, *, force_cloud: bool = False) -> Optional[StorageClient]:
-        smart = cls._smart_storage or get_smart_storage_client()
+        smart = cls._smart_storage or _lazy('get_smart_storage_client')()
         if smart is not None:
             return smart.get_suitable_storage_client(force_cloud=force_cloud)
 
         if force_cloud:
-            cloud = get_api_storage_factory()
+            cloud = _lazy('get_api_storage_factory')()
             if cloud is None:
                 # Build from config like TS _buildStorageOpenOptions
                 config = cls.get_config()
@@ -914,7 +972,7 @@ class Actor(metaclass=_ActorMeta):
                 token = config.get('token')
                 run_id = config.get('actor_run_id')
                 if api_url and token and run_id:
-                    return ScrapelyStorageClient(api_url=api_url, token=token, run_id=run_id)
+                    return _lazy('ScrapelyStorageClient')(api_url=api_url, token=token, run_id=run_id)
                 raise RuntimeError('Cloud storage client is not configured')
             return cloud
         return None
@@ -944,10 +1002,10 @@ class Actor(metaclass=_ActorMeta):
 
         if open_args['id'] is None and open_args['name'] is None and open_args['alias'] is None:
             if cls._default_dataset is None:
-                cls._default_dataset = await Dataset.open(storage_client=storage_client)
+                cls._default_dataset = await _lazy('Dataset').open(storage_client=storage_client)
             return cls._default_dataset
 
-        return await Dataset.open(
+        return await _lazy('Dataset').open(
             id=open_args['id'],
             name=open_args['name'],
             alias=open_args['alias'],
@@ -979,10 +1037,10 @@ class Actor(metaclass=_ActorMeta):
 
         if open_args['id'] is None and open_args['name'] is None and open_args['alias'] is None:
             if cls._default_kvs is None:
-                cls._default_kvs = await KeyValueStore.open(storage_client=storage_client)
+                cls._default_kvs = await _lazy('KeyValueStore').open(storage_client=storage_client)
             return cls._default_kvs
 
-        return await KeyValueStore.open(
+        return await _lazy('KeyValueStore').open(
             id=open_args['id'],
             name=open_args['name'],
             alias=open_args['alias'],
@@ -1014,10 +1072,10 @@ class Actor(metaclass=_ActorMeta):
 
         if open_args['id'] is None and open_args['name'] is None and open_args['alias'] is None:
             if cls._default_rq is None:
-                cls._default_rq = await RequestQueue.open(storage_client=storage_client)
+                cls._default_rq = await _lazy('RequestQueue').open(storage_client=storage_client)
             return cls._default_rq
 
-        return await RequestQueue.open(
+        return await _lazy('RequestQueue').open(
             id=open_args['id'],
             name=open_args['name'],
             alias=open_args['alias'],
@@ -1696,7 +1754,7 @@ class Actor(metaclass=_ActorMeta):
         if cls._event_manager:
             from crawlee.events import EventPersistStateData
             cls._event_manager.emit(
-                event=Event.PERSIST_STATE,
+                event=_lazy('Event').PERSIST_STATE,
                 event_data=EventPersistStateData(is_migrating=True),
             )