agentenv-framework-protocol 0.1.512__tar.gz → 0.1.514__tar.gz

{agentenv_framework_protocol-0.1.512 → agentenv_framework_protocol-0.1.514}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agentenv-framework-protocol
-Version: 0.1.512
+Version: 0.1.514
 Summary: Open data-plane protocol and server SDK for agent environments.
 Project-URL: Homepage, https://www.agentenvframework.com
 Project-URL: Documentation, https://www.agentenvframework.com/docs

{agentenv_framework_protocol-0.1.512 → agentenv_framework_protocol-0.1.514}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agentenv-framework-protocol"
-version = "0.1.512"
+version = "0.1.514"
 description = "Open data-plane protocol and server SDK for agent environments."
 readme = "README.md"
 license = "Apache-2.0"

{agentenv_framework_protocol-0.1.512 → agentenv_framework_protocol-0.1.514}/src/agentenv_protocol/computer/_session_windows.py

@@ -72,8 +72,9 @@ async def launch(argv: list[str], cwd: Path, env: dict[str, str], fds: Optional[
 
 async def stop(pid: int, timeout_s: float) -> None:
     """End the job the helper ``pid`` holds, every process in it: its windows asked to close, then the job ended after
-    ``timeout_s``, or at once when it has no window to close, and waited on until each process it held has exited and
-    it holds none. No one asks how it exited once it's stopped."""
+    ``timeout_s``, or at once when it has no window to close; once the app's processes have closed, the helper, which
+    leaves when its job holds no process but itself, waited on to leave, the job ended should it not; and waited on
+    until each process it held has exited and it holds none. No one asks how it exited once it's stopped."""
     _reaping.forget(pid)
     job = _win32.open_job(pid)
     if job is None:
@@ -85,7 +86,11 @@ async def stop(pid: int, timeout_s: float) -> None:
         deadline = time.monotonic() + (timeout_s if windows else 0)
         while _app_pids(job, pid) and time.monotonic() < deadline:
             await asyncio.sleep(POLL_S)
-        if _app_pids(job, pid):
+        if not _app_pids(job, pid):
+            deadline = time.monotonic() + ENDED_TIMEOUT_S
+            while _win32.job_pids(job) and time.monotonic() < deadline:
+                await asyncio.sleep(POLL_S)
+        if _win32.job_pids(job):
             ending = _win32.open_processes(_win32.job_pids(job))
             try:
                 _win32.terminate_job(job)

agentenv_framework_protocol-0.1.514/tests/test_computer_driver_keys.py

@@ -0,0 +1,44 @@
+"""The named keys X11Driver, WindowsDriver and MacOSDriver map: each a W3C key value, the two PC keyboards' the same,
+and the Mac's those but the keys its keyboard lacks, with its Help key; read from the drivers' sources, so that none of
+the libraries an OS driver imports is needed."""
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+from agentenv_protocol.computer import keys
+
+COMPUTER = Path(keys.__file__).parent
+#: The PC keys a Mac keyboard has no key code for, and the Mac's own Help key, which a PC keyboard lacks.
+MAC_LACKS = {"ContextMenu", "Insert", "Pause", "PrintScreen", "F21", "F22", "F23", "F24"}
+MAC_ONLY = {"Help"}
+
+
+def _named(module: str, *tables: str) -> set[str]:
+    """The keys of the module-level dicts ``tables`` in ``computer/<module>.py``, a dict comprehension's included."""
+    found = set()
+    for node in ast.parse((COMPUTER / f"{module}.py").read_text()).body:
+        if isinstance(node, ast.Assign) and {getattr(t, "id", None) for t in node.targets} & set(tables):
+            for key, value in zip(node.value.keys, node.value.values):
+                if key is None:
+                    names = ast.DictComp(key=value.key, value=ast.Constant(None), generators=value.generators)
+                    found |= set(eval(compile(ast.fix_missing_locations(ast.Expression(names)), module, "eval")))
+                else:
+                    found.add(ast.literal_eval(key))
+    return found
+
+
+def test_every_named_key_a_driver_maps_is_a_w3c_key_value():
+    tables = {"_x11": _named("_x11", "KEYSYMS"), "_windows": _named("_windows", "VIRTUAL_KEYS"),
+              "_macos": _named("_macos", "NAMED", "MODIFIERS")}
+
+    assert all(tables.values())
+    assert {module: sorted(names - set(keys.NAMED) - {" "}) for module, names in tables.items()} == {
+        "_x11": [], "_windows": [], "_macos": []}
+
+
+def test_the_pc_drivers_map_the_same_named_keys_and_the_mac_those_its_keyboard_has():
+    x11, windows = _named("_x11", "KEYSYMS"), _named("_windows", "VIRTUAL_KEYS")
+
+    assert windows == x11
+    assert _named("_macos", "NAMED", "MODIFIERS") == x11 - MAC_LACKS | MAC_ONLY

{agentenv_framework_protocol-0.1.512 → agentenv_framework_protocol-0.1.514}/tests/test_computer_session_windows.py

@@ -1,7 +1,8 @@
 """The Windows session's own logic, its Win32 calls faked and its job helper stood in for: a launch goes through the
 helper and returns its pid once the app has started, or fails saying why it couldn't, and hands no fds; stopping asks
-the app's windows to close, then ends the job after the timeout, or at once with no window to ask, and waits until
-each process it held has exited and it holds none; pausing suspends each of the app's processes but the helper's, and
+the app's windows to close, then ends the job after the timeout, or at once with no window to ask, and, once they've
+closed, waits for the helper to leave, ending the job should it not, until each process it held has exited and it
+holds none; pausing suspends each of the app's processes but the helper's, and
 any one starts as they're suspended, and resumes them, even when the block raises; a job that's gone is neither alive,
 stopped nor paused; the windows listed are those shown, by program, class and title; and the menu launcher is a Start
 Menu shortcut PowerShell writes, named for the app."""
@@ -32,12 +33,14 @@ sys.exit(int(command[0]))
 class FakeWin32:
     """Jobs by their helper's pid, each a list of the pids in it, the helper's first; the session's windows; and every
     call that acts, recorded. An app whose window is asked to close ``closes`` or doesn't, a process ``spawns`` one
-    into its job just before it's suspended, and a job ended by force holds its processes for ``lingers`` more looks,
-    then none, though it's there until its handles close."""
+    into its job just before it's suspended, a job ended by force holds its processes for ``lingers`` more looks, then
+    none, though it's there until its handles close, and a helper alone in its job ``leaves`` after that many looks, as
+    the real one does, or, for None, stays."""
 
     def __init__(self, jobs: dict[int, list[int]], windows: list[Window], closes: bool = True,
-                 spawns: dict[int, int] | None = None, lingers: int = 0) -> None:
+                 spawns: dict[int, int] | None = None, lingers: int = 0, leaves: int | None = 5) -> None:
         self.jobs, self._windows, self.closes, self.spawns, self.lingers = jobs, windows, closes, spawns or {}, lingers
+        self.leaves = leaves
         self.ending: dict[int, int] = {}
         self.posted, self.terminated, self.suspended, self.resumed, self.waited, self.open = [], [], [], [], [], 0
 
@@ -52,6 +55,10 @@ class FakeWin32:
             self.ending[job] -= 1
             if self.ending[job] < 0:
                 self.jobs[job] = []
+        elif self.jobs[job] == [job] and self.leaves is not None:
+            self.leaves -= 1
+            if self.leaves < 0:
+                self.jobs[job] = []
         return list(self.jobs[job])
 
     def open_processes(self, pids):
@@ -107,16 +114,29 @@ def win32(monkeypatch):
 async def test_stopping_asks_the_apps_windows_to_close_and_ends_the_job_only_if_they_dont(win32):
     obliging = win32({HELPER: [HELPER, 901, 902]}, [_window(1, 901), _window(2, 777), _window(3, 902, shown=False)])
     await _session_windows.stop(HELPER, timeout_s=5)
+    obliging_left = not _session_windows.alive(HELPER)
     stubborn = win32({HELPER: [HELPER, 901]}, [_window(1, 901)], closes=False, lingers=3)
     started = time.monotonic()
     await _session_windows.stop(HELPER, timeout_s=0.2)
 
     assert obliging.posted == [1, 3] and obliging.terminated == obliging.waited == [] and obliging.open == 0
+    assert obliging_left
     assert stubborn.posted == [1] and stubborn.terminated == [HELPER] and time.monotonic() - started >= 0.2
     assert stubborn.waited == [[HELPER, 901]] and stubborn.open == 0
     assert stubborn.jobs[HELPER] == [] and not _session_windows.alive(HELPER)
 
 
+@pytest.mark.asyncio
+async def test_a_helper_that_stays_once_its_apps_window_has_closed_is_ended_with_its_job(win32, monkeypatch):
+    monkeypatch.setattr(_session_windows, "ENDED_TIMEOUT_S", 0.1)
+    stuck = win32({HELPER: [HELPER, 901]}, [_window(1, 901)], leaves=None)
+
+    await _session_windows.stop(HELPER, timeout_s=5)
+
+    assert stuck.posted == [1] and stuck.terminated == [HELPER] and stuck.waited == [[HELPER]] and stuck.open == 0
+    assert not _session_windows.alive(HELPER)
+
+
 @pytest.mark.asyncio
 async def test_an_app_with_no_window_to_ask_is_ended_at_once_and_a_gone_job_is_left_be(win32):
     windowless = win32({HELPER: [HELPER, 901]}, [_window(1, 777)])