scrapely-python 0.1.22__tar.gz → 0.1.24__tar.gz

{scrapely_python-0.1.22/src/scrapely_python.egg-info → scrapely_python-0.1.24}/PKG-INFO

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "scrapely-python"
-version = "0.1.22"
+version = "0.1.24"
 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.24/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.24'
+__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.22 → scrapely_python-0.1.24}/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)
@@ -836,7 +880,7 @@ class Actor(metaclass=_ActorMeta):
 
         target = cls._default_dataset
         if dataset is not None:
-            target = dataset if isinstance(dataset, Dataset) else await cls.open_dataset(name=dataset)
+            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)
         )
@@ -878,6 +922,36 @@ class Actor(metaclass=_ActorMeta):
             cls._default_kvs = await cls.open_key_value_store()
         await cls._default_kvs.set_value(key, value, content_type=content_type)
 
+    # Debug capture: raw source payloads for platform diagnostics. Only active when the platform
+    # sets SCRAPELY_DEBUG_CAPTURE=1 on its own diagnostic runs; a no-op in every other run.
+    _DEBUG_CAPTURE_MAX_BYTES = 256 * 1024
+    _DEBUG_CAPTURE_MAX_RECORDS = 500
+    _debug_capture_count = 0
+
+    @staticmethod
+    def debug_capture_record_key(key: str) -> str:
+        """The key-value store record name for a capture key (item URL or id)."""
+        import hashlib
+        return 'DEBUG_CAPTURE_' + hashlib.sha1(str(key).strip().encode('utf-8')).hexdigest()[:24]
+
+    @classmethod
+    async def debug_capture(cls, key: str, payload: Any) -> None:
+        """Save the raw source payload (API JSON or HTML) an item was extracted from, keyed by
+        the item's URL or id. Does nothing unless the platform enabled capture for this run."""
+        if os.environ.get('SCRAPELY_DEBUG_CAPTURE') != '1' or not key:
+            return
+        if cls._debug_capture_count >= cls._DEBUG_CAPTURE_MAX_RECORDS:
+            return
+        try:
+            text = payload if isinstance(payload, str) else json.dumps(payload, default=str, ensure_ascii=False)
+            if isinstance(text, bytes):
+                text = text.decode('utf-8', 'replace')
+            text = text[: cls._DEBUG_CAPTURE_MAX_BYTES]
+            cls._debug_capture_count += 1
+            await cls.set_value(cls.debug_capture_record_key(key), {'key': str(key), 'payload': text})
+        except Exception as err:  # never break the run
+            logging.getLogger('scrapely').debug('debug_capture failed: %s', err)
+
     @classmethod
     def _resolve_open_args(
         cls,
@@ -902,7 +976,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
@@ -915,12 +989,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()
@@ -928,7 +1002,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
@@ -958,10 +1032,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'],
@@ -993,10 +1067,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'],
@@ -1028,10 +1102,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'],
@@ -1710,7 +1784,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),
             )