multiCMD 1.56__tar.gz → 1.58__tar.gz

{multicmd-1.56 → multicmd-1.58}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: multiCMD
-Version: 1.56
+Version: 1.58
 Summary: Run commands simultaneously
 Home-page: https://github.com/yufei-pan/multiCMD
 Author: Yufei Pan
@@ -56,7 +56,7 @@ It works both as a command-line tool and as an importable wrapper around
 pip install multiCMD
 ```
 
-This installs the module and three equivalent console entry points:
+This installs the module and three equivalent commands:
 
 ```bash
 mcmd
@@ -491,6 +491,24 @@ pytest -m "not slow"   # skip intentional sleep-heavy cases
 
 `test_expand_ranges_perf.py` is a manual performance microbenchmark and is not collected by pytest.
 
+## Upgrading to 1.58 from 1.57
+
+- The `multiCMD` command is now a script file, not an entry point, so `entry_points.txt` no longer has two names that differ only in case. All three commands still work the same way, except in the venv case below. From 1.58 on, stock pip 9 on EL7 and EL8 upgrades and uninstalls multiCMD without `configparser.DuplicateOptionError`.
+- With pip 9, the pip of EL7 and EL8 (`pip3 --version`), upgrading from 1.57 or earlier and `pip3 uninstall multiCMD` of those releases stop with `configparser.DuplicateOptionError: ... option 'multicmd' in section 'console_scripts' already exists`, and nothing changes: the installed release keeps working. Run `pip3 install -U pip` once, then upgrade or uninstall.
+- With `--user` the same happens, except that `pip3 install --user -U multiCMD` with no version does not stop: it installs the new release, which works, and leaves the old release's metadata behind. `pip3 list` then shows the old release after `pip3 uninstall multiCMD`, and the next uninstall stops with that error. To avoid this, run `pip3 install --user -U pip` once first. If it has already happened, run that, run `pip3 uninstall multiCMD` until it says multiCMD is not installed, and install again. From 1.58 on the same upgrade leaves the metadata too, but with no error: `pip3 uninstall multiCMD` takes one run per release left.
+- Without `--user`, with multiCMD 1.57 or earlier installed, `pip3 install -U hpcp`, `statblk` or `statbtrfs` stops the same way once a newer multiCMD is out, because pip 9 upgrades dependencies too. `pip3 install -U --no-deps hpcp` gets past it.
+- With pip 10 or later, in a venv whose path has a space or is too long for the kernel's `#!` line, the `multiCMD` spelling does not start (the error varies: "bad interpreter", `import: command not found`), because pip gives a script file a plain `#!` line: use `multicmd`. With pip 9 no spelling starts in such a venv, as in 1.57. uv and system or `--user` installs are not affected.
+- An embedded copy made by the generator now falls back from any failure to import the installed multiCMD, not only the three errors it named.
+
+## Upgrading to 1.57 from 1.56
+
+- Faster command starts on Python 3.6 - 3.10: the wrapper that puts a command in its own process group
+  imports only built-in modules, halving its CPU cost (about 7 ms to 3.5 ms per command on EL8's Python 3.6.8).
+  Nothing else about starting a command changes.
+- Fix: `AsyncExecutor`'s `task.thread` is set by the command's thread once it runs. Before, it was set just before
+  the thread started, and a `task.thread.join()` in that gap returned at once, with the command not yet run.
+  `task.thread` from `run_command(..., wait_for_return=False)` is unchanged.
+
 ## Upgrading to 1.56 from 1.55
 
 - Fix: a command that times out while it redraws a `\r` progress line on stderr keeps its `Timeout!`

{multicmd-1.56 → multicmd-1.58}/README.md

@@ -30,7 +30,7 @@ It works both as a command-line tool and as an importable wrapper around
 pip install multiCMD
 ```
 
-This installs the module and three equivalent console entry points:
+This installs the module and three equivalent commands:
 
 ```bash
 mcmd
@@ -465,6 +465,24 @@ pytest -m "not slow"   # skip intentional sleep-heavy cases
 
 `test_expand_ranges_perf.py` is a manual performance microbenchmark and is not collected by pytest.
 
+## Upgrading to 1.58 from 1.57
+
+- The `multiCMD` command is now a script file, not an entry point, so `entry_points.txt` no longer has two names that differ only in case. All three commands still work the same way, except in the venv case below. From 1.58 on, stock pip 9 on EL7 and EL8 upgrades and uninstalls multiCMD without `configparser.DuplicateOptionError`.
+- With pip 9, the pip of EL7 and EL8 (`pip3 --version`), upgrading from 1.57 or earlier and `pip3 uninstall multiCMD` of those releases stop with `configparser.DuplicateOptionError: ... option 'multicmd' in section 'console_scripts' already exists`, and nothing changes: the installed release keeps working. Run `pip3 install -U pip` once, then upgrade or uninstall.
+- With `--user` the same happens, except that `pip3 install --user -U multiCMD` with no version does not stop: it installs the new release, which works, and leaves the old release's metadata behind. `pip3 list` then shows the old release after `pip3 uninstall multiCMD`, and the next uninstall stops with that error. To avoid this, run `pip3 install --user -U pip` once first. If it has already happened, run that, run `pip3 uninstall multiCMD` until it says multiCMD is not installed, and install again. From 1.58 on the same upgrade leaves the metadata too, but with no error: `pip3 uninstall multiCMD` takes one run per release left.
+- Without `--user`, with multiCMD 1.57 or earlier installed, `pip3 install -U hpcp`, `statblk` or `statbtrfs` stops the same way once a newer multiCMD is out, because pip 9 upgrades dependencies too. `pip3 install -U --no-deps hpcp` gets past it.
+- With pip 10 or later, in a venv whose path has a space or is too long for the kernel's `#!` line, the `multiCMD` spelling does not start (the error varies: "bad interpreter", `import: command not found`), because pip gives a script file a plain `#!` line: use `multicmd`. With pip 9 no spelling starts in such a venv, as in 1.57. uv and system or `--user` installs are not affected.
+- An embedded copy made by the generator now falls back from any failure to import the installed multiCMD, not only the three errors it named.
+
+## Upgrading to 1.57 from 1.56
+
+- Faster command starts on Python 3.6 - 3.10: the wrapper that puts a command in its own process group
+  imports only built-in modules, halving its CPU cost (about 7 ms to 3.5 ms per command on EL8's Python 3.6.8).
+  Nothing else about starting a command changes.
+- Fix: `AsyncExecutor`'s `task.thread` is set by the command's thread once it runs. Before, it was set just before
+  the thread started, and a `task.thread.join()` in that gap returned at once, with the command not yet run.
+  `task.thread` from `run_command(..., wait_for_return=False)` is unchanged.
+
 ## Upgrading to 1.56 from 1.55
 
 - Fix: a command that times out while it redraws a `\r` progress line on stderr keeps its `Timeout!`

{multicmd-1.56 → multicmd-1.58}/multiCMD.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: multiCMD
-Version: 1.56
+Version: 1.58
 Summary: Run commands simultaneously
 Home-page: https://github.com/yufei-pan/multiCMD
 Author: Yufei Pan
@@ -56,7 +56,7 @@ It works both as a command-line tool and as an importable wrapper around
 pip install multiCMD
 ```
 
-This installs the module and three equivalent console entry points:
+This installs the module and three equivalent commands:
 
 ```bash
 mcmd
@@ -491,6 +491,24 @@ pytest -m "not slow"   # skip intentional sleep-heavy cases
 
 `test_expand_ranges_perf.py` is a manual performance microbenchmark and is not collected by pytest.
 
+## Upgrading to 1.58 from 1.57
+
+- The `multiCMD` command is now a script file, not an entry point, so `entry_points.txt` no longer has two names that differ only in case. All three commands still work the same way, except in the venv case below. From 1.58 on, stock pip 9 on EL7 and EL8 upgrades and uninstalls multiCMD without `configparser.DuplicateOptionError`.
+- With pip 9, the pip of EL7 and EL8 (`pip3 --version`), upgrading from 1.57 or earlier and `pip3 uninstall multiCMD` of those releases stop with `configparser.DuplicateOptionError: ... option 'multicmd' in section 'console_scripts' already exists`, and nothing changes: the installed release keeps working. Run `pip3 install -U pip` once, then upgrade or uninstall.
+- With `--user` the same happens, except that `pip3 install --user -U multiCMD` with no version does not stop: it installs the new release, which works, and leaves the old release's metadata behind. `pip3 list` then shows the old release after `pip3 uninstall multiCMD`, and the next uninstall stops with that error. To avoid this, run `pip3 install --user -U pip` once first. If it has already happened, run that, run `pip3 uninstall multiCMD` until it says multiCMD is not installed, and install again. From 1.58 on the same upgrade leaves the metadata too, but with no error: `pip3 uninstall multiCMD` takes one run per release left.
+- Without `--user`, with multiCMD 1.57 or earlier installed, `pip3 install -U hpcp`, `statblk` or `statbtrfs` stops the same way once a newer multiCMD is out, because pip 9 upgrades dependencies too. `pip3 install -U --no-deps hpcp` gets past it.
+- With pip 10 or later, in a venv whose path has a space or is too long for the kernel's `#!` line, the `multiCMD` spelling does not start (the error varies: "bad interpreter", `import: command not found`), because pip gives a script file a plain `#!` line: use `multicmd`. With pip 9 no spelling starts in such a venv, as in 1.57. uv and system or `--user` installs are not affected.
+- An embedded copy made by the generator now falls back from any failure to import the installed multiCMD, not only the three errors it named.
+
+## Upgrading to 1.57 from 1.56
+
+- Faster command starts on Python 3.6 - 3.10: the wrapper that puts a command in its own process group
+  imports only built-in modules, halving its CPU cost (about 7 ms to 3.5 ms per command on EL8's Python 3.6.8).
+  Nothing else about starting a command changes.
+- Fix: `AsyncExecutor`'s `task.thread` is set by the command's thread once it runs. Before, it was set just before
+  the thread started, and a `task.thread.join()` in that gap returned at once, with the command not yet run.
+  `task.thread` from `run_command(..., wait_for_return=False)` is unchanged.
+
 ## Upgrading to 1.56 from 1.55
 
 - Fix: a command that times out while it redraws a `\r` progress line on stderr keeps its `Timeout!`

{multicmd-1.56 → multicmd-1.58}/multiCMD.egg-info/SOURCES.txt

@@ -7,6 +7,7 @@ multiCMD.egg-info/SOURCES.txt
 multiCMD.egg-info/dependency_links.txt
 multiCMD.egg-info/entry_points.txt
 multiCMD.egg-info/top_level.txt
+scripts/multiCMD
 tests/test_api.py
 tests/test_async_executor.py
 tests/test_cli.py
@@ -17,6 +18,7 @@ tests/test_env.py
 tests/test_expand_ranges.py
 tests/test_helpers.py
 tests/test_interrupts.py
+tests/test_packaging.py
 tests/test_parsing.py
 tests/test_ping.py
 tests/test_pool.py

{multicmd-1.56 → multicmd-1.58}/multiCMD.egg-info/entry_points.txt

@@ -1,4 +1,3 @@
 [console_scripts]
 mcmd = multiCMD:main
-multiCMD = multiCMD:main
 multicmd = multiCMD:main

{multicmd-1.56 → multicmd-1.58}/multiCMD.py

@@ -27,9 +27,9 @@ import traceback
 from pprint import pformat
 
 #%% global vars
-version = '1.56'
+version = '1.58'
 __version__ = version
-COMMIT_DATE = '2026-10-23'
+COMMIT_DATE = '2026-11-06'
 # fire-and-forget threads (run_commands with wait_for_return=False) that join_threads() waits on. multiCMD takes no
 # lock for it: each update is one set operation and each snapshot one set.copy(), as for _live_procs below
 __running_threads = set()
@@ -52,7 +52,12 @@ _IS_POSIX = os.name == 'posix'
 # Popen(process_group=) exists from Python 3.11; older Pythons start commands through _PGROUP_EXEC
 _HAS_PROCESS_GROUP = sys.version_info >= (3, 11)
 # exec wrapper for Python < 3.11: joins a new process group, then becomes the command.
-# preexec_fn is not safe with threads, and a new session ( setsid ) would hide the terminal from sudo.
+# Not preexec_fn, tried and measured ( it would save the wrapper's interpreter start ): on 3.6 the forked child frees
+# the other threads' top frames, so the destructors of their locals run in the child and flush the buffers it
+# duplicated, writing a caller's open file twice. On 3.7 - 3.10 preexec_fn runs the at-fork hooks, Python code in the
+# parent: a Ctrl-C at the start of logging's _releaseLock can leave its lock held, and every later command started on
+# another thread hangs on it.
+# Not a new session ( setsid ) either: that would hide the terminal from sudo.
 # It runs in this process's own environment ( so it starts wherever this Python does, LD_LIBRARY_PATH and the
 # like included ). Its first argument is '-' ( the command inherits the wrapper's environment as it is ) or N:
 # the command's own environment is then the N NAME=VALUE entries in the wrapper's variables
@@ -62,36 +67,42 @@ _HAS_PROCESS_GROUP = sys.version_info >= (3, 11)
 # in the wrapper's environment: only a command started with '-' inherits that ( as it always has ).
 _ENV_VAR = '_MULTICMD_ENV_'
 _PGROUP_EXEC = (
-	"import os,signal,sys\n"
+	# only built-in modules: `import os, signal` is half of what the wrapper costs ( signal pulls in enum, os the path
+	# modules ), so the os helpers are spelled out for POSIX, the only place the wrapper runs
+	"import posix,_signal,sys\n"
 	# Python ignores SIGPIPE / SIGXFSZ at startup and an ignored signal survives exec; give the command the defaults
 	"for n in ('SIGPIPE','SIGXFSZ'):\n"
-	"\tif hasattr(signal,n):signal.signal(getattr(signal,n),signal.SIG_DFL)\n"
-	"os.setpgid(0,0)\n"
+	"\tif hasattr(_signal,n):_signal.signal(getattr(_signal,n),_signal.SIG_DFL)\n"
+	"posix.setpgid(0,0)\n"
 	"a=sys.argv\n"
 	"c=a[2]\n"
 	"v=None\n"
 	"if a[1]!='-':\n"
 	"\ttry:\n"
-	# read, not pop: the command is started with exactly the environment built here, and every removal is a scan of the whole environment
-	"\t\tv=dict(os.environb[b'_MULTICMD_ENV_%d'%i].split(b'=',1) for i in range(int(a[1])))\n"
+	# read, not pop: the command is started with exactly the environment built here
+	"\t\tv=dict(posix.environ[b'_MULTICMD_ENV_%d'%i].split(b'=',1) for i in range(int(a[1])))\n"
 	"\texcept(KeyError,ValueError):\n"
 	"\t\tsys.stderr.write('multiCMD: incomplete environment for %r\\n'%c);sys.exit(126)\n"
 	"def x(f):\n"
-	"\tif v is None:os.execv(f,a[2:])\n"
-	"\tos.execve(f,a[2:],v)\n"
+	"\tif v is None:posix.execv(f,a[2:])\n"
+	"\tposix.execve(f,a[2:],v)\n"
+	"def g(f):\n"
+	"\ttry:return posix.stat(f).st_mode&0o170000==0o100000\n"
+	"\texcept(OSError,ValueError):return False\n"
 	"try:\n"
-	"\tif os.sep in c:x(c)\n"
+	"\tif '/' in c:x(c)\n"
 	# a bare name: try the regular files by that name in the PATH directories in turn ( see _spawn ); the first
 	# failure other than ENOENT / ENOTDIR says why it cannot run, and without one it is not found
-	"\tp=os.environ.get('PATH') if v is None else v.get(b'PATH')\n"
+	"\tp=(posix.environ if v is None else v).get(b'PATH')\n"
 	"\tr=None\n"
-	"\tfor d in os.fsdecode(os.defpath if p is None else p).split(os.pathsep):\n"
-	"\t\tf=os.path.join(d or os.curdir,c)\n"
-	"\t\tif os.path.isfile(f):\n"
+	"\tfor d in ("+repr(os.defpath)+" if p is None else p.decode(sys.getfilesystemencoding(),'surrogateescape')).split(':'):\n"
+	"\t\td=d or '.'\n"
+	"\t\tf=d+c if d.endswith('/') else d+'/'+c\n"
+	"\t\tif g(f):\n"
 	"\t\t\ttry:x(f)\n"
 	"\t\t\texcept(FileNotFoundError,NotADirectoryError):pass\n"
 	"\t\t\texcept OSError as e:r=r or e\n"
-	"\traise r or FileNotFoundError(2,os.strerror(2),c)\n"
+	"\traise r or FileNotFoundError(2,posix.strerror(2),c)\n"
 	# a plain command reports as it always has; one with an environment as Popen does ( Python 3.11+: the error with the command as given )
 	"except OSError as e:\n"
 	"\tsys.stderr.write((str(e) if a[1]=='-' else str(OSError(e.errno,e.strerror,c)))+'\\n')\n"
@@ -505,21 +516,16 @@ class AsyncExecutor:
 	def _track(self, thread):
 		'''
 		Track a _Thread about to start until it reports itself finished ( internal )
-		Tracked before it starts, so it is tracked before it can report itself finished, and its task has it
-		before it runs, so _reap() never sees the task without its thread.
+		Tracked before it starts, so it is tracked before it can report itself finished. Its task gets it from
+		_run_executor_task: a task.thread still starting would look finished, as its join() returns at once.
 		'''
 		self._threads[thread] = None
-		if thread.task is not None:
-			thread.task.thread = thread
 
 	def _untrack(self, thread):
 		'''
 		Stop tracking a thread that never started, as it never reports itself finished ( internal )
-		Its task drops it as a finished one does: an executor task has a thread only while it runs.
 		'''
 		self._threads.pop(thread, None)
-		if thread.task is not None and thread.task.thread is thread:
-			thread.task.thread = None
 
 	def _dispatch(self):
 		'''
@@ -2066,7 +2072,9 @@ def _fail_task(task, message, error, quiet=False):
 def _run_executor_task(task, permit, timeout, quiet, dry_run, finished, decor=('', '', ''), use_pty=False):
 	'''
 	Run an AsyncExecutor command, then report this thread finished so the executor joins it and drops it from the task ( internal )
+	An executor task has a thread only while it runs, so task.thread is set here, by the running thread.
 	'''
+	task.thread = threading.current_thread()
 	try:
 		__run_command(task, permit, timeout, quiet, dry_run, decor=decor, use_pty=use_pty)
 	finally:

multicmd-1.58/scripts/multiCMD

@@ -0,0 +1,6 @@
+#!/usr/bin/env python3
+# The mixed-case command, installed as a script and not as an entry point (see setup.py).
+import sys
+from multiCMD import main
+if __name__ == '__main__':
+    sys.exit(main())

{multicmd-1.56 → multicmd-1.58}/setup.py

@@ -11,10 +11,12 @@ setup(
     author_email='pan@zopyr.us',
     url='https://github.com/yufei-pan/multiCMD',
     py_modules=['multiCMD'],
+    # The mixed-case command is a script file and not an entry point: pip 9 (stock on EL7 and EL8) reads entry_points.txt with a
+    # parser that folds case, so two commands that differ only in case make it fail to upgrade or uninstall the package.
+    scripts=['scripts/multiCMD'],
     entry_points={
         'console_scripts': [
             'mcmd=multiCMD:main',
-            'multiCMD=multiCMD:main',
             'multicmd=multiCMD:main',
         ],
     },

{multicmd-1.56 → multicmd-1.58}/tests/test_async_executor.py

@@ -352,6 +352,30 @@ def _started_thread(task):
 	return task.thread
 
 
+def test_a_tasks_thread_shows_only_once_it_runs(monkeypatch):
+	# task.thread is None until the command's thread runs: a thread still starting joins at once, before the command ran
+	real = multiCMD._Thread.start
+	reached, go = threading.Event(), threading.Event()
+	def held(self):
+		if self.task is not None:
+			reached.set()
+			go.wait(5)
+		real(self)
+	monkeypatch.setattr(multiCMD._Thread, 'start', held)
+	ex = AsyncExecutor(max_threads=1, quiet=True)
+	try:
+		task = ex.run_command(['sleep', '0.3'])
+		assert reached.wait(5)
+		assert task.thread is None
+		go.set()
+		thread = _started_thread(task)
+		thread.join()
+		assert task.returncode == 0
+	finally:
+		go.set()
+		ex.cleanup()
+
+
 def test_sigint_helper_fails_a_call_that_returns_first_and_sends_nothing_later():
 	start = time.monotonic()
 	with pytest.raises(pytest.fail.Exception, match='returned before the SIGINT'):

{multicmd-1.56 → multicmd-1.58}/tests/test_env.py

@@ -708,13 +708,10 @@ def test_an_internal_oserror_is_still_an_error_with_a_traceback(launcher, monkey
 			proc.stderr.close()
 
 
-def test_the_wrapper_does_not_unset_each_variable_it_reads():
-	# unsetting one is a scan of the whole environment: N variables would cost N**2
-	assert 'SIGXFZ' not in multiCMD._PGROUP_EXEC and '.pop(' not in multiCMD._PGROUP_EXEC
-	# ( Python before 3.9 calls os.environb.unsetenv, 3.9+ the module's os.unsetenv )
-	code = ("import os, sys\nos.environb.unsetenv = os.unsetenv = lambda *a: sys.exit(99)\n"
+def test_the_wrapper_starts_the_command_with_exactly_the_environment_it_was_given():
+	code = ("import posix, sys\n"
 		"def execve(f, a, e):\n\tprint(sorted(e.items()))\n\tsys.exit(0)\n"
-		"os.execve = execve\nexec(%r)" % multiCMD._PGROUP_EXEC)
+		"posix.execve = execve\nexec(%r)" % multiCMD._PGROUP_EXEC)
 	env = {'PATH': os.environ['PATH'], '_MULTICMD_ENV_0': 'A=1', '_MULTICMD_ENV_1': 'B=x=y'}
 	proc = subprocess.run([sys.executable, '-I', '-S', '-c', code, '2', 'true'], env=env,
 		stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True, timeout=30)
@@ -722,6 +719,18 @@ def test_the_wrapper_does_not_unset_each_variable_it_reads():
 	assert proc.stdout.strip() == "[(b'A', b'1'), (b'B', b'x=y')]"
 
 
+@pytest.mark.parametrize('count', ['-', '0'], ids=['plain', 'environment'])
+def test_the_wrapper_starts_nothing_but_built_in_modules(count):
+	# every command on Python < 3.11 pays for what the wrapper imports: os and signal ( with enum ) double its cost
+	code = ("import posix, sys\nbefore = set(sys.modules)\n"
+		"def run(*a):\n\tprint(sorted(set(sys.modules) - before))\n\tsys.exit(0)\n"
+		"posix.execv = posix.execve = run\nexec(%r)" % multiCMD._PGROUP_EXEC)
+	proc = subprocess.run([sys.executable, '-I', '-S', '-c', code, count, 'sh'], env={'PATH': '/usr/bin:/bin'},
+		stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True, timeout=30)
+	assert proc.returncode == 0, proc.stderr
+	assert proc.stdout.strip() == '[]'
+
+
 def test_tasks_that_never_started_do_not_keep_their_environment():
 	ex = AsyncExecutor(max_threads=1, quiet=True)
 	blocker = ex.run_command(['sh', '-c', 'sleep 0.5'])
@@ -813,6 +822,11 @@ def _sh_status(path, command):
 	return subprocess.run(['/bin/sh', '-c', command], env={'PATH': path}, stdout=subprocess.PIPE, stderr=subprocess.PIPE).returncode
 
 
+# multiCMD does as dash: a fifo in PATH, or a script whose interpreter is missing, is not found ( 127 ). bash as /bin/sh
+# finds the file and says it cannot be run ( 126, and 127 for a missing interpreter from bash 5.2 ): the tests only check that sh does
+# not run it either, so the exact value of sh's own code is not pinned
+
+
 @pytest.mark.parametrize('kind', ['directory', 'fifo', 'unsearchable'])
 @pytest.mark.parametrize('how', ['plain', 'extra_env', 'env'])
 def test_a_path_entry_without_a_regular_file_by_that_name_is_not_found(launcher, tmp_path, monkeypatch, kind, how):
@@ -833,7 +847,7 @@ def test_a_path_entry_without_a_regular_file_by_that_name_is_not_found(launcher,
 		task = _run_in_path(monkeypatch, how, path, command)
 		assert task.returncode == 127 and not task._error, task.stderr
 		assert "No such file or directory: '%s'" % command in ' '.join(task.stderr)
-		assert _sh_status(path, command) == 127
+		assert _sh_status(path, command) in ((126, 127) if kind == 'fifo' else (127,))
 	finally:
 		where.chmod(0o755)
 
@@ -851,7 +865,7 @@ def test_a_script_whose_interpreter_is_missing_is_not_found_whatever_path_follow
 	task = _run_in_path(monkeypatch, how, path, 'badinterp')
 	assert task.returncode == 127 and not task._error, task.stderr
 	assert "No such file or directory: 'badinterp'" in ' '.join(task.stderr)
-	assert _sh_status(path, 'badinterp') == 127
+	assert _sh_status(path, 'badinterp') in (126, 127)
 
 
 @pytest.mark.parametrize('how', ['plain', 'extra_env', 'env'])

{multicmd-1.56 → multicmd-1.58}/tests/test_interrupts.py

@@ -129,7 +129,7 @@ def _left_running(before, wait=6.0):
 		time.sleep(0.02)
 
 
-# on Python 3.6 - 3.9 and 3.14 a Ctrl-C right after a C lock's acquire in a `with lock:` leaves the lock held, and
+# on Python 3.6 - 3.9 and 3.14 a Ctrl-C at one instruction of a `with lock:` can leave the lock held, and
 # Thread.start() takes threading's own _active_limbo_lock so: every thread then hangs as it ends ( CPython's own, see
 # the README ). The stress test below keeps its Ctrl-Cs out of the output readers' Thread.start() there: one that would
 # land inside it is taken right after it
@@ -553,8 +553,8 @@ def test_a_ctrl_c_at_any_point_of_a_serial_run_is_raised(command):
 	# ( matrix of round 12, finding 4 ) one KeyboardInterrupt at each call, return and C-call return of a serial run in
 	# turn, in every frame of the main thread ( subprocess's, os's ... ): run_command() raises it every time, for a
 	# command that runs and for one that is not found. It found a Ctrl-C that Thread.start() turns into RuntimeError on
-	# 3.12 ( see _Thread.start ). threading's own frames are left out where a Ctrl-C right after a `with lock:` acquire
-	# leaves the lock held ( 3.6 - 3.9, 3.14: CPython's own, see the README )
+	# 3.12 ( see _Thread.start ). threading's own frames are left out where a Ctrl-C at one instruction of a `with lock:`
+	# can leave the lock held ( 3.6 - 3.9, 3.14: CPython's own, see the README )
 	skipped = {threading.__file__} if _WITH_MAY_JAM else set()
 	def counted(frame, event):
 		return frame.f_code.co_filename not in skipped
@@ -575,7 +575,8 @@ def test_a_ctrl_c_at_any_point_of_a_serial_run_is_raised(command):
 			break
 		state['k'] += 1
 	assert returned == []
-	assert state['k'] > 100 and not multiCMD._live_procs
+	# ( the matrix went through the run: 'missing' on 3.6 has the fewest points, some 70 and 10 per PATH entry looked in )
+	assert state['k'] > 50 and not multiCMD._live_procs
 
 
 @pytest.mark.skipif(not sys.platform.startswith('linux'), reason='POSIX commands')

multicmd-1.58/tests/test_packaging.py

@@ -0,0 +1,26 @@
+"""The packaging: the commands setup.py installs."""
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+PACKAGE_ROOT = Path(__file__).resolve().parents[1]
+
+
+def test_no_two_commands_differ_only_in_case(tmp_path):
+	pytest.importorskip("setuptools", reason="needs setuptools to run setup.py")
+	# pip 9 (stock on EL7 and EL8) reads entry_points.txt with a parser that folds case, so two commands that differ only
+	# in case make it fail to upgrade or uninstall the package. The mixed-case command is a script file (scripts=) instead.
+	result = subprocess.run([sys.executable, "setup.py", "-q", "egg_info", "--egg-base", str(tmp_path)],
+		cwd=str(PACKAGE_ROOT), env=dict(os.environ, PYTHONDONTWRITEBYTECODE="1"), stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+		universal_newlines=True, timeout=120)
+	assert result.returncode == 0, result.stderr
+	egg_info = tmp_path / "multiCMD.egg-info"
+	entry_points = (egg_info / "entry_points.txt").read_text(encoding="utf-8")
+	names = [line.split("=")[0].strip() for line in entry_points.splitlines() if "=" in line]
+	assert sorted(names) == ["mcmd", "multicmd"]
+	# the mixed-case command ships in the sdist as a script, so the three spellings stay three commands
+	assert "scripts/multiCMD" in (egg_info / "SOURCES.txt").read_text(encoding="utf-8").splitlines()
+	assert (PACKAGE_ROOT / "scripts" / "multiCMD").read_text(encoding="utf-8").startswith("#!")

{multicmd-1.56 → multicmd-1.58}/tests/test_process_groups.py

@@ -49,7 +49,8 @@ TTY_PROBE = textwrap.dedent(r"""
 	sys.path.insert(0, {root!r})
 	import multiCMD
 	multiCMD._HAS_PROCESS_GROUP = {native!r}
-	proc, pgid = multiCMD._spawn(['sh', '-c', 'read x </dev/tty; echo rc=$?'], subprocess.PIPE, subprocess.STDOUT)
+	# ( 2> comes second: bash reports the failed read, which is the point here, but a failed open still shows )
+	proc, pgid = multiCMD._spawn(['sh', '-c', 'read x </dev/tty 2>/dev/null; echo rc=$?'], subprocess.PIPE, subprocess.STDOUT)
 	try:
 		print('RESULT', proc.communicate(timeout=5)[0].decode().strip())
 	except subprocess.TimeoutExpired:

{multicmd-1.56 → multicmd-1.58}/tests/test_supervision.py

@@ -66,10 +66,20 @@ def test_executor_stop_kills_grandchildren_promptly():
 	assert pid_gone(int(task.stdout[0]))
 
 
-def test_timing_fields():
-	task = run_command(['sleep', '0.2'], quiet=True, return_object=True)
-	assert task.start_time <= task.end_time
-	assert task.duration >= 0.2
+def test_timing_fields(tmp_path):
+	# no timing margin: the command runs until the test says so, and the test says so only once start_time is set
+	go = tmp_path / 'go'
+	t0 = time.time()
+	task = run_commands([['sh', '-c', 'until [ -e "$0" ]; do sleep 0.01; done', str(go)]], quiet=True, return_object=True, wait_for_return=False)[0]
+	deadline = time.monotonic() + 30
+	while task.start_time is None and time.monotonic() < deadline:
+		time.sleep(0.01)
+	during = time.time()
+	go.touch()
+	multiCMD.join_threads()
+	t1 = time.time()
+	assert t0 <= task.start_time <= during <= task.end_time <= t1
+	assert task.duration == task.end_time - task.start_time
 	assert multiCMD.Task(['x']).duration is None