df

SYS/tasks.py

@@ -1,4 +1,5 @@
 """Background task handling and IPC helpers for mpv integration."""
+
 from __future__ import annotations
 import errno
 import json
@@ -11,16 +12,18 @@ from SYS.logger import log
 import threading
 import time
 from typing import IO, Iterable
+
+
 def connect_ipc(path: str, timeout: float = 5.0) -> IO[bytes] | None:
     """Connect to the mpv IPC server located at *path*."""
     deadline = time.time() + timeout
     if not path:
         return None
-    if os.name == 'nt':
+    if os.name == "nt":
         # mpv exposes a named pipe on Windows. Keep retrying until it is ready.
         while True:
             try:
-                return open(path, 'r+b', buffering=0)
+                return open(path, "r+b", buffering=0)
             except FileNotFoundError:
                 if time.time() > deadline:
                     return None
@@ -38,7 +41,7 @@ def connect_ipc(path: str, timeout: float = 5.0) -> IO[bytes] | None:
         while True:
             try:
                 sock.connect(path)
-                return sock.makefile('r+b', buffering=0)
+                return sock.makefile("r+b", buffering=0)
             except FileNotFoundError:
                 if time.time() > deadline:
                     return None
@@ -49,74 +52,92 @@ def connect_ipc(path: str, timeout: float = 5.0) -> IO[bytes] | None:
                 if time.time() > deadline:
                     return None
                 time.sleep(0.05)
+
+
 def ipc_sender(ipc: IO[bytes] | None):
     """Create a helper function for sending script messages via IPC."""
     if ipc is None:
+
         def _noop(_event: str, _payload: dict) -> None:
             return None
+
         return _noop
     lock = threading.Lock()
+
     def _send(event: str, payload: dict) -> None:
-        message = json.dumps({'command': ['script-message', event, json.dumps(payload)]}, ensure_ascii=False)
-        encoded = message.encode('utf-8') + b'\n'
+        message = json.dumps(
+            {"command": ["script-message", event, json.dumps(payload)]}, ensure_ascii=False
+        )
+        encoded = message.encode("utf-8") + b"\n"
         with lock:
             try:
                 ipc.write(encoded)
                 ipc.flush()
             except OSError:
                 pass
+
     return _send
+
+
 def iter_stream(stream: Iterable[str]) -> Iterable[str]:
     for raw in stream:
-        yield raw.rstrip('\r\n')
+        yield raw.rstrip("\r\n")
+
+
 def _run_task(args, parser) -> int:
     if not args.command:
         parser.error('run-task requires a command to execute (use "--" before the command).')
     env = os.environ.copy()
     for entry in args.env:
-        key, sep, value = entry.partition('=')
+        key, sep, value = entry.partition("=")
         if not sep:
-            parser.error(f'Invalid environment variable definition: {entry!r}')
+            parser.error(f"Invalid environment variable definition: {entry!r}")
         env[key] = value
     command = list(args.command)
-    if command and command[0] == '--':
+    if command and command[0] == "--":
         command.pop(0)
     notifier = ipc_sender(connect_ipc(args.ipc, timeout=args.ipc_timeout))
     if not command:
-        notifier('downlow-task-event', {
-            'id': args.task_id,
-            'event': 'error',
-            'message': 'No command provided after separator',
-        })
-        log('[downlow.py] No command provided for run-task', file=sys.stderr)
+        notifier(
+            "downlow-task-event",
+            {
+                "id": args.task_id,
+                "event": "error",
+                "message": "No command provided after separator",
+            },
+        )
+        log("[downlow.py] No command provided for run-task", file=sys.stderr)
         return 1
     if command and isinstance(command[0], str) and sys.executable:
         first = command[0].lower()
-        if first in {'python', 'python3', 'py', 'python.exe', 'python3.exe', 'py.exe'}:
+        if first in {"python", "python3", "py", "python.exe", "python3.exe", "py.exe"}:
             command[0] = sys.executable
-    if os.environ.get('DOWNLOW_DEBUG'):
+    if os.environ.get("DOWNLOW_DEBUG"):
         log(f"Launching command: {command}", file=sys.stderr)
-    notifier('downlow-task-event', {
-        'id': args.task_id,
-        'event': 'start',
-        'command': command,
-        'cwd': args.cwd or os.getcwd(),
-    })
+    notifier(
+        "downlow-task-event",
+        {
+            "id": args.task_id,
+            "event": "start",
+            "command": command,
+            "cwd": args.cwd or os.getcwd(),
+        },
+    )
 
     popen_kwargs = {}
-    if os.name == 'nt':
+    if os.name == "nt":
         # Avoid flashing a console window when spawning console-subsystem executables.
         flags = 0
         try:
-            flags |= int(getattr(subprocess, 'CREATE_NO_WINDOW', 0x08000000))
+            flags |= int(getattr(subprocess, "CREATE_NO_WINDOW", 0x08000000))
         except Exception:
             flags |= 0x08000000
-        popen_kwargs['creationflags'] = flags
+        popen_kwargs["creationflags"] = flags
         try:
             si = subprocess.STARTUPINFO()
             si.dwFlags |= subprocess.STARTF_USESHOWWINDOW
             si.wShowWindow = subprocess.SW_HIDE
-            popen_kwargs['startupinfo'] = si
+            popen_kwargs["startupinfo"] = si
         except Exception:
             pass
     try:
@@ -132,44 +153,59 @@ def _run_task(args, parser) -> int:
             **popen_kwargs,
         )
     except FileNotFoundError as exc:
-        notifier('downlow-task-event', {
-            'id': args.task_id,
-            'event': 'error',
-            'message': f'Executable not found: {exc.filename}',
-        })
+        notifier(
+            "downlow-task-event",
+            {
+                "id": args.task_id,
+                "event": "error",
+                "message": f"Executable not found: {exc.filename}",
+            },
+        )
         log(f"{exc}", file=sys.stderr)
         return 1
     stdout_lines: list[str] = []
     stderr_lines: list[str] = []
+
     def pump(stream: IO[str], label: str, sink: list[str]) -> None:
         for line in iter_stream(stream):
             sink.append(line)
-            notifier('downlow-task-event', {
-                'id': args.task_id,
-                'event': label,
-                'line': line,
-            })
+            notifier(
+                "downlow-task-event",
+                {
+                    "id": args.task_id,
+                    "event": label,
+                    "line": line,
+                },
+            )
+
     threads = []
     if process.stdout:
-        t_out = threading.Thread(target=pump, args=(process.stdout, 'stdout', stdout_lines), daemon=True)
+        t_out = threading.Thread(
+            target=pump, args=(process.stdout, "stdout", stdout_lines), daemon=True
+        )
         t_out.start()
         threads.append(t_out)
     if process.stderr:
-        t_err = threading.Thread(target=pump, args=(process.stderr, 'stderr', stderr_lines), daemon=True)
+        t_err = threading.Thread(
+            target=pump, args=(process.stderr, "stderr", stderr_lines), daemon=True
+        )
         t_err.start()
         threads.append(t_err)
     return_code = process.wait()
     for t in threads:
         t.join(timeout=0.1)
-    notifier('downlow-task-event', {
-        'id': args.task_id,
-        'event': 'exit',
-        'returncode': return_code,
-        'success': return_code == 0,
-    })
+    notifier(
+        "downlow-task-event",
+        {
+            "id": args.task_id,
+            "event": "exit",
+            "returncode": return_code,
+            "success": return_code == 0,
+        },
+    )
     # Also mirror aggregated output to stdout/stderr for compatibility when IPC is unavailable.
     if stdout_lines:
-        log('\n'.join(stdout_lines))
+        log("\n".join(stdout_lines))
     if stderr_lines:
-        log('\n'.join(stderr_lines), file=sys.stderr)
+        log("\n".join(stderr_lines), file=sys.stderr)
     return return_code