apify 2.3.0b2__py3-none-any.whl → 2.3.1b1__py3-none-any.whl

apify/_actor.py

@@ -24,6 +24,7 @@ from crawlee.events import (
     EventSystemInfoData,
 )
 
+from apify._charging import ChargeResult, ChargingManager, ChargingManagerImplementation
 from apify._configuration import Configuration
 from apify._consts import EVENT_LISTENERS_TIMEOUT
 from apify._crypto import decrypt_input_secrets, load_private_key
@@ -97,6 +98,8 @@ class _ActorType:
             )
         )
 
+        self._charging_manager = ChargingManagerImplementation(self._configuration, self._apify_client)
+
         self._is_initialized = False
 
     @ignore_docs
@@ -227,6 +230,10 @@ class _ActorType:
         # https://github.com/apify/apify-sdk-python/issues/146
 
         await self._event_manager.__aenter__()
+        self.log.debug('Event manager initialized')
+
+        await self._charging_manager.__aenter__()
+        self.log.debug('Charging manager initialized')
 
         self._is_initialized = True
         _ActorType._is_any_instance_initialized = True
@@ -269,6 +276,7 @@ class _ActorType:
                 await self._event_manager.wait_for_all_listeners_to_complete(timeout=event_listeners_timeout)
 
             await self._event_manager.__aexit__(None, None, None)
+            await self._charging_manager.__aexit__(None, None, None)
 
         await asyncio.wait_for(finalize(), cleanup_timeout.total_seconds())
         self._is_initialized = False
@@ -452,19 +460,46 @@ class _ActorType:
             storage_client=storage_client,
         )
 
-    async def push_data(self, data: dict | list[dict]) -> None:
+    @overload
+    async def push_data(self, data: dict | list[dict]) -> None: ...
+    @overload
+    async def push_data(self, data: dict | list[dict], charged_event_name: str) -> ChargeResult: ...
+    async def push_data(self, data: dict | list[dict], charged_event_name: str | None = None) -> ChargeResult | None:
         """Store an object or a list of objects to the default dataset of the current Actor run.
 
         Args:
             data: The data to push to the default dataset.
+            charged_event_name: If provided and if the Actor uses the pay-per-event pricing model,
+                the method will attempt to charge for the event for each pushed item.
         """
         self._raise_if_not_initialized()
 
         if not data:
-            return
+            return None
+
+        data = data if isinstance(data, list) else [data]
+
+        max_charged_count = (
+            self._charging_manager.calculate_max_event_charge_count_within_limit(charged_event_name)
+            if charged_event_name is not None
+            else None
+        )
 
         dataset = await self.open_dataset()
-        await dataset.push_data(data)
+
+        if max_charged_count is not None and len(data) > max_charged_count:
+            # Push as many items as we can charge for
+            await dataset.push_data(data[:max_charged_count])
+        else:
+            await dataset.push_data(data)
+
+        if charged_event_name:
+            return await self._charging_manager.charge(
+                event_name=charged_event_name,
+                count=min(max_charged_count, len(data)) if max_charged_count is not None else len(data),
+            )
+
+        return None
 
     async def get_input(self) -> Any:
         """Get the Actor input value from the default key-value store associated with the current Actor run."""
@@ -513,6 +548,23 @@ class _ActorType:
         key_value_store = await self.open_key_value_store()
         return await key_value_store.set_value(key, value, content_type=content_type)
 
+    def get_charging_manager(self) -> ChargingManager:
+        """Retrieve the charging manager to access granular pricing information."""
+        self._raise_if_not_initialized()
+        return self._charging_manager
+
+    async def charge(self, event_name: str, count: int = 1) -> ChargeResult:
+        """Charge for a specified number of events - sub-operations of the Actor.
+
+        This is relevant only for the pay-per-event pricing model.
+
+        Args:
+            event_name: Name of the event to be charged for.
+            count: Number of events to charge for.
+        """
+        self._raise_if_not_initialized()
+        return await self._charging_manager.charge(event_name, count)
+
     @overload
     def on(
         self, event_name: Literal[Event.PERSIST_STATE], listener: EventListener[EventPersistStateData]

apify/_charging.py

@@ -0,0 +1,318 @@
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from decimal import Decimal
+from typing import TYPE_CHECKING, Protocol, Union
+
+from pydantic import TypeAdapter
+
+from apify_shared.utils import ignore_docs
+from crawlee._utils.context import ensure_context
+
+from apify._models import ActorRun, PricingModel
+from apify._utils import docs_group
+from apify.log import logger
+from apify.storages import Dataset
+
+if TYPE_CHECKING:
+    from types import TracebackType
+
+    from apify_client import ApifyClientAsync
+
+    from apify._configuration import Configuration
+
+
+run_validator: TypeAdapter[ActorRun | None] = TypeAdapter(Union[ActorRun, None])
+
+
+@docs_group('Interfaces')
+class ChargingManager(Protocol):
+    """Provides fine-grained access to pay-per-event functionality."""
+
+    async def charge(self, event_name: str, count: int = 1) -> ChargeResult:
+        """Charge for a specified number of events - sub-operations of the Actor.
+
+        This is relevant only for the pay-per-event pricing model.
+
+        Args:
+            event_name: Name of the event to be charged for.
+            count: Number of events to charge for.
+        """
+
+    def calculate_total_charged_amount(self) -> Decimal:
+        """Calculate the total amount of money charged for pay-per-event events so far."""
+
+    def calculate_max_event_charge_count_within_limit(self, event_name: str) -> int | None:
+        """Calculate how many instances of an event can be charged before we reach the configured limit.
+
+        Args:
+            event_name: Name of the inspected event.
+        """
+
+    def get_pricing_info(self) -> ActorPricingInfo:
+        """Retrieve detailed information about the effective pricing of the current Actor run.
+
+        This can be used for instance when your code needs to support multiple pricing models in transition periods.
+        """
+
+
+@docs_group('Data structures')
+@dataclass(frozen=True)
+class ChargeResult:
+    """Result of the `ChargingManager.charge` method."""
+
+    event_charge_limit_reached: bool
+    """If true, no more events of this type can be charged within the limit."""
+
+    charged_count: int
+    """Total amount of charged events - may be lower than the requested amount."""
+
+    chargeable_within_limit: dict[str, int | None]
+    """How many events of each known type can still be charged within the limit."""
+
+
+@docs_group('Data structures')
+@dataclass
+class ActorPricingInfo:
+    """Result of the `ChargingManager.get_pricing_info` method."""
+
+    pricing_model: PricingModel | None
+    """The currently effective pricing model."""
+
+    max_total_charge_usd: Decimal
+    """A configured limit for the total charged amount - if you exceed it, you won't receive more money than this."""
+
+    is_pay_per_event: bool
+    """A shortcut - true if the Actor runs with the pay-per-event pricing model."""
+
+    per_event_prices: dict[str, Decimal]
+    """Price of every known event type."""
+
+
+@ignore_docs
+class ChargingManagerImplementation(ChargingManager):
+    """Implementation of the `ChargingManager` Protocol - this is only meant to be instantiated internally."""
+
+    LOCAL_CHARGING_LOG_DATASET_NAME = 'charging_log'
+
+    def __init__(self, configuration: Configuration, client: ApifyClientAsync) -> None:
+        self._max_total_charge_usd = configuration.max_total_charge_usd or Decimal('inf')
+        self._is_at_home = configuration.is_at_home
+        self._actor_run_id = configuration.actor_run_id
+        self._purge_charging_log_dataset = configuration.purge_on_start
+        self._pricing_model: PricingModel | None = None
+
+        if configuration.test_pay_per_event:
+            if self._is_at_home:
+                raise ValueError(
+                    'Using the ACTOR_TEST_PAY_PER_EVENT environment variable is only supported '
+                    'in a local development environment'
+                )
+
+            self._pricing_model = 'PAY_PER_EVENT'
+
+        self._client = client
+        self._charging_log_dataset: Dataset | None = None
+
+        self._charging_state: dict[str, ChargingStateItem] = {}
+        self._pricing_info: dict[str, PricingInfoItem] = {}
+
+        self._not_ppe_warning_printed = False
+        self.active = False
+
+    async def __aenter__(self) -> None:
+        """Initialize the charging manager - this is called by the `Actor` class and shouldn't be invoked manually."""
+        self.active = True
+
+        if self._is_at_home:
+            # Running on the Apify platform - fetch pricing info for the current run.
+
+            if self._actor_run_id is None:
+                raise RuntimeError('Actor run ID not found even though the Actor is running on Apify')
+
+            run = run_validator.validate_python(await self._client.run(self._actor_run_id).get())
+            if run is None:
+                raise RuntimeError('Actor run not found')
+
+            if run.pricing_info is not None:
+                self._pricing_model = run.pricing_info.pricing_model
+
+                if run.pricing_info.pricing_model == 'PAY_PER_EVENT':
+                    for event_name, event_pricing in run.pricing_info.pricing_per_event.actor_charge_events.items():
+                        self._pricing_info[event_name] = PricingInfoItem(
+                            price=event_pricing.event_price_usd,
+                            title=event_pricing.event_title,
+                        )
+
+                    self._max_total_charge_usd = run.options.max_total_charge_usd or self._max_total_charge_usd
+
+            for event_name, count in (run.charged_event_counts or {}).items():
+                price = self._pricing_info.get(event_name, PricingInfoItem(Decimal(), title='')).price
+                self._charging_state[event_name] = ChargingStateItem(
+                    charge_count=count,
+                    total_charged_amount=count * price,
+                )
+
+        if not self._is_at_home and self._pricing_model == 'PAY_PER_EVENT':
+            # We are not running on the Apify platform, but PPE is enabled for testing - open a dataset that
+            # will contain a log of all charge calls for debugging purposes.
+
+            if self._purge_charging_log_dataset:
+                dataset = await Dataset.open(name=self.LOCAL_CHARGING_LOG_DATASET_NAME)
+                await dataset.drop()
+
+            self._charging_log_dataset = await Dataset.open(name=self.LOCAL_CHARGING_LOG_DATASET_NAME)
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        exc_traceback: TracebackType | None,
+    ) -> None:
+        if not self.active:
+            raise RuntimeError('Exiting an uninitialized ChargingManager')
+
+        self.active = False
+
+    @ensure_context
+    async def charge(self, event_name: str, count: int = 1) -> ChargeResult:
+        def calculate_chargeable() -> dict[str, int | None]:
+            """Calculate the maximum number of events of each type that can be charged within the current budget."""
+            return {
+                event_name: self.calculate_max_event_charge_count_within_limit(event_name)
+                for event_name in self._pricing_info
+            }
+
+        # For runs that do not use the pay-per-event pricing model, just print a warning and return
+        if self._pricing_model != 'PAY_PER_EVENT':
+            if not self._not_ppe_warning_printed:
+                logger.warning(
+                    'Ignored attempt to charge for an event - the Actor does not use the pay-per-event pricing'
+                )
+                self._not_ppe_warning_printed = True
+
+            return ChargeResult(
+                event_charge_limit_reached=False,
+                charged_count=0,
+                chargeable_within_limit=calculate_chargeable(),
+            )
+
+        # START OF CRITICAL SECTION - no awaits here
+
+        # Determine the maximum amount of events that can be charged within the budget
+        charged_count = min(count, self.calculate_max_event_charge_count_within_limit(event_name) or count)
+
+        if charged_count == 0:
+            return ChargeResult(
+                event_charge_limit_reached=True,
+                charged_count=0,
+                chargeable_within_limit=calculate_chargeable(),
+            )
+
+        pricing_info = self._pricing_info.get(
+            event_name,
+            PricingInfoItem(
+                price=Decimal()
+                if self._is_at_home
+                else Decimal(
+                    '1'
+                ),  # Use a nonzero price for local development so that the maximum budget can be reached,
+                title=f"Unknown event '{event_name}'",
+            ),
+        )
+
+        # Update the charging state
+        self._charging_state.setdefault(event_name, ChargingStateItem(0, Decimal()))
+        self._charging_state[event_name].charge_count += charged_count
+        self._charging_state[event_name].total_charged_amount += charged_count * pricing_info.price
+
+        # END OF CRITICAL SECTION
+
+        # If running on the platform, call the charge endpoint
+        if self._is_at_home:
+            if self._actor_run_id is None:
+                raise RuntimeError('Actor run ID not configured')
+
+            if event_name in self._pricing_info:
+                await self._client.run(self._actor_run_id).charge(event_name, charged_count)
+            else:
+                logger.warning(f"Attempting to charge for an unknown event '{event_name}'")
+
+        # Log the charged operation (if enabled)
+        if self._charging_log_dataset:
+            await self._charging_log_dataset.push_data(
+                {
+                    'event_name': event_name,
+                    'event_title': pricing_info.title,
+                    'event_price_usd': round(pricing_info.price, 3),
+                    'charged_count': charged_count,
+                    'timestamp': datetime.now(timezone.utc).isoformat(),
+                }
+            )
+
+        # If it is not possible to charge the full amount, log that fact
+        if charged_count < count:
+            subject = 'instance' if count == 1 else 'instances'
+            logger.info(
+                f"Charging {count} ${subject} of '{event_name}' event would exceed max_total_charge_usd "
+                '- only {charged_count} events were charged'
+            )
+
+        max_charge_count = self.calculate_max_event_charge_count_within_limit(event_name)
+
+        return ChargeResult(
+            event_charge_limit_reached=max_charge_count is not None and max_charge_count <= 0,
+            charged_count=charged_count,
+            chargeable_within_limit=calculate_chargeable(),
+        )
+
+    @ensure_context
+    def calculate_total_charged_amount(self) -> Decimal:
+        return sum(
+            (item.total_charged_amount for item in self._charging_state.values()),
+            start=Decimal(),
+        )
+
+    @ensure_context
+    def calculate_max_event_charge_count_within_limit(self, event_name: str) -> int | None:
+        pricing_info = self._pricing_info.get(event_name)
+
+        if pricing_info is not None:
+            price = pricing_info.price
+        elif not self._is_at_home:
+            price = Decimal('1')  # Use a nonzero price for local development so that the maximum budget can be reached
+        else:
+            price = Decimal()
+
+        if not price:
+            return None
+
+        result = (self._max_total_charge_usd - self.calculate_total_charged_amount()) / price
+        return math.floor(result) if result.is_finite() else None
+
+    @ensure_context
+    def get_pricing_info(self) -> ActorPricingInfo:
+        return ActorPricingInfo(
+            pricing_model=self._pricing_model,
+            is_pay_per_event=self._pricing_model == 'PAY_PER_EVENT',
+            max_total_charge_usd=self._max_total_charge_usd
+            if self._max_total_charge_usd is not None
+            else Decimal('inf'),
+            per_event_prices={
+                event_name: pricing_info.price for event_name, pricing_info in self._pricing_info.items()
+            },
+        )
+
+
+@dataclass
+class ChargingStateItem:
+    charge_count: int
+    total_charged_amount: Decimal
+
+
+@dataclass
+class PricingInfoItem:
+    price: Decimal
+    title: str

apify/_configuration.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from datetime import datetime, timedelta
+from decimal import Decimal
 from logging import getLogger
 from typing import Annotated, Any
 
@@ -212,7 +213,7 @@ class Configuration(CrawleeConfiguration):
     ] = None
 
     max_total_charge_usd: Annotated[
-        float | None,
+        Decimal | None,
         Field(
             alias='actor_max_total_charge_usd',
             description='For pay-per-event Actors, the user-set limit on total charges. Do not exceed this limit',
@@ -220,6 +221,14 @@ class Configuration(CrawleeConfiguration):
         BeforeValidator(lambda val: val or None),
     ] = None
 
+    test_pay_per_event: Annotated[
+        bool,
+        Field(
+            alias='actor_test_pay_per_event',
+            description='Enable pay-per-event functionality for local development',
+        ),
+    ] = False
+
     meta_origin: Annotated[
         str | None,
         Field(

apify/_models.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
 from datetime import datetime, timedelta
-from typing import Annotated
+from decimal import Decimal
+from typing import TYPE_CHECKING, Annotated, Literal
 
 from pydantic import BaseModel, BeforeValidator, ConfigDict, Field
 
@@ -11,6 +12,9 @@ from crawlee._utils.urls import validate_http_url
 
 from apify._utils import docs_group
 
+if TYPE_CHECKING:
+    from typing_extensions import TypeAlias
+
 
 @docs_group('Data structures')
 class Webhook(BaseModel):
@@ -42,7 +46,7 @@ class ActorRunMeta(BaseModel):
 class ActorRunStats(BaseModel):
     __model_config__ = ConfigDict(populate_by_name=True)
 
-    input_body_len: Annotated[int, Field(alias='inputBodyLen')]
+    input_body_len: Annotated[int | None, Field(alias='inputBodyLen')] = None
     restart_count: Annotated[int, Field(alias='restartCount')]
     resurrect_count: Annotated[int, Field(alias='resurrectCount')]
     mem_avg_bytes: Annotated[float | None, Field(alias='memAvgBytes')] = None
@@ -67,6 +71,7 @@ class ActorRunOptions(BaseModel):
     timeout: Annotated[timedelta, Field(alias='timeoutSecs')]
     memory_mbytes: Annotated[int, Field(alias='memoryMbytes')]
     disk_mbytes: Annotated[int, Field(alias='diskMbytes')]
+    max_total_charge_usd: Annotated[Decimal | None, Field(alias='maxTotalChargeUsd')] = None
 
 
 @docs_group('Data structures')
@@ -115,3 +120,55 @@ class ActorRun(BaseModel):
     usage: Annotated[ActorRunUsage | None, Field(alias='usage')] = None
     usage_total_usd: Annotated[float | None, Field(alias='usageTotalUsd')] = None
     usage_usd: Annotated[ActorRunUsage | None, Field(alias='usageUsd')] = None
+    pricing_info: Annotated[
+        FreeActorPricingInfo
+        | FlatPricePerMonthActorPricingInfo
+        | PricePerDatasetItemActorPricingInfo
+        | PayPerEventActorPricingInfo
+        | None,
+        Field(alias='pricingInfo', discriminator='pricing_model'),
+    ] = None
+    charged_event_counts: Annotated[
+        dict[str, int] | None,
+        Field(alias='chargedEventCounts'),
+    ] = None
+
+
+class FreeActorPricingInfo(BaseModel):
+    pricing_model: Annotated[Literal['FREE'], Field(alias='pricingModel')]
+
+
+class FlatPricePerMonthActorPricingInfo(BaseModel):
+    pricing_model: Annotated[Literal['FLAT_PRICE_PER_MONTH'], Field(alias='pricingModel')]
+    trial_minutes: Annotated[int | None, Field(alias='trialMinutes')] = None
+    price_per_unit_usd: Annotated[Decimal, Field(alias='pricePerUnitUsd')]
+
+
+class PricePerDatasetItemActorPricingInfo(BaseModel):
+    pricing_model: Annotated[Literal['PRICE_PER_DATASET_ITEM'], Field(alias='pricingModel')]
+    unit_name: Annotated[str | None, Field(alias='unitName')] = None
+    price_per_unit_usd: Annotated[Decimal, Field(alias='pricePerUnitUsd')]
+
+
+class ActorChargeEvent(BaseModel):
+    event_price_usd: Annotated[Decimal, Field(alias='eventPriceUsd')]
+    event_title: Annotated[str, Field(alias='eventTitle')]
+    event_description: Annotated[str | None, Field(alias='eventDescription')] = None
+
+
+class PricingPerEvent(BaseModel):
+    actor_charge_events: Annotated[dict[str, ActorChargeEvent], Field(alias='actorChargeEvents')]
+
+
+class PayPerEventActorPricingInfo(BaseModel):
+    pricing_model: Annotated[Literal['PAY_PER_EVENT'], Field(alias='pricingModel')]
+    pricing_per_event: Annotated[PricingPerEvent, Field(alias='pricingPerEvent')]
+    minimal_max_total_charge_usd: Annotated[Decimal | None, Field(alias='minimalMaxTotalChargeUsd')] = None
+
+
+PricingModel: TypeAlias = Literal[
+    'FREE',
+    'FLAT_PRICE_PER_MONTH',
+    'PRICE_PER_DATASET_ITEM',
+    'PAY_PER_EVENT',
+]

apify/_utils.py

@@ -27,7 +27,7 @@ def is_running_in_ipython() -> bool:
     return getattr(builtins, '__IPYTHON__', False)
 
 
-GroupName = Literal['Classes', 'Abstract classes', 'Data structures', 'Errors', 'Functions']
+GroupName = Literal['Classes', 'Abstract classes', 'Interfaces', 'Data structures', 'Errors', 'Functions']
 
 
 def docs_group(group_name: GroupName) -> Callable:  # noqa: ARG001

apify-2.3.1b1.dist-info/METADATA

@@ -0,0 +1,411 @@
+Metadata-Version: 2.4
+Name: apify
+Version: 2.3.1b1
+Summary: Apify SDK for Python
+Project-URL: Homepage, https://docs.apify.com/sdk/python/
+Project-URL: Apify homepage, https://apify.com
+Project-URL: Changelog, https://docs.apify.com/sdk/python/docs/changelog
+Project-URL: Documentation, https://docs.apify.com/sdk/python/
+Project-URL: Issue tracker, https://github.com/apify/apify-sdk-python/issues
+Project-URL: Repository, https://github.com/apify/apify-sdk-python
+Author-email: "Apify Technologies s.r.o." <support@apify.com>
+License:                                  Apache License
+                                   Version 2.0, January 2004
+                                http://www.apache.org/licenses/
+        
+           TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+        
+           1. Definitions.
+        
+              "License" shall mean the terms and conditions for use, reproduction,
+              and distribution as defined by Sections 1 through 9 of this document.
+        
+              "Licensor" shall mean the copyright owner or entity authorized by
+              the copyright owner that is granting the License.
+        
+              "Legal Entity" shall mean the union of the acting entity and all
+              other entities that control, are controlled by, or are under common
+              control with that entity. For the purposes of this definition,
+              "control" means (i) the power, direct or indirect, to cause the
+              direction or management of such entity, whether by contract or
+              otherwise, or (ii) ownership of fifty percent (50%) or more of the
+              outstanding shares, or (iii) beneficial ownership of such entity.
+        
+              "You" (or "Your") shall mean an individual or Legal Entity
+              exercising permissions granted by this License.
+        
+              "Source" form shall mean the preferred form for making modifications,
+              including but not limited to software source code, documentation
+              source, and configuration files.
+        
+              "Object" form shall mean any form resulting from mechanical
+              transformation or translation of a Source form, including but
+              not limited to compiled object code, generated documentation,
+              and conversions to other media types.
+        
+              "Work" shall mean the work of authorship, whether in Source or
+              Object form, made available under the License, as indicated by a
+              copyright notice that is included in or attached to the work
+              (an example is provided in the Appendix below).
+        
+              "Derivative Works" shall mean any work, whether in Source or Object
+              form, that is based on (or derived from) the Work and for which the
+              editorial revisions, annotations, elaborations, or other modifications
+              represent, as a whole, an original work of authorship. For the purposes
+              of this License, Derivative Works shall not include works that remain
+              separable from, or merely link (or bind by name) to the interfaces of,
+              the Work and Derivative Works thereof.
+        
+              "Contribution" shall mean any work of authorship, including
+              the original version of the Work and any modifications or additions
+              to that Work or Derivative Works thereof, that is intentionally
+              submitted to Licensor for inclusion in the Work by the copyright owner
+              or by an individual or Legal Entity authorized to submit on behalf of
+              the copyright owner. For the purposes of this definition, "submitted"
+              means any form of electronic, verbal, or written communication sent
+              to the Licensor or its representatives, including but not limited to
+              communication on electronic mailing lists, source code control systems,
+              and issue tracking systems that are managed by, or on behalf of, the
+              Licensor for the purpose of discussing and improving the Work, but
+              excluding communication that is conspicuously marked or otherwise
+              designated in writing by the copyright owner as "Not a Contribution."
+        
+              "Contributor" shall mean Licensor and any individual or Legal Entity
+              on behalf of whom a Contribution has been received by Licensor and
+              subsequently incorporated within the Work.
+        
+           2. Grant of Copyright License. Subject to the terms and conditions of
+              this License, each Contributor hereby grants to You a perpetual,
+              worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+              copyright license to reproduce, prepare Derivative Works of,
+              publicly display, publicly perform, sublicense, and distribute the
+              Work and such Derivative Works in Source or Object form.
+        
+           3. Grant of Patent License. Subject to the terms and conditions of
+              this License, each Contributor hereby grants to You a perpetual,
+              worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+              (except as stated in this section) patent license to make, have made,
+              use, offer to sell, sell, import, and otherwise transfer the Work,
+              where such license applies only to those patent claims licensable
+              by such Contributor that are necessarily infringed by their
+              Contribution(s) alone or by combination of their Contribution(s)
+              with the Work to which such Contribution(s) was submitted. If You
+              institute patent litigation against any entity (including a
+              cross-claim or counterclaim in a lawsuit) alleging that the Work
+              or a Contribution incorporated within the Work constitutes direct
+              or contributory patent infringement, then any patent licenses
+              granted to You under this License for that Work shall terminate
+              as of the date such litigation is filed.
+        
+           4. Redistribution. You may reproduce and distribute copies of the
+              Work or Derivative Works thereof in any medium, with or without
+              modifications, and in Source or Object form, provided that You
+              meet the following conditions:
+        
+              (a) You must give any other recipients of the Work or
+                  Derivative Works a copy of this License; and
+        
+              (b) You must cause any modified files to carry prominent notices
+                  stating that You changed the files; and
+        
+              (c) You must retain, in the Source form of any Derivative Works
+                  that You distribute, all copyright, patent, trademark, and
+                  attribution notices from the Source form of the Work,
+                  excluding those notices that do not pertain to any part of
+                  the Derivative Works; and
+        
+              (d) If the Work includes a "NOTICE" text file as part of its
+                  distribution, then any Derivative Works that You distribute must
+                  include a readable copy of the attribution notices contained
+                  within such NOTICE file, excluding those notices that do not
+                  pertain to any part of the Derivative Works, in at least one
+                  of the following places: within a NOTICE text file distributed
+                  as part of the Derivative Works; within the Source form or
+                  documentation, if provided along with the Derivative Works; or,
+                  within a display generated by the Derivative Works, if and
+                  wherever such third-party notices normally appear. The contents
+                  of the NOTICE file are for informational purposes only and
+                  do not modify the License. You may add Your own attribution
+                  notices within Derivative Works that You distribute, alongside
+                  or as an addendum to the NOTICE text from the Work, provided
+                  that such additional attribution notices cannot be construed
+                  as modifying the License.
+        
+              You may add Your own copyright statement to Your modifications and
+              may provide additional or different license terms and conditions
+              for use, reproduction, or distribution of Your modifications, or
+              for any such Derivative Works as a whole, provided Your use,
+              reproduction, and distribution of the Work otherwise complies with
+              the conditions stated in this License.
+        
+           5. Submission of Contributions. Unless You explicitly state otherwise,
+              any Contribution intentionally submitted for inclusion in the Work
+              by You to the Licensor shall be under the terms and conditions of
+              this License, without any additional terms or conditions.
+              Notwithstanding the above, nothing herein shall supersede or modify
+              the terms of any separate license agreement you may have executed
+              with Licensor regarding such Contributions.
+        
+           6. Trademarks. This License does not grant permission to use the trade
+              names, trademarks, service marks, or product names of the Licensor,
+              except as required for reasonable and customary use in describing the
+              origin of the Work and reproducing the content of the NOTICE file.
+        
+           7. Disclaimer of Warranty. Unless required by applicable law or
+              agreed to in writing, Licensor provides the Work (and each
+              Contributor provides its Contributions) on an "AS IS" BASIS,
+              WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+              implied, including, without limitation, any warranties or conditions
+              of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+              PARTICULAR PURPOSE. You are solely responsible for determining the
+              appropriateness of using or redistributing the Work and assume any
+              risks associated with Your exercise of permissions under this License.
+        
+           8. Limitation of Liability. In no event and under no legal theory,
+              whether in tort (including negligence), contract, or otherwise,
+              unless required by applicable law (such as deliberate and grossly
+              negligent acts) or agreed to in writing, shall any Contributor be
+              liable to You for damages, including any direct, indirect, special,
+              incidental, or consequential damages of any character arising as a
+              result of this License or out of the use or inability to use the
+              Work (including but not limited to damages for loss of goodwill,
+              work stoppage, computer failure or malfunction, or any and all
+              other commercial damages or losses), even if such Contributor
+              has been advised of the possibility of such damages.
+        
+           9. Accepting Warranty or Additional Liability. While redistributing
+              the Work or Derivative Works thereof, You may choose to offer,
+              and charge a fee for, acceptance of support, warranty, indemnity,
+              or other liability obligations and/or rights consistent with this
+              License. However, in accepting such obligations, You may act only
+              on Your own behalf and on Your sole responsibility, not on behalf
+              of any other Contributor, and only if You agree to indemnify,
+              defend, and hold each Contributor harmless for any liability
+              incurred by, or claims asserted against, such Contributor by reason
+              of your accepting any such warranty or additional liability.
+        
+           END OF TERMS AND CONDITIONS
+        
+           APPENDIX: How to apply the Apache License to your work.
+        
+              To apply the Apache License to your work, attach the following
+              boilerplate notice, with the fields enclosed by brackets "{}"
+              replaced with your own identifying information. (Don't include
+              the brackets!)  The text should be enclosed in the appropriate
+              comment syntax for the file format. We also recommend that a
+              file or class name and description of purpose be included on the
+              same "printed page" as the copyright notice for easier
+              identification within third-party archives.
+        
+           Copyright 2023 Apify Technologies s.r.o.
+        
+           Licensed under the Apache License, Version 2.0 (the "License");
+           you may not use this file except in compliance with the License.
+           You may obtain a copy of the License at
+        
+               http://www.apache.org/licenses/LICENSE-2.0
+        
+           Unless required by applicable law or agreed to in writing, software
+           distributed under the License is distributed on an "AS IS" BASIS,
+           WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+           See the License for the specific language governing permissions and
+           limitations under the License.
+License-File: LICENSE
+Keywords: apify,automation,chrome,crawlee,crawler,headless,scraper,scraping,sdk
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.9
+Requires-Dist: apify-client>=1.9.2
+Requires-Dist: apify-shared>=1.2.1
+Requires-Dist: crawlee~=0.5.0
+Requires-Dist: cryptography>=42.0.0
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: lazy-object-proxy>=1.10.0
+Requires-Dist: more-itertools>=10.2.0
+Requires-Dist: typing-extensions>=4.1.0
+Requires-Dist: websockets<14.0.0,>=10.0
+Provides-Extra: scrapy
+Requires-Dist: scrapy>=2.11.0; extra == 'scrapy'
+Description-Content-Type: text/markdown
+
+# Apify SDK for Python
+
+The Apify SDK for Python is the official library to create [Apify Actors](https://docs.apify.com/platform/actors)
+in Python. It provides useful features like Actor lifecycle management, local storage emulation, and Actor
+event handling.
+
+If you just need to access the [Apify API](https://docs.apify.com/api/v2) from your Python applications,
+check out the [Apify Client for Python](https://docs.apify.com/api/client/python) instead.
+
+## Installation
+
+The Apify SDK for Python is available on PyPI as the `apify` package.
+For default installation, using Pip, run the following:
+
+```bash
+pip install apify
+```
+
+For users interested in integrating Apify with Scrapy, we provide a package extra called `scrapy`.
+To install Apify with the `scrapy` extra, use the following command:
+
+```bash
+pip install apify[scrapy]
+```
+
+## Documentation
+
+For usage instructions, check the documentation on [Apify Docs](https://docs.apify.com/sdk/python/).
+
+## Examples
+
+Below are few examples demonstrating how to use the Apify SDK with some web scraping-related libraries.
+
+### Apify SDK with HTTPX and BeautifulSoup
+
+This example illustrates how to integrate the Apify SDK with [HTTPX](https://www.python-httpx.org/) and [BeautifulSoup](https://pypi.org/project/beautifulsoup4/) to scrape data from web pages.
+
+```python
+from bs4 import BeautifulSoup
+from httpx import AsyncClient
+
+from apify import Actor
+
+
+async def main() -> None:
+    async with Actor:
+        # Retrieve the Actor input, and use default values if not provided.
+        actor_input = await Actor.get_input() or {}
+        start_urls = actor_input.get('start_urls', [{'url': 'https://apify.com'}])
+
+        # Open the default request queue for handling URLs to be processed.
+        request_queue = await Actor.open_request_queue()
+
+        # Enqueue the start URLs.
+        for start_url in start_urls:
+            url = start_url.get('url')
+            await request_queue.add_request(url)
+
+        # Process the URLs from the request queue.
+        while request := await request_queue.fetch_next_request():
+            Actor.log.info(f'Scraping {request.url} ...')
+
+            # Fetch the HTTP response from the specified URL using HTTPX.
+            async with AsyncClient() as client:
+                response = await client.get(request.url)
+
+            # Parse the HTML content using Beautiful Soup.
+            soup = BeautifulSoup(response.content, 'html.parser')
+
+            # Extract the desired data.
+            data = {
+                'url': actor_input['url'],
+                'title': soup.title.string,
+                'h1s': [h1.text for h1 in soup.find_all('h1')],
+                'h2s': [h2.text for h2 in soup.find_all('h2')],
+                'h3s': [h3.text for h3 in soup.find_all('h3')],
+            }
+
+            # Store the extracted data to the default dataset.
+            await Actor.push_data(data)
+```
+
+### Apify SDK with PlaywrightCrawler from Crawlee
+
+This example demonstrates how to use the Apify SDK alongside `PlaywrightCrawler` from [Crawlee](https://crawlee.dev/python) to perform web scraping.
+
+```python
+from crawlee.crawlers import PlaywrightCrawler, PlaywrightCrawlingContext
+
+from apify import Actor
+
+
+async def main() -> None:
+    async with Actor:
+        # Retrieve the Actor input, and use default values if not provided.
+        actor_input = await Actor.get_input() or {}
+        start_urls = [url.get('url') for url in actor_input.get('start_urls', [{'url': 'https://apify.com'}])]
+
+        # Exit if no start URLs are provided.
+        if not start_urls:
+            Actor.log.info('No start URLs specified in Actor input, exiting...')
+            await Actor.exit()
+
+        # Create a crawler.
+        crawler = PlaywrightCrawler(
+            # Limit the crawl to max requests. Remove or increase it for crawling all links.
+            max_requests_per_crawl=50,
+            headless=True,
+        )
+
+        # Define a request handler, which will be called for every request.
+        @crawler.router.default_handler
+        async def request_handler(context: PlaywrightCrawlingContext) -> None:
+            url = context.request.url
+            Actor.log.info(f'Scraping {url}...')
+
+            # Extract the desired data.
+            data = {
+                'url': context.request.url,
+                'title': await context.page.title(),
+                'h1s': [await h1.text_content() for h1 in await context.page.locator('h1').all()],
+                'h2s': [await h2.text_content() for h2 in await context.page.locator('h2').all()],
+                'h3s': [await h3.text_content() for h3 in await context.page.locator('h3').all()],
+            }
+
+            # Store the extracted data to the default dataset.
+            await context.push_data(data)
+
+            # Enqueue additional links found on the current page.
+            await context.enqueue_links()
+
+        # Run the crawler with the starting URLs.
+        await crawler.run(start_urls)
+```
+
+## What are Actors?
+
+Actors are serverless cloud programs that can do almost anything a human can do in a web browser.
+They can do anything from small tasks such as filling in forms or unsubscribing from online services,
+all the way up to scraping and processing vast numbers of web pages.
+
+They can be run either locally, or on the [Apify platform](https://docs.apify.com/platform/),
+where you can run them at scale, monitor them, schedule them, or publish and monetize them.
+
+If you're new to Apify, learn [what is Apify](https://docs.apify.com/platform/about)
+in the Apify platform documentation.
+
+## Creating Actors
+
+To create and run Actors through Apify Console,
+see the [Console documentation](https://docs.apify.com/academy/getting-started/creating-actors#choose-your-template).
+
+To create and run Python Actors locally, check the documentation for
+[how to create and run Python Actors locally](https://docs.apify.com/sdk/python/docs/overview/running-locally).
+
+## Guides
+
+To see how you can use the Apify SDK with other popular libraries used for web scraping,
+check out our guides for using
+[Requests and HTTPX](https://docs.apify.com/sdk/python/docs/guides/requests-and-httpx),
+[Beautiful Soup](https://docs.apify.com/sdk/python/docs/guides/beautiful-soup),
+[Playwright](https://docs.apify.com/sdk/python/docs/guides/playwright),
+[Selenium](https://docs.apify.com/sdk/python/docs/guides/selenium),
+or [Scrapy](https://docs.apify.com/sdk/python/docs/guides/scrapy).
+
+## Usage concepts
+
+To learn more about the features of the Apify SDK and how to use them,
+check out the Usage Concepts section in the sidebar,
+particularly the guides for the [Actor lifecycle](https://docs.apify.com/sdk/python/docs/concepts/actor-lifecycle),
+[working with storages](https://docs.apify.com/sdk/python/docs/concepts/storages),
+[handling Actor events](https://docs.apify.com/sdk/python/docs/concepts/actor-events)
+or [how to use proxies](https://docs.apify.com/sdk/python/docs/concepts/proxy-management).

{apify-2.3.0b2.dist-info → apify-2.3.1b1.dist-info}/RECORD

@@ -1,12 +1,15 @@
 apify/__init__.py,sha256=HpgKg2FZWJuSPfDygzJ62psylhw4NN4tKFnoYUIhcd4,838
-apify/_actor.py,sha256=gZVbubkFFaNVcEoU_343Cmlc4Svtxd5x9J1WhWZcE4o,46507
-apify/_configuration.py,sha256=T3Z_o_W98iSyTbrutfb578yW51aexZ_V0FcLwTxFLjI,10878
+apify/_actor.py,sha256=EB3gGjASV0PbPJ6BtgOq45HN23vM-9ceNCNRfeh2BkQ,48821
+apify/_charging.py,sha256=m7hJIQde4M7vS4g_4hsNRP5xHNXjYQ8MyqOEGeNb7VY,12267
+apify/_configuration.py,sha256=yidcWHsu-IJ2mmLmXStKq_HHcdfQxZq7koYjlZfRnQ8,11128
 apify/_consts.py,sha256=_Xq4hOfOA1iZ3n1P967YWdyncKivpbX6RTlp_qanUoE,330
 apify/_crypto.py,sha256=e0_aM3l9_5Osk-jszYOOjrAKK60OggSHbiw5c30QnsU,5638
-apify/_models.py,sha256=Btlz-23obKY5tJ75JnUwkVNC2lmU1IEBbdU3HvWaVhg,5748
+apify/_models.py,sha256=-Y0rljBJWxMMCp8iDCTG4UV3bEvNZzp-kx2SYbPfeIY,7919
 apify/_platform_event_manager.py,sha256=44xyV0Lpzf4h4VZ0rkyYg_nhbQkEONNor8_Z9gIKO40,7899
 apify/_proxy_configuration.py,sha256=c-O6_PZ9pUD-i4J0RFEKTtfyJPP2rTRJJA1TH8NVsV8,13189
-apify/_utils.py,sha256=CCLkpAsZKp00ykm88Z_Fbck5PNT0j6mJYOuD0RxzZUs,1620
+apify/_utils.py,sha256=92byxeXTpDFwhBq7ZS-obeXKtKWvVzCZMV0Drg3EjhQ,1634
+apify/log.py,sha256=j-E4t-WeA93bc1NCQRG8sTntehQCiiN8ia-MdQe3_Ts,1291
+apify/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 apify/apify_storage_client/__init__.py,sha256=-UbR68bFsDR6ln8OFs4t50eqcnY36hujO-SeOt-KmcA,114
 apify/apify_storage_client/_apify_storage_client.py,sha256=jTX5vd-K9mnFTyZu2V2dUg7oyWogvmNIDUlEXnvIlOw,2766
 apify/apify_storage_client/_dataset_client.py,sha256=UUodnR_MQBg5RkURrfegkGJWR5OmdPPgPfGepvkdQoU,5580
@@ -16,26 +19,24 @@ apify/apify_storage_client/_key_value_store_collection_client.py,sha256=NxD-3XDJ
 apify/apify_storage_client/_request_queue_client.py,sha256=n-CR-hA5LM6_8IwiMwQ9tT2juavq7X2zC3ZNlrtv-2s,5156
 apify/apify_storage_client/_request_queue_collection_client.py,sha256=MdzgbQb2D8rHWpUlPCrQSHRlAi0fI0PSZ9bYagr-MhY,1571
 apify/apify_storage_client/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-apify/log.py,sha256=j-E4t-WeA93bc1NCQRG8sTntehQCiiN8ia-MdQe3_Ts,1291
-apify/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 apify/scrapy/__init__.py,sha256=m2a0ts_JY9xJkBy4JU5mV8PJqjA3GGKLXBFu4nl-n-A,1048
 apify/scrapy/_actor_runner.py,sha256=rXWSnlQWGskDUH8PtLCv5SkOIx4AiVa4QbCYeCett5c,938
 apify/scrapy/_async_thread.py,sha256=AfeH9ZkSRZXxL11wzwrroDNsTzq4tAvURlinUZBtYMA,4753
 apify/scrapy/_logging_config.py,sha256=hFq90fNtZyjjJA7w2k-mtuEC8xCFiBMTalbwPDcaig4,2022
+apify/scrapy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+apify/scrapy/requests.py,sha256=tOiFtG0kyzbBwtmaOisLAcpJENR1eDtpPR1nRH7JJGg,6551
+apify/scrapy/scheduler.py,sha256=-r1wZjMmeRDPxZKGHO-EYDYpGdDgSPAdNgMFViqUK8E,6019
+apify/scrapy/utils.py,sha256=5cka33PWc_at14yjhnLkCvY4h-ySUgVVhhDLxTy39ZI,1965
 apify/scrapy/middlewares/__init__.py,sha256=tfW-d3WFWLeNEjL8fTmon6NwgD-OXx1Bw2fBdU-wPy4,114
 apify/scrapy/middlewares/apify_proxy.py,sha256=CDAOXS3bcVDZHM3B0GvhXbxEikMIadLF_0P73WL_nI4,5550
 apify/scrapy/middlewares/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 apify/scrapy/pipelines/__init__.py,sha256=GWPeLN_Zwj8vRBWtXW6DaxdB7mvyQ7Jw5Tz1ccgWlZI,119
 apify/scrapy/pipelines/actor_dataset_push.py,sha256=XUUyznQTD-E3wYUUFt2WAOnWhbnRrY0WuedlfYfYhDI,846
 apify/scrapy/pipelines/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-apify/scrapy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-apify/scrapy/requests.py,sha256=tOiFtG0kyzbBwtmaOisLAcpJENR1eDtpPR1nRH7JJGg,6551
-apify/scrapy/scheduler.py,sha256=-r1wZjMmeRDPxZKGHO-EYDYpGdDgSPAdNgMFViqUK8E,6019
-apify/scrapy/utils.py,sha256=5cka33PWc_at14yjhnLkCvY4h-ySUgVVhhDLxTy39ZI,1965
 apify/storages/__init__.py,sha256=FW-z6ubuPnHGM-Wp15T8mR5q6lnpDGrCW-IkgZd5L30,177
 apify/storages/_request_list.py,sha256=-lZJcE5nq69aJhGFJ7Sh2ctqgAWUDyOwYm5_0y1hdAE,5865
 apify/storages/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-apify-2.3.0b2.dist-info/LICENSE,sha256=AsFjHssKjj4LGd2ZCqXn6FBzMqcWdjQre1byPPSypVw,11355
-apify-2.3.0b2.dist-info/METADATA,sha256=I3msK8pLrpUgYlJOoHtXjHuaQKndb-ySirRp2c8f0ok,8696
-apify-2.3.0b2.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-apify-2.3.0b2.dist-info/RECORD,,
+apify-2.3.1b1.dist-info/METADATA,sha256=smwKRzXW6yc8qQBdfNzmI0UX0ixceooEkEsLsiHoM9k,21566
+apify-2.3.1b1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+apify-2.3.1b1.dist-info/licenses/LICENSE,sha256=AsFjHssKjj4LGd2ZCqXn6FBzMqcWdjQre1byPPSypVw,11355
+apify-2.3.1b1.dist-info/RECORD,,

{apify-2.3.0b2.dist-info → apify-2.3.1b1.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.0.1
+Generator: hatchling 1.27.0
 Root-Is-Purelib: true
 Tag: py3-none-any

apify-2.3.0b2.dist-info/METADATA

@@ -1,213 +0,0 @@
-Metadata-Version: 2.3
-Name: apify
-Version: 2.3.0b2
-Summary: Apify SDK for Python
-License: Apache-2.0
-Keywords: apify,sdk,automation,chrome,crawlee,crawler,headless,scraper,scraping
-Author: Apify Technologies s.r.o.
-Author-email: support@apify.com
-Requires-Python: >=3.9,<4.0
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Topic :: Software Development :: Libraries
-Provides-Extra: scrapy
-Requires-Dist: apify-client (>=1.9.1)
-Requires-Dist: apify-shared (>=1.2.1)
-Requires-Dist: crawlee (>=0.5.1,<0.6.0)
-Requires-Dist: cryptography (>=42.0.0)
-Requires-Dist: httpx (>=0.27.0)
-Requires-Dist: lazy-object-proxy (>=1.10.0)
-Requires-Dist: more_itertools (>=10.2.0)
-Requires-Dist: scrapy (>=2.11.0) ; extra == "scrapy"
-Requires-Dist: typing-extensions (>=4.1.0)
-Requires-Dist: websockets (>=10.0,<14.0.0)
-Project-URL: Apify Homepage, https://apify.com
-Project-URL: Changelog, https://docs.apify.com/sdk/python/docs/changelog
-Project-URL: Documentation, https://docs.apify.com/sdk/python/
-Project-URL: Homepage, https://docs.apify.com/sdk/python/
-Project-URL: Issue Tracker, https://github.com/apify/apify-sdk-python/issues
-Project-URL: Repository, https://github.com/apify/apify-sdk-python
-Description-Content-Type: text/markdown
-
-# Apify SDK for Python
-
-The Apify SDK for Python is the official library to create [Apify Actors](https://docs.apify.com/platform/actors)
-in Python. It provides useful features like Actor lifecycle management, local storage emulation, and Actor
-event handling.
-
-If you just need to access the [Apify API](https://docs.apify.com/api/v2) from your Python applications,
-check out the [Apify Client for Python](https://docs.apify.com/api/client/python) instead.
-
-## Installation
-
-The Apify SDK for Python is available on PyPI as the `apify` package.
-For default installation, using Pip, run the following:
-
-```bash
-pip install apify
-```
-
-For users interested in integrating Apify with Scrapy, we provide a package extra called `scrapy`.
-To install Apify with the `scrapy` extra, use the following command:
-
-```bash
-pip install apify[scrapy]
-```
-
-## Documentation
-
-For usage instructions, check the documentation on [Apify Docs](https://docs.apify.com/sdk/python/).
-
-## Examples
-
-Below are few examples demonstrating how to use the Apify SDK with some web scraping-related libraries.
-
-### Apify SDK with HTTPX and BeautifulSoup
-
-This example illustrates how to integrate the Apify SDK with [HTTPX](https://www.python-httpx.org/) and [BeautifulSoup](https://pypi.org/project/beautifulsoup4/) to scrape data from web pages.
-
-```python
-from bs4 import BeautifulSoup
-from httpx import AsyncClient
-
-from apify import Actor
-
-
-async def main() -> None:
-    async with Actor:
-        # Retrieve the Actor input, and use default values if not provided.
-        actor_input = await Actor.get_input() or {}
-        start_urls = actor_input.get('start_urls', [{'url': 'https://apify.com'}])
-
-        # Open the default request queue for handling URLs to be processed.
-        request_queue = await Actor.open_request_queue()
-
-        # Enqueue the start URLs.
-        for start_url in start_urls:
-            url = start_url.get('url')
-            await request_queue.add_request(url)
-
-        # Process the URLs from the request queue.
-        while request := await request_queue.fetch_next_request():
-            Actor.log.info(f'Scraping {request.url} ...')
-
-            # Fetch the HTTP response from the specified URL using HTTPX.
-            async with AsyncClient() as client:
-                response = await client.get(request.url)
-
-            # Parse the HTML content using Beautiful Soup.
-            soup = BeautifulSoup(response.content, 'html.parser')
-
-            # Extract the desired data.
-            data = {
-                'url': actor_input['url'],
-                'title': soup.title.string,
-                'h1s': [h1.text for h1 in soup.find_all('h1')],
-                'h2s': [h2.text for h2 in soup.find_all('h2')],
-                'h3s': [h3.text for h3 in soup.find_all('h3')],
-            }
-
-            # Store the extracted data to the default dataset.
-            await Actor.push_data(data)
-```
-
-### Apify SDK with PlaywrightCrawler from Crawlee
-
-This example demonstrates how to use the Apify SDK alongside `PlaywrightCrawler` from [Crawlee](https://crawlee.dev/python) to perform web scraping.
-
-```python
-from crawlee.crawlers import PlaywrightCrawler, PlaywrightCrawlingContext
-
-from apify import Actor
-
-
-async def main() -> None:
-    async with Actor:
-        # Retrieve the Actor input, and use default values if not provided.
-        actor_input = await Actor.get_input() or {}
-        start_urls = [url.get('url') for url in actor_input.get('start_urls', [{'url': 'https://apify.com'}])]
-
-        # Exit if no start URLs are provided.
-        if not start_urls:
-            Actor.log.info('No start URLs specified in Actor input, exiting...')
-            await Actor.exit()
-
-        # Create a crawler.
-        crawler = PlaywrightCrawler(
-            # Limit the crawl to max requests. Remove or increase it for crawling all links.
-            max_requests_per_crawl=50,
-            headless=True,
-        )
-
-        # Define a request handler, which will be called for every request.
-        @crawler.router.default_handler
-        async def request_handler(context: PlaywrightCrawlingContext) -> None:
-            url = context.request.url
-            Actor.log.info(f'Scraping {url}...')
-
-            # Extract the desired data.
-            data = {
-                'url': context.request.url,
-                'title': await context.page.title(),
-                'h1s': [await h1.text_content() for h1 in await context.page.locator('h1').all()],
-                'h2s': [await h2.text_content() for h2 in await context.page.locator('h2').all()],
-                'h3s': [await h3.text_content() for h3 in await context.page.locator('h3').all()],
-            }
-
-            # Store the extracted data to the default dataset.
-            await context.push_data(data)
-
-            # Enqueue additional links found on the current page.
-            await context.enqueue_links()
-
-        # Run the crawler with the starting URLs.
-        await crawler.run(start_urls)
-```
-
-## What are Actors?
-
-Actors are serverless cloud programs that can do almost anything a human can do in a web browser.
-They can do anything from small tasks such as filling in forms or unsubscribing from online services,
-all the way up to scraping and processing vast numbers of web pages.
-
-They can be run either locally, or on the [Apify platform](https://docs.apify.com/platform/),
-where you can run them at scale, monitor them, schedule them, or publish and monetize them.
-
-If you're new to Apify, learn [what is Apify](https://docs.apify.com/platform/about)
-in the Apify platform documentation.
-
-## Creating Actors
-
-To create and run Actors through Apify Console,
-see the [Console documentation](https://docs.apify.com/academy/getting-started/creating-actors#choose-your-template).
-
-To create and run Python Actors locally, check the documentation for
-[how to create and run Python Actors locally](https://docs.apify.com/sdk/python/docs/overview/running-locally).
-
-## Guides
-
-To see how you can use the Apify SDK with other popular libraries used for web scraping,
-check out our guides for using
-[Requests and HTTPX](https://docs.apify.com/sdk/python/docs/guides/requests-and-httpx),
-[Beautiful Soup](https://docs.apify.com/sdk/python/docs/guides/beautiful-soup),
-[Playwright](https://docs.apify.com/sdk/python/docs/guides/playwright),
-[Selenium](https://docs.apify.com/sdk/python/docs/guides/selenium),
-or [Scrapy](https://docs.apify.com/sdk/python/docs/guides/scrapy).
-
-## Usage concepts
-
-To learn more about the features of the Apify SDK and how to use them,
-check out the Usage Concepts section in the sidebar,
-particularly the guides for the [Actor lifecycle](https://docs.apify.com/sdk/python/docs/concepts/actor-lifecycle),
-[working with storages](https://docs.apify.com/sdk/python/docs/concepts/storages),
-[handling Actor events](https://docs.apify.com/sdk/python/docs/concepts/actor-events)
-or [how to use proxies](https://docs.apify.com/sdk/python/docs/concepts/proxy-management).
-