git-p4son 0.4.0__tar.gz → 0.4.2__tar.gz

{git_p4son-0.4.0 → git_p4son-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: git-p4son
-Version: 0.4.0
+Version: 0.4.2
 Summary: Utility for keeping a Perforce workspace and local git repo in sync
 Author-email: Andreas Andersson <andreas@neoboid.com>
 License-Expression: MIT
@@ -277,6 +277,9 @@ The depot root determines which part of the Perforce workspace git-p4son syncs.
 workspace or just the directory's subtree where the git root is placed. The selection is saved in
 `.git-p4son/config.toml` and used by all subsequent commands.
 
+Nothing in `.git-p4son/` belongs in git. The folder has its own `.gitignore` that ignores everything in it, so there
+is no need to list it in the workspace `.gitignore`.
+
 The saved root uses a `$(workspace)` placeholder for the workspace (client) name, e.g.
 `root = "//$(workspace)/Engine"`. git-p4son substitutes the live workspace name each time it runs, so renaming
 the Perforce workspace does not break the config. You can still store a concrete name (e.g. `//my-workspace/Engine`)
@@ -295,7 +298,7 @@ saves the answer; run `git p4son writable apply` once your files are committed t
 Sync local git repository with a Perforce workspace:
 
 ```sh
-git p4son sync [changelist ...] [--force]
+git p4son sync [changelist ...] [--force] [--dry-run] [--ignore-blocking-processes]
 ```
 
 **Arguments:**
@@ -306,6 +309,9 @@ git p4son sync [changelist ...] [--force]
 
 **Options:**
 - `-f, --force`: Allow syncing to changelists older than the current one.
+- `-n, --dry-run`: Print the resolved sync sequence without syncing. The arguments are validated as for a
+  real sync, but nothing else runs: no clean-workspace checks, no hooks, and no prompts.
+- `--ignore-blocking-processes`: Sync even while a [blocking process](#blocking-processes) is running.
 
 **Examples:**
 ```sh
@@ -316,8 +322,27 @@ git p4son sync 123 156 178  # sync each changelist in sequence, one commit each
 git p4son sync 123 156 head # sync 123, 156, then the latest changelist
 git p4son sync last-synced
 git p4son sync 12345 --force
+git p4son sync --dry-run    # show the changelists a sync to latest would visit
 ```
 
+#### Blocking processes
+
+Syncing while e.g. the Unreal editor is open lets p4 replace assets the editor still has loaded, so the editor
+keeps working against files that no longer match what is on disk. List such processes in `.git-p4son/config.toml`
+and `sync` refuses to start while any of them is running:
+
+```toml
+[sync]
+blocking-processes = ["UnrealEditor", "UnrealLightmass"]
+```
+
+Names are matched with any `.exe` suffix stripped and case ignored, so a single entry covers `UnrealEditor.exe` on
+Windows and `UnrealEditor` on macOS. The check runs before the clean-workspace checks and the pre-sync hooks. A
+setting that is present but malformed, or a process list that cannot be read, aborts the sync rather than silently
+skipping the check.
+
+Pass `--ignore-blocking-processes` to sync once without the check, or remove the setting to turn it off for good.
+
 #### pre-sync hook
 
 Before `git-p4son sync` syncs any changelist, git-p4son runs [hooks](#hooks) from
@@ -334,7 +359,7 @@ from `.git-p4son/hooks/post-sync/`.
 Sync forward from the last synced changelist, splitting selected users' changelists into their own commits:
 
 ```sh
-git p4son sync-split [changelist] [--user NAME ...] [--dry-run]
+git p4son sync-split [changelist] [--user NAME ...] [--dry-run] [--ignore-blocking-processes]
 ```
 
 Syncing straight to the latest changelist lumps your own submitted changelists together with everyone
@@ -348,11 +373,12 @@ own submits one at a time. Repeat `--user` to split out several people's changel
 
 It is equivalent to working out the numbers by hand and running
 `git p4son sync <before-theirs> <theirs> ... head`, and it delegates to `sync` once the sequence is
-resolved, so [pre-sync and post-sync hooks](#hooks), writable-file merging, and the clean-workspace checks
-all behave exactly as they do for `sync`. The clean-workspace checks and the pre-sync hooks are the one
-thing that runs earlier: resolving the sequence costs several Perforce queries, so they go first, and a
-dirty workspace or a hook that aborts the sync says so before that work. They run once for the whole sync,
-and not at all for a `--dry-run` or when there is nothing to sync.
+resolved, so [pre-sync and post-sync hooks](#hooks), [blocking processes](#blocking-processes), writable-file
+merging, and the clean-workspace checks all behave exactly as they do for `sync`. The blocking processes check,
+the clean-workspace checks and the pre-sync hooks are the one thing that runs earlier: resolving the sequence
+costs several Perforce queries, so they go first, and a running blocking process, a dirty workspace or a hook
+that aborts the sync says so before that work. They run once for the whole sync, and not at all for a
+`--dry-run` or when there is nothing to sync.
 
 **Arguments:**
 - `changelist` (optional): Changelist number to sync up to, or `head` for the latest. Omit to sync to the
@@ -362,6 +388,7 @@ and not at all for a `--dry-run` or when there is nothing to sync.
 - `-u, --user NAME`: Perforce user whose changelists to split into their own commits. Repeat the flag to
   select several users. Defaults to the current p4 user (from `p4 info`).
 - `-n, --dry-run`: Print the resolved sync sequence without syncing.
+- `--ignore-blocking-processes`: Sync even while a [blocking process](#blocking-processes) is running.
 
 **Examples:**
 ```sh
@@ -708,49 +735,6 @@ before the first sync.
 After a successful `git-p4son sync` that actually performs sync work, git-p4son runs executable hooks from
 `.git-p4son/hooks/post-sync/`.
 
-### Example hooks
-
-The [`examples/hooks/`](examples/hooks/) directory holds ready-made hooks. Nothing installs them for you:
-symlink or copy the one you want into the matching hook directory in your workspace. Symlinking keeps the hook
-up to date with the clone it points at, and on macOS and Linux the executable bit comes from the file in the
-clone, so no `chmod` is needed.
-
-#### block-while-running (pre-sync)
-
-Aborts the sync while a named process is running, so a sync cannot swap out assets that a running editor still
-has loaded. Link it into your workspace's `pre-sync` hook directory - on macOS and Linux:
-
-```sh
-ln -s /path/to/git-p4son/examples/hooks/pre-sync/block-while-running.py .git-p4son/hooks/pre-sync/
-```
-
-On Windows, from PowerShell. Note that `-Path` is the link to create and `-Target` the existing file, the
-reverse of the `ln -s` argument order, and that `-Target` should be absolute: a relative path is resolved
-against the current directory and quietly produces a broken link.
-
-```powershell
-New-Item -ItemType SymbolicLink `
-  -Path   "C:\p4\my-workspace\.git-p4son\hooks\pre-sync\block-while-running.py" `
-  -Target "C:\src\git-p4son\examples\hooks\pre-sync\block-while-running.py"
-```
-
-Creating a symlink on Windows needs either an elevated shell or Developer Mode enabled (Settings > System >
-For developers). Without one of those, copy the file instead and re-copy it whenever the clone updates.
-
-Which processes block a sync is read from your workspace's own `.git-p4son/config.toml`, so a symlinked hook
-stays per-project:
-
-```toml
-[hooks.block-while-running]
-processes = ["UnrealEditor", "UnrealLightmass"]
-```
-
-Names are matched with any `.exe` suffix stripped and case ignored, so a single entry covers
-`UnrealEditor.exe` on Windows and `UnrealEditor` on macOS. Without that table the hook checks nothing and the
-sync proceeds; a table that is present but malformed aborts the sync rather than silently skipping the check.
-
-Set `GIT_P4SON_SKIP_PROCESS_CHECK=1` to run one sync without the check.
-
 ## Shell Completions
 
 Tab completion is available for bash, zsh, and PowerShell, including commands, flags, and dynamic alias names.

{git_p4son-0.4.0 → git_p4son-0.4.2}/README.md

@@ -254,6 +254,9 @@ The depot root determines which part of the Perforce workspace git-p4son syncs.
 workspace or just the directory's subtree where the git root is placed. The selection is saved in
 `.git-p4son/config.toml` and used by all subsequent commands.
 
+Nothing in `.git-p4son/` belongs in git. The folder has its own `.gitignore` that ignores everything in it, so there
+is no need to list it in the workspace `.gitignore`.
+
 The saved root uses a `$(workspace)` placeholder for the workspace (client) name, e.g.
 `root = "//$(workspace)/Engine"`. git-p4son substitutes the live workspace name each time it runs, so renaming
 the Perforce workspace does not break the config. You can still store a concrete name (e.g. `//my-workspace/Engine`)
@@ -272,7 +275,7 @@ saves the answer; run `git p4son writable apply` once your files are committed t
 Sync local git repository with a Perforce workspace:
 
 ```sh
-git p4son sync [changelist ...] [--force]
+git p4son sync [changelist ...] [--force] [--dry-run] [--ignore-blocking-processes]
 ```
 
 **Arguments:**
@@ -283,6 +286,9 @@ git p4son sync [changelist ...] [--force]
 
 **Options:**
 - `-f, --force`: Allow syncing to changelists older than the current one.
+- `-n, --dry-run`: Print the resolved sync sequence without syncing. The arguments are validated as for a
+  real sync, but nothing else runs: no clean-workspace checks, no hooks, and no prompts.
+- `--ignore-blocking-processes`: Sync even while a [blocking process](#blocking-processes) is running.
 
 **Examples:**
 ```sh
@@ -293,8 +299,27 @@ git p4son sync 123 156 178  # sync each changelist in sequence, one commit each
 git p4son sync 123 156 head # sync 123, 156, then the latest changelist
 git p4son sync last-synced
 git p4son sync 12345 --force
+git p4son sync --dry-run    # show the changelists a sync to latest would visit
 ```
 
+#### Blocking processes
+
+Syncing while e.g. the Unreal editor is open lets p4 replace assets the editor still has loaded, so the editor
+keeps working against files that no longer match what is on disk. List such processes in `.git-p4son/config.toml`
+and `sync` refuses to start while any of them is running:
+
+```toml
+[sync]
+blocking-processes = ["UnrealEditor", "UnrealLightmass"]
+```
+
+Names are matched with any `.exe` suffix stripped and case ignored, so a single entry covers `UnrealEditor.exe` on
+Windows and `UnrealEditor` on macOS. The check runs before the clean-workspace checks and the pre-sync hooks. A
+setting that is present but malformed, or a process list that cannot be read, aborts the sync rather than silently
+skipping the check.
+
+Pass `--ignore-blocking-processes` to sync once without the check, or remove the setting to turn it off for good.
+
 #### pre-sync hook
 
 Before `git-p4son sync` syncs any changelist, git-p4son runs [hooks](#hooks) from
@@ -311,7 +336,7 @@ from `.git-p4son/hooks/post-sync/`.
 Sync forward from the last synced changelist, splitting selected users' changelists into their own commits:
 
 ```sh
-git p4son sync-split [changelist] [--user NAME ...] [--dry-run]
+git p4son sync-split [changelist] [--user NAME ...] [--dry-run] [--ignore-blocking-processes]
 ```
 
 Syncing straight to the latest changelist lumps your own submitted changelists together with everyone
@@ -325,11 +350,12 @@ own submits one at a time. Repeat `--user` to split out several people's changel
 
 It is equivalent to working out the numbers by hand and running
 `git p4son sync <before-theirs> <theirs> ... head`, and it delegates to `sync` once the sequence is
-resolved, so [pre-sync and post-sync hooks](#hooks), writable-file merging, and the clean-workspace checks
-all behave exactly as they do for `sync`. The clean-workspace checks and the pre-sync hooks are the one
-thing that runs earlier: resolving the sequence costs several Perforce queries, so they go first, and a
-dirty workspace or a hook that aborts the sync says so before that work. They run once for the whole sync,
-and not at all for a `--dry-run` or when there is nothing to sync.
+resolved, so [pre-sync and post-sync hooks](#hooks), [blocking processes](#blocking-processes), writable-file
+merging, and the clean-workspace checks all behave exactly as they do for `sync`. The blocking processes check,
+the clean-workspace checks and the pre-sync hooks are the one thing that runs earlier: resolving the sequence
+costs several Perforce queries, so they go first, and a running blocking process, a dirty workspace or a hook
+that aborts the sync says so before that work. They run once for the whole sync, and not at all for a
+`--dry-run` or when there is nothing to sync.
 
 **Arguments:**
 - `changelist` (optional): Changelist number to sync up to, or `head` for the latest. Omit to sync to the
@@ -339,6 +365,7 @@ and not at all for a `--dry-run` or when there is nothing to sync.
 - `-u, --user NAME`: Perforce user whose changelists to split into their own commits. Repeat the flag to
   select several users. Defaults to the current p4 user (from `p4 info`).
 - `-n, --dry-run`: Print the resolved sync sequence without syncing.
+- `--ignore-blocking-processes`: Sync even while a [blocking process](#blocking-processes) is running.
 
 **Examples:**
 ```sh
@@ -685,49 +712,6 @@ before the first sync.
 After a successful `git-p4son sync` that actually performs sync work, git-p4son runs executable hooks from
 `.git-p4son/hooks/post-sync/`.
 
-### Example hooks
-
-The [`examples/hooks/`](examples/hooks/) directory holds ready-made hooks. Nothing installs them for you:
-symlink or copy the one you want into the matching hook directory in your workspace. Symlinking keeps the hook
-up to date with the clone it points at, and on macOS and Linux the executable bit comes from the file in the
-clone, so no `chmod` is needed.
-
-#### block-while-running (pre-sync)
-
-Aborts the sync while a named process is running, so a sync cannot swap out assets that a running editor still
-has loaded. Link it into your workspace's `pre-sync` hook directory - on macOS and Linux:
-
-```sh
-ln -s /path/to/git-p4son/examples/hooks/pre-sync/block-while-running.py .git-p4son/hooks/pre-sync/
-```
-
-On Windows, from PowerShell. Note that `-Path` is the link to create and `-Target` the existing file, the
-reverse of the `ln -s` argument order, and that `-Target` should be absolute: a relative path is resolved
-against the current directory and quietly produces a broken link.
-
-```powershell
-New-Item -ItemType SymbolicLink `
-  -Path   "C:\p4\my-workspace\.git-p4son\hooks\pre-sync\block-while-running.py" `
-  -Target "C:\src\git-p4son\examples\hooks\pre-sync\block-while-running.py"
-```
-
-Creating a symlink on Windows needs either an elevated shell or Developer Mode enabled (Settings > System >
-For developers). Without one of those, copy the file instead and re-copy it whenever the clone updates.
-
-Which processes block a sync is read from your workspace's own `.git-p4son/config.toml`, so a symlinked hook
-stays per-project:
-
-```toml
-[hooks.block-while-running]
-processes = ["UnrealEditor", "UnrealLightmass"]
-```
-
-Names are matched with any `.exe` suffix stripped and case ignored, so a single entry covers
-`UnrealEditor.exe` on Windows and `UnrealEditor` on macOS. Without that table the hook checks nothing and the
-sync proceeds; a table that is present but malformed aborts the sync rather than silently skipping the check.
-
-Set `GIT_P4SON_SKIP_PROCESS_CHECK=1` to run one sync without the check.
-
 ## Shell Completions
 
 Tab completion is available for bash, zsh, and PowerShell, including commands, flags, and dynamic alias names.

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

@@ -7,6 +7,6 @@ creating and updating changelists, and managing Swarm reviews.
 
 CONFIG_DIR = '.git-p4son'
 
-__version__ = "0.4.0"
+__version__ = "0.4.2"
 __author__ = "Andreas Andersson"
 __email__ = "andreas@neoboid.com"

{git_p4son-0.4.0 → git_p4son-0.4.2}/git_p4son/changelist_store.py

@@ -8,6 +8,7 @@ import os
 import re
 
 from . import CONFIG_DIR
+from .config import ensure_config_dir
 from .log import log
 
 
@@ -85,6 +86,7 @@ def save_changelist_alias(name: str, changelist: str, workspace_dir: str, force:
             f'Alias "{name}" already exists (use -f/--force to overwrite)')
         return False
 
+    ensure_config_dir(workspace_dir)
     if not os.path.isdir(changelists_dir):
         log.info(f'Creating {changelists_dir}')
         os.makedirs(changelists_dir, exist_ok=True)

{git_p4son-0.4.0 → git_p4son-0.4.2}/git_p4son/cli.py

@@ -38,6 +38,7 @@ Examples:
   git-p4son sync 123 156 178    # Sync each changelist in sequence, one commit each
   git-p4son sync 123 156 head   # Sync 123, 156, then the latest changelist
   git-p4son sync last-synced    # Re-sync the last synced changelist
+  git-p4son sync --dry-run      # Show the changelists a sync would visit
   git-p4son sync-split          # Sync to latest, your own changelists split out
   git-p4son sync-split 12345    # Same, but stop at changelist 12345
   git-p4son sync-split -u alice -u bob  # Split out alice's and bob's changelists
@@ -103,6 +104,16 @@ Examples:
         action='store_true',
         help='Allow syncing to changelists older than the current one.'
     )
+    sync_parser.add_argument(
+        '-n', '--dry-run',
+        action='store_true',
+        help='Print the resolved sync sequence without syncing'
+    )
+    sync_parser.add_argument(
+        '--ignore-blocking-processes',
+        action='store_true',
+        help='Sync even while a configured blocking process is running'
+    )
 
     # Sync-split subcommand
     sync_split_parser = subparsers.add_parser(
@@ -135,6 +146,11 @@ Examples:
         action='store_true',
         help='Print the resolved sync sequence without syncing'
     )
+    sync_split_parser.add_argument(
+        '--ignore-blocking-processes',
+        action='store_true',
+        help='Sync even while a configured blocking process is running'
+    )
 
     # New subcommand
     new_parser = subparsers.add_parser(
@@ -408,10 +424,11 @@ Examples:
         help='Print the directory instead of the full file path'
     )
 
-    # Hidden _sequence-editor subcommand (used internally by review)
+    # Hidden _sequence-editor subcommand (used internally by review). It is
+    # given no help: argparse lists a subcommand with help=SUPPRESS anyway,
+    # as "==SUPPRESS==", but leaves one without help out of the list.
     seq_editor_parser = subparsers.add_parser(
         '_sequence-editor',
-        help=argparse.SUPPRESS,
     )
     seq_editor_parser.add_argument(
         'filename',

{git_p4son-0.4.0 → git_p4son-0.4.2}/git_p4son/common.py

@@ -256,6 +256,16 @@ def enqueue_lines(stream: IO[str], output_queue: queue.Queue[str]) -> None:
         output_queue.put(line.rstrip())
 
 
+def _terminate(process: subprocess.Popen) -> None:
+    """Terminate a subprocess, killing it if it does not exit in time."""
+    process.terminate()
+    try:
+        process.wait(timeout=5)
+    except subprocess.TimeoutExpired:
+        log.error("Subprocess did not terminate in time. Forcing kill...")
+        process.kill()
+
+
 def run_with_output(command: list[str], cwd: str = '.',
                     on_output: Callable[..., None] | None = None,
                     env: dict[str, str] | None = None) -> RunResult:
@@ -268,6 +278,8 @@ def run_with_output(command: list[str], cwd: str = '.',
         on_output: Callback function for processing output lines
                    If set the funciton will be called with each
                    line and stream (stdout/stderr) as they are written.
+                   An exception raised from it terminates the command
+                   and propagates.
         env: Optional environment variables to add or override
 
     Returns:
@@ -352,14 +364,14 @@ def run_with_output(command: list[str], cwd: str = '.',
         except KeyboardInterrupt:
             log.stop_spinner()
             log.error("CTRL-C pressed, terminate subprocess")
-            process.terminate()
-            try:
-                process.wait(timeout=5)
-            except subprocess.TimeoutExpired:
-                log.error(
-                    "Subprocess did not terminate in time. Forcing kill...")
-                process.kill()
+            _terminate(process)
             sys.exit(1)
+        except Exception:
+            # on_output raising aborts the command: stop the subprocess
+            # rather than letting it run on unobserved.
+            log.stop_spinner()
+            _terminate(process)
+            raise
 
     log.stop_spinner()
 

{git_p4son-0.4.0 → git_p4son-0.4.2}/git_p4son/config.py

@@ -13,6 +13,27 @@ from . import CONFIG_DIR
 _BARE_KEY_RE = re.compile(r'^[A-Za-z0-9_-]+$')
 
 
+def ensure_config_dir(workspace_dir: str) -> None:
+    """Create the config dir with a .gitignore that ignores everything in it.
+
+    Nothing in the config dir belongs in git. A .gitignore of its own keeps
+    it out without touching the workspace .gitignore, which may be checked
+    into Perforce. The file is rewritten when its content differs, which
+    also replaces the state.toml-only ignore file of earlier versions."""
+    config_dir = os.path.join(workspace_dir, CONFIG_DIR)
+    os.makedirs(config_dir, exist_ok=True)
+    gitignore = os.path.join(config_dir, '.gitignore')
+    content = '*\n'
+    try:
+        with open(gitignore, encoding='utf-8') as f:
+            if f.read() == content:
+                return
+    except FileNotFoundError:
+        pass
+    with open(gitignore, 'w', encoding='utf-8') as f:
+        f.write(content)
+
+
 def config_path(workspace_dir: str) -> str:
     """Return the path to the config file."""
     return os.path.join(workspace_dir, CONFIG_DIR, 'config.toml')
@@ -49,6 +70,7 @@ def save_config(workspace_dir: str, config: dict) -> None:
     merged = load_config(workspace_dir)
     for section, values in config.items():
         merged.setdefault(section, {}).update(values)
+    ensure_config_dir(workspace_dir)
     write_toml(config_path(workspace_dir), merged)
 
 

{git_p4son-0.4.0 → git_p4son-0.4.2}/git_p4son/perforce.py

@@ -452,6 +452,16 @@ def parse_p4_sync_line(line: str) -> tuple[str | None, str | None]:
     return (None, None)
 
 
+# p4 writes a synced file to a temp file and renames it into place. On
+# Windows the rename fails when another process holds the target open, e.g.
+# an editor with the asset loaded, leaving the file unsynced.
+_RENAME_FAILED_PREFIX = 'rename: failed to rename '
+
+
+class P4SyncAbortError(CommandError):
+    """Raised to stop a p4 sync that can no longer succeed."""
+
+
 class P4SyncOutputProcessor:
     """Process p4 sync output in real-time."""
 
@@ -465,6 +475,14 @@ class P4SyncOutputProcessor:
             log.info('all files up to date')
             return
 
+        if line.startswith(_RENAME_FAILED_PREFIX):
+            log.error(line)
+            raise P4SyncAbortError(
+                'Aborting sync: p4 could not replace a file, most likely '
+                'because another process has it open. The workspace is left '
+                'partially synced: close that process, then commit or '
+                'restore the synced files before syncing again.')
+
         mode, filename = parse_p4_sync_line(line)
         if not mode or not filename:
             log.warning(f'Unparsable line: {line}')

git_p4son-0.4.2/git_p4son/processes.py

@@ -0,0 +1,98 @@
+"""
+Blocking processes for git-p4son.
+
+A sync is refused while any of the configured blocking processes is running.
+Syncing while e.g. the Unreal editor is open lets p4 replace assets the editor
+still has loaded, so the editor keeps working against files that no longer
+match what is on disk.
+"""
+
+import csv
+import os
+
+from .common import RunError, run
+from .config import load_config
+from .log import log
+
+IGNORE_FLAG = '--ignore-blocking-processes'
+
+
+def get_blocking_processes(workspace_dir: str) -> list[str]:
+    """Return the configured blocking process names; raise ValueError if malformed."""
+    sync = load_config(workspace_dir).get('sync', {})
+    if not isinstance(sync, dict):
+        raise ValueError('sync in config.toml is not a table')
+    names = sync.get('blocking-processes', [])
+    if (not isinstance(names, list)
+            or not all(isinstance(name, str) for name in names)):
+        raise ValueError(
+            'sync.blocking-processes in config.toml must be a list of strings')
+    return names
+
+
+def normalize_process_name(name: str) -> str:
+    """Reduce a process name to a form comparable across platforms.
+
+    Any directory and .exe suffix are dropped and case is ignored, so
+    "UnrealEditor" matches "UnrealEditor.exe" on Windows and a full path in
+    ps output."""
+    name = os.path.basename(name.strip())
+    if name.lower().endswith('.exe'):
+        name = name[:-len('.exe')]
+    return name.lower()
+
+
+def get_running_processes() -> set[str]:
+    """Return the normalized names of all currently running processes."""
+    if os.name == 'nt':
+        # /NH drops the header row. CSV output keeps an image name that
+        # contains spaces or commas inside one quoted field.
+        result = run(['tasklist', '/NH', '/FO', 'CSV'])
+        lines = [line for line in result.stdout if line.strip()]
+        return {normalize_process_name(row[0])
+                for row in csv.reader(lines) if row}
+    # -ww stops ps truncating output to the terminal width, which would
+    # otherwise cut long process names short.
+    result = run(['ps', '-A', '-ww', '-o', 'comm='])
+    return {normalize_process_name(line)
+            for line in result.stdout if line.strip()}
+
+
+def check_no_blocking_processes(workspace_dir: str, ignore: bool) -> bool:
+    """Report whether the sync may go ahead as far as running processes go.
+
+    Nothing configured means nothing to check, so no process listing is
+    made. A malformed config or a process list that cannot be read fails
+    the check: going ahead would silently drop the protection. ignore skips
+    all of it, config included."""
+    if ignore:
+        log.heading('Checking for blocking processes')
+        log.warning(f'Skipped ({IGNORE_FLAG})')
+        return True
+
+    try:
+        names = get_blocking_processes(workspace_dir)
+    except ValueError as error:
+        log.error(f'Could not read the blocking processes: {error}')
+        return False
+    if not names:
+        return True
+
+    log.heading('Checking for blocking processes')
+    try:
+        running = get_running_processes()
+    except (OSError, RunError) as error:
+        log.error(f'Could not list running processes: {error}')
+        return False
+
+    blocking = sorted(name for name in names
+                      if normalize_process_name(name) in running)
+    if not blocking:
+        log.success('None running')
+        return True
+
+    for name in blocking:
+        log.info(name)
+    log.error('Refusing to sync while these blocking processes are running. '
+              f'Close them and sync again, or pass {IGNORE_FLAG}')
+    return False

{git_p4son-0.4.0 → git_p4son-0.4.2}/git_p4son/review.py

@@ -10,6 +10,7 @@ import os
 import shlex
 import subprocess
 from . import CONFIG_DIR
+from .config import ensure_config_dir
 from .changelist_store import alias_exists, validate_alias_name
 from .git import get_commit_lines_since, resolve_editor
 from .log import log
@@ -112,6 +113,7 @@ def review_command(args: argparse.Namespace) -> int:
 
     # Write todo to .git-p4son/reviews/todo
     reviews_dir = _reviews_dir(workspace_dir)
+    ensure_config_dir(workspace_dir)
     os.makedirs(reviews_dir, exist_ok=True)
     todo_file = _todo_path(workspace_dir)
     with open(todo_file, 'w') as f:

git_p4son-0.4.2/git_p4son/state.py

@@ -0,0 +1,38 @@
+"""
+Local, per-user state for git-p4son.
+
+Stored in .git-p4son/state.toml. State here reflects a single user's workspace
+and preferences, e.g. dismissed warnings.
+"""
+
+import os
+
+from . import CONFIG_DIR
+from .config import ensure_config_dir, load_toml, write_toml
+
+
+def state_path(workspace_dir: str) -> str:
+    """Return the path to the local state file."""
+    return os.path.join(workspace_dir, CONFIG_DIR, 'state.toml')
+
+
+def _load(workspace_dir: str) -> dict:
+    return load_toml(state_path(workspace_dir))
+
+
+def _save(workspace_dir: str, state: dict) -> None:
+    ensure_config_dir(workspace_dir)
+    write_toml(state_path(workspace_dir), state)
+
+
+def is_clobber_warning_dismissed(workspace_dir: str) -> bool:
+    """Return whether the user permanently dismissed the clobber warning."""
+    return bool(_load(workspace_dir).get('clobber', {})
+                .get('dismiss_warning', False))
+
+
+def dismiss_clobber_warning(workspace_dir: str) -> None:
+    """Persist that the clobber warning should never be shown again."""
+    state = _load(workspace_dir)
+    state.setdefault('clobber', {})['dismiss_warning'] = True
+    _save(workspace_dir, state)