tasktiger 0.26.1__tar.gz → 0.26.3__tar.gz

{tasktiger-0.26.1/tasktiger.egg-info → tasktiger-0.26.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tasktiger
-Version: 0.26.1
+Version: 0.26.3
 Summary: Python task queue
 Home-page: http://github.com/closeio/tasktiger
 License: MIT

{tasktiger-0.26.1 → tasktiger-0.26.3}/tasktiger/__init__.py

@@ -12,7 +12,7 @@ from .task import Task
 from .tasktiger import TaskTiger, run_worker
 from .worker import Worker
 
-__version__ = "0.26.1"
+__version__ = "0.26.3"
 __all__ = [
     "TaskTiger",
     "Worker",

{tasktiger-0.26.1 → tasktiger-0.26.3}/tasktiger/_internal.py

@@ -15,13 +15,13 @@ from typing import (
     Iterable,
     List,
     Optional,
-    Tuple,
     Type,
     TypedDict,
     Union,
 )
 
 from .exceptions import TaskImportError
+from .types import SerializedRetryStrategy
 
 if TYPE_CHECKING:
     from .task import Task
@@ -134,7 +134,7 @@ def reversed_dotted_parts(s: str) -> Iterable[str]:
         yield s[:idx]
 
 
-def serialize_retry_method(retry_method: Any) -> Tuple[str, Tuple]:
+def serialize_retry_method(retry_method: Any) -> SerializedRetryStrategy:
     if callable(retry_method):
         return (serialize_func_name(retry_method), ())
     else:

{tasktiger-0.26.1 → tasktiger-0.26.3}/tasktiger/schedule.py

@@ -1,5 +1,7 @@
 import datetime
-from typing import Callable, Optional, Tuple
+from typing import Optional
+
+from .types import ScheduleStrategy
 
 __all__ = ["periodic", "cron_expr"]
 
@@ -40,7 +42,7 @@ def periodic(
     weeks: int = 0,
     start_date: Optional[datetime.datetime] = None,
     end_date: Optional[datetime.datetime] = None,
-) -> Tuple[Callable[..., Optional[datetime.datetime]], Tuple]:
+) -> ScheduleStrategy:
     """
     Periodic task schedule: Use to schedule a task to run periodically,
     starting from start_date (or None to be active immediately) until end_date
@@ -94,7 +96,7 @@ def cron_expr(
     expr: str,
     start_date: Optional[datetime.datetime] = None,
     end_date: Optional[datetime.datetime] = None,
-) -> Tuple[Callable[..., Optional[datetime.datetime]], Tuple]:
+) -> ScheduleStrategy:
     """
     Periodic task schedule via cron expression: Use to schedule a task to run periodically,
     starting from start_date (or None to be active immediately) until end_date

{tasktiger-0.26.1 → tasktiger-0.26.3}/tasktiger/task.py

@@ -32,7 +32,7 @@ from ._internal import (
 )
 from .exceptions import QueueFullException, TaskImportError, TaskNotFound
 from .runner import BaseRunner, get_runner_class
-from .types import RetryStrategy
+from .types import RetryStrategy, SerializedRetryStrategy
 
 if TYPE_CHECKING:
     from . import TaskTiger
@@ -55,9 +55,7 @@ class Task:
         lock_key: Optional[Collection[str]] = None,
         retry: Optional[bool] = None,
         retry_on: Optional[Collection[Type[BaseException]]] = None,
-        retry_method: Optional[
-            Union[Callable[[int], float], Tuple[Callable[..., float], Tuple]]
-        ] = None,
+        retry_method: Optional[Union[Callable[[int], float], RetryStrategy]] = None,
         max_queue_size: Optional[int] = None,
         max_stored_executions: Optional[int] = None,
         runner_class: Optional[Type["BaseRunner"]] = None,
@@ -237,7 +235,7 @@ class Task:
         return self._data.get("unique_key")
 
     @property
-    def retry_method(self) -> Optional[RetryStrategy]:
+    def retry_method(self) -> Optional[SerializedRetryStrategy]:
         if "retry_method" in self._data:
             retry_func, retry_args = self._data["retry_method"]
             return retry_func, retry_args

{tasktiger-0.26.1 → tasktiger-0.26.3}/tasktiger/tasktiger.py

@@ -36,6 +36,7 @@ from .redis_semaphore import Semaphore
 from .retry import fixed
 from .runner import BaseRunner
 from .task import Task
+from .types import RetryStrategy, ScheduleStrategy
 from .worker import LOCK_REDIS_KEY, Worker
 
 __all__ = ["TaskTiger"]
@@ -312,10 +313,13 @@ class TaskTiger:
         lock_key: Optional[Collection[str]] = None,
         retry: Optional[bool] = None,
         retry_on: Optional[Collection[Type[BaseException]]] = None,
-        retry_method: Optional[
-            Union[Callable[[int], float], Tuple[Callable[..., float], Tuple]]
+        retry_method: Optional[Union[Callable[[int], float], RetryStrategy]] = None,
+        schedule: Optional[
+            Union[
+                Callable[[datetime.datetime], Optional[datetime.datetime]],
+                ScheduleStrategy,
+            ]
         ] = None,
-        schedule: Optional[Callable] = None,
         batch: bool = False,
         max_queue_size: Optional[int] = None,
         max_stored_executions: Optional[int] = None,
@@ -441,9 +445,7 @@ class TaskTiger:
         when: Optional[Union[datetime.datetime, datetime.timedelta]] = None,
         retry: Optional[bool] = None,
         retry_on: Optional[Collection[Type[BaseException]]] = None,
-        retry_method: Optional[
-            Union[Callable[[int], float], Tuple[Callable[..., float], Tuple]]
-        ] = None,
+        retry_method: Optional[Union[Callable[[int], float], RetryStrategy]] = None,
         max_queue_size: Optional[int] = None,
         max_stored_executions: Optional[int] = None,
         runner_class: Optional[Type["BaseRunner"]] = None,

tasktiger-0.26.3/tasktiger/types.py

@@ -0,0 +1,9 @@
+import datetime
+from typing import Any, Callable, Optional, Sequence, Tuple
+
+RetryStrategy = Tuple[Callable[..., float], Tuple[Any, ...]]
+ScheduleStrategy = Tuple[Callable[..., Optional[datetime.datetime]], Tuple[Any, ...]]
+
+# A retry strategy as stored with a task. The function is replaced with its
+# import path, and the arguments come back as a list after a JSON round trip.
+SerializedRetryStrategy = Tuple[str, Sequence[Any]]

{tasktiger-0.26.1 → tasktiger-0.26.3}/tasktiger/worker.py

@@ -4,7 +4,6 @@ import json
 import os
 import random
 import signal
-import sys
 import time
 import uuid
 from collections import OrderedDict
@@ -832,10 +831,13 @@ class Worker:
                     runner = runner_class(self.tiger)
                     runner.on_permanent_error(task, execution)
 
-            # Exit the process with an error code if a task timed out to
-            # prevent any inconsistent state in case the runner requires it.
+            # Force the process to exit after a task times out. A normal interpreter
+            # shutdown can wait indefinitely for threads started by the task.
             if self.executor.exit_worker_on_job_timeout and has_job_timeout:
-                sys.exit("exiting worker due to job timeout error")
+                try:
+                    os.write(2, b"exiting worker due to job timeout error\n")
+                finally:
+                    os._exit(1)
 
     def _worker_run(self) -> None:
         """

{tasktiger-0.26.1 → tasktiger-0.26.3/tasktiger.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tasktiger
-Version: 0.26.1
+Version: 0.26.3
 Summary: Python task queue
 Home-page: http://github.com/closeio/tasktiger
 License: MIT

{tasktiger-0.26.1 → tasktiger-0.26.3}/tests/tasks.py

@@ -1,4 +1,5 @@
 import json
+import threading
 import time
 from math import ceil
 
@@ -54,6 +55,15 @@ def long_task_killed():
     time.sleep(DELAY * 2)
 
 
+@tiger.task(hard_timeout=DELAY)
+def long_task_with_blocked_thread():
+    blocker = threading.Event()
+    # A non-daemon thread makes normal interpreter shutdown wait indefinitely.
+    thread = threading.Thread(target=blocker.wait, daemon=False)
+    thread.start()
+    time.sleep(DELAY * 2)
+
+
 @tiger.task(hard_timeout=DELAY * 2)
 def long_task_ok():
     # Signal task has started

{tasktiger-0.26.1 → tasktiger-0.26.3}/tests/test_workers.py

@@ -4,7 +4,6 @@ import datetime
 import time
 from multiprocessing import Process
 
-import pytest
 from freezefrog import FreezeTime
 
 from tasktiger import Task, Worker
@@ -15,8 +14,8 @@ from tasktiger.worker import LOCK_REDIS_KEY
 from .config import DELAY
 from .tasks import (
     exception_task,
-    long_task_killed,
     long_task_ok,
+    long_task_with_blocked_thread,
     simple_task,
     sleep_task,
     system_exit_task,
@@ -182,11 +181,19 @@ class TestSyncExecutorWorker:
         ensure_queues(error={"default": 1})
 
     def test_handles_timeout(self, tiger, ensure_queues):
-        Task(tiger, long_task_killed).delay()
-        worker = Worker(tiger, executor_class=SyncExecutor)
-        # Worker should exit to avoid any inconsistencies.
-        with pytest.raises(SystemExit):
-            worker.run(once=True, force_once=True)
+        Task(tiger, long_task_with_blocked_thread).delay()
+        worker = Process(
+            target=external_worker,
+            kwargs={"worker_kwargs": {"executor_class": SyncExecutor}},
+        )
+        worker.start()
+        worker.join(timeout=DELAY * 5)
+        try:
+            assert worker.exitcode == 1
+        finally:
+            if worker.is_alive():
+                worker.kill()
+                worker.join()
         ensure_queues(error={"default": 1})
 
     def test_heartbeat(self, tiger):

tasktiger-0.26.1/tasktiger/types.py

@@ -1,3 +0,0 @@
-from typing import Callable, Tuple
-
-RetryStrategy = Tuple[Callable[..., float], Tuple]