LiveSync 0.3.0__py3-none-any.whl → 0.3.2__py3-none-any.whl

{LiveSync-0.3.0.dist-info → LiveSync-0.3.2.dist-info}/METADATA

@@ -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
@@ -11,7 +11,6 @@ Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: pathspec
-Requires-Dist: pyjson5
 Requires-Dist: watchfiles
 
 # LiveSync
@@ -29,12 +28,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>
 ```
@@ -46,20 +48,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
 
@@ -67,7 +107,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.dist-info/RECORD

@@ -0,0 +1,12 @@
+livesync/__init__.py,sha256=tZrvnAIpVuo9cQHMCvi6l2vup66NXPxRwyR5UBNtCTs,50
+livesync/folder.py,sha256=gkjhE8uBKAPs3hIJQLoCCFF_1KEh9ODrOlbYm-JHNRM,4022
+livesync/livesync.py,sha256=2kNwtM3a1r5moAXCD4BcK0UJYa0EdZP5PTUNiEqKI6g,1294
+livesync/mutex.py,sha256=nHaP0Tge3ZV7jyVBbYsMug5L5YkuJf8_XIbfAdVJkPc,1741
+livesync/run_subprocess.py,sha256=ZZqK9dlOVlJhL0xkKN7bG-BAT558nHk-IJNGqIMeWyM,368
+livesync/sync.py,sha256=9cQwtdLHIBvenzyq0HRJOagPm1OGSDpi43vLBa2aNUs,1635
+LiveSync-0.3.2.dist-info/LICENSE,sha256=QcBlwggRQYhvfTAE481AAMFQfMS_N6Bj8Svh1T6dsnI,1072
+LiveSync-0.3.2.dist-info/METADATA,sha256=I86gj3hllCf1gRvXhJJeFuXCmlSl-Ne-1WWbqdqIOIg,5335
+LiveSync-0.3.2.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+LiveSync-0.3.2.dist-info/entry_points.txt,sha256=4dn5YR27lUlJWea3yqLKLqR4MwqjcqzMR5Q4jVFnytI,52
+LiveSync-0.3.2.dist-info/top_level.txt,sha256=mLwExc6wTUGqxvUkYMio5rxGS1h8bvxpNsR2ebfjSL4,9
+LiveSync-0.3.2.dist-info/RECORD,,

{LiveSync-0.3.0.dist-info → LiveSync-0.3.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.41.2)
+Generator: bdist_wheel (0.42.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

livesync/__init__.py

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

livesync/folder.py

@@ -1,92 +1,91 @@
+from __future__ import annotations
+
 import asyncio
 import subprocess
 import sys
-from dataclasses import dataclass
 from pathlib import Path
-from typing import List, Optional
+from typing import Callable, List, Optional, Union
 
 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}"')
+from .run_subprocess import run_subprocess
 
 
 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
+    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
-
-        # 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.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()
 
-    @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 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(DEFAULT_IGNORES))
+            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.local_path} --> {self.ssh_path}\n'
-        if not (self.local_path / '.git').exists():
-            return summary
+        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.local_path).decode()
+            summary += subprocess.check_output(cmd, cwd=self.source_path).decode()
             cmd = ['git', 'status', '--short', '--branch']
-            summary += subprocess.check_output(cmd, cwd=self.local_path).decode().strip() + '\n'
+            summary += subprocess.check_output(cmd, cwd=self.source_path).decode().strip() + '\n'
         except Exception:
-            pass  # maybe git is not installed
+            pass  # not a git repo, git is not installed, or something else
         return summary
 
-    async def watch(self, on_change_command: Optional[str]) -> None:
+    async def watch(self) -> None:
         try:
-            async for changes in watchfiles.awatch(self.local_path, stop_event=self._stop_watching,
+            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(on_change_command)
+                self.sync()
         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}"')
+    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/livesync.py

@@ -1,74 +1,25 @@
 #!/usr/bin/env python3
 import argparse
-import asyncio
-import sys
-from pathlib import Path
-from typing import List
 
-import pyjson5
+from livesync import Folder, sync
 
-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:
+def main():
     parser = argparse.ArgumentParser(
-        description='Repeatedly synchronize local directories with remote machine',
+        description='Repeatedly synchronize a local directory with a 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('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('host', type=str, help='the target host (e.g. username@hostname)')
+    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()
-    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!')
+    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__':

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/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/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.dist-info/RECORD

@@ -1,10 +0,0 @@
-livesync/__init__.py,sha256=V9nt0JRzIeiiLDVNDMZ20SqLMSqFh8uPViPsp2WYK6g,60
-livesync/folder.py,sha256=NhorutBdi6_0bhLCPjrVi8TIPZ3TPDQxJRQ0L0-3kRU,3619
-livesync/livesync.py,sha256=PKaw-WD4WOZb-X2n4ihj0C8jEOff4s5dopOGiOM3xI4,2586
-livesync/mutex.py,sha256=C3Az3Exfgj1ohKnhWl77TDvuJlv3q2qieSgtJF__Wdc,1646
-LiveSync-0.3.0.dist-info/LICENSE,sha256=QcBlwggRQYhvfTAE481AAMFQfMS_N6Bj8Svh1T6dsnI,1072
-LiveSync-0.3.0.dist-info/METADATA,sha256=pjVKS1x7LaYr_emVuhAwMUIQyK-WKxJYzPUhnVMs9fc,4285
-LiveSync-0.3.0.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
-LiveSync-0.3.0.dist-info/entry_points.txt,sha256=4dn5YR27lUlJWea3yqLKLqR4MwqjcqzMR5Q4jVFnytI,52
-LiveSync-0.3.0.dist-info/top_level.txt,sha256=mLwExc6wTUGqxvUkYMio5rxGS1h8bvxpNsR2ebfjSL4,9
-LiveSync-0.3.0.dist-info/RECORD,,