quality-loop 0.4.0__tar.gz → 0.4.2__tar.gz

{quality_loop-0.4.0/quality_loop.egg-info → quality_loop-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quality-loop
-Version: 0.4.0
+Version: 0.4.2
 Summary: Measure what a product teaches - its skill, tools or manual - with isolated agent runs of real tasks, reported by an operator agent
 Author: craftware
 License-Expression: MIT

{quality_loop-0.4.0 → quality_loop-0.4.2}/quality_loop/__init__.py

@@ -12,4 +12,4 @@ room is handed, putting the user's machine back - is code here, not an
 agent's discretion.
 """
 
-__version__ = "0.4.0"
+__version__ = "0.4.2"

quality_loop-0.4.2/quality_loop/awake.py

@@ -0,0 +1,85 @@
+"""This machine kept from idle sleep while a run is going (issue #16).
+
+A run is mostly waiting - on a session, on a VM - and a machine left alone
+for it goes to sleep: a Mac on battery within minutes. Nothing fails; the
+run just stops while it sleeps, and a VM guest stops with it. One run of
+43 minutes had spent 40 of them asleep.
+
+So the runner holds the platform's "the system is busy" assertion for the
+length of the run, and lets go when it ends. The display may still sleep,
+and closing a laptop's lid still sleeps it: those are the person's to choose.
+
+- macOS: ``caffeinate -i -w <this pid>``, which also ends with this process
+  if it dies without letting go.
+- Windows: ``SetThreadExecutionState(ES_CONTINUOUS | ES_SYSTEM_REQUIRED)``
+  from the runner's thread, cleared at the end (and by Windows when the
+  process exits).
+- Elsewhere nothing is held.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import os
+import shutil
+import subprocess
+import sys
+
+ES_CONTINUOUS = 0x80000000
+ES_SYSTEM_REQUIRED = 0x00000001
+
+
+@contextlib.contextmanager
+def held(say=print):
+    """Idle sleep held off for the ``with`` block, where the platform allows."""
+    release = _hold()
+    if release is None:
+        yield False
+        return
+    say("awake:   idle sleep is held off for the run (closing the lid still sleeps it)")
+    try:
+        yield True
+    finally:
+        release()
+
+
+def _hold():
+    if sys.platform == "darwin":
+        return _hold_mac()
+    if os.name == "nt":
+        return _hold_windows()
+    return None
+
+
+def _hold_mac():
+    caffeinate = shutil.which("caffeinate")
+    if caffeinate is None:
+        return None
+    try:
+        process = subprocess.Popen([caffeinate, "-i", "-w", str(os.getpid())],
+                                   stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL,
+                                   stderr=subprocess.DEVNULL)
+    except OSError:
+        return None
+
+    def release():
+        process.terminate()
+        try:
+            process.wait(5)
+        except subprocess.TimeoutExpired:
+            process.kill()
+
+    return release
+
+
+def _hold_windows():
+    import ctypes
+    try:
+        kernel32 = ctypes.WinDLL("kernel32")
+    except OSError:
+        return None
+    kernel32.SetThreadExecutionState.restype = ctypes.c_uint
+    kernel32.SetThreadExecutionState.argtypes = [ctypes.c_uint]
+    if not kernel32.SetThreadExecutionState(ES_CONTINUOUS | ES_SYSTEM_REQUIRED):
+        return None
+    return lambda: kernel32.SetThreadExecutionState(ES_CONTINUOUS)

{quality_loop-0.4.0 → quality_loop-0.4.2}/quality_loop/guest/__init__.py

@@ -483,8 +483,14 @@ class TartMachine:
 class VMwareMachine:
     """A VMware Fusion VM reverted to a snapshot before the run.
 
-    A snapshot taken while the VM was running comes back running, signed in
-    and with SSH up, after `vmrun start`. The SMB share that was mounted on
+    Take the snapshot with the VM shut down, so that every run boots it. A
+    snapshot taken while it ran comes back running, signed in and with SSH
+    up, in seconds - and with whatever was half done at that moment, every
+    time: Keyhac's image came back with Notepad's hand-off to its packaged
+    app broken, so `notepad.exe` started the inbox one, which crashed within
+    seconds on every run, while the same VM booted was fine. On Windows, the
+    run waits for the automatic sign-in, which the image must have. The SMB
+    share that was mounted on
     the host does not survive the revert, so it is mounted again. The VM is
     shut down afterwards, its share unmounted first: the next run reverts it
     anyway, and a VM `vmrun` left running headless is one the Fusion app
@@ -495,8 +501,7 @@ class VMwareMachine:
     Learnt on Fusion 26 with a vTPM-encrypted Windows 11 VM: `vmrun` cannot
     linked-clone it ("Cannot read the virtual machine configuration file"),
     nor snapshot it while it runs ("Authentication for encrypted virtual
-    machine failed") - take a running-state snapshot in the Fusion app, after
-    `vmrun suspend` (a headless VM does not show there).
+    machine failed"). Shut down, `vmrun -vp <password> snapshot` takes it.
     """
 
     VMRUN = "/Applications/VMware Fusion.app/Contents/Library/vmrun"
@@ -533,9 +538,36 @@ class VMwareMachine:
                              f"to {self.snapshot!r}")
         self._mount()
         self._wait_for_the_clock()
+        if self.guest.windows:
+            self._wait_for_the_desktop()
         print(f"vm:      {self.guest.alias} reverted to {self.snapshot!r}")
         return self
 
+    def _wait_for_the_desktop(self, settle: float = 15.0) -> None:
+        """Wait until the guest's user is signed in, and has been for
+        ``settle`` seconds.
+
+        A booted VM answers SSH before the automatic sign-in has made the
+        desktop session `launch` starts programs in, and that session's
+        first seconds are its startup programs; the run starts after both.
+        A running-state snapshot is past them at once.
+        """
+        deadline = time.monotonic() + self.patience
+        while time.monotonic() < deadline:
+            said = self.guest.ssh(
+                "$e = Get-Process explorer -ErrorAction SilentlyContinue | "
+                "Where-Object { $_.SessionId -gt 0 } | Select-Object -First 1; "
+                "if ($e) { [int]((Get-Date) - $e.StartTime).TotalSeconds } else { -1 }")
+            try:
+                up = int(said.stdout.strip())
+            except ValueError:
+                up = -1
+            if up >= settle:
+                return
+            time.sleep(settle - up if up >= 0 else 3.0)
+        raise GuestError(f"{self.guest.alias}: no signed-in desktop after "
+                         f"{self.patience:.0f}s - is automatic sign-in set up?")
+
     def _mount(self) -> None:
         url = self.guest.settings.get("smb")
         if not url:

{quality_loop-0.4.0 → quality_loop-0.4.2}/quality_loop/runner.py

@@ -41,8 +41,8 @@ import tempfile
 import threading
 
 import quality_loop
-from quality_loop import (audit, drive, operator, pages, processes, progress, report,
-                          room, scenario, screens, standin, transcript)
+from quality_loop import (audit, awake, drive, operator, pages, processes, progress,
+                          report, room, scenario, screens, standin, transcript)
 
 
 class RunnerError(Exception):
@@ -200,7 +200,7 @@ def run(adapter, names: list[str] | None = None, model: str | None = None,
     state = "done"
     try:
         bundle = adapter.bundle()
-        with adapter.product():
+        with awake.held(status.say), adapter.product():
             def work(item):
                 case, variant = item
                 label = label_of(case, variant)

{quality_loop-0.4.0 → quality_loop-0.4.2/quality_loop.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quality-loop
-Version: 0.4.0
+Version: 0.4.2
 Summary: Measure what a product teaches - its skill, tools or manual - with isolated agent runs of real tasks, reported by an operator agent
 Author: craftware
 License-Expression: MIT

{quality_loop-0.4.0 → quality_loop-0.4.2}/quality_loop.egg-info/SOURCES.txt

@@ -6,6 +6,7 @@ quality_loop/__init__.py
 quality_loop/__main__.py
 quality_loop/adapter.py
 quality_loop/audit.py
+quality_loop/awake.py
 quality_loop/cli.py
 quality_loop/compare.py
 quality_loop/config.py
@@ -44,6 +45,7 @@ quality_loop/screens/_windows.py
 quality_loop/skill/SKILL.md
 quality_loop/skill/references/filing.md
 quality_loop/skill/references/setup.md
+tests/test_awake.py
 tests/test_core.py
 tests/test_drive.py
 tests/test_guest.py

quality_loop-0.4.2/tests/test_awake.py

@@ -0,0 +1,45 @@
+"""The runner keeps the machine from idle sleep while a run goes (#16)."""
+
+import os
+import subprocess
+import sys
+
+import pytest
+
+from quality_loop import awake
+
+
+@pytest.mark.skipif(sys.platform != "darwin", reason="caffeinate is macOS's")
+def test_a_mac_holds_caffeinate_on_this_process_for_the_block():
+    said = []
+    with awake.held(said.append) as holding:
+        assert holding
+        listed = subprocess.run(["pgrep", "-f", f"caffeinate -i -w {os.getpid()}"],
+                                capture_output=True, text=True)
+        assert listed.stdout.strip()
+    assert said and said[0].startswith("awake:")
+    listed = subprocess.run(["pgrep", "-f", f"caffeinate -i -w {os.getpid()}"],
+                            capture_output=True, text=True)
+    assert not listed.stdout.strip()
+
+
+def test_where_nothing_can_be_held_the_run_goes_on_quietly(monkeypatch):
+    monkeypatch.setattr(awake.sys, "platform", "linux")
+    monkeypatch.setattr(awake.os, "name", "posix")
+    said = []
+    with awake.held(said.append) as holding:
+        assert holding is False
+    assert said == []
+
+
+def test_a_mac_without_caffeinate_holds_nothing(monkeypatch):
+    monkeypatch.setattr(awake.sys, "platform", "darwin")
+    monkeypatch.setattr(awake.shutil, "which", lambda name: None)
+    with awake.held(lambda line: None) as holding:
+        assert holding is False
+
+
+@pytest.mark.skipif(os.name != "nt", reason="SetThreadExecutionState is Windows'")
+def test_windows_sets_and_clears_the_execution_state():
+    with awake.held(lambda line: None) as holding:
+        assert holding

{quality_loop-0.4.0 → quality_loop-0.4.2}/tests/test_guest.py

@@ -208,6 +208,30 @@ def test_a_terminal_script_is_staged_and_run_with_the_guest_python(share, monkey
     assert (stage / "scripts" / "deploy.py").exists()
 
 
+def test_a_booted_windows_guest_is_waited_for_until_its_desktop_has_settled(share, monkeypatch):
+    """A powered-off snapshot boots: SSH answers before the automatic sign-in
+    has made the desktop, and then its startup programs run."""
+    guest = _guest(share, windows=True, vmx="/v.vmx", snapshot="s")
+    answers = iter(["-1", "-1", "4", "16"])
+    ssh = FakeSSH(lambda c: (next(answers) + "\n", 0))
+    monkeypatch.setattr(guest, "ssh", ssh)
+    slept = []
+    monkeypatch.setattr(guests.time, "sleep", slept.append)
+    guests.VMwareMachine(guest)._wait_for_the_desktop(settle=15)
+    assert len(ssh.commands) == 4 and "explorer" in ssh.commands[0]
+    assert slept == [3.0, 3.0, 11]
+
+
+def test_no_desktop_is_an_error_that_names_automatic_sign_in(share, monkeypatch):
+    guest = _guest(share, windows=True, vmx="/v.vmx", snapshot="s")
+    monkeypatch.setattr(guest, "ssh", FakeSSH(lambda c: ("-1\n", 0)))
+    clock = iter(range(0, 1000, 50))
+    monkeypatch.setattr(guests.time, "monotonic", lambda: next(clock))
+    monkeypatch.setattr(guests.time, "sleep", lambda s: None)
+    with pytest.raises(GuestError, match="automatic sign-in"):
+        guests.VMwareMachine(guest, patience=120)._wait_for_the_desktop()
+
+
 def test_machine_follows_the_settings(share):
     assert isinstance(_guest(share, tart="base").machine(), guests.TartMachine)
     assert isinstance(_guest(share, vmx="/v.vmx", snapshot="s").machine(), guests.VMwareMachine)