zprocess 2.27.1__tar.gz → 2.28.0rc2__tar.gz

{zprocess-2.27.1 → zprocess-2.28.0rc2}/.github/workflows/release.yml

@@ -10,7 +10,7 @@ on:
 
 env:
   OS_LIST_UBUNTU: '["ubuntu-latest"]'
-  OS_LIST_ALL: '["ubuntu-latest", "windows-latest", "macos-latest", "macos-15-intel"]'
+  OS_LIST_ALL: '["ubuntu-latest", "windows-2022", "macos-latest", "macos-15-intel"]'
 
 
 jobs:
@@ -38,9 +38,12 @@ jobs:
         with:
           fetch-depth: 0
 
-      - name: Ignore Tags for non-tag pushes
-        if: "!startsWith(github.ref, 'refs/tags/')"
-        run: git tag -d $(git tag --points-at HEAD)
+      - name: Ignore tags other than the pushed tag
+        # The version comes from the tags at HEAD, so a commit that carries both an rc
+        # tag and a final tag builds the version of the tag that was pushed, and a branch
+        # push of a tagged commit builds a development version.
+        shell: bash
+        run: git tag -d $(git tag --points-at HEAD | grep -vx "${GITHUB_REF_NAME}" || true)
 
       - name: Install Python
         uses: actions/setup-python@v6
@@ -226,9 +229,12 @@ jobs:
         with:
           fetch-depth: 0
 
-      - name: Ignore Tags for non-tag pushes
-        if: "!startsWith(github.ref, 'refs/tags/')"
-        run: git tag -d $(git tag --points-at HEAD)
+      - name: Ignore tags other than the pushed tag
+        # The version comes from the tags at HEAD, so a commit that carries both an rc
+        # tag and a final tag builds the version of the tag that was pushed, and a branch
+        # push of a tagged commit builds a development version.
+        shell: bash
+        run: git tag -d $(git tag --points-at HEAD | grep -vx "${GITHUB_REF_NAME}" || true)
 
       - name: Install Python
         uses: actions/setup-python@v6
@@ -259,7 +265,7 @@ jobs:
           if-no-files-found: error
 
       - name: Install Miniforge
-        uses: conda-incubator/setup-miniconda@v3
+        uses: conda-incubator/setup-miniconda@v4
         with:
           miniforge-version: "latest"
           auto-update-conda: true
@@ -305,7 +311,7 @@ jobs:
           merge-multiple: true
 
       - name: Create GitHub release and upload release asset
-        uses: softprops/action-gh-release@v2
+        uses: softprops/action-gh-release@v3
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
@@ -390,7 +396,7 @@ jobs:
           merge-multiple: true
 
       - name: Install Miniforge
-        uses: conda-incubator/setup-miniconda@v3
+        uses: conda-incubator/setup-miniconda@v4
         with:
           miniforge-version: "latest"
           auto-update-conda: true
@@ -429,7 +435,7 @@ jobs:
           merge-multiple: true
 
       - name: Install Miniforge
-        uses: conda-incubator/setup-miniconda@v3
+        uses: conda-incubator/setup-miniconda@v4
         with:
           miniforge-version: "latest"
           auto-update-conda: true

{zprocess-2.27.1/zprocess.egg-info → zprocess-2.28.0rc2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zprocess
-Version: 2.27.1
+Version: 2.28.0rc2
 Summary: A set of utilities for multiprocessing using zeromq
 Author-email: Christopher Billington <chrisjbillington@gmail.com>
 License-Expression: BSD-2-Clause
@@ -11,11 +11,17 @@ Project-URL: Downloads, https://pypi.org/project/zprocess/
 Project-URL: Tracker, https://github.com/chrisjbillington/zprocess/issues
 Keywords: multiprocessing,IPC,zeromq
 Classifier: Programming Language :: Python :: 3 :: Only
-Requires-Python: >=3.8
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
-Requires-Dist: setuptools_scm
+Requires-Dist: setuptools_scm>=10
 Requires-Dist: pyzmq
+Requires-Dist: appnope; sys_platform == "darwin"
 Requires-Dist: pywin32; sys_platform == "win32"
 Requires-Dist: windows-curses; sys_platform == "win32"
 Provides-Extra: test

{zprocess-2.27.1 → zprocess-2.28.0rc2}/pyproject.toml

@@ -1,9 +1,9 @@
 [build-system]
-requires = ["setuptools", "setuptools_scm"]
+requires = ["setuptools", "setuptools_scm>=10"]
 build-backend = "setuptools.build_meta"
 
 [tool.setuptools_scm]
-version_scheme = "release-branch-semver"
+version_scheme = "semver-pep440-release-branch"
 local_scheme = "no-local-version"
 
 [tool.setuptools.packages]
@@ -20,11 +20,17 @@ license = "BSD-2-Clause"
 license-files = ["LICENSE.txt"]
 classifiers = [
     "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Programming Language :: Python :: 3.15",
 ]
-requires-python = ">=3.8"
+requires-python = ">=3.11"
 dependencies = [
-    "setuptools_scm",
+    "setuptools_scm>=10",
     "pyzmq",
+    "appnope;           sys_platform == 'darwin'",
     "pywin32;           sys_platform == 'win32'",
     "windows-curses;    sys_platform == 'win32'",
 ]

{zprocess-2.27.1 → zprocess-2.28.0rc2}/requirements.txt

@@ -15,4 +15,7 @@ enum34; python_version == '2.7'
 
 # Windows-specific modules:
 pywin32; sys_platform == 'win32'
-windows-curses; sys_platform == 'win32'
+windows-curses; sys_platform == 'win32'
+
+# macOS-specific modules:
+appnope; sys_platform == 'darwin'

{zprocess-2.27.1 → zprocess-2.28.0rc2}/tests/test_zprocess.py

@@ -235,9 +235,9 @@ class HeartbeatClientTestProcess(Process):
         time.sleep(10)
 
 
-class HeartbeatServerTestProcess(Process):
-    """For testing that parent processes are behaving correcly re. heartbeats"""
-    def run(self):
+class HeartbeatServerTestProcess(Process):
+    """For testing that parent processes are behaving correcly re. heartbeats"""
+    def run(self):
         # We'll send heartbeats of our own, independent of the HeartbeatClient
         # already running in this process:
         shared_secret = self.process_tree.shared_secret
@@ -256,89 +256,287 @@ class HeartbeatServerTestProcess(Process):
                 self.to_parent.put(True)
                 time.sleep(1) # Ensure it sends before we return
                 return
-        self.to_parent.put(False)
-        time.sleep(1) # Ensure it sends before we return
-
-
-class HeartbeatTests(unittest.TestCase):
-    def setUp(self):
-        """Create a sock for output redirection and a zmq port to mock a heartbeat
-        server"""
-        import zmq
-        context = SecureContext.instance(shared_secret=shared_secret)
-        self.heartbeat_sock = context.socket(zmq.REP)
-        heartbeat_port = self.heartbeat_sock.bind_to_random_port('tcp://127.0.0.1')
-
-        class mock_heartbeat_server(object):
-            port = heartbeat_port
-
-        self.mock_heartbeat_server = mock_heartbeat_server
-
-    def test_subproc_lives_with_heartbeats(self):
-        _default_process_tree.heartbeat_server = self.mock_heartbeat_server
-        self.process = HeartbeatClientTestProcess()
-        self.process.start()
-        for i in range(3):
-            # Wait for a heartbeat request:
-            self.assertTrue(self.heartbeat_sock.poll(3000))
-            # Echo it back:
-            self.heartbeat_sock.send(self.heartbeat_sock.recv())
-
-    def test_subproc_dies_without_heartbeats(self):
-        _default_process_tree.heartbeat_server = self.mock_heartbeat_server
-        self.process = HeartbeatClientTestProcess()
-        self.process.start()
-        # Wait for a heartbeat request:
-        self.assertTrue(self.heartbeat_sock.poll(3000))
-        # Don't respond to it
-        time.sleep(2)
-        # Process should be dead:
-        self.assertIsNot(self.process.child.poll(), None)
-
-    def test_subproc_dies_on_incorrect_response(self):
-        _default_process_tree.heartbeat_server = self.mock_heartbeat_server
-        self.process = HeartbeatClientTestProcess()
-        self.process.start()
-        # Wait for a heartbeat request:
-        self.assertTrue(self.heartbeat_sock.poll(3000))
-        # Echo it back wrongly:
-        self.heartbeat_sock.send(self.heartbeat_sock.recv() + b'wrong')
-        time.sleep(1)
-        # Process should be dead:
-        self.assertIsNot(self.process.child.poll(), None)
-
-    def test_subproc_survives_until_kill_lock_released(self):
-        _default_process_tree.heartbeat_server = self.mock_heartbeat_server
-        self.process = HeartbeatClientTestProcess()
-        to_child, from_child = self.process.start()
-        # Wait for a heartbeat request:
-        self.assertTrue(self.heartbeat_sock.poll(3000))
-        # Tell child to acquire kill lock for 3 sec:
-        to_child.put(None)
-        # Don't respond to the heartbeat, process should still be alive 2 sec later
-        time.sleep(2)
-        # Process should be alive:
-        self.assertIs(self.process.child.poll(), None)
-        # After kill lock released, child should be terminated:
-        time.sleep(2)
-        # Process should be dead:
-        self.assertIsNot(self.process.child.poll(), None)
-
-    def test_parent_correctly_responds_to_heartbeats(self):
-        # No mock server this time, we're testing the real one:
-        _default_process_tree.heartbeat_server = None
-        self.process = HeartbeatServerTestProcess()
+        self.to_parent.put(False)
+        time.sleep(1) # Ensure it sends before we return
+
+
+class ScriptedHeartbeatServer(object):
+    def __init__(self, shared_secret, script, default='good'):
+        import zmq
+
+        self.context = SecureContext.instance(shared_secret=shared_secret)
+        self.script = list(script)
+        self.default = default
+        self.actions = []
+        self.request_times = []
+        self._lock = threading.Lock()
+        self._running = True
+        self._request_event = threading.Event()
+        self.sock = self.context.socket(zmq.ROUTER)
+        self.port = self.sock.bind_to_random_port('tcp://127.0.0.1')
+        self.thread = threading.Thread(target=self.mainloop)
+        self.thread.daemon = True
+        self.thread.start()
+
+    def _next_action(self):
+        with self._lock:
+            if self.script:
+                action = self.script.pop(0)
+            else:
+                action = self.default
+            self.actions.append(action)
+            return action
+
+    def request_count(self):
+        with self._lock:
+            return len(self.request_times)
+
+    def wait_for_requests(self, count, timeout):
+        deadline = time.time() + timeout
+        while time.time() < deadline:
+            if self.request_count() >= count:
+                return True
+            self._request_event.wait(min(0.1, deadline - time.time()))
+            self._request_event.clear()
+        return self.request_count() >= count
+
+    def inter_request_intervals(self):
+        with self._lock:
+            times = list(self.request_times)
+        return [later - earlier for earlier, later in zip(times, times[1:])]
+
+    def mainloop(self):
+        while self._running:
+            try:
+                if not self.sock.poll(100):
+                    continue
+                msg = self.sock.recv_multipart()
+                with self._lock:
+                    self.request_times.append(time.time())
+                self._request_event.set()
+                action = self._next_action()
+                payload = msg[-1]
+                if action == 'good':
+                    self.sock.send_multipart(msg[:-1] + [payload])
+                elif action == 'malformed':
+                    self.sock.send_multipart(msg[:-1] + [payload + b'wrong'])
+                elif action == 'drop':
+                    continue
+                else:
+                    raise ValueError(action)
+            except zmq.ZMQError:
+                if self._running:
+                    raise
+
+    def close(self):
+        self._running = False
+        self.sock.close(linger=0)
+        self.thread.join(timeout=1)
+
+
+class HeartbeatTests(unittest.TestCase):
+    def setUp(self):
+        self.heartbeat_server = None
+
+    def _process_tree(
+        self, allowed_missed_heartbeats=None, heartbeat_interval=None
+    ):
+        if allowed_missed_heartbeats is None and heartbeat_interval is None:
+            return _default_process_tree
+
+        class ConfiguredHeartbeatProcessTree(type(_default_process_tree)):
+            def subprocess(tree_self, *args, **kwargs):
+                if allowed_missed_heartbeats is not None:
+                    kwargs.setdefault(
+                        'allowed_missed_heartbeats', allowed_missed_heartbeats
+                    )
+                if heartbeat_interval is not None:
+                    kwargs.setdefault('heartbeat_interval', heartbeat_interval)
+                return super(
+                    ConfiguredHeartbeatProcessTree, tree_self
+                ).subprocess(*args, **kwargs)
+
+        process_tree = ConfiguredHeartbeatProcessTree(
+            shared_secret=shared_secret,
+            allow_insecure=_default_process_tree.allow_insecure,
+            zlock_host=_default_process_tree.zlock_host,
+            zlock_port=_default_process_tree.zlock_port,
+            zlog_host=_default_process_tree.zlog_host,
+            zlog_port=_default_process_tree.zlog_port,
+        )
+        process_tree.heartbeat_server = self.heartbeat_server
+        return process_tree
+
+    def _start_heartbeat_process(
+        self,
+        allowed_missed_heartbeats=None,
+        heartbeat_interval=None,
+        script=None,
+        default='good',
+    ):
+        self.heartbeat_server = ScriptedHeartbeatServer(
+            shared_secret, script or [], default=default
+        )
+        process_tree = self._process_tree(
+            allowed_missed_heartbeats,
+            heartbeat_interval=heartbeat_interval,
+        )
+        self.process = HeartbeatClientTestProcess(process_tree=process_tree)
+        return self.process.start()
+
+    def _assert_process_exits_within(self, timeout):
+        deadline = time.time() + timeout
+        while time.time() < deadline:
+            if self.process.child.poll() is not None:
+                return
+            time.sleep(0.1)
+        self.fail('process did not exit within %.1f seconds' % timeout)
+
+    def _assert_alive_after_requests(self, request_count, timeout):
+        self.assertTrue(
+            self.heartbeat_server.wait_for_requests(request_count, timeout),
+            'server did not receive %d heartbeats' % request_count,
+        )
+        time.sleep(0.2)
+        self.assertIs(self.process.child.poll(), None)
+
+    def _assert_intervals_are_timeouts(self, minimum_interval):
+        intervals = self.heartbeat_server.inter_request_intervals()
+        self.assertTrue(intervals, 'expected at least two heartbeat requests')
+        self.assertTrue(
+            all(interval >= minimum_interval for interval in intervals),
+            'expected timeout-sized gaps, got %r' % intervals,
+        )
+
+    def _assert_intervals_are_immediate_retries(self, maximum_interval):
+        intervals = self.heartbeat_server.inter_request_intervals()
+        self.assertTrue(intervals, 'expected at least two heartbeat requests')
+        self.assertTrue(
+            all(interval <= maximum_interval for interval in intervals),
+            'expected malformed replies to avoid timeout gaps, got %r' % intervals,
+        )
+
+    def test_subproc_lives_with_working_heartbeats(self):
+        self._start_heartbeat_process(allowed_missed_heartbeats=5)
+        self._assert_alive_after_requests(3, 5)
+
+    def test_subproc_survives_missing_heartbeats_below_budget(self):
+        for failures in range(1, 5):
+            with self.subTest(failures=failures):
+                self._start_heartbeat_process(
+                    allowed_missed_heartbeats=failures + 1,
+                    script=['drop'] * failures + ['good'],
+                )
+                self._assert_alive_after_requests(failures + 1, (failures + 1) * 3)
+                self._assert_intervals_are_timeouts(1.5)
+                self.process.terminate()
+                self.heartbeat_server.close()
+                self.process = None
+                self.heartbeat_server = None
+
+    def test_subproc_dies_after_1_to_5_missing_heartbeats(self):
+        for failures in range(1, 6):
+            with self.subTest(failures=failures):
+                self._start_heartbeat_process(
+                    allowed_missed_heartbeats=failures,
+                    script=['drop'] * failures,
+                )
+                self.assertTrue(
+                    self.heartbeat_server.wait_for_requests(failures, failures * 3),
+                    'server did not receive %d dropped heartbeats' % failures,
+                )
+                self._assert_process_exits_within(3)
+                if failures > 1:
+                    self._assert_intervals_are_timeouts(1.5)
+                self.process = None
+                self.heartbeat_server.close()
+                self.heartbeat_server = None
+
+    def test_subproc_survives_malformed_heartbeats_below_budget(self):
+        for failures in range(1, 5):
+            with self.subTest(failures=failures):
+                self._start_heartbeat_process(
+                    allowed_missed_heartbeats=failures + 1,
+                    script=['malformed'] * failures + ['good'],
+                )
+                self._assert_alive_after_requests(failures + 1, (failures + 1) * 2)
+                self._assert_intervals_are_immediate_retries(1.5)
+                self.process.terminate()
+                self.heartbeat_server.close()
+                self.process = None
+                self.heartbeat_server = None
+
+    def test_subproc_dies_after_1_to_5_malformed_heartbeats(self):
+        for failures in range(1, 6):
+            with self.subTest(failures=failures):
+                self._start_heartbeat_process(
+                    allowed_missed_heartbeats=failures,
+                    script=['malformed'] * failures,
+                )
+                self.assertTrue(
+                    self.heartbeat_server.wait_for_requests(failures, failures * 2),
+                    'server did not receive %d malformed heartbeats' % failures,
+                )
+                self._assert_process_exits_within(2)
+                if failures > 1:
+                    self._assert_intervals_are_immediate_retries(1.5)
+                self.process = None
+                self.heartbeat_server.close()
+                self.heartbeat_server = None
+
+    def test_successful_heartbeat_resets_miss_counter(self):
+        self._start_heartbeat_process(
+            allowed_missed_heartbeats=2,
+            script=['malformed', 'good', 'malformed', 'good'],
+        )
+        self._assert_alive_after_requests(4, 8)
+        self._assert_intervals_are_immediate_retries(1.5)
+
+    def test_configured_heartbeat_interval_controls_request_cadence(self):
+        self._start_heartbeat_process(
+            allowed_missed_heartbeats=3,
+            heartbeat_interval=0.2,
+        )
+        self.assertTrue(self.heartbeat_server.wait_for_requests(3, 3))
+        intervals = self.heartbeat_server.inter_request_intervals()[:2]
+        self.assertTrue(
+            all(0.1 <= interval < 0.8 for interval in intervals),
+            'expected configured heartbeat-sized gaps, got %r' % intervals,
+        )
+
+    def test_subproc_survives_until_kill_lock_released(self):
+        to_child, from_child = self._start_heartbeat_process(
+            allowed_missed_heartbeats=1, script=['good', 'drop']
+        )
+        self.assertTrue(self.heartbeat_server.wait_for_requests(1, 3))
+        # Tell child to acquire kill lock for 3 sec:
+        to_child.put(None)
+        # Don't respond to the heartbeat, process should still be alive 2 sec later
+        time.sleep(2)
+        # Process should be alive:
+        self.assertIs(self.process.child.poll(), None)
+        # After kill lock released, child should be terminated:
+        self._assert_process_exits_within(3)
+        # Process should be dead:
+        self.assertIsNot(self.process.child.poll(), None)
+
+    def test_parent_correctly_responds_to_heartbeats(self):
+        # No mock server this time, we're testing the real one:
+        _default_process_tree.heartbeat_server = None
+        self.process = HeartbeatServerTestProcess()
         to_child, from_child = self.process.start()
         to_child.put(_default_process_tree.heartbeat_server.port)
         self.assertTrue(from_child.sock.poll(1000))
         self.assertTrue(from_child.get())
-
-    def tearDown(self):
-        self.heartbeat_sock.close()
-        try:
-            self.process.terminate()
-        except Exception:
-            pass # already dead
+
+    def tearDown(self):
+        if self.heartbeat_server is not None:
+            self.heartbeat_server.close()
+        try:
+            if getattr(self, 'process', None) is not None:
+                self.process.terminate()
+        except Exception:
+            pass # already dead
 
 class TestEventProcess(Process):
     def run(self):

{zprocess-2.27.1 → zprocess-2.28.0rc2}/zprocess/__version__.py

@@ -6,7 +6,7 @@ if (root / '.git').is_dir():
     from setuptools_scm import get_version
 
     __version__ = get_version(
-        root, version_scheme="release-branch-semver", local_scheme="no-local-version"
+        root, version_scheme="semver-pep440-release-branch", local_scheme="no-local-version"
     )
 else:
     try:

{zprocess-2.27.1 → zprocess-2.28.0rc2}/zprocess/process_tree.py

@@ -156,6 +156,11 @@ class HeartbeatServer(object):
         context = SecureContext.instance(shared_secret=shared_secret)
         self.sock = context.socket(zmq.REP)
         self.port = self.sock.bind_to_random_port(bind_address)
+        if sys.platform == 'darwin':
+            # App Nap delays the replies of an idle GUI process, and its subprocesses
+            # would take it for dead:
+            import appnope
+            appnope.nope()
         self.mainloop_thread = threading.Thread(target=self.mainloop)
         self.mainloop_thread.daemon = True
         self.mainloop_thread.start()
@@ -170,45 +175,56 @@ class HeartbeatServer(object):
 
 
 class HeartbeatClient(object):
+    """A heartbeating thread that terminates the process, unless a lock is held,
+    once allowed_missed_heartbeats heartbeats in a row have had no correct reply."""
+
+    DEFAULT_ALLOWED_MISSED_HEARTBEATS = 5
 
     # How long between heartbeats?
     HEARTBEAT_INTERVAL = 1
-    # How long without a heartbeat until we kill the process? Wait longer when the
-    # heartbeat server is remote to be more forgiving of the network:
+    # How long to wait for each reply? Wait longer when the heartbeat server is
+    # remote to be more forgiving of the network:
     LOCALHOST_TIMEOUT = 1
     REMOTE_TIMEOUT = 10
 
-    """A heartbeating thread that terminates the process if it doesn't get the
-    heartbeats back within one second, unless a lock is held."""
     def __init__(self, server_host, server_port,
-                 shared_secret=None, allow_insecure=False):
+                 shared_secret=None, allow_insecure=False,
+                 heartbeat_interval=HEARTBEAT_INTERVAL,
+                 allowed_missed_heartbeats=DEFAULT_ALLOWED_MISSED_HEARTBEATS):
         self.lock = KillLock()
-        context = SecureContext.instance(shared_secret=shared_secret)
-        self.sock = context.socket(zmq.REQ, allow_insecure=allow_insecure)
-        self.sock.setsockopt(zmq.LINGER, 0)
         server_ip = gethostbyname(server_host)
-        self.sock.connect('tcp://{}:{}'.format(server_ip, server_port))
-        self.mainloop_thread = threading.Thread(target=self.mainloop)
-        self.mainloop_thread.daemon = True
-        self.mainloop_thread.start()
         if isinstance(server_ip, bytes):
             server_ip = server_ip.decode()
+        context = SecureContext.instance(shared_secret=shared_secret)
+        # A DEALER, not a REQ, so that a late reply is still read after the next
+        # heartbeat is sent:
+        self.sock = context.socket(zmq.DEALER, allow_insecure=allow_insecure)
+        self.sock.setsockopt(zmq.LINGER, 0)
+        self.sock.connect('tcp://{}:{}'.format(server_ip, server_port))
+        self.heartbeat_interval = heartbeat_interval
+        self.allowed_missed_heartbeats = allowed_missed_heartbeats
+        self.missed_parent_contacts = 0
         if ipaddress.ip_address(server_ip).is_loopback:
             self.timeout = self.LOCALHOST_TIMEOUT
         else:
             self.timeout = self.REMOTE_TIMEOUT
+        self.mainloop_thread = threading.Thread(target=self.mainloop)
+        self.mainloop_thread.daemon = True
+        self.mainloop_thread.start()
 
     def mainloop(self):
         try:
             pid = str(os.getpid()).encode('utf8')
-            while True:
-                time.sleep(self.HEARTBEAT_INTERVAL)
-                self.sock.send(pid, zmq.NOBLOCK)
-                if not self.sock.poll(self.timeout * 1000):
-                    break
-                msg = self.sock.recv()
-                if not msg == pid:
-                    break
+            while self.missed_parent_contacts < self.allowed_missed_heartbeats:
+                time.sleep(self.heartbeat_interval)
+                self.sock.send_multipart([b'', pid])
+                self.missed_parent_contacts += 1
+                self.sock.poll(self.timeout * 1000)
+                # Read every reply waiting. A late one still counts, so that a parent
+                # that is merely slow to reply is not taken for dead:
+                while self.sock.poll(0):
+                    if self.sock.recv_multipart()[-1] == pid:
+                        self.missed_parent_contacts = 0
             if not zprocess._silent:
                 print('Heartbeat failure', file=sys.stderr)
             os.kill(os.getpid(), signal.SIGTERM)
@@ -1259,6 +1275,8 @@ class ProcessTree(object):
         output_redirection_port=None,
         remote_process_client=None,
         startup_timeout=5,
+        heartbeat_interval=HeartbeatClient.HEARTBEAT_INTERVAL,
+        allowed_missed_heartbeats=HeartbeatClient.DEFAULT_ALLOWED_MISSED_HEARTBEATS,
         pymodule=False,
         args=None,
         startup_queue=None,
@@ -1325,6 +1343,8 @@ class ProcessTree(object):
             'from_parent_port': to_child_port,
             'heartbeat_server_host': 'localhost',
             'heartbeat_server_port': self.heartbeat_server.port,
+            'heartbeat_interval': heartbeat_interval,
+            'allowed_missed_heartbeats': allowed_missed_heartbeats,
             'broker_host': self.broker_host,
             'broker_in_port': self.broker_in_port,
             'broker_out_port': self.broker_out_port,
@@ -1442,6 +1462,14 @@ class ProcessTree(object):
             heartbeat_server_port,
             shared_secret=self.shared_secret,
             allow_insecure=self.allow_insecure,
+            heartbeat_interval=parentinfo.get(
+                'heartbeat_interval',
+                HeartbeatClient.HEARTBEAT_INTERVAL,
+            ),
+            # TODO: remove legacy code in the future (introduced 2026)
+            # Older parents will not include this field, so preserve the legacy
+            # single-miss behavior when connecting to them.
+            allowed_missed_heartbeats=parentinfo.get('allowed_missed_heartbeats', 1),
         )
 
         self.broker_host = parentinfo['broker_host']

{zprocess-2.27.1 → zprocess-2.28.0rc2}/zprocess/utils.py

@@ -187,7 +187,14 @@ def disable_quick_edit():
             # Already disabled, nothing for us to do.
             return
         new_mode = (orig_mode | ENABLE_EXTENDED_FLAGS) & ~ENABLE_QUICK_EDIT
-        console.SetConsoleMode(new_mode)
+        try:
+            console.SetConsoleMode(new_mode)
+        except pywintypes.error:
+            # The console rejects the mode. This happens when the process was relaunched
+            # from a PowerShell prompt: while PSReadLine waits for input it leaves
+            # ENABLE_ECHO_INPUT set without ENABLE_LINE_INPUT, and SetConsoleMode rejects
+            # any mode with that combination.
+            return
         atexit.register(console.SetConsoleMode, orig_mode)
 
         

{zprocess-2.27.1 → zprocess-2.28.0rc2/zprocess.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zprocess
-Version: 2.27.1
+Version: 2.28.0rc2
 Summary: A set of utilities for multiprocessing using zeromq
 Author-email: Christopher Billington <chrisjbillington@gmail.com>
 License-Expression: BSD-2-Clause
@@ -11,11 +11,17 @@ Project-URL: Downloads, https://pypi.org/project/zprocess/
 Project-URL: Tracker, https://github.com/chrisjbillington/zprocess/issues
 Keywords: multiprocessing,IPC,zeromq
 Classifier: Programming Language :: Python :: 3 :: Only
-Requires-Python: >=3.8
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
-Requires-Dist: setuptools_scm
+Requires-Dist: setuptools_scm>=10
 Requires-Dist: pyzmq
+Requires-Dist: appnope; sys_platform == "darwin"
 Requires-Dist: pywin32; sys_platform == "win32"
 Requires-Dist: windows-curses; sys_platform == "win32"
 Provides-Extra: test

{zprocess-2.27.1 → zprocess-2.28.0rc2}/zprocess.egg-info/SOURCES.txt

@@ -31,6 +31,8 @@ zprocess.egg-info/PKG-INFO
 zprocess.egg-info/SOURCES.txt
 zprocess.egg-info/dependency_links.txt
 zprocess.egg-info/requires.txt
+zprocess.egg-info/scm_file_list.json
+zprocess.egg-info/scm_version.json
 zprocess.egg-info/top_level.txt
 zprocess/examples/example_child.py
 zprocess/examples/example_parent.py

{zprocess-2.27.1 → zprocess-2.28.0rc2}/zprocess.egg-info/requires.txt

@@ -1,6 +1,9 @@
-setuptools_scm
+setuptools_scm>=10
 pyzmq
 
+[:sys_platform == "darwin"]
+appnope
+
 [:sys_platform == "win32"]
 pywin32
 windows-curses

zprocess-2.28.0rc2/zprocess.egg-info/scm_file_list.json

@@ -0,0 +1,51 @@
+{
+  "files": [
+    ".github/workflows/release-vars.sh",
+    ".github/workflows/release.yml",
+    ".gitignore",
+    "LICENSE.txt",
+    "README.md",
+    "doc/Makefile",
+    "doc/conf.py",
+    "doc/index.rst",
+    "doc/requirements.txt",
+    "pyproject.toml",
+    "pytest.ini",
+    "requirements.txt",
+    "run_tests.py",
+    "tests/GUI_output_redirection.py",
+    "tests/output_redirection.py",
+    "tests/test_remote.py",
+    "tests/test_zlock_server.py",
+    "tests/test_zlog_server.py",
+    "tests/test_zprocess.py",
+    "zprocess/__init__.py",
+    "zprocess/__version__.py",
+    "zprocess/clientserver.py",
+    "zprocess/cryptoproxy.py",
+    "zprocess/examples/example_child.py",
+    "zprocess/examples/example_parent.py",
+    "zprocess/examples/processclass_example.py",
+    "zprocess/examples/processclass_remote_example.py",
+    "zprocess/locking/__init__.py",
+    "zprocess/locking/__main__.py",
+    "zprocess/makesecret.py",
+    "zprocess/process_class_wrapper.py",
+    "zprocess/process_tree.py",
+    "zprocess/remote/__init__.py",
+    "zprocess/remote/__main__.py",
+    "zprocess/remote/curses_server.py",
+    "zprocess/remote/server.py",
+    "zprocess/security.py",
+    "zprocess/socks/__init__.py",
+    "zprocess/socks/server.py",
+    "zprocess/tasks.py",
+    "zprocess/utils.py",
+    "zprocess/zlock/__init__.py",
+    "zprocess/zlock/__main__.py",
+    "zprocess/zlock/server.py",
+    "zprocess/zlog/__init__.py",
+    "zprocess/zlog/__main__.py",
+    "zprocess/zlog/server.py"
+  ]
+}

zprocess-2.28.0rc2/zprocess.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "2.28.0rc2",
+  "distance": 0,
+  "node": "gf5f4685a7407c990e468b8fbb84eb1aeb1bc5725",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-10-17"
+}