labtasker 0.2.7__tar.gz → 0.2.9__tar.gz

{labtasker-0.2.7 → labtasker-0.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: labtasker
-Version: 0.2.7
+Version: 0.2.9
 Summary: A task queue system for lab experiments
 Author-email: Your Name <your.email@example.com>
 License: Apache License 2.0
@@ -40,6 +40,8 @@ Requires-Dist: mongomock<4.4.0,>=4.3.0
 Requires-Dist: jsonpickle<5.0.0,>=4.0.2
 Requires-Dist: mslex<2.0.0,>=1.3.0
 Requires-Dist: pexpect<5.0.0,>=4.9.0
+Requires-Dist: pip>=25
+Requires-Dist: dateparser<2.0.0,>=1.2.2
 Provides-Extra: dev
 Requires-Dist: pytest<9.0.0,>=8.0.0; extra == "dev"
 Requires-Dist: pytest-cov<7.0.0,>=5.0.0; extra == "dev"
@@ -50,9 +52,9 @@ Requires-Dist: flake8<8.0.0,>=7.0.0; extra == "dev"
 Requires-Dist: pre-commit<5.0.0,>=3.0.0; extra == "dev"
 Requires-Dist: freezegun<2.0.0,>=1.5.0; extra == "dev"
 Requires-Dist: pytest-docker<4.0.0,>=3.0.0; extra == "dev"
-Requires-Dist: pytest-asyncio<1.1.0,>=0.24.0; extra == "dev"
+Requires-Dist: pytest-asyncio<1.2.0,>=0.24.0; extra == "dev"
 Requires-Dist: asgi-lifespan<3.0.0,>=2.1.0; extra == "dev"
-Requires-Dist: tox<4.28.0,>=4.24.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"
 Provides-Extra: doc
@@ -62,6 +64,7 @@ Requires-Dist: mike<2.2.0,>=2.1.3; extra == "doc"
 Provides-Extra: plugins
 Requires-Dist: labtasker-plugin-task-count; extra == "plugins"
 Requires-Dist: labtasker-plugin-script-generate; extra == "plugins"
+Requires-Dist: labtasker-plugin-task-recency; extra == "plugins"
 Dynamic: license-file
 
 <p align="center"><em>Make your ML experiment wrapper scripts smarter with...</em></p>

{labtasker-0.2.7 → labtasker-0.2.9}/labtasker/__init__.py

@@ -1,13 +1,13 @@
-__version__ = "0.2.7"
+__version__ = "0.2.9"
 
 from labtasker.client.client_api import *
 from labtasker.client.core.config import get_client_config
 from labtasker.client.core.exceptions import *
 from labtasker.client.core.paths import get_labtasker_client_config_path
-from labtasker.client.core.version_checker import check_pypi_status
+from labtasker.client.core.version_checker import check_package_version
 from labtasker.filtering import install_traceback_filter, set_traceback_filter_hook
 
-check_pypi_status()
+check_package_version()
 
 # by default, traceback filter is enabled.
 # you may disable it via client config

{labtasker-0.2.7 → labtasker-0.2.9}/labtasker/api_models.py

@@ -1,20 +1,56 @@
+import warnings
 from datetime import datetime
-from typing import Any, Dict, List, Literal, Optional, Tuple, Union
+from typing import Any, Dict, List, Literal, Optional, Tuple, TypeVar, Union
 
 from packaging.version import Version
-from pydantic import BaseModel, ConfigDict, Field, SecretStr, field_validator
+from pydantic import (
+    BaseModel,
+    ConfigDict,
+    Field,
+    SecretStr,
+    ValidationInfo,
+    field_validator,
+    model_validator,
+)
 
 from labtasker import __version__
 from labtasker.constants import Priority
-from labtasker.utils import validate_dict_keys
+from labtasker.utils import _disable_check_var, validate_dict_keys
 
 
 class BaseApiModel(BaseModel):
-    """
-    Base API model for all API models.
-    """
+    """Base API model for all API models."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="ignore")
+    unknown_fields: Dict[str, Any] = Field(
+        default_factory=dict, exclude=True
+    )  # marked as excluded from serialization
+
+    @model_validator(mode="before")
+    @classmethod
+    def collect_unknown_fields(
+        cls, data: Dict[str, Any], info: ValidationInfo
+    ) -> Dict[str, Any]:
+        if _disable_check_var.get():  # if check is disabled, return data
+            return data
+
+        if isinstance(data, dict):
+            # Get the set of model field names
+            model_field_names = set(cls.model_fields.keys())  # type: ignore
 
-    model_config = ConfigDict(populate_by_name=True)
+            unknown_fields = {
+                k: v for k, v in data.items() if k not in model_field_names
+            }
+
+            if unknown_fields:
+                warnings.warn(
+                    f"Unknown fields provided to {cls.__name__}: {', '.join(unknown_fields.keys())}; "
+                    f"It could be that your client and server version mismatch. Try upgrading both to latest versions.",
+                    UserWarning,
+                )
+                data["_unknown_fields"] = unknown_fields
+
+        return data
 
 
 class BaseRequestModel(BaseApiModel):
@@ -119,13 +155,100 @@ class TaskSubmitRequest(
     priority: int = Priority.MEDIUM
 
 
-class TaskFetchRequest(BaseRequestModel):
+T = TypeVar("T", bound="DatetimeSerializationMixin")
+
+
+class DatetimeSerializationMixin:
+    """
+    A mixin that enables proper serialization and deserialization of datetime objects
+    in the extra_filter field.
+
+    This mixin should be used with BaseModel.
+    Example: class MyModel(DatetimeSerializationMixin, BaseModel):
+    """
+
+    # Define a model validator to process datetime markers in input data
+    @model_validator(mode="before")
+    @classmethod
+    def process_datetime_markers(cls, data: Any) -> Any:
+        """Process incoming data to convert datetime markers in extra_filter field"""
+        if (
+            isinstance(data, dict)
+            and "extra_filter" in data
+            and data["extra_filter"] is not None
+        ):
+            data["extra_filter"] = cls._process_datetime_markers(data["extra_filter"])
+        return data
+
+    # Add a field validator for extra_filter field
+    @field_validator("extra_filter", mode="before")
+    @classmethod
+    def validate_extra_filter(
+        cls, value: Optional[Dict[str, Any]]
+    ) -> Optional[Dict[str, Any]]:
+        """Validate and process extra_filter field"""
+        if value is None:
+            return None
+        return cls._process_datetime_markers(value)
+
+    @classmethod
+    def _process_datetime_markers(cls, obj: Any) -> Any:
+        """Process data recursively to convert datetime markers to datetime objects"""
+        if isinstance(obj, dict):
+            # Check if it's a datetime marker
+            if "_dt" in obj and len(obj) == 1 and isinstance(obj["_dt"], str):
+                try:
+                    return datetime.fromisoformat(obj["_dt"])
+                except ValueError:
+                    pass
+            # Process regular dictionary
+            return {k: cls._process_datetime_markers(v) for k, v in obj.items()}
+        elif isinstance(obj, list):
+            return [cls._process_datetime_markers(item) for item in obj]
+        return obj
+
+    def dump_to_json_dict(self) -> Dict[str, Any]:
+        """
+        Dump the model to a JSON-serializable dictionary with datetime objects
+        in extra_filter converted to {"_dt": iso_format} representation.
+
+        This method doesn't modify the model_config, but provides a way to
+        properly serialize datetime objects in the extra_filter field.
+
+        Returns:
+            Dict[str, Any]: A JSON-serializable dictionary
+        """
+        # First get the standard model dump
+        data = self.model_dump()  # type: ignore[attr-defined]
+
+        # Process extra_filter field if it exists
+        if "extra_filter" in data and data["extra_filter"] is not None:
+            data["extra_filter"] = self._process_datetime_objects(data["extra_filter"])
+
+        return data
+
+    def _process_datetime_objects(self, obj: Any) -> Any:
+        """Process data recursively to convert datetime objects to markers"""
+        if isinstance(obj, dict):
+            return {k: self._process_datetime_objects(v) for k, v in obj.items()}
+        elif isinstance(obj, list):
+            return [self._process_datetime_objects(item) for item in obj]
+        elif isinstance(obj, datetime):
+            return {"_dt": obj.isoformat()}
+        elif isinstance(obj, tuple):
+            # Convert tuples to lists for JSON serialization
+            return [self._process_datetime_objects(item) for item in obj]
+        return obj
+
+
+class TaskFetchRequest(DatetimeSerializationMixin, BaseRequestModel):  # type: ignore[misc]
     worker_id: Optional[str] = None
     eta_max: Optional[str] = None
     heartbeat_timeout: Optional[float] = None
     start_heartbeat: bool = True
     required_fields: Optional[List[str]] = None
     extra_filter: Optional[Dict[str, Any]] = None
+    cmd: Optional[Union[str, List[str]]] = None
 
 
 class Task(
@@ -149,7 +272,7 @@ class Task(
     priority: int
     metadata: Dict
     args: Dict
-    cmd: Union[str, List[str]]
+    cmd: Optional[Union[str, List[str]]]
     summary: Dict
     worker_id: Optional[str]
 
@@ -204,7 +327,7 @@ class TaskFetchResponse(BaseResponseModel):
     task: Optional[Task] = None
 
 
-class TaskLsRequest(BaseRequestModel):
+class TaskLsRequest(DatetimeSerializationMixin, BaseRequestModel):  # type: ignore[misc]
     offset: int = Field(0, ge=0)
     limit: int = Field(100, gt=0, le=1000)
     task_id: Optional[str] = None
@@ -266,7 +389,7 @@ class WorkerStatusUpdateRequest(BaseRequestModel):
     status: str = Field(..., pattern=r"^(active|suspended|crashed)$")
 
 
-class WorkerLsRequest(BaseRequestModel):
+class WorkerLsRequest(DatetimeSerializationMixin, BaseRequestModel):  # type: ignore[misc]
     offset: int = Field(0, ge=0)
     limit: int = Field(100, gt=0, le=1000)
     worker_id: Optional[str] = None

{labtasker-0.2.7 → labtasker-0.2.9}/labtasker/client/cli/cli.py

@@ -12,7 +12,7 @@ from labtasker.client.core.api import health_check
 from labtasker.client.core.config import requires_client_config
 from labtasker.client.core.exceptions import LabtaskerNetworkError
 from labtasker.client.core.logging import stderr_console, stdout_console
-from labtasker.client.core.version_checker import check_pypi_status
+from labtasker.client.core.version_checker import check_package_version
 
 app = typer.Typer(context_settings={"help_option_names": ["-h", "--help"]})
 
@@ -20,7 +20,7 @@ app = typer.Typer(context_settings={"help_option_names": ["-h", "--help"]})
 def version_callback(value: bool):
     if value:
         stdout_console.print(f"Labtasker Version: {__version__}")
-        check_pypi_status(force_check=True, blocking=True)
+        check_package_version(force_check=True, blocking=True)
         raise typer.Exit()
 
 

{labtasker-0.2.7 → labtasker-0.2.9}/labtasker/client/cli/init.py

@@ -211,12 +211,12 @@ def setup_queue(base_url, base_url_verified) -> Tuple[str, str]:
 def confirm_set_traceback_filter() -> bool:
     choices = [
         Choice(
-            "Yes: I want better exception formatting and sensitive text filtering.",
-            data=True,
+            "No: I want more compatibility than security.",
+            data=False,
         ),
         Choice(
-            "No: I just want compatibility.",
-            data=False,
+            "Yes: I want better exception formatting and sensitive text filtering.",
+            data=True,
         ),
     ]
     choice = ListPrompt(

{labtasker-0.2.7 → labtasker-0.2.9}/labtasker/client/cli/loop.py

@@ -1,14 +1,11 @@
 """Implements `labtasker loop xxx`"""
 
-import json
 import os
-import subprocess
 import sys
 from collections import defaultdict
 from pathlib import Path
 from typing import List, Optional
 
-import pexpect
 import typer
 from typing_extensions import Annotated
 
@@ -16,6 +13,7 @@ from labtasker.client.cli.cli import app
 from labtasker.client.core.cli_utils import (
     cli_utils_decorator,
     eta_max_validation,
+    is_piped_io,
     parse_filter,
 )
 from labtasker.client.core.cmd_parser import cmd_interpolate
@@ -26,9 +24,14 @@ from labtasker.client.core.job_runner import loop_run
 from labtasker.client.core.logging import (
     logger,
     set_verbose,
-    stderr_console,
     verbose_print,
 )
+from labtasker.client.core.utils import (
+    check_pty_available,
+    json_serializer,
+    run_with_pty,
+    run_with_subprocess,
+)
 
 
 class InfiniteDefaultDict(defaultdict):
@@ -44,76 +47,6 @@ class InfiniteDefaultDict(defaultdict):
         return super().get(key, default)
 
 
-def _check_pty_available(opt: bool) -> bool:
-    if opt and os.name == "nt":
-        stderr_console.print(
-            "[bold orange1]Warning:[/bold orange1] PTY is not available on Windows. "
-            "Disabling PTY support."
-        )
-        return False
-    return opt
-
-
-def _stream_child_output(child) -> None:
-    """Stream the output of a pexpect child in real-time, supporting progress bars."""
-    try:
-        while True:
-            try:
-                output = child.read_nonblocking(size=1024, timeout=0.1)
-                if output:
-                    # keep \r
-                    sys.stdout.write(output)
-                    sys.stdout.flush()
-            except pexpect.TIMEOUT:
-                continue
-            except pexpect.EOF:
-                break
-    finally:
-        child.close()
-
-
-def _run_with_pty(cmd, shell_exec=None, use_shell=False):
-    """Run a command with PTY support for interactive programs."""
-    if use_shell:
-        shell_exec = shell_exec or "/bin/sh"
-        child = pexpect.spawn(shell_exec, ["-c", cmd], encoding="utf-8")
-    else:
-        child = pexpect.spawn(cmd[0], cmd[1:], encoding="utf-8")
-
-    _stream_child_output(child)
-
-    return child.exitstatus
-
-
-def _run_with_subprocess(cmd, shell_exec=None, use_shell=False):
-    """Run a command using standard subprocess approach."""
-    with subprocess.Popen(
-        args=cmd,
-        stdin=subprocess.PIPE,
-        stdout=subprocess.PIPE,
-        stderr=subprocess.PIPE,
-        text=True,
-        executable=shell_exec,
-        shell=use_shell,
-    ) as process:
-        while True:
-            output = process.stdout.readline()
-            error = process.stderr.readline()
-
-            if output:
-                sys.stdout.write(output.strip())
-                sys.stdout.flush()
-            if error:
-                sys.stderr.write(error.strip())
-                sys.stderr.flush()
-
-            # Break when process completes and streams are empty
-            if process.poll() is not None and not output and not error:
-                break
-
-        return process.returncode
-
-
 @app.command()
 @cli_utils_decorator
 def loop(
@@ -163,7 +96,7 @@ def loop(
     ),
     use_pty: bool = typer.Option(
         os.name == "posix",  # enabled by default on POSIX systems
-        callback=_check_pty_available,
+        callback=check_pty_available,
         help="Use pseudo terminal on POSIX systems for better interactive program support.",
     ),
     verbose: bool = typer.Option(  # noqa
@@ -201,7 +134,7 @@ def loop(
             input_cmd = f.read().strip()
 
     # 3. Try reading from stdin if shell mode is enabled
-    if not input_cmd and not sys.stdin.isatty():
+    if not input_cmd and is_piped_io():
         input_cmd = sys.stdin.read().strip()
 
     # Final validation: ensure a command is present
@@ -211,7 +144,7 @@ def loop(
         )
 
     parsed_filter = parse_filter(extra_filter)
-    verbose_print(f"Parsed filter: {json.dumps(parsed_filter, indent=4)}")
+    verbose_print(f"Parsed filter: {json_serializer(parsed_filter, indent=4)}")
 
     if heartbeat_timeout is None:
         heartbeat_timeout = get_client_config().task.heartbeat_interval * 3
@@ -244,12 +177,10 @@ def loop(
         try:
             if use_pty:
                 # Use pexpect with PTY on POSIX systems
-                exit_code = _run_with_pty(interpolated_cmd, executable, use_shell)
+                exit_code = run_with_pty(interpolated_cmd, executable, use_shell)
             else:
                 # Standard subprocess approach for non-PTY execution
-                exit_code = _run_with_subprocess(
-                    interpolated_cmd, executable, use_shell
-                )
+                exit_code = run_with_subprocess(interpolated_cmd, executable, use_shell)
 
             if exit_code != 0:
                 raise _LabtaskerJobFailed(

{labtasker-0.2.7 → labtasker-0.2.9}/labtasker/client/cli/task.py

@@ -1,7 +1,6 @@
 """Manage tasks (CRUD operations)."""
 
 import io
-import json
 import os
 import sys
 import tempfile
@@ -22,7 +21,6 @@ from typing_extensions import Annotated
 from labtasker.api_models import Task, TaskUpdateRequest
 from labtasker.client.core.api import (
     delete_task,
-    get_queue,
     ls_tasks,
     submit_task,
     update_tasks,
@@ -31,6 +29,8 @@ from labtasker.client.core.cli_utils import (
     LsFmtChoices,
     cli_utils_decorator,
     confirm,
+    get_editor,
+    is_piped_io,
     ls_format_iter,
     pager_iterator,
     parse_dict,
@@ -47,6 +47,8 @@ from labtasker.client.core.logging import (
     stdout_console,
     verbose_print,
 )
+from labtasker.client.core.pager import echo_via_pager_no_check_isatty
+from labtasker.client.core.utils import json_serializer
 from labtasker.constants import Priority
 
 app = typer.Typer()
@@ -237,6 +239,10 @@ def ls(
         help="Only show task IDs that match the query, rather than full entry. "
         "Useful when using in bash scripts.",
     ),
+    ansi: bool = typer.Option(
+        True,
+        help="Enable ANSI colors.",
+    ),
     pager: bool = typer.Option(
         True,
         help="Enable pagination.",
@@ -268,6 +274,11 @@ def ls(
         callback=set_verbose,
         is_eager=True,
     ),
+    piped_in: bool = typer.Option(
+        False,
+        "--piped-in",
+        help="Read from stdin. Useful in cascaded commands to display final result. e.g. `labtasker xxx | labtasker ls --piped-in`",
+    ),
 ):
     """
     List and filter tasks in the queue.
@@ -298,10 +309,34 @@ def ls(
     else:
         parsed_sort = parse_sort(sort)
 
-    get_queue()  # validate auth and queue existence, prevent err swallowed by pager
-
     extra_filter = parse_filter(extra_filter)
-    verbose_print(f"Parsed filter: {json.dumps(extra_filter, indent=4)}")
+    verbose_print(f"Parsed filter: {json_serializer(extra_filter, indent=4)}")
+
+    # Check for piped input (task ids could be passed through cascaded commands e.g. labtasker xxx | labtasker yyy)
+    if piped_in:
+        if any([task_id, task_name, status, extra_filter]):
+            raise typer.BadParameter(
+                "Cannot use --task-id, --task-name, --status, or --extra-filter with piped input --piped-in enabled."
+            )
+        # Read task IDs from stdin (pipe)
+        piped_task_ids = [line.strip() for line in sys.stdin if line.strip()]
+        verbose_print(f"Received {len(piped_task_ids)} task IDs from pipe")
+
+        # If we have piped task IDs but no task_id is specified yet
+        if piped_task_ids:
+            # If there's only one task ID from pipe and no task_id specified, use it directly
+            if len(piped_task_ids) == 1 and not task_id:
+                task_id = piped_task_ids[0]
+                verbose_print(f"Using single piped task ID: {task_id}")
+            # If there are multiple task IDs, use them to build an extra filter
+            elif len(piped_task_ids) > 1:
+                # Build a filter to include all piped task IDs
+                extra_filter = {"_id": {"$in": piped_task_ids}}
+
+                verbose_print(
+                    f"Created filter from {len(piped_task_ids)} piped task IDs"
+                )
+
     page_iter = pager_iterator(
         fetch_function=partial(
             ls_tasks,
@@ -321,16 +356,18 @@ def ls(
         raise typer.Exit()  # exit directly without other printing
 
     if pager:
-        click.echo_via_pager(
+        echo_via_pager_no_check_isatty(
             ls_format_iter[fmt](
                 page_iter,
                 use_rich=False,
-            )
+                ansi=ansi,
+            ),
         )
     else:
         for item in ls_format_iter[fmt](
             page_iter,
             use_rich=True,
+            ansi=ansi,
         ):
             stdout_console.print(item)
 
@@ -397,9 +434,9 @@ def update(
         "-q",
         help="Disable interactive mode and confirmations. Set this to true if you are using this in a bash script.",
     ),
-    editor: Optional[str] = typer.Option(
-        None,
-        help="Editor to use for modifying task data incase you didn't specify --update.",
+    editor: str = typer.Option(
+        get_editor(),
+        help="Editor to use for modifying task data in case you didn't specify --update.",
     ),
     verbose: bool = typer.Option(
         False,
@@ -417,10 +454,14 @@ def update(
     priority, and other settings. You can update multiple tasks at once by using
     filters, and either specify updates directly or use an interactive editor.
 
+    You can also pipe task IDs from other commands, for example:
+    `labtasker task ls -q | labtasker task update -u 'status=cancelled'`
+
     Examples:
         labtasker task update --id "task-123" -- priority=10
         labtasker task update --status pending -- metadata.tag=important
         labtasker task update --name "training" --editor vim  # Open in editor
+        labtasker task ls -q | labtasker task update -u status=cancelled  # `task ls` can be replaced with one of the self-implemented plugin commands.
     """
     if updates and option_updates:
         raise typer.BadParameter(
@@ -434,7 +475,28 @@ def update(
 
     updates = updates or option_updates
     extra_filter = parse_filter(extra_filter)
-    verbose_print(f"Parsed filter: {json.dumps(extra_filter, indent=4)}")
+    verbose_print(f"Parsed filter: {json_serializer(extra_filter, indent=4)}")
+
+    # Check for piped input (task ids could be passed through cascaded commands e.g. labtasker xxx | labtasker yyy)
+    if is_piped_io() and not any([task_id, task_name, status, extra_filter]):
+        # Read task IDs from stdin (pipe)
+        piped_task_ids = [line.strip() for line in sys.stdin if line.strip()]
+        verbose_print(f"Received {len(piped_task_ids)} task IDs from pipe")
+
+        # If we have piped task IDs but no task_id is specified yet
+        if piped_task_ids:
+            # If there's only one task ID from pipe and no task_id specified, use it directly
+            if len(piped_task_ids) == 1 and not task_id:
+                task_id = piped_task_ids[0]
+                verbose_print(f"Using single piped task ID: {task_id}")
+            # If there are multiple task IDs, use them to build an extra filter
+            elif len(piped_task_ids) > 1:
+                # Build a filter to include all piped task IDs
+                extra_filter = {"_id": {"$in": piped_task_ids}}
+
+                verbose_print(
+                    f"Created filter from {len(piped_task_ids)} piped task IDs"
+                )
 
     # readonly fields
     readonly_fields: Set[str] = (
@@ -541,7 +603,7 @@ def handle_editor_mode(old_tasks, readonly_fields, editor):
                     try:
                         task_updates.append(
                             TaskUpdateRequest(
-                                _id=old_tasks[i].task_id,
+                                task_id=old_tasks[i].task_id,
                                 replace_fields=replace_fields,
                                 **ud,
                             )
@@ -569,12 +631,12 @@ def handle_editor_mode(old_tasks, readonly_fields, editor):
                     raise typer.Abort()
                 # Continue the loop with the current file state
 
+        return task_updates
+
     finally:
         if temp_file_path and temp_file_path.exists():
             temp_file_path.unlink()
 
-    return task_updates
-
 
 def handle_non_editor_mode(old_tasks, updates, readonly_fields):
     """Handles update tasks without an editor and returns task updates."""
@@ -595,7 +657,7 @@ def handle_non_editor_mode(old_tasks, updates, readonly_fields):
     for i, task in enumerate(old_tasks):
         task_updates.append(
             TaskUpdateRequest(
-                _id=task.task_id, replace_fields=replace_fields, **update_dict
+                task_id=task.task_id, replace_fields=replace_fields, **update_dict
             )
         )
 
@@ -655,6 +717,9 @@ def display_updated_tasks(updated_tasks, update_dicts):
     console = rich.console.Console()
     with console.capture() as capture:
         console.print(Syntax(s.getvalue(), "yaml"))
+
+    # use normal pager instead of echo_via_pager_no_check_isatty
+    # because it would break the test cases for update task
     click.echo_via_pager(capture.get())
 
 
@@ -662,7 +727,7 @@ def display_updated_tasks(updated_tasks, update_dicts):
 @cli_utils_decorator
 def delete(
     task_ids: List[str] = typer.Argument(
-        ... if sys.stdin.isatty() else None,
+        ... if not is_piped_io() else None,
         help="IDs of the task to delete.",
     ),
     yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation prompt."),