Remove Actor.config

Author: Pijukatel

docs/02_concepts/09_running_webserver.mdx

@@ -13,9 +13,9 @@ The URL is available in the following places:
 
 - In Apify Console, on the Actor run details page as the **Container URL** field.
 - In the API as the `container_url` property of the [Run object](https://docs.apify.com/api/v2#/reference/actors/run-object/get-run).
-- In the Actor as the `Actor.config.container_url` property.
+- In the Actor as the `Actor.configuration.container_url` property.
 
-The web server running inside the container must listen at the port defined by the `Actor.config.container_port` property. When running Actors locally, the port defaults to `4321`, so the web server will be accessible at `http://localhost:4321`.
+The web server running inside the container must listen at the port defined by the `Actor.configuration.container_port` property. When running Actors locally, the port defaults to `4321`, so the web server will be accessible at `http://localhost:4321`.
 
 ## Example
 

docs/02_concepts/code/07_webhook_preventing.py

@@ -7,7 +7,7 @@ async def main() -> None:
         webhook = Webhook(
             event_types=['ACTOR.RUN.FAILED'],
             request_url='https://example.com/run-failed',
-            idempotency_key=Actor.config.actor_run_id,
+            idempotency_key=Actor.configuration.actor_run_id,
         )
 
         # Add the webhook to the Actor.

docs/02_concepts/code/09_webserver.py

@@ -22,9 +22,9 @@ def run_server() -> None:
     # and save a reference to the server.
     global http_server
     with ThreadingHTTPServer(
-        ('', Actor.config.web_server_port), RequestHandler
+        ('', Actor.configuration.web_server_port), RequestHandler
     ) as server:
-        Actor.log.info(f'Server running on {Actor.config.web_server_port}')
+        Actor.log.info(f'Server running on {Actor.configuration.web_server_port}')
         http_server = server
         server.serve_forever()
 

docs/02_concepts/code/conditional_actor_charge.py

@@ -13,6 +13,6 @@ async def main() -> None:
         if Actor.get_charging_manager().get_pricing_info().is_pay_per_event:
             # highlight-end
             await Actor.push_data({'hello': 'world'}, 'dataset-item')
-        elif charged_items < (Actor.config.max_paid_dataset_items or 0):
+        elif charged_items < (Actor.configuration.max_paid_dataset_items or 0):
             await Actor.push_data({'hello': 'world'})
             charged_items += 1

docs/03_guides/code/03_playwright.py

@@ -40,7 +40,7 @@ async def main() -> None:
         async with async_playwright() as playwright:
             # Configure the browser to launch in headless mode as per Actor configuration.
             browser = await playwright.chromium.launch(
-                headless=Actor.config.headless,
+                headless=Actor.configuration.headless,
                 args=['--disable-gpu'],
             )
             context = await browser.new_context()

docs/03_guides/code/04_selenium.py

@@ -41,7 +41,7 @@ async def main() -> None:
         Actor.log.info('Launching Chrome WebDriver...')
         chrome_options = ChromeOptions()
 
-        if Actor.config.headless:
+        if Actor.configuration.headless:
             chrome_options.add_argument('--headless')
 
         chrome_options.add_argument('--no-sandbox')

docs/04_upgrading/upgrading_to_v3.md

@@ -15,11 +15,12 @@ Support for Python 3.9 has been dropped. The Apify Python SDK v3.x now requires
 - Services in `Actor` can't be changed after calling `Actor.init`, entering the `async with Actor` context manager or after requesting them from the `Actor`
 - Services in `Actor` can be different from services in Crawler
 
+
 **Now (v3.0):**
 
 ```python
 from crawlee.crawlers import BasicCrawler
-from crawlee.storage_clients import MemoryStorageClient, FileSystemStorageClient
+from crawlee.storage_clients import MemoryStorageClient
 from crawlee.configuration import Configuration
 from crawlee.events import LocalEventManager
 from apify import Actor
@@ -41,6 +42,9 @@ async def main():
         )
 ```
 
+## Removed Actor.config property
+- `Actor.config` property has been removed. Use `Actor.configuration` instead.
+
 ## Storages
 
 <!-- TODO -->

src/apify/_actor.py

@@ -197,11 +197,6 @@ def apify_client(self) -> ApifyClientAsync:
 
     @property
     def configuration(self) -> Configuration:
-        """The Configuration instance the Actor instance uses. Deprecated."""
-        return self.config
-
-    @property
-    def config(self) -> Configuration:
         """The Configuration instance the Actor instance uses."""
         if self._configuration:
             return self._configuration
@@ -225,7 +220,7 @@ def _finalize_implicit_configuration(self) -> Configuration:
             )
         # Use the configuration from the service locator
         self._configuration = Configuration.get_global_configuration()
-        return self.config
+        return self.configuration
 
     def _finalize_implicit_local_storage_client(self) -> StorageClient:
         """Set implicit local storage client in the actor and return it.
@@ -256,13 +251,13 @@ def event_manager(self) -> EventManager:
         """The EventManager instance the Actor instance uses."""
         return (
             ApifyEventManager(
-                configuration=self.config,
-                persist_state_interval=self.config.persist_state_interval,
+                configuration=self.configuration,
+                persist_state_interval=self.configuration.persist_state_interval,
             )
             if self.is_at_home()
             else LocalEventManager(
-                system_info_interval=self.config.system_info_interval,
-                persist_state_interval=self.config.persist_state_interval,
+                system_info_interval=self.configuration.system_info_interval,
+                persist_state_interval=self.configuration.persist_state_interval,
             )
         )
 
@@ -285,7 +280,7 @@ def _raise_if_cloud_requested_but_not_configured(self, *, force_cloud: bool) ->
         if not force_cloud:
             return
 
-        if not self.is_at_home() and self.config.token is None:
+        if not self.is_at_home() and self.configuration.token is None:
             raise RuntimeError(
                 'In order to use the Apify cloud storage from your computer, '
                 'you need to provide an Apify token using the APIFY_TOKEN environment variable.'
@@ -304,7 +299,7 @@ async def init(self) -> None:
         """
         if self._configuration:
             # Set explicitly the configuration in the service locator
-            service_locator.set_configuration(self.config)
+            service_locator.set_configuration(self.configuration)
         else:
             self._finalize_implicit_configuration()
 
@@ -448,8 +443,8 @@ def new_client(
                 (increases exponentially from this value).
             timeout: The socket timeout of the HTTP requests sent to the Apify API.
         """
-        token = token or self.config.token
-        api_url = api_url or self.config.api_base_url
+        token = token or self.configuration.token
+        api_url = api_url or self.configuration.api_base_url
         return ApifyClientAsync(
             token=token,
             api_url=api_url,
@@ -496,7 +491,7 @@ async def open_dataset(
             id=id,
             alias=alias,
             name=name,
-            configuration=self.config,
+            configuration=self.configuration,
             storage_client=storage_client,
         )
 
@@ -534,7 +529,7 @@ async def open_key_value_store(
             id=id,
             alias=alias,
             name=name,
-            configuration=self.config,
+            configuration=self.configuration,
             storage_client=storage_client,
         )
 
@@ -575,7 +570,7 @@ async def open_request_queue(
             id=id,
             alias=alias,
             name=name,
-            configuration=self.config,
+            configuration=self.configuration,
             storage_client=storage_client,
         )
 
@@ -624,9 +619,9 @@ async def get_input(self) -> Any:
         """Get the Actor input value from the default key-value store associated with the current Actor run."""
         self._raise_if_not_initialized()
 
-        input_value = await self.get_value(self.config.input_key)
-        input_secrets_private_key = self.config.input_secrets_private_key_file
-        input_secrets_key_passphrase = self.config.input_secrets_private_key_passphrase
+        input_value = await self.get_value(self.configuration.input_key)
+        input_secrets_private_key = self.configuration.input_secrets_private_key_file
+        input_secrets_key_passphrase = self.configuration.input_secrets_private_key_passphrase
         if input_secrets_private_key and input_secrets_key_passphrase:
             private_key = load_private_key(
                 input_secrets_private_key,
@@ -674,7 +669,7 @@ def get_charging_manager(self) -> ChargingManager:
 
     @cached_property
     def charging_manager_implementation(self) -> ChargingManagerImplementation:
-        return ChargingManagerImplementation(self.config, self.apify_client)
+        return ChargingManagerImplementation(self.configuration, self.apify_client)
 
     async def charge(self, event_name: str, count: int = 1) -> ChargeResult:
         """Charge for a specified number of events - sub-operations of the Actor.
@@ -767,7 +762,7 @@ def off(self, event_name: Event, listener: Callable | None = None) -> None:
 
     def is_at_home(self) -> bool:
         """Return `True` when the Actor is running on the Apify platform, and `False` otherwise (e.g. local run)."""
-        return self.config.is_at_home
+        return self.configuration.is_at_home
 
     def get_env(self) -> dict:
         """Return a dictionary with information parsed from all the `APIFY_XXX` environment variables.
@@ -793,7 +788,7 @@ def get_env(self) -> dict:
                 aliases = [field_name]
 
             for alias in aliases:
-                config[alias] = getattr(self.config, field_name)
+                config[alias] = getattr(self.configuration, field_name)
 
         env_vars = {env_var.value.lower(): env_var.name.lower() for env_var in [*ActorEnvVars, *ApifyEnvVars]}
         return {option_name: config[env_var] for env_var, option_name in env_vars.items() if env_var in config}
@@ -870,13 +865,13 @@ async def start(
 
     def _get_remaining_time(self) -> timedelta | None:
         """Get time remaining from the actor timeout. Returns `None` if not on an Apify platform."""
-        if self.is_at_home() and self.config.timeout_at:
-            return self.config.timeout_at - datetime.now(tz=timezone.utc)
+        if self.is_at_home() and self.configuration.timeout_at:
+            return self.configuration.timeout_at - datetime.now(tz=timezone.utc)
 
         self.log.warning(
             'Returning `None` instead of remaining time. Using `RemainingTime` argument is only possible when the Actor'
             ' is running on the Apify platform and when the timeout for the Actor run is set. '
-            f'{self.is_at_home()=}, {self.config.timeout_at=}'
+            f'{self.is_at_home()=}, {self.configuration.timeout_at=}'
         )
         return None
 
@@ -1081,13 +1076,13 @@ async def metamorph(
             return
 
         if not custom_after_sleep:
-            custom_after_sleep = self.config.metamorph_after_sleep
+            custom_after_sleep = self.configuration.metamorph_after_sleep
 
         # If is_at_home() is True, config.actor_run_id is always set
-        if not self.config.actor_run_id:
+        if not self.configuration.actor_run_id:
             raise RuntimeError('actor_run_id cannot be None when running on the Apify platform.')
 
-        await self.apify_client.run(self.config.actor_run_id).metamorph(
+        await self.apify_client.run(self.configuration.actor_run_id).metamorph(
             target_actor_id=target_actor_id,
             run_input=run_input,
             target_actor_build=target_actor_build,
@@ -1124,7 +1119,7 @@ async def reboot(
         _ActorType._is_rebooting = True
 
         if not custom_after_sleep:
-            custom_after_sleep = self.config.metamorph_after_sleep
+            custom_after_sleep = self.configuration.metamorph_after_sleep
 
         # Call all the listeners for the PERSIST_STATE and MIGRATING events, and wait for them to finish.
         # PERSIST_STATE listeners are called to allow the Actor to persist its state before the reboot.
@@ -1144,10 +1139,10 @@ async def reboot(
             *[listener(EventMigratingData()) for listener in migrating_listeners],
         )
 
-        if not self.config.actor_run_id:
+        if not self.configuration.actor_run_id:
             raise RuntimeError('actor_run_id cannot be None when running on the Apify platform.')
 
-        await self.apify_client.run(self.config.actor_run_id).reboot()
+        await self.apify_client.run(self.configuration.actor_run_id).reboot()
 
         if custom_after_sleep:
             await asyncio.sleep(custom_after_sleep.total_seconds())
@@ -1186,11 +1181,11 @@ async def add_webhook(
             return
 
         # If is_at_home() is True, config.actor_run_id is always set
-        if not self.config.actor_run_id:
+        if not self.configuration.actor_run_id:
             raise RuntimeError('actor_run_id cannot be None when running on the Apify platform.')
 
         await self.apify_client.webhooks().create(
-            actor_run_id=self.config.actor_run_id,
+            actor_run_id=self.configuration.actor_run_id,
             event_types=webhook.event_types,
             request_url=webhook.request_url,
             payload_template=webhook.payload_template,
@@ -1222,10 +1217,10 @@ async def set_status_message(
             return None
 
         # If is_at_home() is True, config.actor_run_id is always set
-        if not self.config.actor_run_id:
+        if not self.configuration.actor_run_id:
             raise RuntimeError('actor_run_id cannot be None when running on the Apify platform.')
 
-        api_result = await self.apify_client.run(self.config.actor_run_id).update(
+        api_result = await self.apify_client.run(self.configuration.actor_run_id).update(
             status_message=status_message, is_status_message_terminal=is_terminal
         )
 
@@ -1280,7 +1275,7 @@ async def create_proxy_configuration(
             country_code=country_code,
             proxy_urls=proxy_urls,
             new_url_function=new_url_function,
-            _actor_config=self.config,
+            _actor_config=self.configuration,
             _apify_client=self._apify_client,
         )
 

tests/integration/test_actor_call_timeouts.py

@@ -30,7 +30,7 @@ async def main() -> None:
 
             # Start another run of this actor with timeout set to the time remaining in this actor run
             other_run_data = await Actor.call(
-                actor_id=Actor.config.actor_id or '',
+                actor_id=Actor.configuration.actor_id or '',
                 run_input={'called_from_another_actor': True},
                 timeout='RemainingTime',
             )
@@ -39,13 +39,13 @@ async def main() -> None:
                 # To make sure that the actor is started
                 await asyncio.sleep(5)
                 assert other_run_data.options is not None
-                assert Actor.config.timeout_at is not None
-                assert Actor.config.started_at is not None
+                assert Actor.configuration.timeout_at is not None
+                assert Actor.configuration.started_at is not None
 
-                remaining_time_after_actor_start = Actor.config.timeout_at - datetime.now(tz=timezone.utc)
+                remaining_time_after_actor_start = Actor.configuration.timeout_at - datetime.now(tz=timezone.utc)
 
                 assert other_run_data.options.timeout > remaining_time_after_actor_start
-                assert other_run_data.options.timeout < Actor.config.timeout_at - Actor.config.started_at
+                assert other_run_data.options.timeout < Actor.configuration.timeout_at - Actor.configuration.started_at
             finally:
                 # Make sure the other actor run is aborted
                 await Actor.apify_client.run(other_run_data.id).abort()
@@ -77,7 +77,7 @@ async def main() -> None:
 
             # Start another run of this actor with timeout set to the time remaining in this actor run
             other_run_data = await Actor.call(
-                actor_id=Actor.config.actor_id or '',
+                actor_id=Actor.configuration.actor_id or '',
                 run_input={'called_from_another_actor': True},
                 timeout='RemainingTime',
             )
@@ -88,13 +88,13 @@ async def main() -> None:
                 await asyncio.sleep(5)
 
                 assert other_run_data.options is not None
-                assert Actor.config.timeout_at is not None
-                assert Actor.config.started_at is not None
+                assert Actor.configuration.timeout_at is not None
+                assert Actor.configuration.started_at is not None
 
-                remaining_time_after_actor_start = Actor.config.timeout_at - datetime.now(tz=timezone.utc)
+                remaining_time_after_actor_start = Actor.configuration.timeout_at - datetime.now(tz=timezone.utc)
 
                 assert other_run_data.options.timeout > remaining_time_after_actor_start
-                assert other_run_data.options.timeout < Actor.config.timeout_at - Actor.config.started_at
+                assert other_run_data.options.timeout < Actor.configuration.timeout_at - Actor.configuration.started_at
             finally:
                 # Make sure the other actor run is aborted
                 await Actor.apify_client.run(other_run_data.id).abort()

tests/integration/test_actor_create_proxy_configuration.py

@@ -40,7 +40,10 @@ async def test_create_proxy_configuration_with_groups_and_country(
     async def main() -> None:
         await Actor.init()
 
-        proxy_url_suffix = f'{Actor.config.proxy_password}@{Actor.config.proxy_hostname}:{Actor.config.proxy_port}'
+        proxy_url_suffix = (
+            f'{Actor.configuration.proxy_password}@{Actor.configuration.proxy_hostname}:'
+            f'{Actor.configuration.proxy_port}'
+        )
         proxy_configuration = await Actor.create_proxy_configuration(actor_proxy_input={'useApifyProxy': True})
 
         assert proxy_configuration is not None