LiveSync 0.3.0__tar.gz → 0.3.2__tar.gz

{LiveSync-0.3.0 → LiveSync-0.3.2/LiveSync.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: LiveSync
-Version: 0.3.0
+Version: 0.3.2
 Summary: Repeatedly synchronize local workspace with a (slow) remote machine
 Home-page: https://github.com/zauberzeug/livesync
 Author: Zauberzeug GmbH
@@ -26,12 +26,15 @@ It is available as [PyPI package](https://pypi.org/project/livesync/) and hosted
 
 [VS Code Remote Development](https://code.visualstudio.com/docs/remote/remote-overview) and similar tools are great as long as your remote machine is powerful enough.
 But if your target is a Raspberry Pi, Jetson Nano/Xavier/Orin, Beagle Board or similar, it feels like coding in jelly.
-Especially if you run powerful extensions like Pylance.
+Especially if you run powerful extensions like Pylance, GitHub Copilot or Duet AI.
 LiveSync solves this by watching your code for changes and just copying the modifications to the slow remote machine.
+So you can develop on your own machine (and run tests there in the background) while all your changes appear also on the remote.
 It works best if you have some kind of reload mechanism in place on the target ([NiceGUI](https://nicegui.io), [FastAPI](https://fastapi.tiangolo.com/) or [Flask](https://flask.palletsprojects.com/) for example).
 
 ## Usage
 
+### BASH
+
 ```bash
 livesync <source> <username>@<host>
 ```
@@ -43,20 +46,58 @@ Press `CTRL-C` to abort the synchronization.
 Positional arguments:
 
 - `<source>`
-  local folder or VSCode workspace file
-- `<username>@<host>`
-  target user and host (e.g. username@hostname)
+  local folder
+- `<target>`
+  target user, host and path (e.g. user@host:~/path; path defaults to source folder name in home directory)
+- `<rsync_args>`
+  arbitrary rsync parameters after "--"
 
 Options:
 
-- `--target-root TARGET_ROOT`
-  subfolder on target to synchronize to (default: "")
-- `--target-port TARGET_PORT`
+- `--ssh-port SSH_PORT`
   SSH port on target (default: 22)
 - `--on-change ON_CHANGE`
   command to be executed on remote host after any file change (default: None)
 - `--mutex-interval MUTEX_INTERVAL`
   interval in which mutex is updated (default: 10 seconds)
+- `--ignore-mutex`
+  ignore mutex (use with caution) (default: False)
+
+### Python
+
+Simple example (where `robot` is the ssh hostname of the target system):
+
+```py
+from livesync import Folder, sync
+
+sync(
+    Folder('.', 'robot:~/navigation'),
+    Folder('../rosys', 'robot:~/rosys'),
+)
+```
+
+The `sync` call will block until the script is aborted.
+The `Folder` class allows to set the `port` and an `on_change` bash command which is executed after a sync has been performed.
+Via the `rsync_args` build method you can pass additional options to configure rsync.
+
+Advanced example:
+
+```py
+import argparse
+from livesync import Folder, sync
+
+parser = argparse.ArgumentParser(description='Sync local code with robot.')
+parser.add_argument('robot', help='Robot hostname')
+
+args = parser.parse_args()
+
+touch = 'touch ~/robot/main.py'
+sync(
+    Folder('.', f'{args.robot}:~/navigation', on_change='touch ~/navigation/main.py'),
+    Folder('../rosys', f'{args.robot}:~/rosys').rsync_args(add='-L', remove='--checksum'),
+    mutex_interval=30,
+)
+```
 
 ### Notes
 
@@ -64,7 +105,6 @@ Options:
 - Only one user per target host should run LiveSync at a time. Therefore LiveSync provides a mutex mechanism.
 - You can create a `.syncignore` file in any source directory to skip additional files and directories from syncing.
 - If a `.syncignore` file doesn't exist, it is automatically created containing `.git/`, `__pycache__/`, `.DS_Store`, `*.tmp`, and `.env`.
-- If you pass a VSCode workspace file as `source`, LiveSync will synchronize each directory listed in the `folders` section.
 
 ## Installation
 

{LiveSync-0.3.0 → LiveSync-0.3.2}/LiveSync.egg-info/SOURCES.txt

@@ -10,4 +10,6 @@ LiveSync.egg-info/top_level.txt
 livesync/__init__.py
 livesync/folder.py
 livesync/livesync.py
-livesync/mutex.py
+livesync/mutex.py
+livesync/run_subprocess.py
+livesync/sync.py

{LiveSync-0.3.0 → LiveSync-0.3.2}/LiveSync.egg-info/requires.txt

@@ -1,3 +1,2 @@
 pathspec
-pyjson5
 watchfiles

{LiveSync-0.3.0/LiveSync.egg-info → LiveSync-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: LiveSync
-Version: 0.3.0
+Version: 0.3.2
 Summary: Repeatedly synchronize local workspace with a (slow) remote machine
 Home-page: https://github.com/zauberzeug/livesync
 Author: Zauberzeug GmbH
@@ -26,12 +26,15 @@ It is available as [PyPI package](https://pypi.org/project/livesync/) and hosted
 
 [VS Code Remote Development](https://code.visualstudio.com/docs/remote/remote-overview) and similar tools are great as long as your remote machine is powerful enough.
 But if your target is a Raspberry Pi, Jetson Nano/Xavier/Orin, Beagle Board or similar, it feels like coding in jelly.
-Especially if you run powerful extensions like Pylance.
+Especially if you run powerful extensions like Pylance, GitHub Copilot or Duet AI.
 LiveSync solves this by watching your code for changes and just copying the modifications to the slow remote machine.
+So you can develop on your own machine (and run tests there in the background) while all your changes appear also on the remote.
 It works best if you have some kind of reload mechanism in place on the target ([NiceGUI](https://nicegui.io), [FastAPI](https://fastapi.tiangolo.com/) or [Flask](https://flask.palletsprojects.com/) for example).
 
 ## Usage
 
+### BASH
+
 ```bash
 livesync <source> <username>@<host>
 ```
@@ -43,20 +46,58 @@ Press `CTRL-C` to abort the synchronization.
 Positional arguments:
 
 - `<source>`
-  local folder or VSCode workspace file
-- `<username>@<host>`
-  target user and host (e.g. username@hostname)
+  local folder
+- `<target>`
+  target user, host and path (e.g. user@host:~/path; path defaults to source folder name in home directory)
+- `<rsync_args>`
+  arbitrary rsync parameters after "--"
 
 Options:
 
-- `--target-root TARGET_ROOT`
-  subfolder on target to synchronize to (default: "")
-- `--target-port TARGET_PORT`
+- `--ssh-port SSH_PORT`
   SSH port on target (default: 22)
 - `--on-change ON_CHANGE`
   command to be executed on remote host after any file change (default: None)
 - `--mutex-interval MUTEX_INTERVAL`
   interval in which mutex is updated (default: 10 seconds)
+- `--ignore-mutex`
+  ignore mutex (use with caution) (default: False)
+
+### Python
+
+Simple example (where `robot` is the ssh hostname of the target system):
+
+```py
+from livesync import Folder, sync
+
+sync(
+    Folder('.', 'robot:~/navigation'),
+    Folder('../rosys', 'robot:~/rosys'),
+)
+```
+
+The `sync` call will block until the script is aborted.
+The `Folder` class allows to set the `port` and an `on_change` bash command which is executed after a sync has been performed.
+Via the `rsync_args` build method you can pass additional options to configure rsync.
+
+Advanced example:
+
+```py
+import argparse
+from livesync import Folder, sync
+
+parser = argparse.ArgumentParser(description='Sync local code with robot.')
+parser.add_argument('robot', help='Robot hostname')
+
+args = parser.parse_args()
+
+touch = 'touch ~/robot/main.py'
+sync(
+    Folder('.', f'{args.robot}:~/navigation', on_change='touch ~/navigation/main.py'),
+    Folder('../rosys', f'{args.robot}:~/rosys').rsync_args(add='-L', remove='--checksum'),
+    mutex_interval=30,
+)
+```
 
 ### Notes
 
@@ -64,7 +105,6 @@ Options:
 - Only one user per target host should run LiveSync at a time. Therefore LiveSync provides a mutex mechanism.
 - You can create a `.syncignore` file in any source directory to skip additional files and directories from syncing.
 - If a `.syncignore` file doesn't exist, it is automatically created containing `.git/`, `__pycache__/`, `.DS_Store`, `*.tmp`, and `.env`.
-- If you pass a VSCode workspace file as `source`, LiveSync will synchronize each directory listed in the `folders` section.
 
 ## Installation
 

{LiveSync-0.3.0 → LiveSync-0.3.2}/README.md

@@ -13,12 +13,15 @@ It is available as [PyPI package](https://pypi.org/project/livesync/) and hosted
 
 [VS Code Remote Development](https://code.visualstudio.com/docs/remote/remote-overview) and similar tools are great as long as your remote machine is powerful enough.
 But if your target is a Raspberry Pi, Jetson Nano/Xavier/Orin, Beagle Board or similar, it feels like coding in jelly.
-Especially if you run powerful extensions like Pylance.
+Especially if you run powerful extensions like Pylance, GitHub Copilot or Duet AI.
 LiveSync solves this by watching your code for changes and just copying the modifications to the slow remote machine.
+So you can develop on your own machine (and run tests there in the background) while all your changes appear also on the remote.
 It works best if you have some kind of reload mechanism in place on the target ([NiceGUI](https://nicegui.io), [FastAPI](https://fastapi.tiangolo.com/) or [Flask](https://flask.palletsprojects.com/) for example).
 
 ## Usage
 
+### BASH
+
 ```bash
 livesync <source> <username>@<host>
 ```
@@ -30,20 +33,58 @@ Press `CTRL-C` to abort the synchronization.
 Positional arguments:
 
 - `<source>`
-  local folder or VSCode workspace file
-- `<username>@<host>`
-  target user and host (e.g. username@hostname)
+  local folder
+- `<target>`
+  target user, host and path (e.g. user@host:~/path; path defaults to source folder name in home directory)
+- `<rsync_args>`
+  arbitrary rsync parameters after "--"
 
 Options:
 
-- `--target-root TARGET_ROOT`
-  subfolder on target to synchronize to (default: "")
-- `--target-port TARGET_PORT`
+- `--ssh-port SSH_PORT`
   SSH port on target (default: 22)
 - `--on-change ON_CHANGE`
   command to be executed on remote host after any file change (default: None)
 - `--mutex-interval MUTEX_INTERVAL`
   interval in which mutex is updated (default: 10 seconds)
+- `--ignore-mutex`
+  ignore mutex (use with caution) (default: False)
+
+### Python
+
+Simple example (where `robot` is the ssh hostname of the target system):
+
+```py
+from livesync import Folder, sync
+
+sync(
+    Folder('.', 'robot:~/navigation'),
+    Folder('../rosys', 'robot:~/rosys'),
+)
+```
+
+The `sync` call will block until the script is aborted.
+The `Folder` class allows to set the `port` and an `on_change` bash command which is executed after a sync has been performed.
+Via the `rsync_args` build method you can pass additional options to configure rsync.
+
+Advanced example:
+
+```py
+import argparse
+from livesync import Folder, sync
+
+parser = argparse.ArgumentParser(description='Sync local code with robot.')
+parser.add_argument('robot', help='Robot hostname')
+
+args = parser.parse_args()
+
+touch = 'touch ~/robot/main.py'
+sync(
+    Folder('.', f'{args.robot}:~/navigation', on_change='touch ~/navigation/main.py'),
+    Folder('../rosys', f'{args.robot}:~/rosys').rsync_args(add='-L', remove='--checksum'),
+    mutex_interval=30,
+)
+```
 
 ### Notes
 
@@ -51,7 +92,6 @@ Options:
 - Only one user per target host should run LiveSync at a time. Therefore LiveSync provides a mutex mechanism.
 - You can create a `.syncignore` file in any source directory to skip additional files and directories from syncing.
 - If a `.syncignore` file doesn't exist, it is automatically created containing `.git/`, `__pycache__/`, `.DS_Store`, `*.tmp`, and `.env`.
-- If you pass a VSCode workspace file as `source`, LiveSync will synchronize each directory listed in the `folders` section.
 
 ## Installation
 

LiveSync-0.3.2/livesync/__init__.py

@@ -0,0 +1,2 @@
+from .folder import Folder
+from .sync import sync

LiveSync-0.3.2/livesync/folder.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+import asyncio
+import subprocess
+import sys
+from pathlib import Path
+from typing import Callable, List, Optional, Union
+
+import pathspec
+import watchfiles
+
+from .run_subprocess import run_subprocess
+
+
+class Folder:
+    DEFAULT_IGNORES = ['.git/', '__pycache__/', '.DS_Store', '*.tmp', '.env']
+    DEFAULT_RSYNC_ARGS = ['--prune-empty-dirs', '--delete', '-a', '-v', '-z', '--checksum', '--no-t']
+
+    def __init__(self,
+                 source_path: Union[str, Path],
+                 target: str, *,
+                 ssh_port: int = 22,
+                 on_change: Optional[Union[str, Callable]] = None,
+                 ) -> None:
+        self.source_path = Path(source_path).resolve()  # one should avoid `absolute` if Python < 3.11
+        if ':' not in target:
+            target = f'{target}:{self.source_path.name}'
+        self.target = target
+        self.host, self.target_path = target.split(':')
+        self.ssh_port = ssh_port
+        self.on_change = on_change or None
+        self._rsync_args: List[str] = self.DEFAULT_RSYNC_ARGS[:]
+        self._stop_watching = asyncio.Event()
+
+        if not self.source_path.is_dir():
+            print(f'Invalid path: {self.source_path}')
+            sys.exit(1)
+
+        match_pattern = pathspec.patterns.gitwildmatch.GitWildMatchPattern  # https://stackoverflow.com/a/22090594/3419103
+        self._ignore_spec = pathspec.PathSpec.from_lines(match_pattern, self._get_ignores())
+
+    def rsync_args(self,
+                   add: Optional[str] = None,
+                   remove: Optional[str] = None,
+                   replace: Optional[str] = None) -> Folder:
+        if replace is not None:
+            self._rsync_args.clear()
+        add_args = (add or '').split() + (replace or '').split()
+        remove_args = remove.split() if remove else []
+        self._rsync_args += [arg for arg in add_args if arg not in self._rsync_args]
+        self._rsync_args = [arg for arg in self._rsync_args if arg not in remove_args]
+        return self
+
+    def _get_ignores(self) -> List[str]:
+        path = self.source_path / '.syncignore'
+        if not path.is_file():
+            path.write_text('\n'.join(self.DEFAULT_IGNORES))
+        return [line.strip() for line in path.read_text().splitlines() if not line.startswith('#')]
+
+    def get_summary(self) -> str:
+        summary = f'{self.source_path} --> {self.target}\n'
+        try:
+            cmd = ['git', 'log', '--pretty=format:[%h]\n', '-n', '1']
+            summary += subprocess.check_output(cmd, cwd=self.source_path).decode()
+            cmd = ['git', 'status', '--short', '--branch']
+            summary += subprocess.check_output(cmd, cwd=self.source_path).decode().strip() + '\n'
+        except Exception:
+            pass  # not a git repo, git is not installed, or something else
+        return summary
+
+    async def watch(self) -> None:
+        try:
+            async for changes in watchfiles.awatch(self.source_path, stop_event=self._stop_watching,
+                                                   watch_filter=lambda _, filepath: not self._ignore_spec.match_file(filepath)):
+                for change, filepath in changes:
+                    print('?+U-'[change], filepath)
+                self.sync()
+        except RuntimeError as e:
+            if 'Already borrowed' not in str(e):
+                raise
+
+    def sync(self) -> None:
+        args = ' '.join(self._rsync_args)
+        args += ''.join(f' --exclude="{e}"' for e in self._get_ignores())
+        args += f' -e "ssh -p {self.ssh_port}"'  # NOTE: use SSH with custom port
+        args += f' --rsync-path="mkdir -p {self.target_path} && rsync"'  # NOTE: create target folder if not exists
+        run_subprocess(f'rsync {args} "{self.source_path}/" "{self.target}/"', quiet=True)
+        if isinstance(self.on_change, str):
+            run_subprocess(f'ssh {self.host} -p {self.ssh_port} "cd {self.target_path}; {self.on_change}"')
+        if callable(self.on_change):
+            self.on_change()

LiveSync-0.3.2/livesync/livesync.py

@@ -0,0 +1,26 @@
+#!/usr/bin/env python3
+import argparse
+
+from livesync import Folder, sync
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='Repeatedly synchronize a local directory with a remote machine',
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+    parser.add_argument('source', type=str, default='.', help='local source folder')
+    parser.add_argument('target', type=str, help='target path (e.g. username@hostname:/path/to/target)')
+    parser.add_argument('--ssh-port', type=int, default=22, help='SSH port on target')
+    parser.add_argument('--on-change', type=str, help='command to be executed on remote host after any file change')
+    parser.add_argument('--mutex-interval', type=int, default=10, help='interval in which mutex is updated')
+    parser.add_argument('--ignore-mutex', action='store_true', help='ignore mutex (use with caution)')
+    parser.add_argument('rsync_args', nargs=argparse.REMAINDER, help='arbitrary rsync parameters after "--"')
+    args = parser.parse_args()
+
+    folder = Folder(args.source, args.target, ssh_port=args.ssh_port, on_change=args.on_change)
+    folder.rsync_args(' '.join(args.rsync_args))
+    sync(folder, mutex_interval=args.mutex_interval, ignore_mutex=args.ignore_mutex)
+
+
+if __name__ == '__main__':
+    main()

{LiveSync-0.3.0 → LiveSync-0.3.2}/livesync/mutex.py

@@ -4,22 +4,23 @@ import subprocess
 from datetime import datetime, timedelta
 from typing import Optional
 
-from .folder import Target
-
-MUTEX_FILEPATH = '~/.livesync_mutex'
-
 
 class Mutex:
+    DEFAULT_FILEPATH = '~/.livesync_mutex'
 
-    def __init__(self, target: Target) -> None:
-        self.target = target
+    def __init__(self, host: str, port: int) -> None:
+        self.host = host
+        self.port = port
         self.occupant: Optional[str] = None
         self.user_id = socket.gethostname()
 
-    def is_free(self, info: str) -> bool:
+    def is_free(self) -> bool:
         try:
-            output = self._run_ssh_command(f'cat {MUTEX_FILEPATH} || echo "{self.tag}\n{info}"').splitlines()[0]
-            words = output.strip().split()
+            command = f'[ -f {self.DEFAULT_FILEPATH} ] && cat {self.DEFAULT_FILEPATH} || echo'
+            output = self._run_ssh_command(command).strip()
+            if not output:
+                return True
+            words = output.splitlines()[0].strip().split()
             self.occupant = words[0]
             occupant_ok = self.occupant == self.user_id
             mutex_datetime = datetime.fromisoformat(words[1])
@@ -30,10 +31,10 @@ class Mutex:
             return False
 
     def set(self, info: str) -> bool:
-        if not self.is_free(info):
+        if not self.is_free():
             return False
         try:
-            self._run_ssh_command(f'echo "{self.tag}\n{info}" > {MUTEX_FILEPATH}')
+            self._run_ssh_command(f'echo "{self.tag}\n{info}" > {self.DEFAULT_FILEPATH}')
             return True
         except subprocess.CalledProcessError:
             print('Could not write mutex file')
@@ -44,5 +45,5 @@ class Mutex:
         return f'{self.user_id} {datetime.now().isoformat()}'
 
     def _run_ssh_command(self, command: str) -> str:
-        ssh_command = ['ssh', self.target.host, '-p', str(self.target.port), command]
+        ssh_command = ['ssh', self.host, '-p', str(self.port), command]
         return subprocess.check_output(ssh_command, stderr=subprocess.DEVNULL).decode()

LiveSync-0.3.2/livesync/run_subprocess.py

@@ -0,0 +1,11 @@
+import subprocess
+
+
+def run_subprocess(command: str, *, quiet: bool = False) -> None:
+    try:
+        result = subprocess.run(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, check=True)
+        if not quiet:
+            print(result.stdout.decode())
+    except subprocess.CalledProcessError as e:
+        print(e.stdout.decode())
+        raise

LiveSync-0.3.2/livesync/sync.py

@@ -0,0 +1,47 @@
+import asyncio
+import sys
+from typing import Iterable
+
+from .folder import Folder
+from .mutex import Mutex
+
+
+def get_summary(folders: Iterable[Folder]) -> str:
+    return '\n'.join(folder.get_summary() for folder in folders).replace('"', '\'')
+
+
+async def run_folder_tasks(folders: Iterable[Folder], mutex_interval: float, ignore_mutex: bool = False) -> None:
+    try:
+        if not ignore_mutex:
+            summary = get_summary(folders)
+            mutexes = {folder.host: Mutex(folder.host, folder.ssh_port) for folder in folders}
+            for mutex in mutexes.values():
+                print(f'Checking mutex on {mutex.host}', flush=True)
+                if not mutex.set(summary):
+                    print(f'Target is in use by {mutex.occupant}')
+                    sys.exit(1)
+
+        for folder in folders:
+            print(f'  {folder.source_path} --> {folder.target}', flush=True)
+            folder.sync()
+
+        for folder in folders:
+            print(f'Watch folder {folder.source_path}', flush=True)
+            asyncio.create_task(folder.watch())
+
+        while True:
+            if not ignore_mutex:
+                summary = get_summary(folders)
+                for mutex in mutexes.values():
+                    if not mutex.set(summary):
+                        break
+            await asyncio.sleep(mutex_interval)
+    except Exception as e:
+        print(e)
+
+
+def sync(*folders: Folder, mutex_interval: float = 10, ignore_mutex: bool = False) -> None:
+    try:
+        asyncio.run(run_folder_tasks(folders, mutex_interval, ignore_mutex=ignore_mutex))
+    except KeyboardInterrupt:
+        print('Bye!')

LiveSync-0.3.0/livesync/__init__.py

@@ -1,2 +0,0 @@
-from .folder import Folder, Target
-from .mutex import Mutex

LiveSync-0.3.0/livesync/folder.py

@@ -1,92 +0,0 @@
-import asyncio
-import subprocess
-import sys
-from dataclasses import dataclass
-from pathlib import Path
-from typing import List, Optional
-
-import pathspec
-import watchfiles
-
-KWONLY_SLOTS = {'kw_only': True, 'slots': True} if sys.version_info >= (3, 10) else {}
-DEFAULT_IGNORES = ['.git/', '__pycache__/', '.DS_Store', '*.tmp', '.env']
-
-
-def run_subprocess(command: str, *, quiet: bool = False) -> None:
-    result = subprocess.run(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, check=True)
-    if not quiet:
-        print(result.stdout.decode())
-
-
-@dataclass(**KWONLY_SLOTS)
-class Target:
-    host: str
-    port: int
-    root: Path
-
-    def make_target_root_directory(self) -> None:
-        print(f'make target root directory {self.root}')
-        run_subprocess(f'ssh {self.host} -p {self.port} "mkdir -p {self.root}"')
-
-
-class Folder:
-
-    def __init__(self, local_dir: Path, target: Target) -> None:
-        self.local_path = local_dir.resolve()  # one should avoid `absolute` if Python < 3.11
-        self.target = target
-
-        # from https://stackoverflow.com/a/22090594/3419103
-        match_pattern = pathspec.patterns.gitwildmatch.GitWildMatchPattern
-        self._ignore_spec = pathspec.PathSpec.from_lines(match_pattern, self.get_ignores())
-
-        self._stop_watching = asyncio.Event()
-
-    @property
-    def target_path(self) -> Path:
-        return self.target.root / self.local_path.stem
-
-    @property
-    def ssh_path(self) -> str:
-        return f'{self.target.host}:{self.target_path}'
-
-    def get_ignores(self) -> List[str]:
-        path = self.local_path / '.syncignore'
-        if not path.is_file():
-            path.write_text('\n'.join(DEFAULT_IGNORES))
-        return [line.strip() for line in path.read_text().splitlines() if not line.startswith('#')]
-
-    def get_summary(self) -> str:
-        summary = f'{self.local_path} --> {self.ssh_path}\n'
-        if not (self.local_path / '.git').exists():
-            return summary
-        try:
-            cmd = ['git', 'log', '--pretty=format:[%h]\n', '-n', '1']
-            summary += subprocess.check_output(cmd, cwd=self.local_path).decode()
-            cmd = ['git', 'status', '--short', '--branch']
-            summary += subprocess.check_output(cmd, cwd=self.local_path).decode().strip() + '\n'
-        except Exception:
-            pass  # maybe git is not installed
-        return summary
-
-    async def watch(self, on_change_command: Optional[str]) -> None:
-        try:
-            async for changes in watchfiles.awatch(self.local_path, stop_event=self._stop_watching,
-                                                   watch_filter=lambda _, filepath: not self._ignore_spec.match_file(filepath)):
-                for change, filepath in changes:
-                    print('?+U-'[change], filepath)
-                self.sync(on_change_command)
-        except RuntimeError as e:
-            if 'Already borrowed' not in str(e):
-                raise
-
-    def stop_watching(self) -> None:
-        self._stop_watching.set()
-
-    def sync(self, post_sync_command: Optional[str] = None) -> None:
-        args = '--prune-empty-dirs --delete -avz --checksum --no-t'
-        # args += ' --mkdirs'  # INFO: this option is not available in rsync < 3.2.3
-        args += ''.join(f' --exclude="{e}"' for e in self.get_ignores())
-        args += f' -e "ssh -p {self.target.port}"'
-        run_subprocess(f'rsync {args} {self.local_path}/ {self.ssh_path}/', quiet=True)
-        if post_sync_command:
-            run_subprocess(f'ssh {self.target.host} -p {self.target.port} "cd {self.target_path}; {post_sync_command}"')

LiveSync-0.3.0/livesync/livesync.py

@@ -1,75 +0,0 @@
-#!/usr/bin/env python3
-import argparse
-import asyncio
-import sys
-from pathlib import Path
-from typing import List
-
-import pyjson5
-
-from livesync import Folder, Mutex, Target
-
-
-def git_summary(folders: List[Folder]) -> str:
-    return '\n'.join(f.get_summary() for f in folders).replace('"', '\'')
-
-
-async def async_main() -> None:
-    parser = argparse.ArgumentParser(
-        description='Repeatedly synchronize local directories with remote machine',
-        formatter_class=argparse.ArgumentDefaultsHelpFormatter)
-    parser.add_argument('source', type=str, help='local source folder or VSCode workspace file')
-    parser.add_argument('--target-root', type=str, default='', help='subfolder on target to synchronize to')
-    parser.add_argument('--target-port', type=int, default=22, help='SSH port on target')
-    parser.add_argument('--on-change', type=str, help='command to be executed on remote host after any file change')
-    parser.add_argument('--mutex-interval', type=int, default=10, help='interval in which mutex is updated')
-    parser.add_argument('host', type=str, help='the target host (e.g. username@hostname)')
-    args = parser.parse_args()
-    source = Path(args.source)
-    target = Target(host=args.host, port=args.target_port, root=Path(args.target_root))
-
-    folders: List[Folder] = []
-    if source.is_file():
-        workspace = pyjson5.decode(source.read_text())
-        paths = [Path(f['path']) for f in workspace['folders']]
-        folders = [Folder(p, target) for p in paths if p.is_dir()]
-    else:
-        folders = [Folder(source, target)]
-
-    for folder in folders:
-        if not folder.local_path.is_dir():
-            print(f'Invalid path: {folder.local_path}')
-            sys.exit(1)
-
-    print('Checking mutex...')
-    mutex = Mutex(target)
-    if not mutex.set(git_summary(folders)):
-        print(f'Target is in use by {mutex.occupant}')
-        sys.exit(1)
-
-    if args.target_root:
-        print('Creating target root directory...')
-        target.make_target_root_directory()
-
-    print('Initial sync...')
-    for folder in folders:
-        print(f'  {folder.local_path} --> {folder.ssh_path}')
-        folder.sync(post_sync_command=args.on_change)
-
-    print('Watching for file changes...')
-    for folder in folders:
-        asyncio.create_task(folder.watch(on_change_command=args.on_change))
-
-    while mutex.set(git_summary(folders)):
-        await asyncio.sleep(args.mutex_interval)
-
-
-def main():
-    try:
-        asyncio.run(async_main())
-    except KeyboardInterrupt:
-        print('Bye!')
-
-
-if __name__ == '__main__':
-    main()