overcode 0.5.3__tar.gz → 0.5.4__tar.gz

{overcode-0.5.3/src/overcode.egg-info → overcode-0.5.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: overcode
-Version: 0.5.3
+Version: 0.5.4
 Summary: A supervisor for managing multiple Claude Code instances in tmux
 Author: Mike Bond
 Project-URL: Homepage, https://github.com/mkb23/overcode

{overcode-0.5.3 → overcode-0.5.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "overcode"
-version = "0.5.3"
+version = "0.5.4"
 description = "A supervisor for managing multiple Claude Code instances in tmux"
 authors = [
     {name = "Mike Bond"}
@@ -61,7 +61,7 @@ export = [
 ]
 
 [project.scripts]
-overcode = "overcode.cli:main"
+overcode = "overcode.entrypoint:main"
 tui-eye = "overcode.testing.tui_eye:main"
 
 [tool.setuptools.packages.find]

{overcode-0.5.3 → overcode-0.5.4}/src/overcode/backends/opencode2_stats.py

@@ -60,7 +60,9 @@ from ..stats_reader import (
 from .opencode_stats import (
     _as_float,
     _as_int,
+    _cached_records,
     _launch_ms,
+    _optional_ms,
     _parse_model,
     _placeholders,
     _table_columns,
@@ -216,6 +218,69 @@ def _row_identities(rows: Sequence[sqlite3.Row]) -> Tuple[Optional[str], Optiona
     return _parse_model(active["model"]), (active["agent"] or None)
 
 
+def _scan_sql(ids: Sequence[str]) -> Tuple[str, List[Any]]:
+    """The newest ``_MESSAGE_SCAN_LIMIT`` user/assistant rows of each
+    conversation — narrow columns only, unordered across conversations.
+
+    One bounded probe per conversation rather than one ``session_id IN
+    (...) ORDER BY ... LIMIT`` over all of them — the shared sort's cost
+    grew roughly quadratically with the number of owned ids (#476; the v1
+    reader's ``_scan_sql`` has the numbers). Inside one conversation
+    ``seq`` is assigned in insertion order, so ``ORDER BY seq DESC`` on the
+    unique ``(session_id, seq)`` index yields exactly the newest rows
+    without a sort; the caller merges by ``(time_created, seq)`` in Python.
+
+    ``data`` is deliberately not selected: on a real store an assistant
+    row carries its tool output inline (1 KB-1 MB); bodies are fetched
+    once per version through ``opencode_stats._cached_records``.
+    """
+    probe = (
+        "SELECT * FROM (SELECT id, session_id, type, seq, time_created, "
+        "time_updated FROM session_message WHERE session_id = ? "
+        "AND type IN ('user', 'assistant') ORDER BY seq DESC LIMIT ?)"
+    )
+    sql = " UNION ALL ".join([probe] * len(ids))
+    params: List[Any] = []
+    for sid in ids:
+        params.extend((sid, _MESSAGE_SCAN_LIMIT))
+    return sql, params
+
+
+def _parse_session_message_record(
+    data: Optional[str], mtype: Any
+) -> Tuple[Optional[Dict[str, Any]], bool]:
+    """Extract what the scan needs from a v2 ``session_message.data`` body.
+
+    ``mtype`` is the row's ``type`` column (the envelope has no role).
+    """
+    try:
+        envelope = json.loads(data) if data is not None else None
+    except (ValueError, TypeError):
+        return None, False
+    if not isinstance(envelope, dict):
+        return None, False
+    tokens = envelope.get("tokens")
+    tokens = tokens if isinstance(tokens, dict) else {}
+    cache = tokens.get("cache")
+    cache = cache if isinstance(cache, dict) else {}
+    times = envelope.get("time")
+    times = times if isinstance(times, dict) else {}
+    agent = envelope.get("agent")
+    record = {
+        "input": _as_int(tokens.get("input")),
+        "output": _as_int(tokens.get("output")),
+        "reasoning": _as_int(tokens.get("reasoning")),
+        "cache_read": _as_int(cache.get("read")),
+        "cache_write": _as_int(cache.get("write")),
+        "created": _optional_ms(times.get("created")),
+        "completed": _optional_ms(times.get("completed")),
+        "model": _parse_model(envelope.get("model")),
+        "agent": agent if isinstance(agent, str) and agent else None,
+    }
+    in_flight = mtype == "assistant" and record["completed"] is None
+    return record, not in_flight
+
+
 def _scan_messages(
     conn: sqlite3.Connection,
     session_ids: Sequence[str],
@@ -246,24 +311,22 @@ def _scan_messages(
     if not ids:
         return out
 
-    sql = (
-        "SELECT id, session_id, type, time_created, data FROM session_message "
-        f"WHERE session_id IN ({_placeholders(len(ids))}) "
-        "AND type IN ('user', 'assistant') "
-        "ORDER BY time_created DESC, seq DESC LIMIT ?"
-    )
+    sql, params = _scan_sql(ids)
     try:
-        rows = conn.execute(sql, (*ids, _MESSAGE_SCAN_LIMIT * max(1, len(ids)))).fetchall()
+        rows = conn.execute(sql, params).fetchall()
+        rows.sort(key=lambda row: (row[4], row[3]), reverse=True)
+        records = _cached_records(
+            conn, "session_message",
+            [(row[0], row[5], row[2]) for row in rows],
+            _parse_session_message_record,
+        )
     except sqlite3.Error:
         return out
 
     seen_context = False
-    for _msg_id, session_id, mtype, time_created, data in rows:
-        try:
-            envelope = json.loads(data)
-        except (ValueError, TypeError):
-            continue
-        if not isinstance(envelope, dict):
+    for msg_id, session_id, mtype, _seq, time_created, _updated in rows:
+        record = records.get(msg_id)
+        if record is None:
             continue
         if mtype == "user":
             out["interaction_count"] += 1
@@ -271,22 +334,13 @@ def _scan_messages(
         if mtype != "assistant":
             continue
 
-        tokens = envelope.get("tokens")
-        tokens = tokens if isinstance(tokens, dict) else {}
-        cache = tokens.get("cache")
-        cache = cache if isinstance(cache, dict) else {}
-
         # v2's assistant data has no `tokens.total` (verified); the context
         # size is the processed prompt — input + cache read + cache write —
         # the semantics AgentSessionStats.current_context_tokens documents.
         # Rows arrive newest-first, and only the active conversation's
         # context is meaningful — an older /new session's is stale.
         if not seen_context and (active_id is None or session_id == active_id):
-            context = (
-                _as_int(tokens.get("input"))
-                + _as_int(cache.get("read"))
-                + _as_int(cache.get("write"))
-            )
+            context = record["input"] + record["cache_read"] + record["cache_write"]
             if context > 0:
                 out["current_context_tokens"] = context
                 seen_context = True
@@ -296,32 +350,24 @@ def _scan_messages(
         # tracked session's identities must not leak into the active
         # conversation.
         if active_id is not None and session_id == active_id:
-            if out["model"] is None:
-                parsed_model = _parse_model(envelope.get("model"))
-                if parsed_model:
-                    out["model"] = parsed_model
-            if out["agent"] is None:
-                agent = envelope.get("agent")
-                if isinstance(agent, str) and agent:
-                    out["agent"] = agent
-
-        times = envelope.get("time")
-        times = times if isinstance(times, dict) else {}
-        created = times.get("created")
-        completed = times.get("completed")
-        if isinstance(created, (int, float)) and isinstance(completed, (int, float)):
+            if out["model"] is None and record["model"]:
+                out["model"] = record["model"]
+            if out["agent"] is None and record["agent"]:
+                out["agent"] = record["agent"]
+
+        created = record["created"]
+        completed = record["completed"]
+        if created is not None and completed is not None:
             elapsed = (completed - created) / 1000.0
             if elapsed > 0:
                 out["work_times"].append(elapsed)
 
         if since_ms is not None and _as_int(time_created) >= since_ms:
             window = out["window"]
-            window["input_tokens"] += _as_int(tokens.get("input"))
-            window["output_tokens"] += _as_int(tokens.get("output")) + _as_int(
-                tokens.get("reasoning")
-            )
-            window["cache_creation_tokens"] += _as_int(cache.get("write"))
-            window["cache_read_tokens"] += _as_int(cache.get("read"))
+            window["input_tokens"] += record["input"]
+            window["output_tokens"] += record["output"] + record["reasoning"]
+            window["cache_creation_tokens"] += record["cache_write"]
+            window["cache_read_tokens"] += record["cache_read"]
 
     out["work_times"].reverse()
     return out

{overcode-0.5.3 → overcode-0.5.4}/src/overcode/backends/opencode_stats.py

@@ -26,9 +26,10 @@ daemon tick.
 import json
 import os
 import sqlite3
+import threading
 from datetime import datetime
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Sequence, Tuple
+from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple
 
 from .. import model_metadata
 from ..stats_reader import (
@@ -323,6 +324,159 @@ def fetch_rows_for_directory(
     return conn.execute(sql, (*candidates, since_ms)).fetchall()
 
 
+def _scan_sql(ids: Sequence[str]) -> Tuple[str, List[Any]]:
+    """The newest ``_MESSAGE_SCAN_LIMIT`` rows of each conversation — narrow
+    columns only, unordered across conversations.
+
+    One bounded probe per conversation, not one ``WHERE session_id IN (...)
+    ORDER BY ... LIMIT`` over all of them: SQLite answers the latter through
+    a temp B-tree fed by every candidate row, so its cost grew roughly
+    quadratically with the number of owned ids (~2 ms at one, ~115 ms at
+    eight on a real store — per agent, per second, for the burn rate; #476).
+    Each probe here walks the ``(session_id, time_created)`` index backwards
+    and stops at its own limit, which is also what the per-session scan
+    limit documents. The caller merges in Python: an SQL ``ORDER BY`` over
+    the union would materialise every row again.
+
+    ``data`` is deliberately not selected — see ``_cached_records``.
+    """
+    probe = (
+        "SELECT * FROM (SELECT id, session_id, time_created, time_updated "
+        "FROM message WHERE session_id = ? ORDER BY time_created DESC LIMIT ?)"
+    )
+    sql = " UNION ALL ".join([probe] * len(ids))
+    params: List[Any] = []
+    for sid in ids:
+        params.extend((sid, _MESSAGE_SCAN_LIMIT))
+    return sql, params
+
+
+# Per-row parse cache (#476). The TUI re-reads a conversation's newest rows
+# every second for the burn rate and every 5 s for the stats columns, and
+# on a real store an assistant row is 1 KB-1 MB of JSON (tool output
+# travels inline). So the scan selects only the narrow columns — they all
+# sit in the row's first page, so it never touches overflow pages — and
+# fetches + parses ``data`` only for rows it has not seen at that
+# ``time_updated``. opencode rewrites ``time_updated`` whenever it rewrites
+# a row (on a live store an assistant row's ``time_updated`` is its
+# ``time.completed``); an assistant row still in flight (no
+# ``time.completed`` yet) is never cached, so a stale key cannot freeze it.
+# Entries are small extracted records, never the envelope.
+_ROW_CACHE_MAX = 50_000
+_row_cache: Dict[Tuple[str, str, str], Tuple[Any, Any]] = {}
+_row_cache_lock = threading.Lock()
+
+# A parsed row: the record the scan consumes, and whether it may be cached.
+RowParser = Callable[[Optional[str], Any], Tuple[Optional[Dict[str, Any]], bool]]
+
+
+def clear_row_cache() -> None:
+    """Drop every cached row record (tests)."""
+    with _row_cache_lock:
+        _row_cache.clear()
+
+
+def _database_key(conn: sqlite3.Connection) -> str:
+    """The file behind ``conn`` — cache entries must not cross stores."""
+    try:
+        for _seq, name, file in conn.execute("PRAGMA database_list"):
+            if name == "main":
+                return file or ""
+    except sqlite3.Error:
+        pass
+    return ""
+
+
+def _fetch_data(
+    conn: sqlite3.Connection, table: str, ids: Sequence[str]
+) -> Dict[str, str]:
+    """``data`` for the given row ids, by primary key."""
+    out: Dict[str, str] = {}
+    for start in range(0, len(ids), 500):
+        chunk = list(ids[start : start + 500])
+        sql = f"SELECT id, data FROM {table} WHERE id IN ({_placeholders(len(chunk))})"
+        for msg_id, data in conn.execute(sql, chunk):
+            out[msg_id] = data
+    return out
+
+
+def _cached_records(
+    conn: sqlite3.Connection,
+    table: str,
+    rows: Sequence[Tuple[str, Any, Any]],
+    parse: RowParser,
+) -> Dict[str, Optional[Dict[str, Any]]]:
+    """Records for ``rows`` of ``(id, time_updated, hint)``, parsed at most
+    once per ``(store, table, id, time_updated)``.
+
+    ``hint`` is handed to ``parse`` alongside the body (v2 keeps the row
+    type outside the envelope). Unparseable rows map to None.
+    """
+    db = _database_key(conn)
+    records: Dict[str, Optional[Dict[str, Any]]] = {}
+    missing: List[Tuple[str, Any, Any]] = []
+    for msg_id, version, hint in rows:
+        entry = _row_cache.get((db, table, msg_id))
+        if entry is not None and entry[0] == version:
+            records[msg_id] = entry[1]
+        else:
+            missing.append((msg_id, version, hint))
+    if not missing:
+        return records
+
+    bodies = _fetch_data(conn, table, [msg_id for msg_id, _, _ in missing])
+    fresh: Dict[Tuple[str, str, str], Tuple[Any, Any]] = {}
+    for msg_id, version, hint in missing:
+        record, cacheable = parse(bodies.get(msg_id), hint)
+        records[msg_id] = record
+        if cacheable:
+            fresh[(db, table, msg_id)] = (version, record)
+    if fresh:
+        with _row_cache_lock:
+            if len(_row_cache) + len(fresh) > _ROW_CACHE_MAX:
+                # Bound growth: drop the oldest half (insertion order).
+                for stale in list(_row_cache)[: _ROW_CACHE_MAX // 2]:
+                    del _row_cache[stale]
+            _row_cache.update(fresh)
+    return records
+
+
+def _optional_ms(value: Any) -> Optional[float]:
+    return value if isinstance(value, (int, float)) else None
+
+
+def _parse_message_record(
+    data: Optional[str], _hint: Any
+) -> Tuple[Optional[Dict[str, Any]], bool]:
+    """Extract what the scan needs from a v1 ``message.data`` envelope."""
+    try:
+        envelope = json.loads(data) if data is not None else None
+    except (ValueError, TypeError):
+        return None, False
+    if not isinstance(envelope, dict):
+        return None, False
+    tokens = envelope.get("tokens")
+    tokens = tokens if isinstance(tokens, dict) else {}
+    cache = tokens.get("cache")
+    cache = cache if isinstance(cache, dict) else {}
+    times = envelope.get("time")
+    times = times if isinstance(times, dict) else {}
+    role = envelope.get("role")
+    record = {
+        "role": role,
+        "total": _as_int(tokens.get("total")),
+        "input": _as_int(tokens.get("input")),
+        "output": _as_int(tokens.get("output")),
+        "reasoning": _as_int(tokens.get("reasoning")),
+        "cache_read": _as_int(cache.get("read")),
+        "cache_write": _as_int(cache.get("write")),
+        "created": _optional_ms(times.get("created")),
+        "completed": _optional_ms(times.get("completed")),
+    }
+    in_flight = role == "assistant" and record["completed"] is None
+    return record, not in_flight
+
+
 def _scan_messages(
     conn: sqlite3.Connection,
     session_ids: Sequence[str],
@@ -345,64 +499,53 @@ def _scan_messages(
     if not ids:
         return out
 
-    sql = (
-        "SELECT id, session_id, time_created, data FROM message "
-        f"WHERE session_id IN ({_placeholders(len(ids))}) "
-        "ORDER BY time_created DESC LIMIT ?"
-    )
+    sql, params = _scan_sql(ids)
     try:
-        rows = conn.execute(sql, (*ids, _MESSAGE_SCAN_LIMIT * max(1, len(ids)))).fetchall()
+        rows = conn.execute(sql, params).fetchall()
+        rows.sort(key=lambda row: row[2], reverse=True)  # time_created DESC
+        records = _cached_records(
+            conn, "message", [(row[0], row[3], None) for row in rows],
+            _parse_message_record,
+        )
     except sqlite3.Error:
         return out
 
     seen_context = False
-    for _msg_id, session_id, time_created, data in rows:
-        try:
-            envelope = json.loads(data)
-        except (ValueError, TypeError):
+    for msg_id, session_id, time_created, _updated in rows:
+        record = records.get(msg_id)
+        if record is None:
             continue
-        if not isinstance(envelope, dict):
-            continue
-        role = envelope.get("role")
+        role = record["role"]
         if role == "user":
             out["interaction_count"] += 1
             continue
         if role != "assistant":
             continue
 
-        tokens = envelope.get("tokens")
-        tokens = tokens if isinstance(tokens, dict) else {}
-        cache = tokens.get("cache")
-        cache = cache if isinstance(cache, dict) else {}
-
         # Rows arrive newest-first, so the first assistant turn carrying a
         # total is the live context size. Only the active conversation's
         # context is meaningful — an older /new session's is stale.
         if (
             not seen_context
-            and tokens.get("total")
+            and record["total"]
             and (active_id is None or session_id == active_id)
         ):
-            out["current_context_tokens"] = _as_int(tokens.get("total"))
+            out["current_context_tokens"] = record["total"]
             seen_context = True
 
-        times = envelope.get("time")
-        times = times if isinstance(times, dict) else {}
-        created = times.get("created")
-        completed = times.get("completed")
-        if isinstance(created, (int, float)) and isinstance(completed, (int, float)):
+        created = record["created"]
+        completed = record["completed"]
+        if created is not None and completed is not None:
             elapsed = (completed - created) / 1000.0
             if elapsed > 0:
                 out["work_times"].append(elapsed)
 
         if since_ms is not None and _as_int(time_created) >= since_ms:
             window = out["window"]
-            window["input_tokens"] += _as_int(tokens.get("input"))
-            window["output_tokens"] += _as_int(tokens.get("output")) + _as_int(
-                tokens.get("reasoning")
-            )
-            window["cache_creation_tokens"] += _as_int(cache.get("write"))
-            window["cache_read_tokens"] += _as_int(cache.get("read"))
+            window["input_tokens"] += record["input"]
+            window["output_tokens"] += record["output"] + record["reasoning"]
+            window["cache_creation_tokens"] += record["cache_write"]
+            window["cache_read_tokens"] += record["cache_read"]
 
     out["work_times"].reverse()
     return out
@@ -697,6 +840,7 @@ def _launch_ms(session: Any) -> Optional[int]:
 
 __all__ = [
     "EXPECTED_MESSAGE_COLUMNS",
+    "clear_row_cache",
     "EXPECTED_SESSION_COLUMNS",
     "OpencodeStatsReader",
     "connect",

overcode-0.5.4/src/overcode/entrypoint.py

@@ -0,0 +1,40 @@
+"""Console-script entry point for the ``overcode`` command.
+
+The typer CLI in :mod:`overcode.cli` imports typer, rich, libtmux and the
+launcher before it can dispatch anything — roughly 70 ms of CPU per
+process. That is fine for a human typing commands, but the same binary is
+what every agent's hooks run (``overcode hook-handler``) on *every*
+PreToolUse / PostToolUse / Stop / ... event. Across a fleet of busy agents
+that adds up to whole cores burned on Python imports, competing with the
+tmux server and the terminal for CPU — visible as typing lag.
+
+So the hook path is dispatched here, before the CLI package is imported.
+Everything else falls through to the full typer app unchanged.
+"""
+
+import sys
+
+# Subcommands that must not pay for the typer CLI import. Only ``hook-handler``
+# today; each entry maps to a zero-argument callable resolved lazily.
+_FAST_PATHS = {
+    "hook-handler": ("overcode.hook_handler", "handle_hook_event"),
+}
+
+
+def main() -> None:
+    """Dispatch ``overcode <cmd>``; fast-path hook events, else run the CLI."""
+    argv = sys.argv[1:]
+    if len(argv) == 1 and argv[0] in _FAST_PATHS:
+        module_name, func_name = _FAST_PATHS[argv[0]]
+        import importlib
+
+        getattr(importlib.import_module(module_name), func_name)()
+        return
+
+    from .cli import main as cli_main
+
+    cli_main()
+
+
+if __name__ == "__main__":
+    main()

{overcode-0.5.3 → overcode-0.5.4}/src/overcode/launcher.py

@@ -15,7 +15,7 @@ import os
 import time
 import uuid
 from pathlib import Path
-from typing import List, Optional
+from typing import Any, Dict, List, Optional, Tuple
 
 import re
 
@@ -45,6 +45,26 @@ from .exceptions import TmuxNotFoundError, AgentCliNotFoundError, InvalidSession
 SESSION_NAME_PATTERN = re.compile(r"^[a-zA-Z0-9_-]{1,64}$")
 
 
+def window_lookup(windows: List[Dict[str, Any]]) -> Tuple[set, set]:
+    """Build (names, index-strings) sets from a ``list_windows()`` result.
+
+    Lets callers answer "does window X exist?" for many X from one tmux
+    round-trip, with the same semantics as ``TmuxManager.window_exists``:
+    exact name match, falling back to a legacy digit-string index match.
+    """
+    names = {w.get("name", "") for w in windows}
+    indices = {str(w.get("index")) for w in windows if w.get("index") is not None}
+    return names, indices
+
+
+def window_in_lookup(window: str, lookup: Tuple[set, set]) -> bool:
+    """Existence check against ``window_lookup`` output (see there)."""
+    names, indices = lookup
+    if window in names:
+        return True
+    return window.isdigit() and window in indices
+
+
 def validate_session_name(name: str) -> None:
     """Validate session name format.
 
@@ -904,22 +924,29 @@ class AgentLauncher:
         # Filter to only sessions belonging to this tmux session
         my_sessions = [s for s in all_sessions if s.tmux_session == self.tmux.session_name]
 
+        # One tmux round-trip for the whole call: the window list serves both
+        # the legacy-index migration and the existence checks below. The old
+        # per-session window_exists() cost two tmux commands per agent, and
+        # the TUI calls this every 10s.
+        tmux_windows = self._list_tmux_windows_cheap()
+
         # Migrate legacy digit-string tmux_window values to actual window names.
         # Pre-name-based sessions stored window index (e.g. 4 → "4") but the new
         # code expects the window name (e.g. "overcode2"). Resolve via tmux.
-        self._migrate_legacy_window_ids(my_sessions)
+        self._migrate_legacy_window_ids(my_sessions, tmux_windows)
 
         # Detect terminated sessions (tmux window gone but session still tracked)
         if detect_terminated:
             from .follow_mode import _check_hook_stop, _check_report
             from .status_constants import STATUS_WAITING_OVERSIGHT
 
+            existing = window_lookup(tmux_windows)
             newly_terminated = []
             newly_done: list[str] = []  # session ids of children that just flipped to done (#432)
             for session in my_sessions:
                 # Only check non-terminated sessions
                 if session.status not in ("terminated", "done"):
-                    if not self.tmux.window_exists(session.tmux_window):
+                    if not window_in_lookup(session.tmux_window, existing):
                         # Child agents with Stop hook: check for report first
                         if (session.parent_session_id is not None
                                 and _check_hook_stop(self.tmux.session_name, session.name)):
@@ -1162,14 +1189,32 @@ class AgentLauncher:
 
         return success
 
-    def _migrate_legacy_window_ids(self, sessions: List[Session]) -> None:
+    def _list_tmux_windows_cheap(self) -> List[Dict[str, Any]]:
+        """Window list without per-window pane commands (one tmux command).
+
+        Tolerates tmux managers that don't accept ``include_command``
+        (test doubles, older subclasses).
+        """
+        try:
+            return self.tmux.list_windows(include_command=False)
+        except TypeError:
+            return self.tmux.list_windows()
+
+    def _migrate_legacy_window_ids(
+        self, sessions: List[Session], windows: Optional[List[Dict[str, Any]]] = None
+    ) -> None:
         """Migrate legacy digit-string tmux_window values to actual window names.
 
         Legacy sessions stored the window index (int) which got converted to a
         digit string like "4". We resolve these to the actual window name by
         looking up the tmux window list by index.
+
+        Args:
+            windows: pre-fetched ``list_windows()`` result to avoid a second
+                tmux round-trip; fetched here when omitted.
         """
-        windows = self.tmux.list_windows()
+        if windows is None:
+            windows = self._list_tmux_windows_cheap()
         if not windows:
             return
         index_to_name = {str(w['index']): w['name'] for w in windows}