apify 3.4.2b3__tar.gz → 3.4.2b4__tar.gz

{apify-3.4.2b3 → apify-3.4.2b4}/CHANGELOG.md

@@ -9,6 +9,7 @@ All notable changes to this project will be documented in this file.
 
 - [**breaking**] Remove deprecated APIs ([#918](https://github.com/apify/apify-sdk-python/pull/918)) ([3e5728d](https://github.com/apify/apify-sdk-python/commit/3e5728d94cb8fd879d5a76e33a03d55792d835d5)) by [@vdusek](https://github.com/vdusek), closes [#635](https://github.com/apify/apify-sdk-python/issues/635)
 - [**breaking**] Mark secondary arguments as keyword-only ([#917](https://github.com/apify/apify-sdk-python/pull/917)) ([eb94c99](https://github.com/apify/apify-sdk-python/commit/eb94c992ec4aba1cd7cf4dfd7a98731cb304651b)) by [@vdusek](https://github.com/vdusek), closes [#881](https://github.com/apify/apify-sdk-python/issues/881)
+- [**breaking**] Adapt to apify-client v3 ([#719](https://github.com/apify/apify-sdk-python/pull/719)) ([10203bc](https://github.com/apify/apify-sdk-python/commit/10203bc51e67590c97938b37d81614376bc3d29a)) by [@vdusek](https://github.com/vdusek), closes [#697](https://github.com/apify/apify-sdk-python/issues/697), [#736](https://github.com/apify/apify-sdk-python/issues/736), [#770](https://github.com/apify/apify-sdk-python/issues/770), [#853](https://github.com/apify/apify-sdk-python/issues/853)
 
 ### ⚙️ Miscellaneous Tasks
 

{apify-3.4.2b3 → apify-3.4.2b4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: apify
-Version: 3.4.2b3
+Version: 3.4.2b4
 Summary: Apify SDK for Python
 Project-URL: Apify Homepage, https://apify.com
 Project-URL: Changelog, https://docs.apify.com/sdk/python/docs/changelog
@@ -225,8 +225,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: Libraries
 Requires-Python: >=3.11
-Requires-Dist: apify-client<3.0.0,>=2.3.0
-Requires-Dist: apify-shared<3.0.0,>=2.0.0
+Requires-Dist: apify-client<4.0.0,>=3.0.0
 Requires-Dist: cachetools>=5.5.0
 Requires-Dist: crawlee<2.0.0,>=1.0.4
 Requires-Dist: cryptography>=42.0.0

{apify-3.4.2b3 → apify-3.4.2b4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "apify"
-version = "3.4.2b3"
+version = "3.4.2b4"
 description = "Apify SDK for Python"
 authors = [{ name = "Apify Technologies s.r.o.", email = "support@apify.com" }]
 license = { file = "LICENSE" }
@@ -34,8 +34,7 @@ keywords = [
     "scraping",
 ]
 dependencies = [
-    "apify-client>=2.3.0,<3.0.0",
-    "apify-shared>=2.0.0,<3.0.0",
+    "apify-client>=3.0.0,<4.0.0",
     "crawlee>=1.0.4,<2.0.0",
     "cachetools>=5.5.0",
     "cryptography>=42.0.0",
@@ -197,7 +196,7 @@ builtins-ignorelist = ["id"]
 
 [tool.ruff.lint.isort]
 known-local-folder = ["apify"]
-known-first-party = ["apify_client", "apify_shared", "crawlee"]
+known-first-party = ["apify_client", "crawlee"]
 
 [tool.ruff.lint.pylint]
 max-branches = 18

{apify-3.4.2b3 → apify-3.4.2b4}/src/apify/__init__.py

@@ -1,6 +1,6 @@
 from importlib import metadata
 
-from apify_shared.consts import WebhookEventType
+from apify_client._literals import WebhookEventType
 from crawlee import Request
 from crawlee.events import (
     Event,
@@ -14,13 +14,18 @@ from crawlee.events import (
 
 from apify._actor import Actor
 from apify._configuration import Configuration
-from apify._models import Webhook
+from apify._consts import ActorEnvVars, ApifyEnvVars
 from apify._proxy_configuration import ProxyConfiguration, ProxyInfo
+from apify._webhook import Webhook
+from apify.events._types import ActorEventTypes
 
 __version__ = metadata.version('apify')
 
 __all__ = [
     'Actor',
+    'ActorEnvVars',
+    'ActorEventTypes',
+    'ApifyEnvVars',
     'Configuration',
     'Event',
     'EventAbortingData',

{apify-3.4.2b3 → apify-3.4.2b4}/src/apify/_actor.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import asyncio
 import sys
+import warnings
 from contextlib import suppress
 from datetime import UTC, datetime, timedelta
 from functools import cached_property
@@ -12,7 +13,6 @@ from more_itertools import flatten
 from pydantic import AliasChoices
 
 from apify_client import ApifyClientAsync
-from apify_shared.consts import ActorEnvVars, ActorExitCodes, ApifyEnvVars
 from crawlee import service_locator
 from crawlee.errors import ServiceConflictError
 from crawlee.events import (
@@ -27,11 +27,11 @@ from crawlee.events import (
 
 from apify._charging import DEFAULT_DATASET_ITEM_EVENT, ChargeResult, ChargingManager, ChargingManagerImplementation
 from apify._configuration import Configuration
-from apify._consts import EVENT_LISTENERS_TIMEOUT
+from apify._consts import EVENT_LISTENERS_TIMEOUT, EXIT_CODE_ERROR_USER_FUNCTION_THREW, ActorEnvVars, ApifyEnvVars
 from apify._crypto import decrypt_input_secrets, load_private_key
-from apify._models import ActorRun
 from apify._proxy_configuration import ProxyConfiguration
 from apify._utils import docs_group, docs_name, ensure_context, get_system_info, is_running_in_ipython
+from apify._webhook import to_client_representations
 from apify.events import ApifyEventManager, EventManager, LocalEventManager
 from apify.log import _configure_logging, logger
 from apify.storage_clients import ApifyStorageClient, SmartApifyStorageClient
@@ -45,11 +45,12 @@ if TYPE_CHECKING:
     from types import TracebackType
     from typing import Self
 
-    from apify_shared.consts import ActorPermissionLevel
+    from apify_client._literals import ActorPermissionLevel
+    from apify_client._models import Run
     from crawlee._types import JsonSerializable
     from crawlee.proxy_configuration import _NewUrlFunction
 
-    from apify._models import Webhook
+    from apify._webhook import Webhook
 
 MainReturnType = TypeVar('MainReturnType')
 
@@ -234,7 +235,7 @@ class _ActorType:
             # In IPython, we don't run `sys.exit()` during Actor exits,
             # so the exception traceback will be printed on its own
             self.log.exception('Actor failed with an exception', exc_info=exc_value)
-            self.exit_code = ActorExitCodes.ERROR_USER_FUNCTION_THREW.value
+            self.exit_code = EXIT_CODE_ERROR_USER_FUNCTION_THREW
 
         self._is_exiting = True
         self.log.info('Exiting Actor', extra={'exit_code': self.exit_code})
@@ -504,19 +505,31 @@ class _ActorType:
             max_retries: How many times to retry a failed request at most.
             min_delay_between_retries: How long will the client wait between retrying requests
                 (increases exponentially from this value).
-            timeout: The socket timeout of the HTTP requests sent to the Apify API.
+            timeout: Baseline HTTP timeout for medium-duration API operations. The underlying client uses
+                separate timeout tiers for short/medium/long/max-duration calls; passing a value here scales
+                all four tiers proportionally (short = `timeout / 6`, long = `timeout * 12`,
+                max = `timeout * 12`).
         """
-        token = token or self.configuration.token
-        api_url = api_url or self.configuration.api_base_url
-        return ApifyClientAsync(
-            token=token,
-            api_url=api_url,
-            max_retries=max_retries,
-            min_delay_between_retries_millis=int(min_delay_between_retries.total_seconds() * 1000)
-            if min_delay_between_retries is not None
-            else None,
-            timeout_secs=int(timeout.total_seconds()) if timeout else None,
-        )
+        # Forward only the explicitly provided options; omitting the rest lets `ApifyClientAsync` apply its
+        # own defaults, so the SDK doesn't have to import and re-pass the client's private default constants.
+        client_kwargs: dict[str, Any] = {
+            'token': token or self.configuration.token,
+            'api_url': api_url or self.configuration.api_base_url,
+        }
+        if max_retries is not None:
+            client_kwargs['max_retries'] = max_retries
+        if min_delay_between_retries is not None:
+            client_kwargs['min_delay_between_retries'] = min_delay_between_retries
+        if timeout is not None:
+            # `apify-client` v3 splits the timeout into four tiers; scale them from the single baseline,
+            # mirroring the client's default ratios (medium = baseline, short = baseline / 6,
+            # long = max = baseline * 12).
+            client_kwargs['timeout_short'] = timeout / 6
+            client_kwargs['timeout_medium'] = timeout
+            client_kwargs['timeout_long'] = timeout * 12
+            client_kwargs['timeout_max'] = timeout * 12
+
+        return ApifyClientAsync(**client_kwargs)
 
     @_ensure_context
     async def open_dataset(
@@ -870,7 +883,7 @@ class _ActorType:
         force_permission_level: ActorPermissionLevel | None = None,
         wait_for_finish: int | None = None,
         webhooks: list[Webhook] | None = None,
-    ) -> ActorRun:
+    ) -> Run:
         """Run an Actor on the Apify platform.
 
         Unlike `Actor.call`, this method just starts the run without waiting for finish.
@@ -903,13 +916,6 @@ class _ActorType:
         """
         client = self.new_client(token=token) if token else self.apify_client
 
-        if webhooks:
-            serialized_webhooks = [
-                hook.model_dump(by_alias=True, exclude_unset=True, exclude_defaults=True) for hook in webhooks
-            ]
-        else:
-            serialized_webhooks = None
-
         if timeout == 'inherit':
             actor_start_timeout = self._get_remaining_time()
         elif timeout is None:
@@ -919,21 +925,20 @@ class _ActorType:
         else:
             raise ValueError(f'Invalid timeout {timeout!r}: expected `None`, `"inherit"`, or a `timedelta`.')
 
-        api_result = await client.actor(actor_id).start(
+        actor_client = client.actor(actor_id)
+        return await actor_client.start(
             run_input=run_input,
             content_type=content_type,
             build=build,
             max_total_charge_usd=max_total_charge_usd,
             restart_on_error=restart_on_error,
             memory_mbytes=memory_mbytes,
-            timeout_secs=int(actor_start_timeout.total_seconds()) if actor_start_timeout is not None else None,
+            run_timeout=actor_start_timeout,
             force_permission_level=force_permission_level,
             wait_for_finish=wait_for_finish,
-            webhooks=serialized_webhooks,
+            webhooks=to_client_representations(webhooks),
         )
 
-        return ActorRun.model_validate(api_result)
-
     @_ensure_context
     async def abort(
         self,
@@ -942,7 +947,7 @@ class _ActorType:
         token: str | None = None,
         status_message: str | None = None,
         gracefully: bool | None = None,
-    ) -> ActorRun:
+    ) -> Run:
         """Abort given Actor run on the Apify platform using the current user account.
 
         The user account is determined by the `APIFY_TOKEN` environment variable.
@@ -959,13 +964,17 @@ class _ActorType:
             Info about the aborted Actor run.
         """
         client = self.new_client(token=token) if token else self.apify_client
+        run_client = client.run(run_id)
 
         if status_message:
-            await client.run(run_id).update(status_message=status_message)
+            await run_client.update(status_message=status_message)
+
+        run = await run_client.abort(gracefully=gracefully)
 
-        api_result = await client.run(run_id).abort(gracefully=gracefully)
+        if run is None:
+            raise RuntimeError(f'Failed to abort Actor run with ID "{run_id}".')
 
-        return ActorRun.model_validate(api_result)
+        return run
 
     @_ensure_context
     async def call(
@@ -984,7 +993,7 @@ class _ActorType:
         webhooks: list[Webhook] | None = None,
         wait: timedelta | None = None,
         logger: logging.Logger | None | Literal['default'] = 'default',
-    ) -> ActorRun | None:
+    ) -> Run:
         """Start an Actor on the Apify Platform and wait for it to finish before returning.
 
         It waits indefinitely, unless the wait argument is provided.
@@ -1020,13 +1029,6 @@ class _ActorType:
         """
         client = self.new_client(token=token) if token else self.apify_client
 
-        if webhooks:
-            serialized_webhooks = [
-                hook.model_dump(by_alias=True, exclude_unset=True, exclude_defaults=True) for hook in webhooks
-            ]
-        else:
-            serialized_webhooks = None
-
         if timeout == 'inherit':
             actor_call_timeout = self._get_remaining_time()
         elif timeout is None:
@@ -1036,21 +1038,25 @@ class _ActorType:
         else:
             raise ValueError(f'Invalid timeout {timeout!r}: expected `None`, `"inherit"`, or a `timedelta`.')
 
-        api_result = await client.actor(actor_id).call(
+        actor_client = client.actor(actor_id)
+        run = await actor_client.call(
             run_input=run_input,
             content_type=content_type,
             build=build,
             max_total_charge_usd=max_total_charge_usd,
             restart_on_error=restart_on_error,
             memory_mbytes=memory_mbytes,
-            timeout_secs=int(actor_call_timeout.total_seconds()) if actor_call_timeout is not None else None,
+            run_timeout=actor_call_timeout,
             force_permission_level=force_permission_level,
-            webhooks=serialized_webhooks,
-            wait_secs=int(wait.total_seconds()) if wait is not None else None,
+            webhooks=to_client_representations(webhooks),
+            wait_duration=wait,
             logger=logger,
         )
 
-        return ActorRun.model_validate(api_result)
+        if run is None:
+            raise RuntimeError(f'Failed to call Actor with ID "{actor_id}".')
+
+        return run
 
     @_ensure_context
     async def call_task(
@@ -1065,7 +1071,7 @@ class _ActorType:
         webhooks: list[Webhook] | None = None,
         wait: timedelta | None = None,
         token: str | None = None,
-    ) -> ActorRun | None:
+    ) -> Run:
         """Start an Actor task on the Apify Platform and wait for it to finish before returning.
 
         It waits indefinitely, unless the wait argument is provided.
@@ -1098,13 +1104,6 @@ class _ActorType:
         """
         client = self.new_client(token=token) if token else self.apify_client
 
-        if webhooks:
-            serialized_webhooks = [
-                hook.model_dump(by_alias=True, exclude_unset=True, exclude_defaults=True) for hook in webhooks
-            ]
-        else:
-            serialized_webhooks = None
-
         if timeout == 'inherit':
             task_call_timeout = self._get_remaining_time()
         elif timeout is None:
@@ -1114,17 +1113,21 @@ class _ActorType:
         else:
             raise ValueError(f'Invalid timeout {timeout!r}: expected `None`, `"inherit"`, or a `timedelta`.')
 
-        api_result = await client.task(task_id).call(
+        task_client = client.task(task_id)
+        run = await task_client.call(
             task_input=task_input,
             build=build,
             restart_on_error=restart_on_error,
             memory_mbytes=memory_mbytes,
-            timeout_secs=int(task_call_timeout.total_seconds()) if task_call_timeout is not None else None,
-            webhooks=serialized_webhooks,
-            wait_secs=int(wait.total_seconds()) if wait is not None else None,
+            run_timeout=task_call_timeout,
+            webhooks=to_client_representations(webhooks),
+            wait_duration=wait,
         )
 
-        return ActorRun.model_validate(api_result)
+        if run is None:
+            raise RuntimeError(f'Failed to call Task with ID "{task_id}".')
+
+        return run
 
     @_ensure_context
     async def metamorph(
@@ -1238,14 +1241,7 @@ class _ActorType:
             await asyncio.sleep(custom_after_sleep.total_seconds())
 
     @_ensure_context
-    async def add_webhook(
-        self,
-        webhook: Webhook,
-        *,
-        ignore_ssl_errors: bool | None = None,
-        do_not_retry: bool | None = None,
-        idempotency_key: str | None = None,
-    ) -> None:
+    async def add_webhook(self, webhook: Webhook, *, idempotency_key: str | None = None) -> None:
         """Create an ad-hoc webhook for the current Actor run.
 
         This webhook lets you receive a notification when the Actor run finished or failed.
@@ -1256,15 +1252,18 @@ class _ActorType:
         For more information about Apify Actor webhooks, please see the [documentation](https://docs.apify.com/webhooks).
 
         Args:
-            webhook: The webhook to be added
-            ignore_ssl_errors: Whether the webhook should ignore SSL errors returned by request_url
-            do_not_retry: Whether the webhook should retry sending the payload to request_url upon failure.
-            idempotency_key: A unique identifier of a webhook. You can use it to ensure that you won't create
-                the same webhook multiple times.
-
-        Returns:
-            The created webhook.
+            webhook: The webhook to be added. It is automatically bound to the current Actor run.
+            idempotency_key: Deprecated. Pass `idempotency_key` on the `Webhook` instance instead.
+                Will be removed in version 5.0.0.
         """
+        if idempotency_key is not None:
+            warnings.warn(
+                'Passing `idempotency_key` to `Actor.add_webhook()` is deprecated and will be removed in version '
+                '5.0.0. Set it on the `Webhook` instance instead.',
+                DeprecationWarning,
+                stacklevel=2,
+            )
+
         if not self.is_at_home():
             self.log.error('Actor.add_webhook() is only supported when running on the Apify platform.')
             return
@@ -1278,9 +1277,11 @@ class _ActorType:
             event_types=webhook.event_types,
             request_url=webhook.request_url,
             payload_template=webhook.payload_template,
-            ignore_ssl_errors=ignore_ssl_errors,
-            do_not_retry=do_not_retry,
-            idempotency_key=idempotency_key,
+            headers_template=webhook.headers_template,
+            ignore_ssl_errors=webhook.ignore_ssl_errors,
+            do_not_retry=webhook.do_not_retry,
+            idempotency_key=idempotency_key if idempotency_key is not None else webhook.idempotency_key,
+            is_ad_hoc=True,
         )
 
     @_ensure_context
@@ -1289,7 +1290,7 @@ class _ActorType:
         status_message: str,
         *,
         is_terminal: bool | None = None,
-    ) -> ActorRun | None:
+    ) -> Run | None:
         """Set the status message for the current Actor run.
 
         Args:
@@ -1308,11 +1309,18 @@ class _ActorType:
         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.configuration.actor_run_id).update(
-            status_message=status_message, is_status_message_terminal=is_terminal
+        run_client = self.apify_client.run(self.configuration.actor_run_id)
+        run = await run_client.update(
+            status_message=status_message,
+            is_status_message_terminal=is_terminal,
         )
 
-        return ActorRun.model_validate(api_result)
+        if run is None:
+            raise RuntimeError(
+                f'Failed to set status message for Actor run with ID "{self.configuration.actor_run_id}".'
+            )
+
+        return run
 
     @_ensure_context
     async def create_proxy_configuration(

{apify-3.4.2b3 → apify-3.4.2b4}/src/apify/_charging.py

@@ -5,18 +5,18 @@ from contextvars import ContextVar
 from dataclasses import dataclass
 from datetime import UTC, datetime
 from decimal import Decimal
-from typing import TYPE_CHECKING, Protocol, TypedDict
+from typing import TYPE_CHECKING, Annotated, Literal, Protocol, TypedDict
 
-from pydantic import TypeAdapter
+from pydantic import BaseModel, ConfigDict, Field
+
+import apify_client._models as _client_models
+from apify_client._models import ActorChargeEvent as ClientActorChargeEvent
+from apify_client._models import FlatPricePerMonthActorPricingInfo as ClientFlatPricePerMonth
+from apify_client._models import FreeActorPricingInfo as ClientFree
+from apify_client._models import PayPerEventActorPricingInfo as ClientPayPerEvent
+from apify_client._models import PricePerDatasetItemActorPricingInfo as ClientPricePerDatasetItem
+from apify_client._models import PricingPerEvent as ClientPricingPerEvent
 
-from apify._models import (
-    ActorRun,
-    FlatPricePerMonthActorPricingInfo,
-    FreeActorPricingInfo,
-    PayPerEventActorPricingInfo,
-    PricePerDatasetItemActorPricingInfo,
-    PricingModel,
-)
 from apify._utils import ReentrantLock, docs_group, ensure_context
 from apify.log import logger
 from apify.storages import Dataset
@@ -28,7 +28,8 @@ if TYPE_CHECKING:
 
     from apify._configuration import Configuration
 
-run_validator = TypeAdapter[ActorRun | None](ActorRun | None)
+PricingModel = Literal['PAY_PER_EVENT', 'PRICE_PER_DATASET_ITEM', 'FLAT_PRICE_PER_MONTH', 'FREE']
+"""Pricing model for an Actor."""
 
 DEFAULT_DATASET_ITEM_EVENT = 'apify-default-dataset-item'
 
@@ -39,6 +40,80 @@ charging_manager_ctx: ContextVar[ChargingManager | None] = ContextVar('charging_
 _ensure_context = ensure_context('active')
 
 
+# These are thin subclasses of the `apify-client` pricing models. The Apify platform serializes Actor
+# pricing info into the `APIFY_ACTOR_PRICING_INFO` env var (parsed by `Configuration.actor_pricing_info`),
+# but omits several fields that `apify-client` v3 marks as required (`apifyMarginPercentage`, `createdAt`,
+# `startedAt`, per-event `eventDescription`, and per-variant `trialMinutes` / `pricePerUnitUsd` / `unitName`).
+# Each subclass relaxes only those omitted fields to optional, so the env var deserializes without faking
+# values. Because every subclass is-a `apify-client` model, the API-returned `Run.pricing_info` (already an
+# `apify-client` instance) flows through the same code paths without conversion.
+
+
+class _RelaxedPricingMetadata(BaseModel):
+    """Mixin relaxing the `CommonActorPricingInfo` metadata fields the platform env var omits."""
+
+    model_config = ConfigDict(populate_by_name=True, extra='allow')
+
+    apify_margin_percentage: Annotated[float | None, Field(alias='apifyMarginPercentage')] = None
+    created_at: Annotated[datetime | None, Field(alias='createdAt')] = None
+    started_at: Annotated[datetime | None, Field(alias='startedAt')] = None
+
+
+@docs_group('Charging')
+class ActorChargeEvent(ClientActorChargeEvent):
+    # `event_description` is required in apify-client but omitted from the env var.
+    event_description: Annotated[str | None, Field(alias='eventDescription')] = None
+
+
+@docs_group('Charging')
+class PricingPerEvent(ClientPricingPerEvent):
+    actor_charge_events: Annotated[dict[str, ActorChargeEvent] | None, Field(alias='actorChargeEvents')] = None
+
+
+@docs_group('Charging')
+class FreeActorPricingInfo(_RelaxedPricingMetadata, ClientFree):
+    pass
+
+
+@docs_group('Charging')
+class FlatPricePerMonthActorPricingInfo(_RelaxedPricingMetadata, ClientFlatPricePerMonth):
+    trial_minutes: Annotated[int | None, Field(alias='trialMinutes')] = None
+    price_per_unit_usd: Annotated[float | None, Field(alias='pricePerUnitUsd')] = None
+
+
+@docs_group('Charging')
+class PricePerDatasetItemActorPricingInfo(_RelaxedPricingMetadata, ClientPricePerDatasetItem):
+    unit_name: Annotated[str | None, Field(alias='unitName')] = None
+    # `price_per_unit_usd` is already optional in apify-client - inherited.
+
+
+@docs_group('Charging')
+class PayPerEventActorPricingInfo(_RelaxedPricingMetadata, ClientPayPerEvent):
+    # Re-typed to the relaxed element so an omitted `eventDescription` validates; the field stays required.
+    pricing_per_event: Annotated[PricingPerEvent, Field(alias='pricingPerEvent')]
+
+
+ActorPricingInfoModel = ClientFree | ClientFlatPricePerMonth | ClientPricePerDatasetItem | ClientPayPerEvent
+"""Common supertype of both env-var-parsed SDK subclasses and the API-returned `Run.pricing_info`."""
+
+# apify-client ships these models with deferred forward refs (`__pydantic_complete__` is False), so the
+# subclasses must be rebuilt - with the `TieredPricing*` names in scope - before the env-var discriminated
+# union can validate standalone.
+_pricing_rebuild_namespace = vars(_client_models) | {
+    'ActorChargeEvent': ActorChargeEvent,
+    'PricingPerEvent': PricingPerEvent,
+}
+for _pricing_model in (
+    ActorChargeEvent,
+    PricingPerEvent,
+    FreeActorPricingInfo,
+    FlatPricePerMonthActorPricingInfo,
+    PricePerDatasetItemActorPricingInfo,
+    PayPerEventActorPricingInfo,
+):
+    _pricing_model.model_rebuild(_types_namespace=_pricing_rebuild_namespace)
+
+
 @docs_group('Charging')
 class ChargingManager(Protocol):
     """Provides fine-grained access to pay-per-event functionality.
@@ -173,6 +248,7 @@ class ChargingManagerImplementation(ChargingManager):
 
         self._charging_state: dict[str, ChargingStateItem] = {}
         self._pricing_info: dict[str, PricingInfoItem] = {}
+        self._tier_priced_events: set[str] = set()
 
         self._not_ppe_warning_printed = False
         self.active = False
@@ -202,10 +278,16 @@ class ChargingManagerImplementation(ChargingManager):
         else:
             self._pricing_model = pricing_info.pricing_model if pricing_info else None
 
-        # Load per-event pricing information
-        if pricing_info is not None and isinstance(pricing_info, PayPerEventActorPricingInfo):
+        # Load per-event pricing information. Check against the apify-client base so both env-var-parsed
+        # SDK subclasses and the API-returned model match.
+        if isinstance(pricing_info, ClientPayPerEvent):
             actor_charge_events = pricing_info.pricing_per_event.actor_charge_events or {}
             for event_name, event_pricing in actor_charge_events.items():
+                if event_pricing.event_price_usd is None:
+                    # Tier-priced event - not chargeable via the SDK's flat-price path; tracked so a later
+                    # charge attempt is reported accurately rather than as an "unknown event".
+                    self._tier_priced_events.add(event_name)
+                    continue
                 self._pricing_info[event_name] = PricingInfoItem(
                     price=Decimal(str(event_pricing.event_price_usd)),
                     title=event_pricing.event_title,
@@ -309,6 +391,10 @@ class ChargingManagerImplementation(ChargingManager):
                     pass
                 elif event_name in self._pricing_info:
                     await self._client.run(self._actor_run_id).charge(event_name, count=charged_count)
+                elif event_name in self._tier_priced_events:
+                    logger.warning(
+                        f"Event '{event_name}' is tier-priced and is not chargeable via the pay-per-event API."
+                    )
                 else:
                     logger.warning(f"Attempting to charge for an unknown event '{event_name}'")
 
@@ -427,7 +513,8 @@ class ChargingManagerImplementation(ChargingManager):
             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())
+            run = await self._client.run(self._actor_run_id).get()
+
             if run is None:
                 raise RuntimeError('Actor run not found')
 
@@ -469,12 +556,6 @@ class PricingInfoItem:
 
 
 class _FetchedPricingInfoDict(TypedDict):
-    pricing_info: (
-        FreeActorPricingInfo
-        | FlatPricePerMonthActorPricingInfo
-        | PricePerDatasetItemActorPricingInfo
-        | PayPerEventActorPricingInfo
-        | None
-    )
+    pricing_info: ActorPricingInfoModel | None
     charged_event_counts: dict[str, int]
     max_total_charge_usd: Decimal

{apify-3.4.2b3 → apify-3.4.2b4}/src/apify/_configuration.py

@@ -15,7 +15,7 @@ from crawlee._utils.models import timedelta_ms
 from crawlee._utils.urls import validate_http_url
 from crawlee.configuration import Configuration as CrawleeConfiguration
 
-from apify._models import (
+from apify._charging import (
     FlatPricePerMonthActorPricingInfo,
     FreeActorPricingInfo,
     PayPerEventActorPricingInfo,
@@ -71,6 +71,21 @@ def _load_storage_keys(data: None | str | ActorStorages) -> ActorStorages | None
     }
 
 
+def _parse_actor_pricing_info(data: Any) -> Any:
+    """Parse the raw `APIFY_ACTOR_PRICING_INFO` env var value into a pydantic-friendly form.
+
+    Deserializes a JSON string when needed. Treats `None`, an empty string, and an empty/
+    discriminator-less JSON object (`{}` - the value the platform sets for Actors without a configured
+    pricing model) as "no pricing info" so the union validator doesn't fail on a missing discriminator.
+    """
+    if data is None or data == '':
+        return None
+    pricing_info = json.loads(data) if isinstance(data, str) else data
+    if isinstance(pricing_info, dict) and not (pricing_info.get('pricingModel') or pricing_info.get('pricing_model')):
+        return None
+    return pricing_info
+
+
 @docs_group('Configuration')
 class Configuration(CrawleeConfiguration):
     """A class for specifying the configuration of an Actor.
@@ -446,7 +461,7 @@ class Configuration(CrawleeConfiguration):
             description='JSON string with prising info of the actor',
             discriminator='pricing_model',
         ),
-        BeforeValidator(lambda data: json.loads(data) if isinstance(data, str) else data or None),
+        BeforeValidator(_parse_actor_pricing_info),
     ] = None
 
     charged_event_counts: Annotated[