Fixes

Author: vdusek

src/apify/_actor.py

@@ -885,7 +885,8 @@ async def start(
                 f'Invalid timeout {timeout!r}: expected `None`, `"inherit"`, `"RemainingTime"`, or a `timedelta`.'
             )
 
-        api_result = await client.actor(actor_id).start(
+        actor_client = client.actor(actor_id)
+        run = await actor_client.start(
             run_input=run_input,
             content_type=content_type,
             build=build,
@@ -895,7 +896,11 @@ async def start(
             webhooks=serialized_webhooks,
         )
 
-        return ActorRun.model_validate(api_result)
+        if run is None:
+            raise RuntimeError(f'Failed to start Actor with ID "{actor_id}".')
+
+        run_dict = run.model_dump(by_alias=True)
+        return ActorRun.model_validate(run_dict)
 
     async def abort(
         self,
@@ -923,13 +928,18 @@ async def abort(
         self._raise_if_not_initialized()
 
         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)
+        run_dict = run.model_dump(by_alias=True)
+        return ActorRun.model_validate(run_dict)
 
     async def call(
         self,
@@ -1002,7 +1012,8 @@ async def call(
                 f'Invalid timeout {timeout!r}: expected `None`, `"inherit"`, `"RemainingTime"`, 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,
@@ -1013,7 +1024,11 @@ async def call(
             logger=logger,
         )
 
-        return ActorRun.model_validate(api_result)
+        if run is None:
+            raise RuntimeError(f'Failed to call Actor with ID "{actor_id}".')
+
+        run_dict = run.model_dump(by_alias=True)
+        return ActorRun.model_validate(run_dict)
 
     async def call_task(
         self,
@@ -1075,7 +1090,8 @@ async def call_task(
         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,
             memory_mbytes=memory_mbytes,
@@ -1084,7 +1100,11 @@ async def call_task(
             wait_secs=int(wait.total_seconds()) if wait is not None else None,
         )
 
-        return ActorRun.model_validate(api_result)
+        if run is None:
+            raise RuntimeError(f'Failed to call Task with ID "{task_id}".')
+
+        run_dict = run.model_dump(by_alias=True)
+        return ActorRun.model_validate(run_dict)
 
     async def metamorph(
         self,
@@ -1261,11 +1281,19 @@ async def set_status_message(
         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}".'
+            )
+
+        run_dict = run.model_dump(by_alias=True)
+        return ActorRun.model_validate(run_dict)
 
     async def create_proxy_configuration(
         self,

src/apify/_models.py

@@ -94,32 +94,82 @@ class ActorRunUsage(BaseModel):
 
 @docs_group('Actor')
 class ActorRun(BaseModel):
+    """Represents an Actor run and its associated data."""
+
     __model_config__ = ConfigDict(populate_by_name=True)
 
     id: Annotated[str, Field(alias='id')]
+    """Unique identifier of the Actor run."""
+
     act_id: Annotated[str, Field(alias='actId')]
+    """ID of the Actor that was run."""
+
     user_id: Annotated[str, Field(alias='userId')]
+    """ID of the user who started the run."""
+
     actor_task_id: Annotated[str | None, Field(alias='actorTaskId')] = None
+    """ID of the Actor task, if the run was started from a task."""
+
     started_at: Annotated[datetime, Field(alias='startedAt')]
+    """Time when the Actor run started."""
+
     finished_at: Annotated[datetime | None, Field(alias='finishedAt')] = None
+    """Time when the Actor run finished."""
+
     status: Annotated[ActorJobStatus, Field(alias='status')]
+    """Current status of the Actor run."""
+
     status_message: Annotated[str | None, Field(alias='statusMessage')] = None
+    """Detailed message about the run status."""
+
     is_status_message_terminal: Annotated[bool | None, Field(alias='isStatusMessageTerminal')] = None
+    """Whether the status message is terminal (final)."""
+
     meta: Annotated[ActorRunMeta, Field(alias='meta')]
+    """Metadata about the Actor run."""
+
     stats: Annotated[ActorRunStats, Field(alias='stats')]
+    """Statistics of the Actor run."""
+
     options: Annotated[ActorRunOptions, Field(alias='options')]
+    """Configuration options for the Actor run."""
+
     build_id: Annotated[str, Field(alias='buildId')]
+    """ID of the Actor build used for this run."""
+
     exit_code: Annotated[int | None, Field(alias='exitCode')] = None
+    """Exit code of the Actor run process."""
+
     default_key_value_store_id: Annotated[str, Field(alias='defaultKeyValueStoreId')]
+    """ID of the default key-value store for this run."""
+
     default_dataset_id: Annotated[str, Field(alias='defaultDatasetId')]
+    """ID of the default dataset for this run."""
+
     default_request_queue_id: Annotated[str, Field(alias='defaultRequestQueueId')]
+    """ID of the default request queue for this run."""
+
     build_number: Annotated[str | None, Field(alias='buildNumber')] = None
+    """Build number of the Actor build used for this run."""
+
     container_url: Annotated[str, Field(alias='containerUrl')]
+    """URL of the container running the Actor."""
+
     is_container_server_ready: Annotated[bool | None, Field(alias='isContainerServerReady')] = None
+    """Whether the container's HTTP server is ready to accept requests."""
+
     git_branch_name: Annotated[str | None, Field(alias='gitBranchName')] = None
+    """Name of the git branch used for the Actor build."""
+
     usage: Annotated[ActorRunUsage | None, Field(alias='usage')] = None
+    """Resource usage statistics for the run."""
+
     usage_total_usd: Annotated[float | None, Field(alias='usageTotalUsd')] = None
+    """Total cost of the run in USD."""
+
     usage_usd: Annotated[ActorRunUsage | None, Field(alias='usageUsd')] = None
+    """Resource usage costs in USD."""
+
     pricing_info: Annotated[
         FreeActorPricingInfo
         | FlatPricePerMonthActorPricingInfo
@@ -128,10 +178,13 @@ class ActorRun(BaseModel):
         | None,
         Field(alias='pricingInfo', discriminator='pricing_model'),
     ] = None
+    """Pricing information for the Actor."""
+
     charged_event_counts: Annotated[
         dict[str, int] | None,
         Field(alias='chargedEventCounts'),
     ] = None
+    """Count of charged events for pay-per-event pricing model."""
 
 
 class FreeActorPricingInfo(BaseModel):

tests/integration/actor/test_actor_api_helpers.py

@@ -135,7 +135,10 @@ async def main_outer() -> None:
     inner_actor = await make_actor(label='start-inner', main_func=main_inner)
     outer_actor = await make_actor(label='start-outer', main_func=main_outer)
 
-    inner_actor_id = (await inner_actor.get() or {})['id']
+    inner_actor_get_result = await inner_actor.get()
+    assert inner_actor_get_result is not None, 'Failed to get inner actor ID'
+
+    inner_actor_id = inner_actor_get_result.id
     test_value = crypto_random_object_id()
 
     run_result_outer = await run_actor(
@@ -180,7 +183,10 @@ async def main_outer() -> None:
     inner_actor = await make_actor(label='call-inner', main_func=main_inner)
     outer_actor = await make_actor(label='call-outer', main_func=main_outer)
 
-    inner_actor_id = (await inner_actor.get() or {})['id']
+    inner_actor_get_result = await inner_actor.get()
+    assert inner_actor_get_result is not None, 'Failed to get inner actor ID'
+
+    inner_actor_id = inner_actor_get_result.id
     test_value = crypto_random_object_id()
 
     run_result_outer = await run_actor(
@@ -226,7 +232,10 @@ async def main_outer() -> None:
     inner_actor = await make_actor(label='call-task-inner', main_func=main_inner)
     outer_actor = await make_actor(label='call-task-outer', main_func=main_outer)
 
-    inner_actor_id = (await inner_actor.get() or {})['id']
+    inner_actor_get_result = await inner_actor.get()
+    assert inner_actor_get_result is not None, 'Failed to get inner actor ID'
+
+    inner_actor_id = inner_actor_get_result.id
     test_value = crypto_random_object_id()
 
     task = await apify_client_async.tasks().create(
@@ -332,7 +341,10 @@ async def main_outer() -> None:
     inner_actor = await make_actor(label='metamorph-inner', main_func=main_inner)
     outer_actor = await make_actor(label='metamorph-outer', main_func=main_outer)
 
-    inner_actor_id = (await inner_actor.get() or {})['id']
+    inner_actor_get_result = await inner_actor.get()
+    assert inner_actor_get_result is not None, 'Failed to get inner actor ID'
+
+    inner_actor_id = inner_actor_get_result.id
     test_value = crypto_random_object_id()
 
     run_result_outer = await run_actor(

tests/integration/actor/test_actor_charge.py

@@ -35,6 +35,7 @@ async def main() -> None:
     actor_client = await make_actor('ppe', main_func=main)
 
     await actor_client.update(
+        default_run_build='latest',
         pricing_infos=[
             {
                 'pricingModel': 'PAY_PER_EVENT',
@@ -48,7 +49,7 @@ async def main() -> None:
                     },
                 },
             },
-        ]
+        ],
     )
 
     actor = await actor_client.get()
@@ -82,8 +83,12 @@ async def test_actor_charge_basic(
     # Refetch until the platform gets its act together
     for is_last_attempt, _ in retry_counter(30):
         await asyncio.sleep(1)
+
         updated_run = await apify_client_async.run(run.id).get()
-        run = ActorRun.model_validate(updated_run)
+        assert updated_run is not None, 'Updated run should not be None'
+
+        updated_run_dict = updated_run.model_dump(by_alias=True)
+        run = ActorRun.model_validate(updated_run_dict)
 
         try:
             assert run.status == ActorJobStatus.SUCCEEDED
@@ -104,8 +109,12 @@ async def test_actor_charge_limit(
     # Refetch until the platform gets its act together
     for is_last_attempt, _ in retry_counter(30):
         await asyncio.sleep(1)
+
         updated_run = await apify_client_async.run(run.id).get()
-        run = ActorRun.model_validate(updated_run)
+        assert updated_run is not None, 'Updated run should not be None'
+
+        updated_run_dict = updated_run.model_dump(by_alias=True)
+        run = ActorRun.model_validate(updated_run_dict)
 
         try:
             assert run.status == ActorJobStatus.SUCCEEDED