labtasker 0.2.10__tar.gz → 0.2.12__tar.gz

{labtasker-0.2.10 → labtasker-0.2.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: labtasker
-Version: 0.2.10
+Version: 0.2.12
 Summary: A task queue system for lab experiments
 Author-email: Your Name <your.email@example.com>
 License: Apache License 2.0
@@ -57,6 +57,7 @@ Requires-Dist: asgi-lifespan<3.0.0,>=2.1.0; extra == "dev"
 Requires-Dist: tox<4.29.0,>=4.24.0; extra == "dev"
 Requires-Dist: pytest-dependency<0.7.0,>=0.6.0; extra == "dev"
 Requires-Dist: pytest-sugar<2.0.0,>=1.0.0; extra == "dev"
+Requires-Dist: rust-just<2.0.0,>=1.42.4; extra == "dev"
 Provides-Extra: doc
 Requires-Dist: mkdocs-material<9.7.0,>=9.6.5; extra == "doc"
 Requires-Dist: mkdocs-glightbox<0.5.0,>=0.4.0; extra == "doc"

{labtasker-0.2.10 → labtasker-0.2.12}/labtasker/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.2.10"
+__version__ = "0.2.12"
 
 from labtasker.client.client_api import *
 from labtasker.client.core.config import get_client_config

{labtasker-0.2.10 → labtasker-0.2.12}/labtasker/client/cli/worker.py

@@ -102,6 +102,12 @@ def ls(
         "--name",
         help="Filter by worker name.",
     ),
+    status: Optional[str] = typer.Option(
+        None,
+        "--status",
+        "-s",
+        help="Filter by worker status. One of `active`, `suspended`, `crashed`.",
+    ),
     extra_filter: Optional[str] = typer.Option(
         None,
         "--extra-filter",
@@ -164,6 +170,7 @@ def ls(
             ls_workers,
             worker_id=worker_id,
             worker_name=worker_name,
+            status=status,
             extra_filter=extra_filter,
         ),
         offset=offset,

{labtasker-0.2.10 → labtasker-0.2.12}/labtasker/client/client_api.py

@@ -70,7 +70,7 @@ assert len(set(__all__)) == len(__all__), "Duplicated symbols in __all__"
 
 def loop(
     required_fields: Optional[List[str]] = None,
-    extra_filter: Optional[Dict[str, Any]] = None,
+    extra_filter: Optional[Union[str, Dict[str, Any]]] = None,
     cmd: Optional[Union[str, List[str]]] = None,
     worker_id: Optional[str] = None,
     create_worker_kwargs: Optional[Dict[str, Any]] = None,
@@ -82,7 +82,7 @@ def loop(
 
     Args:
         required_fields: Fields (or extra fields other than specified using Required(...)) required for task execution in a dot-separated manner. E.g. ["arg1.arg11", "arg2.arg22"]
-        extra_filter: Additional filtering criteria for tasks
+        extra_filter: Additional filtering criteria for tasks. Dict in MongoDB syntax or string in Python syntax is allowed.
         cmd: Command line arguments that runs current process. Default to sys.argv
         worker_id: Specific worker ID to use
         create_worker_kwargs: Arguments for default worker creation

{labtasker-0.2.10 → labtasker-0.2.12}/labtasker/client/core/api.py

@@ -35,6 +35,7 @@ from labtasker.client.core.utils import (
     cast_http_error,
     display_server_notifications,
     raise_for_status,
+    transpile_query_safe,
 )
 from labtasker.constants import Priority
 from labtasker.security import SecretStr, get_auth_headers
@@ -63,11 +64,21 @@ __all__ = [
 ]
 
 
+def _is_network_transient_error(exception):
+    return isinstance(exception, (httpx.TransportError, ConnectionError, TimeoutError))
+
+
 def _network_err_retry(func):
     @wraps(func)
     def wrapper(*args, **kwargs):
         return stamina.retry(
-            on=httpx.TransportError, attempts=5, wait_initial=0.5, wait_max=10.0
+            on=_is_network_transient_error,
+            attempts=10,
+            timeout=100.0,
+            wait_initial=0.5,
+            wait_max=16.0,
+            wait_jitter=1.0,
+            wait_exp_base=2.0,
         )(func)(*args, **kwargs)
 
     return wrapper
@@ -193,7 +204,7 @@ def fetch_task(
     heartbeat_timeout: Optional[float] = None,
     start_heartbeat: bool = True,
     required_fields: Optional[List[str]] = None,
-    extra_filter: Optional[Dict[str, Any]] = None,
+    extra_filter: Optional[Union[str, Dict[str, Any]]] = None,
     client: Optional[httpx.Client] = None,
     cmd: Optional[Union[str, List[str]]] = None,
 ) -> TaskFetchResponse:
@@ -206,6 +217,9 @@ def fetch_task(
             "Either eta_max or start_heartbeat must be specified."
         )
 
+    if isinstance(extra_filter, str):  # transpile to mongodb query
+        extra_filter = transpile_query_safe(query_str=extra_filter)
+
     payload = TaskFetchRequest(
         worker_id=worker_id,
         eta_max=eta_max,
@@ -268,12 +282,15 @@ def report_task_status(
 @_network_err_retry
 def refresh_task_heartbeat(
     task_id: str,
+    worker_id: Optional[str] = None,
     client: Optional[httpx.Client] = None,
 ) -> None:
     """Refresh the heartbeat of a task."""
     if client is None:
         client = get_httpx_client()
-    response = client.post(f"/api/v1/queues/me/tasks/{task_id}/heartbeat")
+    response = client.post(
+        f"/api/v1/queues/me/tasks/{task_id}/heartbeat", params={"worker_id": worker_id}
+    )
     raise_for_status(response)
 
 
@@ -303,7 +320,7 @@ def ls_workers(
     worker_id: Optional[str] = None,
     worker_name: Optional[str] = None,
     status: Optional[str] = None,
-    extra_filter: Optional[Dict[str, Any]] = None,
+    extra_filter: Optional[Union[str, Dict[str, Any]]] = None,
     limit: int = 100,
     offset: int = 0,
     sort: Optional[List[Tuple[str, int]]] = None,
@@ -312,6 +329,10 @@ def ls_workers(
     """List workers."""
     if client is None:
         client = get_httpx_client()
+
+    if isinstance(extra_filter, str):  # transpile to mongodb query
+        extra_filter = transpile_query_safe(query_str=extra_filter)
+
     payload = WorkerLsRequest(
         worker_id=worker_id,
         worker_name=worker_name,
@@ -364,7 +385,7 @@ def ls_tasks(
     task_id: Optional[str] = None,
     task_name: Optional[str] = None,
     status: Optional[str] = None,
-    extra_filter: Optional[Dict[str, Any]] = None,
+    extra_filter: Optional[Union[str, Dict[str, Any]]] = None,
     limit: int = 100,
     offset: int = 0,
     sort: Optional[List[Tuple[str, int]]] = None,
@@ -373,6 +394,10 @@ def ls_tasks(
     """List tasks in a queue."""
     if client is None:
         client = get_httpx_client()
+
+    if isinstance(extra_filter, str):  # transpile to mongodb query
+        extra_filter = transpile_query_safe(query_str=extra_filter)
+
     payload = TaskLsRequest(
         task_id=task_id,
         task_name=task_name,

{labtasker-0.2.10 → labtasker-0.2.12}/labtasker/client/core/cli_utils.py

@@ -34,7 +34,7 @@ from labtasker.client.core.exceptions import (
     QueryTranspilerError,
 )
 from labtasker.client.core.logging import stderr_console
-from labtasker.client.core.query_transpiler import transpile_query
+from labtasker.client.core.utils import transpile_query_safe
 from labtasker.utils import parse_time_interval, unflatten_dict
 
 DT = TypeVar("DT")
@@ -84,7 +84,7 @@ def parse_filter(filter_str: Optional[str]) -> Optional[Dict[str, Any]]:
         return parse_dict(d_str=filter_str)
     except typer.BadParameter:
         try:
-            return transpile_query(query_str=filter_str)  # type: ignore[arg-type]
+            return transpile_query_safe(query_str=filter_str)  # type: ignore[arg-type]
         except QueryTranspilerError as e:
             raise typer.BadParameter(f"Invalid filter str: {e}") from e
 

{labtasker-0.2.10 → labtasker-0.2.12}/labtasker/client/core/events.py

@@ -176,9 +176,9 @@ class EventListener:
             self._retry_context_iter = stamina.retry_context(
                 on=httpx.TransportError,
                 attempts=10,
-                timeout=60,
+                timeout=100.0,
                 wait_initial=0.5,
-                wait_max=8.0,
+                wait_max=16.0,
                 wait_jitter=1.0,
                 wait_exp_base=2.0,
             ).__iter__()

{labtasker-0.2.10 → labtasker-0.2.12}/labtasker/client/core/heartbeat.py

@@ -18,8 +18,9 @@ __all__ = [
 
 class Heartbeat:
 
-    def __init__(self, task_id, heartbeat_interval):
+    def __init__(self, task_id, worker_id, heartbeat_interval):
         self.task_id = task_id
+        self.worker_id = worker_id
         self.heartbeat_interval = heartbeat_interval
 
         self._thread = None
@@ -39,6 +40,7 @@ class Heartbeat:
         self._thread.start()
 
     def delay(self, interval: float) -> bool:
+        """Returns False if it should exit."""
         slice_t = 0.05  # check for stop event
         start_time = time.perf_counter()
         while True:
@@ -67,11 +69,12 @@ class Heartbeat:
         """Refresh heartbeat periodically"""
         while True:
             try:
-                refresh_task_heartbeat(task_id=self.task_id)
+                refresh_task_heartbeat(task_id=self.task_id, worker_id=self.worker_id)
             except Exception as e:
-                logger.error(f"Heartbeat failed for task {self.task_id}: {e}")
+                logger.error(f"Failed to refresh heartbeat: {str(e)}")
+                raise
 
-            # check if heartbeat should stop
+            # Check if heartbeat should stop
             if not self.delay(self.heartbeat_interval):
                 break
 
@@ -85,6 +88,9 @@ class Heartbeat:
             except FileNotFoundError:
                 pass
 
+    def is_alive(self):
+        return self._thread and self._thread.is_alive()
+
 
 _current_heartbeat: ContextVar[Optional[Heartbeat]] = ContextVar(
     "heartbeat", default=None
@@ -92,7 +98,10 @@ _current_heartbeat: ContextVar[Optional[Heartbeat]] = ContextVar(
 
 
 def start_heartbeat(
-    task_id, heartbeat_interval: Optional[float] = None, raise_error=True
+    task_id,
+    worker_id: Optional[str] = None,
+    heartbeat_interval: Optional[float] = None,
+    raise_error=True,
 ):
     logger.debug("Try starting heartbeat.")
     if _current_heartbeat.get() is not None:
@@ -102,12 +111,14 @@ def start_heartbeat(
 
     heartbeat_manager = Heartbeat(
         task_id=task_id,
+        worker_id=worker_id,
         heartbeat_interval=heartbeat_interval
         or get_client_config().task.heartbeat_interval,
     )
     heartbeat_manager.start()
     _current_heartbeat.set(heartbeat_manager)
     logger.debug("Heartbeat started.")
+    return heartbeat_manager
 
 
 def end_heartbeat(raise_error=True):

{labtasker-0.2.10 → labtasker-0.2.12}/labtasker/client/core/job_runner.py

@@ -38,6 +38,7 @@ from labtasker.client.core.exceptions import (
 from labtasker.client.core.heartbeat import end_heartbeat, start_heartbeat
 from labtasker.client.core.logging import log_to_file, logger, stderr_console
 from labtasker.client.core.paths import get_labtasker_log_dir, set_labtasker_log_dir
+from labtasker.client.core.utils import transpile_query_safe
 from labtasker.utils import parse_time_interval
 
 __all__ = [
@@ -106,7 +107,7 @@ def dump_task_info():
 
 def loop_run(
     required_fields: List[str],
-    extra_filter: Optional[Dict[str, Any]] = None,
+    extra_filter: Optional[Union[str, Dict[str, Any]]] = None,
     cmd: Optional[Union[str, List[str]]] = None,
     worker_id: Optional[str] = None,
     create_worker_kwargs: Optional[Dict[str, Any]] = None,
@@ -142,6 +143,9 @@ def loop_run(
                 f"Invalid eta_max {eta_max}. ETA max must be a valid duration string (e.g. '1h', '1h30m', '50s')"
             )
 
+    if isinstance(extra_filter, str):  # transpile to mongodb query
+        extra_filter = transpile_query_safe(query_str=extra_filter)
+
     # Check connection and authentication
     try:
         get_queue()
@@ -216,7 +220,9 @@ def loop_run(
                     dump_task_info()
 
                     with log_to_file(file_path=get_labtasker_log_dir() / "run.log"):
-                        start_heartbeat(task_id=current_task_id())
+                        start_heartbeat(
+                            task_id=current_task_id(), worker_id=current_worker_id()
+                        )
                         success_flag = False
                         try:
                             func_args = (task.args, *args) if pass_args_dict else args

{labtasker-0.2.10 → labtasker-0.2.12}/labtasker/client/core/query_transpiler.py

@@ -1,6 +1,7 @@
 import ast
+import difflib
 from datetime import timezone
-from typing import Any, Dict, List, NoReturn, Type
+from typing import Any, Dict, List, NoReturn, Optional, Type
 
 import dateparser
 from rich.console import Console
@@ -154,9 +155,10 @@ class QueryTranspiler(ast.NodeVisitor):
         ast.Or: "$or",  # a or b -> {$or: [a, b]}
     }
 
-    def __init__(self, query_str: str):
+    def __init__(self, query_str: str, allowed_fields: Optional[List[str]] = None):
         super().__init__()
         self.query_str = query_str
+        self.allowed_fields = allowed_fields
 
     def _report_error(
         self, node: ast.AST, msg: str, exception: Type[QueryTranspilerError]
@@ -701,6 +703,20 @@ class QueryTranspiler(ast.NodeVisitor):
         Python: field_name
         MongoDB: "field_name" (as a field reference)
         """
+        if self.allowed_fields and node.id not in self.allowed_fields:
+            suggestions = difflib.get_close_matches(
+                node.id, self.allowed_fields, n=1, cutoff=0.6
+            )
+            suggestion_msg = (
+                f" Maybe you meant '{suggestions[0]}'?" if suggestions else ""
+            )
+
+            self._report_error(
+                node=node,
+                msg=f"Field '{node.id}' is unknown or not allowed.{suggestion_msg}"
+                f"\nAllowed fields: {', '.join(sorted(self.allowed_fields))}",
+                exception=QueryTranspilerValueError,
+            )
         return node.id
 
     def visit_Attribute(self, node: ast.Attribute) -> str:
@@ -960,7 +976,9 @@ class QueryTranspiler(ast.NodeVisitor):
         )
 
 
-def transpile_query(query_str: str) -> Dict[str, Any]:
+def transpile_query(
+    query_str: str, allowed_fields: Optional[List[str]] = None
+) -> Dict[str, Any]:
     """
     Transpile a Python-like query string and convert it to a MongoDB query object.
 
@@ -969,6 +987,7 @@ def transpile_query(query_str: str) -> Dict[str, Any]:
 
     Args:
         query_str: A string containing a Python-like expression to be converted
+        allowed_fields: A list of allowed fields (e.g. ast.Name.id). If None, allowed_fields will not be checked.
 
     Returns:
         A dictionary representing the equivalent MongoDB query
@@ -979,7 +998,7 @@ def transpile_query(query_str: str) -> Dict[str, Any]:
     try:
         query_str = query_str.strip()
         parsed_ast = ast.parse(query_str)
-        visitor = QueryTranspiler(query_str=query_str)
+        visitor = QueryTranspiler(query_str=query_str, allowed_fields=allowed_fields)
         result = visitor.visit(parsed_ast)
 
         if isinstance(result, bool) or isinstance(result, int):

{labtasker-0.2.10 → labtasker-0.2.12}/labtasker/client/core/utils.py

@@ -3,7 +3,7 @@ import os
 import subprocess
 import sys
 import threading
-from functools import wraps
+from functools import partial, wraps
 from typing import Any, Callable, Optional
 
 import httpx
@@ -20,6 +20,7 @@ from labtasker.client.core.exceptions import (
 )
 from labtasker.client.core.logging import stderr_console, stdout_console
 from labtasker.client.core.paths import get_labtasker_client_config_path
+from labtasker.client.core.query_transpiler import transpile_query
 
 server_notification_prefix = {
     "info": "[bold dodger_blue1]INFO(notification):[/bold dodger_blue1] ",
@@ -33,6 +34,31 @@ server_notification_level = {
     "high": 2,
 }
 
+transpile_query_safe = partial(
+    transpile_query,
+    allowed_fields=[
+        "task_id",
+        "queue_id",
+        "status",
+        "task_name",
+        "created_at",
+        "start_time",
+        "last_heartbeat",
+        "last_modified",
+        "heartbeat_timeout",
+        "task_timeout",
+        "max_retries",
+        "retries",
+        "priority",
+        "metadata",
+        "args",
+        "cmd",
+        "summary",
+        "worker_id",
+        "worker_name",
+    ],
+)
+
 
 def json_serializer(obj: Any, **kwargs) -> str:
     return json.dumps(to_jsonable_python(obj), **kwargs)

{labtasker-0.2.10 → labtasker-0.2.12}/labtasker/constants.py

@@ -7,5 +7,4 @@ class Priority(int, Enum):
     HIGH = 20
 
 
-KEY_PATTERN = r"^[a-zA-Z0-9_-]+$"
 DOT_SEPARATED_KEY_PATTERN = r"^[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+)*$"

{labtasker-0.2.10 → labtasker-0.2.12}/labtasker/server/database.py

@@ -674,22 +674,52 @@ class DBService:
     @retry_on_transient
     @validate_arg
     def refresh_task_heartbeat(
-        self,
-        queue_id: str,
-        task_id: str,
-    ) -> bool:
+        self, queue_id: str, task_id: str, worker_id: Optional[str] = None
+    ):
         """Update task heartbeat timestamp."""
+        query = {"_id": task_id, "queue_id": queue_id, "status": "running"}
+
         with self._client.start_session() as session:
             with session.start_transaction():
-                return (
-                    self._tasks.update_one(
-                        {"_id": task_id, "queue_id": queue_id},
-                        {"$set": {"last_heartbeat": get_current_time()}},
-                        session=session,
-                    ).modified_count
-                    > 0
+                # Find the task in a single query
+                task = self._tasks.find_one(query)
+                if not task:
+                    raise HTTPException(
+                        status_code=HTTP_404_NOT_FOUND,
+                        detail=f"Task '{task_id}' not found in queue '{queue_id}' or not in 'running' state",
+                    )
+
+                # Validate worker if provided
+                if worker_id:
+                    if task["worker_id"] != worker_id:
+                        raise HTTPException(
+                            status_code=HTTP_403_FORBIDDEN,
+                            detail=f"Task '{task_id}' is assigned to worker '{task['worker_id']}', not '{worker_id}'",
+                        )
+
+                    # Check worker status in a single query
+                    worker = self._workers.find_one(
+                        {"_id": worker_id, "status": WorkerState.ACTIVE}
+                    )
+                    if not worker:
+                        raise HTTPException(
+                            status_code=HTTP_404_NOT_FOUND,
+                            detail=f"Worker '{worker_id}' not found or not active",
+                        )
+
+                # Update the task heartbeat
+                result = self._tasks.update_one(
+                    query,
+                    {"$set": {"last_heartbeat": get_current_time()}},
+                    session=session,
                 )
 
+                if result.modified_count == 0:
+                    raise HTTPException(
+                        status_code=HTTP_404_NOT_FOUND,
+                        detail=f"Failed to update heartbeat for task '{task_id}' - it may have changed state during the operation",
+                    )
+
     @retry_on_transient
     @validate_arg
     def worker_report_task_status(

{labtasker-0.2.10 → labtasker-0.2.12}/labtasker/server/endpoints.py

@@ -1,9 +1,9 @@
 import asyncio
 import uuid
 from contextlib import asynccontextmanager
-from typing import Any, Dict, List
+from typing import Any, Dict, List, Optional
 
-from fastapi import Depends, FastAPI, HTTPException, Request
+from fastapi import Depends, FastAPI, HTTPException, Query, Request
 from sse_starlette.sse import EventSourceResponse
 from starlette.status import (
     HTTP_201_CREATED,
@@ -309,16 +309,14 @@ def report_task_status(
 )
 def refresh_task_heartbeat(
     task_id: str,
+    worker_id: Optional[str] = Query(None),  # use query param
     queue: Dict[str, Any] = Depends(get_verified_queue_dependency),
     db: DBService = Depends(get_db),
 ):
     """Update task heartbeat timestamp."""
-    done = db.refresh_task_heartbeat(
-        queue_id=queue["_id"],
-        task_id=task_id,
+    db.refresh_task_heartbeat(
+        queue_id=queue["_id"], task_id=task_id, worker_id=worker_id
     )
-    if not done:
-        raise HTTPException(status_code=HTTP_404_NOT_FOUND, detail="Task not found.")
 
 
 @app.get(

{labtasker-0.2.10 → labtasker-0.2.12}/labtasker/server/fsm.py

@@ -43,7 +43,12 @@ class StateTransitionEventHandle:
             self.commit()
 
     def commit(self):
-        event_data = StateTransitionEvent(
+        event_data = self._create_event_data()
+        self._publish_event(event_data)
+        self._entity_data = None
+
+    def _create_event_data(self):
+        return StateTransitionEvent(
             entity_type=self.entity_type,
             queue_id=self.queue_id,
             entity_id=self.entity_id,
@@ -54,9 +59,17 @@ class StateTransitionEventHandle:
             entity_data=self._entity_data,
         )
 
+    def _publish_event(self, event_data):
         # Use fully synchronous event publishing
         event_manager.publish_event(self.queue_id, event_data)
-        self._entity_data = None
+
+
+class NullEventHandle(StateTransitionEventHandle):
+    """A placeholder that does nothing. (Used for cases where triggering event publishing is undesired)"""
+
+    def _publish_event(self, event_data):
+        # Override to do nothing
+        pass
 
 
 class State(str, Enum):
@@ -140,6 +153,18 @@ class BaseFSM:
     def state(self):
         return self._state
 
+    def null_transition(self) -> NullEventHandle:
+        """Perform a null transition and return a handle"""
+        return NullEventHandle(
+            entity_type=self.ENTITY_TYPE,
+            entity_id=self.entity_id,
+            queue_id=self.queue_id,
+            old_state=str(self._state),
+            new_state=str(self._state),
+            transition_time=get_current_time(),
+            metadata=self.metadata,
+        )
+
     def transition_to(self, new_state: State) -> StateTransitionEventHandle:
         """Perform state transition and return a handle"""
         old_state = self._state
@@ -190,6 +215,7 @@ class TaskFSM(BaseFSM):
         TaskState.FAILED: {
             TaskState.PENDING,
             TaskState.CANCELLED,
+            TaskState.FAILED,  # null transition (for more tolerance)
         },  # Can be reset and requeued
         TaskState.CANCELLED: {
             TaskState.PENDING,
@@ -280,11 +306,15 @@ class TaskFSM(BaseFSM):
         Transitions:
         - RUNNING -> PENDING (if retries < max_retries)
         - RUNNING -> FAILED (if retries >= max_retries)
+        - FAILED -> FAILED (null transition, does nothing)
         - Others -> InvalidStateTransition (invalid)
 
         Note: FAILED state can transition back to PENDING for retries
         until max_retries is reached.
         """
+        if self.state == TaskState.FAILED:
+            return self.null_transition()
+
         if self.state != TaskState.RUNNING:
             raise InvalidStateTransition(f"Cannot fail task in {self.state} state")
 
@@ -305,7 +335,10 @@ class WorkerFSM(BaseFSM):
             WorkerState.CRASHED,
         },
         WorkerState.SUSPENDED: {WorkerState.ACTIVE},  # Manual transition
-        WorkerState.CRASHED: {WorkerState.ACTIVE},  # Manual transition
+        WorkerState.CRASHED: {
+            WorkerState.ACTIVE,  # Manual transition
+            WorkerState.CRASHED,  # null transition (for more tolerance)
+        },
     }
 
     def __init__(
@@ -366,7 +399,11 @@ class WorkerFSM(BaseFSM):
         Transitions:
         - ACTIVE -> ACTIVE
         - ACTIVE -> CRASHED (retries >= max_retries)
+        - CRASHED -> CRASHED (null transition, does nothing)
         """
+        if self.state == WorkerState.CRASHED:
+            return self.null_transition()
+
         if self.state != WorkerState.ACTIVE:
             raise InvalidStateTransition(f"Cannot fail worker in {self.state} state")
 

{labtasker-0.2.10 → labtasker-0.2.12}/labtasker.egg-info/SOURCES.txt

@@ -154,7 +154,8 @@ tests/test_client/test_cli/test_task.py
 tests/test_client/test_cli/test_worker.py
 tests/test_client/test_core/__init__.py
 tests/test_client/test_core/test_cli_utils.py
-tests/test_client/test_core/test_heartbeat.py
+tests/test_client/test_core/test_heartbeat_e2e.py
+tests/test_client/test_core/test_heartbeat_unit.py
 tests/test_client/test_core/test_job_runner.py
 tests/test_client/test_core/test_logging.py
 tests/test_client/test_core/test_loop_internal_error_handler.py

{labtasker-0.2.10 → labtasker-0.2.12}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "labtasker"
-version = "0.2.10"
+version = "0.2.12"
 description = "A task queue system for lab experiments"
 authors = [{ name = "Your Name", email = "your.email@example.com" }]
 license = { text = "Apache License 2.0" }
@@ -64,6 +64,7 @@ dev = [
     "tox (>=4.24.0,<4.29.0)",
     "pytest-dependency (>=0.6.0,<0.7.0)",
     "pytest-sugar (>=1.0.0,<2.0.0)",
+    "rust-just (>=1.42.4,<2.0.0)",
 ]
 doc = [
     "mkdocs-material (>=9.6.5,<9.7.0)",
@@ -132,7 +133,6 @@ disable_error_code = [
     "no-redef",
     "import-untyped"
 ]
-python_version = "3.10"
 warn_unused_configs = true
 ignore_missing_imports = true
 show_error_codes = true