Draft

Author: Pijukatel

src/apify/_actor.py

@@ -4,7 +4,7 @@
 import os
 import sys
 from contextlib import suppress
-from datetime import timedelta
+from datetime import datetime, timedelta, timezone
 from typing import TYPE_CHECKING, Any, Callable, Literal, TypeVar, cast, overload
 
 from lazy_object_proxy import Proxy
@@ -734,9 +734,11 @@ async def start(
             serialized_webhooks = None
 
         if timeout == 'RemainingTime':
-            actor_start_timeout = await self._get_remaining_time(client)
+            actor_start_timeout = await self._get_remaining_time()
         elif isinstance(timeout, str):
-            raise ValueError(f'`timeout` can be `None`, `RemainingTime` or `timedelta` instance, but is {timeout=}')
+            raise ValueError(
+                f'`timeout` can be `None`, `RemainingTime` literal or `timedelta` instance, but is {timeout=}'
+            )
         else:
             actor_start_timeout = timeout
 
@@ -752,14 +754,10 @@ async def start(
 
         return ActorRun.model_validate(api_result)
 
-    async def _get_remaining_time(self, client: ApifyClientAsync) -> timedelta | None:
-        """Get time remaining from the actor timeout. Returns `None` if not on Apify platform."""
-        if self.is_at_home() and self.configuration.actor_run_id:
-            run_data = await client.run(self.configuration.actor_run_id).get()
-            if run_data is not None and (timeout := run_data.get('options', {}).get('timeoutSecs', None)):
-                runtime = timedelta(seconds=run_data.get('runTimeSecs', None))
-                remaining_time = timeout - runtime
-            return timedelta(seconds=remaining_time)
+    async def _get_remaining_time(self) -> timedelta | None:
+        """Get time remaining from the actor timeout. Returns `None` if not on an Apify platform."""
+        if self.is_at_home() and self.configuration.timeout_at:
+            return self.configuration.timeout_at - datetime.now(tz=timezone.utc)
 
         self.log.warning('Using `RemainingTime` argument for timeout outside of the Apify platform. Returning `None`')
         return None
@@ -848,9 +846,11 @@ async def call(
             serialized_webhooks = None
 
         if timeout == 'RemainingTime':
-            actor_call_timeout = await self._get_remaining_time(client)
+            actor_call_timeout = await self._get_remaining_time()
         elif isinstance(timeout, str):
-            raise ValueError(f'`timeout` can be `None`, `RemainingTime` or `timedelta` instance, but is {timeout=}')
+            raise ValueError(
+                f'`timeout` can be `None`, `RemainingTime` literal or `timedelta` instance, but is {timeout=}'
+            )
         else:
             actor_call_timeout = timeout
 

tests/integration/conftest.py

@@ -30,7 +30,7 @@
 _TOKEN_ENV_VAR = 'APIFY_TEST_USER_API_TOKEN'
 _API_URL_ENV_VAR = 'APIFY_INTEGRATION_TESTS_API_URL'
 _SDK_ROOT_PATH = Path(__file__).parent.parent.parent.resolve()
-_DEFAULT_TEST_TIMEOUT = 600
+
 
 @pytest.fixture
 def prepare_test_env(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> Callable[[], None]:
@@ -315,7 +315,7 @@ async def _make_actor(
             name=actor_name,
             default_run_build='latest',
             default_run_memory_mbytes=256,
-            default_run_timeout_secs=_DEFAULT_TEST_TIMEOUT,
+            default_run_timeout_secs=600,
             versions=[
                 {
                     'versionNumber': '0.0',
@@ -331,7 +331,7 @@ async def _make_actor(
         print(f'Building Actor {actor_name}...')
         build_result = await actor_client.build(version_number='0.0')
         build_client = client.build(build_result['id'])
-        build_client_result = await build_client.wait_for_finish(wait_secs=_DEFAULT_TEST_TIMEOUT)
+        build_client_result = await build_client.wait_for_finish(wait_secs=600)
 
         assert build_client_result is not None
         assert build_client_result['status'] == ActorJobStatus.SUCCEEDED
@@ -408,7 +408,7 @@ async def _run_actor(
 
         client = ApifyClientAsync(token=apify_token, api_url=os.getenv(_API_URL_ENV_VAR))
         run_client = client.run(call_result['id'])
-        run_result = await run_client.wait_for_finish(wait_secs=_DEFAULT_TEST_TIMEOUT)
+        run_result = await run_client.wait_for_finish(wait_secs=600)
 
         return ActorRun.model_validate(run_result)
 

tests/integration/test_actor_call.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+import asyncio
+from typing import TYPE_CHECKING
+
+from apify import Actor
+
+if TYPE_CHECKING:
+    from .conftest import MakeActorFunction, RunActorFunction
+
+
+async def test_actor_start_remaining_timeout(
+    make_actor: MakeActorFunction,
+    run_actor: RunActorFunction,
+) -> None:
+    async def main() -> None:
+        from datetime import datetime, timezone
+
+        async with Actor:
+            actor_input = (await Actor.get_input()) or {}
+            if actor_input.get('called_from_another_actor', False) is True:
+                return
+
+            await asyncio.sleep(1)
+            # Start another run of this actor with timeout set to the time remaining in this actor run
+            other_run_data = await Actor.start(
+                actor_id=Actor.configuration.actor_id or '',
+                run_input={'called_from_another_actor': True},
+                timeout='RemainingTime',
+            )
+
+            # To make sure that the actor is started
+            await asyncio.sleep(5)
+
+            assert Actor.configuration.timeout_at is not None
+            assert Actor.configuration.started_at is not None
+            assert other_run_data is not None
+            assert other_run_data.options is not None
+
+            remaining_time_after_actor_start = Actor.configuration.timeout_at - datetime.now(tz=timezone.utc)
+
+            try:
+                assert other_run_data.options.timeout > remaining_time_after_actor_start
+                assert other_run_data.options.timeout < Actor.configuration.timeout_at - Actor.configuration.started_at
+            finally:
+                # Abort the other actor run after asserting the timeouts
+                await Actor.apify_client.run(other_run_data.id).abort()
+
+    actor = await make_actor(label='remaining-timeout', main_func=main)
+    run_result = await run_actor(actor)
+
+    assert run_result.status == 'SUCCEEDED'
+
+
+async def test_actor_call_remaining_timeout(
+    make_actor: MakeActorFunction,
+    run_actor: RunActorFunction,
+) -> None:
+    async def main() -> None:
+        from datetime import datetime, timezone
+
+        async with Actor:
+            actor_input = (await Actor.get_input()) or {}
+            if actor_input.get('called_from_another_actor', False) is True:
+                return
+
+            await asyncio.sleep(1)
+            # Start another run of this actor with timeout set to the time remaining in this actor run
+            other_run_data = await Actor.call(
+                actor_id=Actor.configuration.actor_id or '',
+                run_input={'called_from_another_actor': True},
+                timeout='RemainingTime',
+            )
+
+            # To make sure that the actor is started
+            await asyncio.sleep(5)
+
+            assert Actor.configuration.timeout_at is not None
+            assert Actor.configuration.started_at is not None
+            assert other_run_data is not None
+            assert other_run_data.options is not None
+
+            remaining_time_after_actor_start = Actor.configuration.timeout_at - datetime.now(tz=timezone.utc)
+
+            try:
+                assert other_run_data.options.timeout > remaining_time_after_actor_start
+                assert other_run_data.options.timeout < Actor.configuration.timeout_at - Actor.configuration.started_at
+            finally:
+                # Abort the other actor run after asserting the timeouts
+                await Actor.apify_client.run(other_run_data.id).abort()
+
+    actor = await make_actor(label='remaining-timeout', main_func=main)
+    run_result = await run_actor(actor)
+
+    assert run_result.status == 'SUCCEEDED'