libpipe 0.6__tar.gz → 0.7__tar.gz

{libpipe-0.6 → libpipe-0.7}/PKG-INFO

@@ -1,23 +1,28 @@
 Metadata-Version: 2.4
 Name: libpipe
-Version: 0.6
+Version: 0.7
 Summary: Pipeline orchestration and node management utilities
-License: GPL-3.0-or-later
+License-Expression: GPL-3.0-or-later
 License-File: LICENSE
 Author: Florent Mertens
 Author-email: florent.mertens@gmail.com
-Requires-Python: >=3.10
-Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
+Requires-Python: >=3.10,<4.0
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Provides-Extra: dev
 Requires-Dist: asyncssh (>=2.0)
 Requires-Dist: click (>=8.0)
 Requires-Dist: progressbar2 (>=3.40)
+Requires-Dist: pytest (>=8.0) ; extra == "dev"
+Requires-Dist: pytest-cov (>=5.0) ; extra == "dev"
+Requires-Dist: ruff (==0.16.1) ; extra == "dev"
 Requires-Dist: toml (>=0.10)
+Project-URL: Homepage, https://gitlab.com/flomertens/libpipe
+Project-URL: Issues, https://gitlab.com/flomertens/libpipe/-/issues
 Project-URL: Repository, https://gitlab.com/flomertens/libpipe
 Description-Content-Type: text/markdown
 

{libpipe-0.6 → libpipe-0.7}/libpipe/attrmap.py

@@ -1,11 +1,10 @@
 # Some parts inspired by the AttrDict package written by Brendan Curran-Johnson (MIT Licence)
 
-import re
+import collections
 import copy
 import functools
-
+import re
 from collections.abc import Mapping
-import collections
 
 
 def merge(left, right):
@@ -130,7 +129,7 @@ class AttrMap(Mapping):
         # sequence type seems like more trouble than it is worth.
         # If people want full serialization, they can pickle, and in
         # 99% of cases, sequence_type won't change anyway
-        return "AttrMap({mapping})".format(mapping=repr(self._mapping))
+        return f"AttrMap({self._mapping!r})"
 
     @classmethod
     def _valid_name(cls, key):
@@ -158,9 +157,7 @@ class AttrMap(Mapping):
 
         if key not in self or not self._valid_name(key):
             raise AttributeError(
-                "'{cls}' instance has no attribute '{name}'".format(
-                    cls=self.__class__.__name__, name=key
-                )
+                f"'{self.__class__.__name__}' instance has no attribute '{key}'"
             )
 
         return self._build(self[key])
@@ -251,9 +248,7 @@ class AttrMap(Mapping):
             Mapping.__setattr__(self, key, value)
         else:
             raise TypeError(
-                "'{cls}' does not allow attribute creation.".format(
-                    cls=self.__class__.__name__
-                )
+                f"'{self.__class__.__name__}' does not allow attribute creation."
             )
 
     def __delattr__(self, key, force=False):  # pragma: no cover
@@ -267,9 +262,7 @@ class AttrMap(Mapping):
             Mapping.__delattr__(self, key, force=force)
         else:
             raise TypeError(
-                "'{cls}' does not allow attribute deletion.".format(
-                    cls=self.__class__.__name__
-                )
+                f"'{self.__class__.__name__}' does not allow attribute deletion."
             )
 
     def set_data(self, mapping):
@@ -301,7 +294,7 @@ class AttrMap(Mapping):
 
     def get(self, key, default=None):
         try:
-            return functools.reduce(lambda x, y: x[y], [self] + key.split('.'))
+            return functools.reduce(lambda x, y: x[y], [self, *key.split('.')])
         except KeyError:
             return None
 
@@ -356,8 +349,8 @@ class OrderedSet(collections.abc.MutableSet):
 
     def __repr__(self):
         if not self:
-            return '%s()' % (self.__class__.__name__,)
-        return '%s(%r)' % (self.__class__.__name__, list(self))
+            return f'{self.__class__.__name__}()'
+        return f'{self.__class__.__name__}({list(self)!r})'
 
     def __eq__(self, other):
         if isinstance(other, OrderedSet):

{libpipe-0.6 → libpipe-0.7}/libpipe/futils.py

@@ -2,10 +2,10 @@
 #
 # Author: F. Mertens
 
-import re
 import os
-import time
+import re
 import shutil
+import time
 
 
 def file_not_found_retry(fct, n_try, *args, **kargs):
@@ -28,7 +28,7 @@ def reglob(path, exp, invert=False):
     else:
         res = [f for f in os.listdir(path) if not m.search(f)]
 
-    return map(lambda x: "%s/%s" % (path, x, ), res)
+    return (f"{path}/{x}" for x in res)
 
 
 def rm_if_exist(directory, verbose=False):
@@ -54,21 +54,23 @@ def is_file(f):
 def zip_copy(dir_ins, dir_outs, filename, filename_out=None, verbose=True, n_retry=1):
     if not filename_out:
         filename_out = filename
-    for dir_in, dir_out in zip(dir_ins, dir_outs):
+    for dir_in, dir_out in zip(dir_ins, dir_outs, strict=False):
         if verbose:
             print(f'Copy {dir_in}/{filename} -> {dir_out}/{filename_out}')
-        file_not_found_retry(shutil.copyfile, n_retry, f'{dir_in}/{filename}', f'{dir_out}/{filename_out}')
+        file_not_found_retry(shutil.copyfile, n_retry, f'{dir_in}/{filename}',
+                             f'{dir_out}/{filename_out}')
 
 
 def zip_copytree(dir_ins, dir_outs, dirname, verbose=True, n_retry=1):
-    for dir_in, dir_out in zip(dir_ins, dir_outs):
+    for dir_in, dir_out in zip(dir_ins, dir_outs, strict=False):
         if verbose:
             print(f'Copy {dir_in}/{dirname} -> {dir_out}/{dirname}')
-        file_not_found_retry(shutil.copytree, n_retry, f'{dir_in}/{dirname}', f'{dir_out}/{dirname}')
+        file_not_found_retry(shutil.copytree, n_retry, f'{dir_in}/{dirname}',
+                             f'{dir_out}/{dirname}')
 
 
 def zip_rename(dir_ins, dir_outs, filename_or_dirname=None, verbose=True, n_retry=1):
-    for f_in, f_out in zip(dir_ins, dir_outs):
+    for f_in, f_out in zip(dir_ins, dir_outs, strict=False):
         if filename_or_dirname is not None:
             f_in = f'{f_in}/{filename_or_dirname}'
             f_out = f'{f_out}/{filename_or_dirname}'
@@ -78,7 +80,7 @@ def zip_rename(dir_ins, dir_outs, filename_or_dirname=None, verbose=True, n_retr
 
 
 def zip_rename_reg(dir_ins, dir_outs, regex, verbose=True, invert=False, n_retry=1):
-    for f_in, f_out in zip(dir_ins, dir_outs):
+    for f_in, f_out in zip(dir_ins, dir_outs, strict=False):
         for f_in2 in reglob(f_in, regex, invert=invert):
             f_out2 = f'{f_out}/{os.path.basename(f_in2)}'
             if verbose:

{libpipe-0.6 → libpipe-0.7}/libpipe/settings.py

@@ -71,11 +71,8 @@ class BaseSettings(attrmap.AttrMap):
         else:
             for k, v in c_file.items():
                 if isinstance(v, dict):
-                    if 'type' in v.keys():
-                        t = v['type']
-                    else:
-                        t = k
-                    if t not in c_default.keys():
+                    t = v.get('type', k)
+                    if t not in c_default:
                         print(f'Warning: no default for section {k} of type {t}')
                         continue
                     t_default = c_default[t]
@@ -120,7 +117,8 @@ class BaseSettings(attrmap.AttrMap):
             with open(file, mode='w') as f:
                 toml.dump(dict(m), f)
 
-    def duplicate(self, out_file, copy_parset_files=False, strip_parents_keys=False, **config_modifiers):
+    def duplicate(self, out_file, copy_parset_files=False, strip_parents_keys=False,
+                  **config_modifiers):
         s_out = self.copy()
         s_out.set_file(out_file)
         s_out['default_settings'] = ''

{libpipe-0.6 → libpipe-0.7}/libpipe/tools/nodetool.py

@@ -1,13 +1,11 @@
 #!/usr/bin/env python
 
-import os
 import json
+import os
 
 import click
 
-from libpipe import worker
-from libpipe import __version__
-
+from libpipe import __version__, worker
 
 t_file = click.Path(exists=True, dir_okay=False)
 
@@ -21,7 +19,8 @@ def main():
 @main.command('run_all')
 @click.argument('cmd_list', type=t_file)
 @click.option('--nodes_string', '-n', help='Range of nodes to use', type=str, default='localhost')
-@click.option('--max_concurrent', '-m', help='Maximum concurrent tasks on a node', type=int, default=5)
+@click.option('--max_concurrent', '-m', type=int, default=5,
+              help='Maximum concurrent tasks on a node')
 @click.option('--env_file', '-e', help='Environment source file', type=t_file)
 @click.option('--dry_run', '-d', help='Dry run, only print commands', is_flag=True)
 @click.option('--log_file', help='Log output to log_file', type=str, default=None)
@@ -31,7 +30,10 @@ def run_all(cmd_list, nodes_string, max_concurrent, env_file, dry_run, log_file)
                                   env_file=env_file, dry_run=dry_run, debug=dry_run)
 
     i_log_file = log_file
-    for i, cmd in enumerate(open(cmd_list).readlines()):
+    with open(cmd_list) as f:
+        cmds = f.readlines()
+
+    for i, cmd in enumerate(cmds):
         if log_file is not None:
             i_log_file = log_file + f'.{i + 1}'
         pool.add(cmd.strip(), output_file=i_log_file)
@@ -64,7 +66,7 @@ def run_on_all_nodes(cmd, nodes_string, env_file, dry_run):
 @click.option('--log_file', '-l', help='Log output to log_file', type=str, default=None)
 def init_job(name, cmd, target_node, log_file):
     ''' Add a job to a job list file NAME. If job file does not exist, create one. '''
-    if os.path.exists(name):        
+    if os.path.exists(name):
         with open(name) as json_file:
             jobs = json.load(json_file)
     else:
@@ -78,9 +80,11 @@ def init_job(name, cmd, target_node, log_file):
 
 @main.command('run_joblist')
 @click.argument('name', type=t_file)
-@click.option('--nodes_string', '-n', help='Range of nodes to use. By default use the target nodes in the joblist',
+@click.option('--nodes_string', '-n',
+              help='Range of nodes to use. By default use the target nodes in the joblist',
               type=str, default='joblist')
-@click.option('--max_concurrent', '-m', help='Maximum concurrent tasks on a node', type=int, default=5)
+@click.option('--max_concurrent', '-m', type=int, default=5,
+              help='Maximum concurrent tasks on a node')
 @click.option('--env_file', '-e', help='Environment source file', type=t_file)
 @click.option('--dry_run', '-d', help='Dry run, only print commands', is_flag=True)
 @click.option('--worker_name', '-w', help='Name of the worker', type=str, default='Run joblist')
@@ -90,7 +94,7 @@ def run_joblist(name, nodes_string, max_concurrent, env_file, dry_run, worker_na
         jobs = json.load(json_file)
 
     if nodes_string == 'joblist':
-        all_nodes = set([job['target_node'] for job in jobs['jobs'] if job['target_node'] is not None])
+        all_nodes = {job['target_node'] for job in jobs['jobs'] if job['target_node'] is not None}
         if len(all_nodes) == 0:
             all_nodes = ['localhost']
     else:

{libpipe-0.6 → libpipe-0.7}/libpipe/worker.py

@@ -2,24 +2,24 @@
 #
 # Authors: F.Mertens
 
+import asyncio
+import collections
+import contextlib
+import datetime
+import getpass
+import itertools
 import os
 import re
-import sys
-import time
 import shlex
-import socket
 import signal
-import getpass
-import asyncio
-import datetime
-import itertools
-import collections
+import socket
+import sys
+import time
 from enum import Enum
 
 import asyncssh
 import progressbar
-from click import style, secho
-
+from click import secho, style
 
 localhost_shortname = socket.gethostname().split('.', 1)[0]
 
@@ -48,7 +48,7 @@ def expend_num_ranges(s):
 
 
 def get_hosts(host_string):
-    hosts = list(set(host for k in host_string.split(',') for host in expend_num_ranges(k)))
+    hosts = list({host for k in host_string.split(',') for host in expend_num_ranges(k)})
     return [localhost_shortname if h == 'localhost' else h for h in hosts]
 
 
@@ -74,14 +74,14 @@ class WorkerStatus(Enum):
     CLOSED = 4
 
 
-class Process(object):
+class Process:
 
     def __init__(self, client, process):
         self.client = client
         self.process = process
 
 
-class Task(object):
+class Task:
     """Represent a task executed by the worker pool
 
     Attributes:
@@ -115,46 +115,50 @@ class Task(object):
             try:
                 self._done_callback()
             except Exception as exc:
-                err_msg = f'Error executing return callback of task {self.name}: {str(exc)}\n'
+                err_msg = f'Error executing return callback of task {self.name}: {exc!s}\n'
         if self._task_done_callback is not None:
             try:
                 self._task_done_callback(self)
             except Exception as exc:
-                err_msg = f'Error executing return callback of task {self.name}: {str(exc)}\n'
+                err_msg = f'Error executing return callback of task {self.name}: {exc!s}\n'
 
         return err_msg
 
     def init_log(self):
         if self.output_file is not None:
-            self.fd = open(self.output_file, 'w')
+            self.fd = open(self.output_file, 'w')  # noqa: SIM115 - closed in close_log()
             self.fd.write(f'# Logging starting at {datetime.datetime.now()}\n')
             self.fd.write(f'# Input command: {self.command}\n')
 
     def set_process(self, process):
         self.process = process
         if hasattr(self.process.process, 'pid'):
-            self.log(f'Starting on host {self.process.client.host} with PID {self.process.process.pid}\n\n', 
-                     self.process.client.host)
+            self.log(f'Starting on host {self.process.client.host} with PID '
+                     f'{self.process.process.pid}\n\n', self.process.client.host)
             if self.pid_filename is not None:
                 try:
                     with open(self.pid_filename, 'w') as fd:
                         fd.write(f'{self.process.client.host} {self.process.process.pid}')
-                    self.log(f'Starting on host {self.process.client.host} with PID {self.process.process.pid}\n\n',
-                             self.process.client.host)
+                    self.log(f'Starting on host {self.process.client.host} with PID '
+                             f'{self.process.process.pid}\n\n', self.process.client.host)
                 except Exception:
-                    self.log(f'Error creating PID file {self.pid_filename}', self.process.client.host, err=True)
+                    self.log(f'Error creating PID file {self.pid_filename}',
+                             self.process.client.host, err=True)
 
     async def terminate(self):
         if self.process is not None and hasattr(self.process.process, 'pid'):
             if self.process.client.host == localhost_shortname:
-                self.log(f'Killing local process PID {self.process.process.pid}\n', 'local', err=True)
+                self.log(f'Killing local process PID {self.process.process.pid}\n',
+                         'local', err=True)
                 try:
                     os.killpg(os.getpgid(self.process.process.pid), signal.SIGTERM)
                 except ProcessLookupError:
                     print(f'Process {self.process.process.pid} not found')
             else:
-                self.log(f'Killing remote process PID {self.process.process.pid}\n', self.process.client.host, err=True)
-                kill_remote(self.process.client.host, self.process.client.user, self.process.process.pid)
+                self.log(f'Killing remote process PID {self.process.process.pid}\n',
+                         self.process.client.host, err=True)
+                kill_remote(self.process.client.host, self.process.client.user,
+                            self.process.process.pid)
 
     def log(self, line, host, err=False):
         if isinstance(line, bytes):
@@ -178,12 +182,13 @@ class Task(object):
             self.log(line, host, err=err)
 
     def close_log(self):
-        if self.pid_filename and os.path.exists(self.pid_filename):
-            if not self.keep_pid_file_on_error or self.returncode == 0:
-                os.remove(self.pid_filename)
+        if (self.pid_filename and os.path.exists(self.pid_filename)
+                and (not self.keep_pid_file_on_error or self.returncode == 0)):
+            os.remove(self.pid_filename)
         if self.fd is not None:
             try:
-                self.fd.write(f'\n\n# Logging stopped at {datetime.datetime.now()} with code: {self.returncode}\n')
+                self.fd.write(f'\n\n# Logging stopped at {datetime.datetime.now()} '
+                              f'with code: {self.returncode}\n')
                 self.fd.close()
             except Exception:
                 print(f'Error closing log file for task {self.name}. Ignoring.')
@@ -225,7 +230,7 @@ class SSHClient(asyncssh.SSHClient):
 
     def connection_made(self, conn):
         self.connected = True
-        print('Connection made to %s.' % conn.get_extra_info('peername')[0])
+        print('Connection made to {}.'.format(conn.get_extra_info('peername')[0]))
 
     def connection_lost(self, exc):
         if exc:
@@ -234,7 +239,7 @@ class SSHClient(asyncssh.SSHClient):
         self.connected = False
 
 
-class Client(object):
+class Client:
 
     def __init__(self, host, user=None, force_sync=True, password=None, connect_timeout=15):
         self.host = host
@@ -295,7 +300,7 @@ class Client(object):
 
         async with self.creating_session:
             process = await self.conn.create_process('echo $$;' + task.command)
-        
+
         try:
             process.pid = int(await process.stdout.readline())
         except ValueError:
@@ -325,7 +330,7 @@ class Client(object):
         return self.client is not None and self.client.connected
 
 
-class LocalClient(object):
+class LocalClient:
 
     def __init__(self, host='local', force_sync=True):
         self.host = host
@@ -336,8 +341,9 @@ class LocalClient(object):
         self.started.set()
 
     async def execute(self, task):
-        process = await asyncio.create_subprocess_shell(task.command, stdout=asyncio.subprocess.PIPE,
-                                                        stderr=asyncio.subprocess.PIPE, preexec_fn=os.setpgrp)
+        process = await asyncio.create_subprocess_shell(
+            task.command, stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE, preexec_fn=os.setpgrp)
         task.set_process(Process(self, process))
 
         await asyncio.gather(
@@ -358,7 +364,7 @@ class LocalClient(object):
         pass
 
 
-class Worker(object):
+class Worker:
 
     def __init__(self, client, name):
         self.client = client
@@ -376,13 +382,11 @@ class Worker(object):
         try:
             await self.client.start()
         except Exception as exc:
-            err_msg = f'Error starting client: {str(exc)}\n'
+            err_msg = f'Error starting client: {exc!s}\n'
             # transient failure: allow task retry to pick a worker again
             self.status = WorkerStatus.IDLE
-            try:
+            with contextlib.suppress(Exception):
                 self.client.close()  # ensure clean slate
-            except Exception:
-                pass
             return False, err_msg
 
         await self.client.started.wait()
@@ -390,18 +394,16 @@ class Worker(object):
         try:
             await self.client.execute(task)
         except ConnectionError as exc:
-            err_msg = f'Error connecting client: {str(exc)}\n'
+            err_msg = f'Error connecting client: {exc!s}\n'
             self.status = WorkerStatus.IDLE
-            try:
+            with contextlib.suppress(Exception):
                 self.client.close()
-            except Exception:
-                pass
             return False, err_msg
         except asyncio.CancelledError:
             err_msg = f'Task {self.name} has been canceled\n'
             return True, err_msg
         except Exception as exc:
-            err_msg = f'Error executing task {self.name}: {str(exc)}\n'
+            err_msg = f'Error executing task {self.name}: {exc!s}\n'
             self.status = WorkerStatus.IDLE
             return False, err_msg
 
@@ -452,7 +454,7 @@ class WorkerPoolReport:
         return task.run_on_host or "?"
 
 
-class WorkerPool(object):
+class WorkerPool:
 
     def __init__(self, hosts, name='Worker', max_tasks_per_worker=4,
                  env_source_file=None, user=None, max_time=None, force_sync=False,
@@ -463,11 +465,13 @@ class WorkerPool(object):
         Args:
             name (str): Name of the worker pool.
             hosts (list): List of host names, reachable via ssh (if not local host).
-            max_tasks_per_worker (int, optional): Maximum number of tasks to execute concurrently on an host.
+            max_tasks_per_worker (int, optional): Maximum number of tasks to execute
+                concurrently on an host.
             env_source_file (str, optional): Name of a file to source before executing a task.
             user (str, optional): User to connect
             connect_timeout (int, optional): Per-attempt SSH connection timeout, in seconds.
-            host_cooldown_s (int, optional): Time a just-failed host is avoided while a healthy one exists.
+            host_cooldown_s (int, optional): Time a just-failed host is avoided while
+                a healthy one exists.
         """
         if asyncio.get_event_loop().is_closed():
             asyncio.set_event_loop(asyncio.new_event_loop())
@@ -534,9 +538,10 @@ class WorkerPool(object):
 
             await asyncio.sleep(0.1)
 
-    def add(self, command, name=None, output_file=None, task_done_callback=None, done_callback=None, 
+    def add(self, command, name=None, output_file=None, task_done_callback=None, done_callback=None,
             run_on_host=None, n_try=3, pid_filename=None, keep_pid_file_on_error=False):
-        """Add a command to execute by a worker in the pool. Optionally output result in output_file.
+        """Add a command to execute by a worker in the pool. Optionally output result
+        in output_file.
 
         Args:
             command (str): Command to execute.
@@ -544,13 +549,11 @@ class WorkerPool(object):
             output_file (str, optional): Optional filename to log output into.
         """
         if run_on_host is not None and run_on_host not in self.hosts:
-            print(f'Requested run_on_host "{run_on_host}" is not in the hosts list. Releasing constraint ...')
+            print(f'Requested run_on_host "{run_on_host}" is not in the hosts list. '
+                  'Releasing constraint ...')
             run_on_host = None
 
-        if self.env_file:
-            script = f". {shlex.quote(self.env_file)}; {command}"
-        else:
-            script = command
+        script = f". {shlex.quote(self.env_file)}; {command}" if self.env_file else command
 
         command = f"bash -lc {shlex.quote(script)}"
 
@@ -563,8 +566,9 @@ class WorkerPool(object):
             return
 
         self.tasks.append(Task(name, command, output_file=output_file, done_callback=done_callback,
-                               task_done_callback=task_done_callback, run_on_host=run_on_host, n_try=n_try, 
-                               pid_filename=pid_filename, keep_pid_file_on_error=keep_pid_file_on_error))
+                               task_done_callback=task_done_callback, run_on_host=run_on_host,
+                               n_try=n_try, pid_filename=pid_filename,
+                               keep_pid_file_on_error=keep_pid_file_on_error))
 
     def get_all_tasks(self):
         tasks = collections.defaultdict(list)
@@ -589,8 +593,10 @@ class WorkerPool(object):
                             if running_time > (self.max_time + update_interval):
                                 task = worker.running_task
                                 task.timed_out = True
-                                task.log(f'Task timeout: waited for {running_time:.2f} s', worker.client.host, err=True)
-                                task.log(f'Command was: {task.command}', worker.client.host, err=True)
+                                task.log(f'Task timeout: waited for {running_time:.2f} s',
+                                         worker.client.host, err=True)
+                                task.log(f'Command was: {task.command}',
+                                         worker.client.host, err=True)
                                 await task.terminate()
 
         except asyncio.CancelledError:
@@ -632,7 +638,8 @@ class WorkerPool(object):
 
         loop = asyncio.get_event_loop()
 
-        loop.add_signal_handler(signal.SIGTERM, lambda: asyncio.ensure_future(self.shutdown(exit_code=1)))
+        loop.add_signal_handler(signal.SIGTERM,
+                                lambda: asyncio.ensure_future(self.shutdown(exit_code=1)))
 
         try:
             loop.run_until_complete(self.process_tasks())
@@ -640,7 +647,7 @@ class WorkerPool(object):
             loop.run_until_complete(self.terminate_all())
             raise
         except asyncio.CancelledError:
-            secho(f'Error: one (or more) task(s) have been canceled', fg='red')
+            secho('Error: one (or more) task(s) have been canceled', fg='red')
         finally:
             for worker in self.workers:
                 worker.close()
@@ -668,7 +675,8 @@ class WorkerPool(object):
             if report.failed:
                 print("\nFailed tasks:")
                 for t in report.failed:
-                    print(f" - {t.name} | status={t.status.name} | host={report.host_of(t)} | rc={t.returncode}")
+                    print(f" - {t.name} | status={t.status.name} | "
+                          f"host={report.host_of(t)} | rc={t.returncode}")
 
             print("==========================\n")
 

libpipe-0.7/pyproject.toml

@@ -0,0 +1,61 @@
+[build-system]
+requires = ["poetry-core>=2.0"]
+build-backend = "poetry.core.masonry.api"
+
+[project]
+name = "libpipe"
+version = "0.7"
+description = "Pipeline orchestration and node management utilities"
+readme = "README.md"
+license = "GPL-3.0-or-later"
+authors = [
+    { name = "Florent Mertens", email = "florent.mertens@gmail.com" }
+]
+requires-python = ">=3.10,<4.0"
+
+dependencies = [
+    "asyncssh>=2.0",
+    "progressbar2>=3.40",
+    "toml>=0.10",
+    "click>=8.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0",
+    "pytest-cov>=5.0",
+    "ruff==0.16.1",
+]
+
+[project.urls]
+Homepage = "https://gitlab.com/flomertens/libpipe"
+Repository = "https://gitlab.com/flomertens/libpipe"
+Issues = "https://gitlab.com/flomertens/libpipe/-/issues"
+
+[project.scripts]
+nodetool = "libpipe.tools.nodetool:main"
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+
+[tool.ruff.lint]
+select = [
+    "E",
+    "W",
+    "F",
+    "I",
+    "B",
+    "UP",
+    "C4",
+    "SIM",
+    "PIE",
+    "NPY",
+    "RUF",
+]
+
+[tool.ruff.lint.per-file-ignores]
+"**/__init__.py" = ["F401"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

libpipe-0.6/pyproject.toml

@@ -1,34 +0,0 @@
-[build-system]
-requires = ["poetry-core>=1.9.0"]
-build-backend = "poetry.core.masonry.api"
-
-[project]
-name = "libpipe"
-version = "0.6"
-description = "Pipeline orchestration and node management utilities"
-readme = "README.md"
-license = { text = "GPL-3.0-or-later" }
-authors = [
-    { name = "Florent Mertens", email = "florent.mertens@gmail.com" }
-]
-requires-python = ">=3.10"
-
-dependencies = [
-    "asyncssh>=2.0",
-    "progressbar2>=3.40",
-    "toml>=0.10",
-    "click>=8.0",
-]
-
-[project.urls]
-Repository = "https://gitlab.com/flomertens/libpipe"
-
-[project.scripts]
-nodetool = "libpipe.tools.nodetool:main"
-
-[tool.poetry.group.dev.dependencies]
-pytest = "^8.0"
-pytest-cov = "^5.0"
-
-[tool.pytest.ini_options]
-testpaths = ["tests"]