fastws-cli 0.0.24__tar.gz → 0.0.26__tar.gz

{fastws_cli-0.0.24/fastws_cli.egg-info → fastws_cli-0.0.26}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastws-cli
-Version: 0.0.24
+Version: 0.0.26
 Summary: Fast workspace tools for multi-repo management
 Author: Jeremy Howard
 License-Expression: Apache-2.0
@@ -217,9 +217,11 @@ Set `native-binaries = true` under `[tool.fastws]` to build and install the bina
 
 `cargo develop` also copies the `data/` subdirectory of `[tool.maturin].data` into the active venv, as a wheel install does. For example, `data/share/jupyter/kernels/<name>/kernel.json` is installed as `share/jupyter/kernels/<name>/kernel.json`, where Jupyter finds the kernel. `cargo develop` installs the binaries it builds, not the staged copies in `scripts/`.
 
-For distribution wheels containing these binaries, use `fastws.build_backend` as the build backend and include `fastws-cli>=0.0.20` alongside maturin in `[build-system].requires`. Set `[tool.maturin].data` to a generated wheel-data directory. The backend replaces its `scripts/` subdirectory with the current Python-free binaries, then delegates packaging to maturin. Explicit profile and target arguments from maturin's build settings also apply to the binaries.
+Each Cargo build that fastws runs holds a shared `flock` on `/tmp/aai-ws-timing.lock`. A speed test that takes that lock exclusively then never times code while a build runs. A build waits up to 5 minutes for such a timing to finish, then goes ahead without the lock. Python code takes the same lock with `fastws.cargo.timing_lock`: `with timing_lock(exclusive=True):` around a timing, and `with timing_lock():` around a test run. An exclusive hold that has waited 30 seconds prints the processes that have the lock's file open. It raises `TimeoutError` after 5 minutes.
 
-Editable builds through this backend install only Python metadata and the source path. `ws-sync` then runs `cargo develop` to build and install the extension, the binaries and the wheel data files. After standalone `uv sync`, run `cargo develop` yourself.
+Use `fastws.build_backend` as the build backend of a mixed project, and include `fastws-cli>=0.0.25` alongside maturin in `[build-system].requires`. Its editable builds install only Python metadata and the source path, and compile no Rust. `ws-sync` then runs `cargo develop` to build and install the extension, the binaries and the wheel data files. After standalone `uv sync`, run `cargo develop` yourself.
+
+For distribution wheels containing the binaries, also set `[tool.maturin].data` to a generated wheel-data directory. With `native-binaries = true`, wheel builds through the backend replace its `scripts/` subdirectory with the current Python-free binaries, then delegate packaging to maturin. Explicit profile and target arguments from maturin's build settings also apply to the binaries. Without `native-binaries`, wheel builds go straight to maturin, and `[tool.maturin].data` is optional.
 
 Direct maturin CLI builds bypass the Python build backend. Stage the binaries first with the shared command:
 
@@ -228,6 +230,17 @@ cargo stage --profile dist
 maturin build --profile dist
 ```
 
+### `cargo wait`
+
+Wait until a Cargo workspace compiles:
+
+```bash
+cargo wait
+cargo wait --path /path/to/workspace
+```
+
+Use it when another process's unfinished edits stop the workspace compiling, such as a second agent working in the same tree. Each check runs `cargo check --all-targets` while holding the timing lock shared, as builds do. After a failed check, `cargo wait` prints Cargo's first error line. It checks again once a source file of a local package changes and then stays unchanged for 2 seconds. Local packages are the workspace's members and its path dependencies, such as a sibling crate that `ws-sync` patches in. When a check passes, it prints `compiles` and exits. After `--patience` seconds, 1800 by default, it prints the last check's errors and exits with status 1.
+
 ### `ws-sync`
 
 Syncing proceeds in this order:

{fastws_cli-0.0.24 → fastws_cli-0.0.26}/README.md

@@ -191,9 +191,11 @@ Set `native-binaries = true` under `[tool.fastws]` to build and install the bina
 
 `cargo develop` also copies the `data/` subdirectory of `[tool.maturin].data` into the active venv, as a wheel install does. For example, `data/share/jupyter/kernels/<name>/kernel.json` is installed as `share/jupyter/kernels/<name>/kernel.json`, where Jupyter finds the kernel. `cargo develop` installs the binaries it builds, not the staged copies in `scripts/`.
 
-For distribution wheels containing these binaries, use `fastws.build_backend` as the build backend and include `fastws-cli>=0.0.20` alongside maturin in `[build-system].requires`. Set `[tool.maturin].data` to a generated wheel-data directory. The backend replaces its `scripts/` subdirectory with the current Python-free binaries, then delegates packaging to maturin. Explicit profile and target arguments from maturin's build settings also apply to the binaries.
+Each Cargo build that fastws runs holds a shared `flock` on `/tmp/aai-ws-timing.lock`. A speed test that takes that lock exclusively then never times code while a build runs. A build waits up to 5 minutes for such a timing to finish, then goes ahead without the lock. Python code takes the same lock with `fastws.cargo.timing_lock`: `with timing_lock(exclusive=True):` around a timing, and `with timing_lock():` around a test run. An exclusive hold that has waited 30 seconds prints the processes that have the lock's file open. It raises `TimeoutError` after 5 minutes.
 
-Editable builds through this backend install only Python metadata and the source path. `ws-sync` then runs `cargo develop` to build and install the extension, the binaries and the wheel data files. After standalone `uv sync`, run `cargo develop` yourself.
+Use `fastws.build_backend` as the build backend of a mixed project, and include `fastws-cli>=0.0.25` alongside maturin in `[build-system].requires`. Its editable builds install only Python metadata and the source path, and compile no Rust. `ws-sync` then runs `cargo develop` to build and install the extension, the binaries and the wheel data files. After standalone `uv sync`, run `cargo develop` yourself.
+
+For distribution wheels containing the binaries, also set `[tool.maturin].data` to a generated wheel-data directory. With `native-binaries = true`, wheel builds through the backend replace its `scripts/` subdirectory with the current Python-free binaries, then delegate packaging to maturin. Explicit profile and target arguments from maturin's build settings also apply to the binaries. Without `native-binaries`, wheel builds go straight to maturin, and `[tool.maturin].data` is optional.
 
 Direct maturin CLI builds bypass the Python build backend. Stage the binaries first with the shared command:
 
@@ -202,6 +204,17 @@ cargo stage --profile dist
 maturin build --profile dist
 ```
 
+### `cargo wait`
+
+Wait until a Cargo workspace compiles:
+
+```bash
+cargo wait
+cargo wait --path /path/to/workspace
+```
+
+Use it when another process's unfinished edits stop the workspace compiling, such as a second agent working in the same tree. Each check runs `cargo check --all-targets` while holding the timing lock shared, as builds do. After a failed check, `cargo wait` prints Cargo's first error line. It checks again once a source file of a local package changes and then stays unchanged for 2 seconds. Local packages are the workspace's members and its path dependencies, such as a sibling crate that `ws-sync` patches in. When a check passes, it prints `compiles` and exits. After `--patience` seconds, 1800 by default, it prints the last check's errors and exits with status 1.
+
 ### `ws-sync`
 
 Syncing proceeds in this order:

{fastws_cli-0.0.24 → fastws_cli-0.0.26}/fastws/__init__.py

@@ -1,4 +1,6 @@
-__version__ = "0.0.24"
+__version__ = "0.0.26"
+
+
 
 
 

{fastws_cli-0.0.24 → fastws_cli-0.0.26}/fastws/build_backend.py

@@ -1,4 +1,4 @@
-r"Maturin build backend that includes Cargo binaries in Python wheels."
+r"Maturin build backend whose editable installs compile no Rust, and whose wheels can include Cargo binaries."
 import argparse, base64, csv, hashlib, io
 from pathlib import Path
 from tempfile import TemporaryDirectory
@@ -8,13 +8,15 @@ from .cargo import settings, stage_binaries
 
 
 def _stage(config_settings):
+    root = Path.cwd()
+    tool = settings(root)
+    if not tool.get('fastws', {}).get('native-binaries'): return
     parser = argparse.ArgumentParser(add_help=False)
     parser.add_argument('--profile')
     parser.add_argument('--release', action='store_true')
     parser.add_argument('--target')
     args, _ = parser.parse_known_args(maturin.get_maturin_pep517_args(config_settings))
-    root = Path.cwd()
-    profile = args.profile or ('release' if args.release else settings(root)['maturin'].get('profile', 'release'))
+    profile = args.profile or ('release' if args.release else tool['maturin'].get('profile', 'release'))
     stage_binaries(root, profile, args.target)
 
 
@@ -46,7 +48,7 @@ def build_editable(wheel_directory, config_settings=None, metadata_directory=Non
 
 
 def prepare_metadata_for_build_wheel(metadata_directory, config_settings=None):
-    (Path.cwd()/settings(Path.cwd())['maturin']['data']).mkdir(parents=True, exist_ok=True)
+    if data := settings(Path.cwd())['maturin'].get('data'): (Path.cwd()/data).mkdir(parents=True, exist_ok=True)
     return maturin.prepare_metadata_for_build_wheel(metadata_directory, config_settings)
 
 

fastws_cli-0.0.26/fastws/cargo.py

@@ -0,0 +1,143 @@
+r"Build and install Cargo artifacts for mixed Rust/Python projects."
+import fcntl, json, os, shutil, subprocess, sys, sysconfig, time
+from contextlib import contextmanager
+from pathlib import Path
+
+try: import tomllib
+except ModuleNotFoundError: import tomli as tomllib
+
+# The file whose lock keeps timings and builds apart on this machine. Timings take it exclusively. Builds and test runs take it shared.
+_TIMING_LOCK = '/tmp/aai-ws-timing.lock'
+
+
+class ConfigError(ValueError):
+    "A project's `pyproject.toml` lacks a setting that a command needs."
+
+
+def settings(root):
+    "Read the project's tool configuration."
+    return tomllib.loads((root/'pyproject.toml').read_text()).get('tool', {})
+
+
+def cargo(root, *args):
+    "Run Cargo in the project and return its standard output."
+    return subprocess.run(['cargo', *args], cwd=root, stdout=subprocess.PIPE, text=True, check=True).stdout
+
+
+def members(root):
+    "The manifests of the workspace's member packages."
+    return {Path(p['manifest_path']) for p in json.loads(cargo(root, 'metadata', '--no-deps', '--format-version', '1'))['packages']}
+
+
+def _lock_users():
+    "The other processes that have the timing lock's file open, as `pid command` strings from `lsof`. On macOS, where `lsof` doesn't show `flock` holds, the list also includes any process waiting for the lock."
+    users, pid = [], ''
+    for line in subprocess.run(['lsof', '+c', '0', '-F', 'pc', _TIMING_LOCK], capture_output=True, text=True).stdout.splitlines():
+        if line[:1] == 'p': pid = line[1:]
+        elif line[:1] == 'c' and pid != str(os.getpid()): users.append(f'{pid} {line[1:]}')
+    return users
+
+
+@contextmanager
+def timing_lock(
+    exclusive=False, # Take the lock exclusively, as a timing does; False: take it shared, as a build or a test run does
+):
+    "Hold the lock that keeps this machine's timings apart from its builds and test runs. A hold waits up to 5 minutes for the lock. After that, a shared hold goes ahead without it. An exclusive hold raises `TimeoutError`. An exclusive hold that has waited 30 seconds prints, once, the other processes that have the lock's file open."
+    with open(_TIMING_LOCK, 'a') as f:
+        start, waiting, reported = time.monotonic(), False, False
+        while True:
+            try:
+                fcntl.flock(f, (fcntl.LOCK_EX if exclusive else fcntl.LOCK_SH) | fcntl.LOCK_NB)
+                break
+            except BlockingIOError: pass
+            waited = time.monotonic() - start
+            if waited > 300:
+                if exclusive: raise TimeoutError(f'a build or another timing has held {_TIMING_LOCK} for 5 minutes')
+                print(f'going ahead although a timing still holds {_TIMING_LOCK}', file=sys.stderr)
+                break
+            if not waiting: print(f'waiting for {"a build or another timing" if exclusive else "a timing"} to release {_TIMING_LOCK}', file=sys.stderr)
+            waiting = True
+            if exclusive and not reported and waited > 30:
+                print(f'{_TIMING_LOCK} is still taken after 30 seconds. Processes with it open: {", ".join(_lock_users()) or "none"}', file=sys.stderr)
+                reported = True
+            time.sleep(0.25)
+        yield
+
+
+def check(root):
+    "Check every target of the workspace with Cargo, holding the timing lock shared. Cargo's messages are in the result's `stderr`."
+    with timing_lock(): return subprocess.run(['cargo', 'check', '--all-targets', '--message-format=short'], cwd=root, stderr=subprocess.PIPE, text=True)
+
+
+def sources(root):
+    "The manifests, and the target directories or files, of the local packages that the workspace builds: its members and its path dependencies."
+    res = set()
+    for p in json.loads(cargo(root, 'metadata', '--format-version', '1'))['packages']:
+        if p['source'] is not None: continue
+        manifest = Path(p['manifest_path'])
+        res.add(manifest)
+        for t in p['targets']:
+            src = Path(t['src_path'])
+            res.add(src if src.parent == manifest.parent else src.parent)
+    return res
+
+
+def build(root, *, library=True, binaries=False, profile=None, target=None, no_default_features=False):
+    "Build with Cargo and return the compiler artifacts of the workspace's packages."
+    cfg = settings(root)['maturin']
+    cmd = ['build', '--manifest-path', str((root/'Cargo.toml').resolve()), '--message-format=json-diagnostic-short,json-render-diagnostics']
+    if library: cmd.append('--lib')
+    if binaries: cmd.append('--bins')
+    if profile := profile or cfg.get('profile'): cmd += ['--profile', profile]
+    if target: cmd += ['--target', target]
+    if no_default_features: cmd.append('--no-default-features')
+    else:
+        if features := cfg.get('features'): cmd += ['--features', ','.join(features)]
+        for flag in ('all-features', 'no-default-features'):
+            if cfg.get(flag): cmd.append('--' + flag)
+    with timing_lock(): messages = [json.loads(line) for line in cargo(root, *cmd).splitlines()]
+    workspace = members(root)
+    return [m for m in messages if m.get('reason') == 'compiler-artifact' and Path(m['manifest_path']) in workspace]
+
+
+def replace(source, destination):
+    "Replace an installed artifact without changing the file held by running processes."
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    tmp = destination.with_name(destination.name + '.tmp')
+    shutil.copy2(source, tmp)
+    os.replace(tmp, destination)
+    return destination
+
+
+def develop(root):
+    "Install a Python extension, opted-in binaries and wheel data files from one Cargo build."
+    tool = settings(root)
+    cfg = tool['maturin']
+    if 'python-source' not in cfg: raise ConfigError(r'cargo develop requires tool.maturin.python-source')
+    binaries = tool.get('fastws', {}).get('native-binaries', False)
+    artifacts = build(root, binaries=binaries, profile='test')
+    artifact, = [m for m in artifacts if 'cdylib' in m['target']['crate_types']]
+    lib, = [f for f in artifact['filenames'] if Path(f).suffix in ('.dylib', '.so', '.dll')]
+    module = cfg.get('module-name', artifact['target']['name'])
+    dest = root/cfg['python-source']/Path(*module.split('.'))
+    replace(lib, dest.with_name(dest.name + sysconfig.get_config_var('EXT_SUFFIX')))
+    env = Path(os.environ.get('VIRTUAL_ENV', sys.prefix))
+    if binaries:
+        scripts = env/('Scripts' if os.name == 'nt' else 'bin')
+        for m in artifacts:
+            if m.get('executable'): replace(m['executable'], scripts/Path(m['executable']).name)
+    # Editable builds through `build_backend` don't install the wheel's data files, which a wheel install puts under the prefix.
+    if 'data' in cfg:
+        data = root/cfg['data']/'data'
+        for f in data.rglob('*'):
+            if f.is_file(): replace(f, env/f.relative_to(data))
+
+
+def stage_binaries(root, profile=None, target=None):
+    "Stage Python-free Cargo binaries in maturin's wheel-data directory."
+    cfg = settings(root)['maturin']
+    if 'data' not in cfg: raise ConfigError(r'staging native binaries requires tool.maturin.data')
+    dest = root/cfg['data']/'scripts'
+    artifacts = build(root, library=False, binaries=True, profile=profile, target=target, no_default_features=True)
+    if dest.exists(): shutil.rmtree(dest)
+    return [replace(m['executable'], dest/Path(m['executable']).name) for m in artifacts if m.get('executable')]

{fastws_cli-0.0.24 → fastws_cli-0.0.26}/fastws/core.py

@@ -1,9 +1,10 @@
 "Fast workspace tools for multi-repo management."
 
-__all__ = ["ws_setup", "ws_clone", "ws_pull", "ws_status", "ws_branches", "ws_build", "ws_sync", "ws_add", "ws_remove", "cargo_develop", "cargo_stage"]
+__all__ = ["ws_setup", "ws_clone", "ws_pull", "ws_status", "ws_branches", "ws_build", "ws_sync", "ws_add", "ws_remove", "cargo_develop", "cargo_stage", "cargo_wait"]
 
 import ast, fnmatch, glob, hashlib, json, os, re, shlex, shutil, subprocess, sys, time
 from pathlib import Path
+from contextlib import contextmanager
 from concurrent.futures import ThreadPoolExecutor
 
 from fastcore.parallel import parallel_async_gen
@@ -556,6 +557,14 @@ def _build_projects(root: Path, repos_file: str, project: str = None) -> list[tu
     dirs = dep_closure(key, graph)
     return [(n,d) for n,d in res if d in dirs]
 
+@contextmanager
+def _quietly():
+    "Exit without a traceback where a command fails or a project lacks a setting. A failed command exits with its status. Use this only where the command printed its own errors. A missing setting prints its message and exits with status 1."
+    from .cargo import ConfigError
+    try: yield
+    except subprocess.CalledProcessError as e: raise SystemExit(e.returncode) from None
+    except ConfigError as e: raise SystemExit(str(e)) from None
+
 @call_parse(pos=['command'])
 def cargo_develop(
     command: str = 'develop', # Subcommand name supplied by Cargo
@@ -563,7 +572,7 @@ def cargo_develop(
 ):
     r"Build and install a mixed Rust/Python project's extension and opted-in binaries."
     from .cargo import develop
-    develop(Path(path).resolve())
+    with _quietly(): develop(Path(path).resolve())
 
 @call_parse(pos=['command'])
 def cargo_stage(
@@ -574,7 +583,33 @@ def cargo_stage(
 ):
     r"Stage Python-free native binaries for maturin wheel builds."
     from .cargo import stage_binaries
-    for dest in stage_binaries(Path(path).resolve(), profile or None, target or None): print(f'Staged {dest}')
+    with _quietly():
+        for dest in stage_binaries(Path(path).resolve(), profile or None, target or None): print(f'Staged {dest}')
+
+def _newest(paths):
+    "Newest file mtime among `paths`, walking each directory as `_src_mtime` does"
+    return max((_src_mtime(p) if p.is_dir() else p.stat().st_mtime) for p in paths if p.exists())
+
+@call_parse(pos=['command'])
+def cargo_wait(
+    command: str = 'wait', # Subcommand name supplied by Cargo
+    path: str = '.', # Cargo workspace directory
+    patience: int = 1800, # Seconds to wait before giving up
+):
+    r"Wait until a Cargo workspace compiles, checking again after each edit to its local packages' sources."
+    from .cargo import check, sources
+    root, start = Path(path).resolve(), time.monotonic()
+    with _quietly(): srcs = sources(root)
+    while (res := check(root)).returncode:
+        if time.monotonic() - start > patience: raise SystemExit(f'{res.stderr}gave up after {patience} s')
+        print(next((l for l in res.stderr.splitlines() if 'error' in l), 'cargo check failed'), file=sys.stderr)
+        before = _newest(srcs)
+        while (now := _newest(srcs)) == before and time.monotonic() - start < patience: time.sleep(1)
+        while True:
+            time.sleep(2)
+            if (later := _newest(srcs)) == now: break
+            now = later
+    print('compiles')
 
 @call_parse
 def ws_build(
@@ -898,58 +933,60 @@ async def ws_sync(
     upgrade: bool = False,  # Force the once-daily dependency upgrade pass
 ):
     "Pull the workspace baseline, clone missing shared/local repos, then pull projects and sync; upgrade dependencies daily."
-    root = _ws_root(workspace, repos_file, pyproject_file, template_file)
-    repos_path = _resolve_path(root, repos_file)
-    pyproject_path = _resolve_path(root, pyproject_file)
-    template_path = _resolve_path(root, template_file)
-    await _pull_workspace(root)
-    entries = _load_repo_entries(repos_path, root)
-    await _clone_repos(entries, workers)
-    repos = await _discover_ws_repos(root)
-
-    if missing_repos := _update_repos_file(repos_path, repos): print(f"Added local repos: {', '.join(missing_repos)}")
-    entries = _load_repo_entries(repos_path, root)
-    ext_dirs = [d for _,d,_ in entries if d.resolve().parent != root.resolve()]
-    dirs = [d for _,d,_ in entries]
-    try: dirs = await _changed_dirs(dirs)
-    except Exception: pass
-    await _pull(dirs, workers=workers)
-
-    if not pyproject_path.exists(): _sync_ws_pyproject(pyproject_path, template_path, [])
-    added_ex, removed_ex = _sync_ws_excludes(pyproject_path, root, {d.name for _,d,_ in entries if d.resolve().parent == root.resolve()})
-    if added_ex: print(f"Auto-excluded from the workspace: {', '.join(added_ex)}")
-    if removed_ex: print(f"No longer excluded from the workspace: {', '.join(removed_ex)}")
-
-    missing_projects = _sync_ws_pyproject(pyproject_path, template_path, _ws_projects(root), _external_projects(root, ext_dirs),
-        _repo_extras(root, entries))
-    if missing_projects: print(f"Added workspace projects: {', '.join(missing_projects)}")
-    projects = _build_projects(root, repos_file)
-    _sync_build_isolation(pyproject_path, projects)
-
-    wrapper_added = _sync_cargo_wrapper(root)
-    added_p, removed_p = _sync_cargo_patches(root)
-    if added_p: print(f"Cargo patches added: {', '.join(added_p)}")
-    if removed_p: print(f"Cargo patches removed: {', '.join(removed_p)}")
-    if wrapper_added: print("Cargo builds now use sccache")
-
-    js_members = _npm_dirs(root)
-    if _native_js(js_members): _check_rustup()
-    added_j, removed_j = _sync_ws_package_json(root, js_members)
-    if added_j: print(f"JS workspace packages added: {', '.join(added_j)}")
-    if removed_j: print(f"JS workspace packages removed: {', '.join(removed_j)}")
-
-    if bad := _pending_dirs(root):
-        print(f"⚠️  Skipping uv sync, not Python projects yet (scaffold with e.g. nbdev-new or ship-new, or remove): {', '.join(bad)}")
-        return
-    up = upgrade or _should_upgrade(root)
-    if up: _cargo_update(root, workers=workers)
-    _sync_cargo_keys(root)
-    subprocess.run(["uv", "sync", "-U"] if up else ["uv", "sync"], check=True, cwd=root)
-    for _,d in projects:
-        cfg = tomllib.loads((d/'pyproject.toml').read_text()).get('tool', {}).get('maturin', {})
-        if 'python-source' in cfg and cfg.get('bindings') != 'bin': cargo_develop(path=str(d))
-    if up: _upgrade_stamp(root).touch()
-    if js_members: _sync_js(root, js_members)
+    with _quietly():
+        root = _ws_root(workspace, repos_file, pyproject_file, template_file)
+        repos_path = _resolve_path(root, repos_file)
+        pyproject_path = _resolve_path(root, pyproject_file)
+        template_path = _resolve_path(root, template_file)
+        await _pull_workspace(root)
+        entries = _load_repo_entries(repos_path, root)
+        await _clone_repos(entries, workers)
+        repos = await _discover_ws_repos(root)
+    
+        if missing_repos := _update_repos_file(repos_path, repos): print(f"Added local repos: {', '.join(missing_repos)}")
+        entries = _load_repo_entries(repos_path, root)
+        ext_dirs = [d for _,d,_ in entries if d.resolve().parent != root.resolve()]
+        dirs = [d for _,d,_ in entries]
+        try: dirs = await _changed_dirs(dirs)
+        except Exception: pass
+        await _pull(dirs, workers=workers)
+    
+        if not pyproject_path.exists(): _sync_ws_pyproject(pyproject_path, template_path, [])
+        added_ex, removed_ex = _sync_ws_excludes(pyproject_path, root, {d.name for _,d,_ in entries if d.resolve().parent == root.resolve()})
+        if added_ex: print(f"Auto-excluded from the workspace: {', '.join(added_ex)}")
+        if removed_ex: print(f"No longer excluded from the workspace: {', '.join(removed_ex)}")
+    
+        missing_projects = _sync_ws_pyproject(pyproject_path, template_path, _ws_projects(root), _external_projects(root, ext_dirs),
+            _repo_extras(root, entries))
+        if missing_projects: print(f"Added workspace projects: {', '.join(missing_projects)}")
+        projects = _build_projects(root, repos_file)
+        _sync_build_isolation(pyproject_path, projects)
+    
+        wrapper_added = _sync_cargo_wrapper(root)
+        added_p, removed_p = _sync_cargo_patches(root)
+        if added_p: print(f"Cargo patches added: {', '.join(added_p)}")
+        if removed_p: print(f"Cargo patches removed: {', '.join(removed_p)}")
+        if wrapper_added: print("Cargo builds now use sccache")
+    
+        js_members = _npm_dirs(root)
+        if _native_js(js_members): _check_rustup()
+        added_j, removed_j = _sync_ws_package_json(root, js_members)
+        if added_j: print(f"JS workspace packages added: {', '.join(added_j)}")
+        if removed_j: print(f"JS workspace packages removed: {', '.join(removed_j)}")
+    
+        if bad := _pending_dirs(root):
+            print(f"⚠️  Skipping uv sync, not Python projects yet (scaffold with e.g. nbdev-new or ship-new, or remove): {', '.join(bad)}")
+            return
+        up = upgrade or _should_upgrade(root)
+        if up: _cargo_update(root, workers=workers)
+        _sync_cargo_keys(root)
+        subprocess.run(["uv", "sync", "-U"] if up else ["uv", "sync"], check=True, cwd=root)
+        from .cargo import develop
+        for _,d in projects:
+            cfg = tomllib.loads((d/'pyproject.toml').read_text()).get('tool', {}).get('maturin', {})
+            if 'python-source' in cfg and cfg.get('bindings') != 'bin': develop(d.resolve())
+        if up: _upgrade_stamp(root).touch()
+        if js_members: _sync_js(root, js_members)
 
 @call_parse
 async def ws_add(

{fastws_cli-0.0.24 → fastws_cli-0.0.26/fastws_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastws-cli
-Version: 0.0.24
+Version: 0.0.26
 Summary: Fast workspace tools for multi-repo management
 Author: Jeremy Howard
 License-Expression: Apache-2.0
@@ -217,9 +217,11 @@ Set `native-binaries = true` under `[tool.fastws]` to build and install the bina
 
 `cargo develop` also copies the `data/` subdirectory of `[tool.maturin].data` into the active venv, as a wheel install does. For example, `data/share/jupyter/kernels/<name>/kernel.json` is installed as `share/jupyter/kernels/<name>/kernel.json`, where Jupyter finds the kernel. `cargo develop` installs the binaries it builds, not the staged copies in `scripts/`.
 
-For distribution wheels containing these binaries, use `fastws.build_backend` as the build backend and include `fastws-cli>=0.0.20` alongside maturin in `[build-system].requires`. Set `[tool.maturin].data` to a generated wheel-data directory. The backend replaces its `scripts/` subdirectory with the current Python-free binaries, then delegates packaging to maturin. Explicit profile and target arguments from maturin's build settings also apply to the binaries.
+Each Cargo build that fastws runs holds a shared `flock` on `/tmp/aai-ws-timing.lock`. A speed test that takes that lock exclusively then never times code while a build runs. A build waits up to 5 minutes for such a timing to finish, then goes ahead without the lock. Python code takes the same lock with `fastws.cargo.timing_lock`: `with timing_lock(exclusive=True):` around a timing, and `with timing_lock():` around a test run. An exclusive hold that has waited 30 seconds prints the processes that have the lock's file open. It raises `TimeoutError` after 5 minutes.
 
-Editable builds through this backend install only Python metadata and the source path. `ws-sync` then runs `cargo develop` to build and install the extension, the binaries and the wheel data files. After standalone `uv sync`, run `cargo develop` yourself.
+Use `fastws.build_backend` as the build backend of a mixed project, and include `fastws-cli>=0.0.25` alongside maturin in `[build-system].requires`. Its editable builds install only Python metadata and the source path, and compile no Rust. `ws-sync` then runs `cargo develop` to build and install the extension, the binaries and the wheel data files. After standalone `uv sync`, run `cargo develop` yourself.
+
+For distribution wheels containing the binaries, also set `[tool.maturin].data` to a generated wheel-data directory. With `native-binaries = true`, wheel builds through the backend replace its `scripts/` subdirectory with the current Python-free binaries, then delegate packaging to maturin. Explicit profile and target arguments from maturin's build settings also apply to the binaries. Without `native-binaries`, wheel builds go straight to maturin, and `[tool.maturin].data` is optional.
 
 Direct maturin CLI builds bypass the Python build backend. Stage the binaries first with the shared command:
 
@@ -228,6 +230,17 @@ cargo stage --profile dist
 maturin build --profile dist
 ```
 
+### `cargo wait`
+
+Wait until a Cargo workspace compiles:
+
+```bash
+cargo wait
+cargo wait --path /path/to/workspace
+```
+
+Use it when another process's unfinished edits stop the workspace compiling, such as a second agent working in the same tree. Each check runs `cargo check --all-targets` while holding the timing lock shared, as builds do. After a failed check, `cargo wait` prints Cargo's first error line. It checks again once a source file of a local package changes and then stays unchanged for 2 seconds. Local packages are the workspace's members and its path dependencies, such as a sibling crate that `ws-sync` patches in. When a check passes, it prints `compiles` and exits. After `--patience` seconds, 1800 by default, it prints the last check's errors and exits with status 1.
+
 ### `ws-sync`
 
 Syncing proceeds in this order:

{fastws_cli-0.0.24 → fastws_cli-0.0.26}/fastws_cli.egg-info/entry_points.txt

@@ -1,6 +1,7 @@
 [console_scripts]
 cargo-develop = fastws.core:cargo_develop
 cargo-stage = fastws.core:cargo_stage
+cargo-wait = fastws.core:cargo_wait
 ws-add = fastws.core:ws_add
 ws-branches = fastws.core:ws_branches
 ws-build = fastws.core:ws_build

{fastws_cli-0.0.24 → fastws_cli-0.0.26}/pyproject.toml

@@ -36,6 +36,7 @@ dev = [
 [project.scripts]
 cargo-develop = "fastws.core:cargo_develop"
 cargo-stage = "fastws.core:cargo_stage"
+cargo-wait = "fastws.core:cargo_wait"
 ws-setup = "fastws.core:ws_setup"
 ws-clone = "fastws.core:ws_clone"
 ws-pull = "fastws.core:ws_pull"

fastws_cli-0.0.24/fastws/cargo.py

@@ -1,81 +0,0 @@
-r"Build and install Cargo artifacts for mixed Rust/Python projects."
-import json, os, shutil, subprocess, sys, sysconfig
-from pathlib import Path
-
-try: import tomllib
-except ModuleNotFoundError: import tomli as tomllib
-
-
-def settings(root):
-    "Read the project's tool configuration."
-    return tomllib.loads((root/'pyproject.toml').read_text()).get('tool', {})
-
-
-def cargo(root, *args):
-    "Run Cargo in the project and return its standard output."
-    return subprocess.run(['cargo', *args], cwd=root, stdout=subprocess.PIPE, text=True, check=True).stdout
-
-
-def members(root):
-    "The manifests of the workspace's member packages."
-    return {Path(p['manifest_path']) for p in json.loads(cargo(root, 'metadata', '--no-deps', '--format-version', '1'))['packages']}
-
-
-def build(root, *, library=True, binaries=False, profile=None, target=None, no_default_features=False):
-    "Build with Cargo and return the compiler artifacts of the workspace's packages."
-    cfg = settings(root)['maturin']
-    cmd = ['build', '--manifest-path', str((root/'Cargo.toml').resolve()), '--message-format=json-render-diagnostics']
-    if library: cmd.append('--lib')
-    if binaries: cmd.append('--bins')
-    if profile := profile or cfg.get('profile'): cmd += ['--profile', profile]
-    if target: cmd += ['--target', target]
-    if no_default_features: cmd.append('--no-default-features')
-    else:
-        if features := cfg.get('features'): cmd += ['--features', ','.join(features)]
-        for flag in ('all-features', 'no-default-features'):
-            if cfg.get(flag): cmd.append('--' + flag)
-    messages = [json.loads(line) for line in cargo(root, *cmd).splitlines()]
-    workspace = members(root)
-    return [m for m in messages if m.get('reason') == 'compiler-artifact' and Path(m['manifest_path']) in workspace]
-
-
-def replace(source, destination):
-    "Replace an installed artifact without changing the file held by running processes."
-    destination.parent.mkdir(parents=True, exist_ok=True)
-    tmp = destination.with_name(destination.name + '.tmp')
-    shutil.copy2(source, tmp)
-    os.replace(tmp, destination)
-    return destination
-
-
-def develop(root):
-    "Install a Python extension, opted-in binaries and wheel data files from one Cargo build."
-    tool = settings(root)
-    cfg = tool['maturin']
-    if 'python-source' not in cfg: raise SystemExit(r'cargo develop requires tool.maturin.python-source')
-    binaries = tool.get('fastws', {}).get('native-binaries', False)
-    artifacts = build(root, binaries=binaries, profile='test')
-    artifact, = [m for m in artifacts if 'cdylib' in m['target']['crate_types']]
-    lib, = [f for f in artifact['filenames'] if Path(f).suffix in ('.dylib', '.so', '.dll')]
-    module = cfg.get('module-name', artifact['target']['name'])
-    dest = root/cfg['python-source']/Path(*module.split('.'))
-    replace(lib, dest.with_name(dest.name + sysconfig.get_config_var('EXT_SUFFIX')))
-    env = Path(os.environ.get('VIRTUAL_ENV', sys.prefix))
-    if binaries:
-        scripts = env/('Scripts' if os.name == 'nt' else 'bin')
-        for m in artifacts:
-            if m.get('executable'): replace(m['executable'], scripts/Path(m['executable']).name)
-    # Editable builds through `build_backend` don't install the wheel's data files, which a wheel install puts under the prefix.
-    if 'data' in cfg:
-        data = root/cfg['data']/'data'
-        for f in data.rglob('*'):
-            if f.is_file(): replace(f, env/f.relative_to(data))
-
-
-def stage_binaries(root, profile=None, target=None):
-    "Stage Python-free Cargo binaries in maturin's wheel-data directory."
-    cfg = settings(root)['maturin']
-    dest = root/cfg['data']/'scripts'
-    artifacts = build(root, library=False, binaries=True, profile=profile, target=target, no_default_features=True)
-    if dest.exists(): shutil.rmtree(dest)
-    return [replace(m['executable'], dest/Path(m['executable']).name) for m in artifacts if m.get('executable')]