LiveSync 0.2.2__py3-none-any.whl → 0.3.1__py3-none-any.whl

{LiveSync-0.2.2.dist-info → LiveSync-0.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: LiveSync
-Version: 0.2.2
+Version: 0.3.1
 Summary: Repeatedly synchronize local workspace with a (slow) remote machine
 Home-page: https://github.com/zauberzeug/livesync
 Author: Zauberzeug GmbH
@@ -10,8 +10,8 @@ Keywords: sync remote watch filesystem development deploy live hot reload
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: watchfiles
 Requires-Dist: pathspec
+Requires-Dist: watchfiles
 
 # LiveSync
 
@@ -34,29 +34,65 @@ It works best if you have some kind of reload mechanism in place on the target (
 
 ## Usage
 
+### BASH
+
 ```bash
-cd <my_project_folder>
-livesync <username>@<host>
+livesync <source> <username>@<host>
 ```
 
 LiveSync uses rsync (SSH) to copy the files, so the `<username>@<host>` must be accessible via SSH (ideally by key, not password or passphrase, because it will be called over and over).
 
 Press `CTRL-C` to abort the synchronization.
 
+Positional arguments:
+
+- `<source>`
+  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:
+
+- `--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)
+
+### Python
+
+Simple example:
+
+```py
+from livesync import Folder, sync
+
+sync(
+    Folder('.', 'robot:~/navigation'),
+    Folder('../rosys', 'robot:~/rosys'),
+)
+```
+
+Advanced example:
+
+```py
+from livesync import Folder, sync
+
+sync(
+    Folder('.', 'robot:~/navigation', on_change='touch ~/navigation/main.py'),
+    Folder('../rosys', 'robot:~/rosys', ssh_port=2222).rsync_args(add='-L', remove='--checksum'),
+    mutex_interval=30,
+)
+```
+
 ### Notes
 
 - We suggest you have some auto-reloading in place on the (slow) target machine, like [NiceGUI](https://nicegui.io).
 - Only one user per target host should run LiveSync at a time. Therefore LiveSync provides a mutex mechanism.
-- By default `.git/` folders are not synchronized.
-- All files and directories from the `.gitignore` of any source directory are also excluded from synchronization.
 - You can create a `.syncignore` file in any source directory to skip additional files and directories from syncing.
-- If LiveSync finds a VSCode workspace file, it will synchronize each directory listed in the `folders` section.
-
-### Options
-
-- `--on-change [command]` command to be executed on remote host after any file change
-- `--source [SOURCE]` source folder on local host instead of VSCode workspace file
-- `--mutex-interval [INTERVAL]` interval for updating the mutex
+- If a `.syncignore` file doesn't exist, it is automatically created containing `.git/`, `__pycache__/`, `.DS_Store`, `*.tmp`, and `.env`.
 
 ## Installation
 

LiveSync-0.3.1.dist-info/RECORD

@@ -0,0 +1,12 @@
+livesync/__init__.py,sha256=tZrvnAIpVuo9cQHMCvi6l2vup66NXPxRwyR5UBNtCTs,50
+livesync/folder.py,sha256=09blUNJI-VFPg7FXEgEHXMKffmFf82swNOLvSEgnS7o,4069
+livesync/livesync.py,sha256=gOFq8_mxAGEt3pXt_5EtlpFqLwE5sZwfbRsHiUh-F6k,1159
+livesync/mutex.py,sha256=nHaP0Tge3ZV7jyVBbYsMug5L5YkuJf8_XIbfAdVJkPc,1741
+livesync/run_subprocess.py,sha256=ZZqK9dlOVlJhL0xkKN7bG-BAT558nHk-IJNGqIMeWyM,368
+livesync/sync.py,sha256=r0CWptPcIvYs6uv9iV_JM7My360dSHMeFYAISntpQTA,1446
+LiveSync-0.3.1.dist-info/LICENSE,sha256=QcBlwggRQYhvfTAE481AAMFQfMS_N6Bj8Svh1T6dsnI,1072
+LiveSync-0.3.1.dist-info/METADATA,sha256=kDBdMh9Jd3VQyhCCein4Dij5fBABstkS0ixEfOB3PeM,4576
+LiveSync-0.3.1.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+LiveSync-0.3.1.dist-info/entry_points.txt,sha256=4dn5YR27lUlJWea3yqLKLqR4MwqjcqzMR5Q4jVFnytI,52
+LiveSync-0.3.1.dist-info/top_level.txt,sha256=mLwExc6wTUGqxvUkYMio5rxGS1h8bvxpNsR2ebfjSL4,9
+LiveSync-0.3.1.dist-info/RECORD,,

{LiveSync-0.2.2.dist-info → LiveSync-0.3.1.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,97 +1,93 @@
+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 {}
-
-
-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_excludes())
-
+        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_excludes(self) -> List[str]:
-        return ['.git/', '__pycache__/', '.DS_Store', '*.tmp', '.env'] + \
-            self._parse_ignore_file(self.local_path / '.syncignore') + \
-            self._parse_ignore_file(self.local_path / '.gitignore')
-
-    @staticmethod
-    def _parse_ignore_file(path: Path) -> List[str]:
+        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():
-            return []
-        with path.open() as f:
-            return [line.strip() for line in f.readlines() if not line.startswith('#')]
+            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():
+        summary = f'{self.source_path} --> {self.target}\n'
+        if not (self.source_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()
+            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
         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_excludes())
-        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,79 +1,24 @@
 #!/usr/bin/env python3
 import argparse
-import asyncio
-import json
-import sys
-from pathlib import Path
-from typing import List
 
-from livesync import Folder, Mutex, Target
+from livesync import Folder, sync
 
 
-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 workspace with remote machine')
+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('--source', type=str, help='source folder on local host instead of VSCode workspace file')
     parser.add_argument('--mutex-interval', type=int, default=10, help='interval in which mutex is updated')
-    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('host', type=str, help='the target host (e.g. username@hostname)')
+    parser.add_argument('rsync_args', nargs=argparse.REMAINDER, help='arbitrary rsync parameters after "--"')
     args = parser.parse_args()
-    target = Target(host=args.host, port=args.target_port, root=Path(args.target_root))
-
-    folders: List[Folder] = []
-    workspaces = list(Path.cwd().glob('*.code-workspace'))
-    if args.source is None and workspaces:
-
-        if len(workspaces) > 1:
-            print('Multiple VSCode workspace files found.')
-            print('Provide --source argument or run livesync in a directory with a single *.code-workspace file.')
-            sys.exit(1)
-
-        print(f'Reading VSCode workspace file {workspaces[0]}...')
-
-        workspace = json.loads(workspaces[0].read_text())
-        paths = [Path(f['path']) for f in workspace['folders']]
-        folders = [Folder(p, target) for p in paths if p.is_dir()]
-    else:
-        source_path = Path(args.source or '.')
-        if not source_path.is_dir():
-            print(f'Invalid source path: {source_path}')
-            sys.exit(1)
-
-        folders = [Folder(source_path, target)]
 
-    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)
 
 
 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,45 @@
+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) -> None:
+    try:
+        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:
+            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) -> None:
+    try:
+        asyncio.run(run_folder_tasks(folders, mutex_interval))
+    except KeyboardInterrupt:
+        print('Bye!')

LiveSync-0.2.2.dist-info/RECORD

@@ -1,10 +0,0 @@
-livesync/__init__.py,sha256=V9nt0JRzIeiiLDVNDMZ20SqLMSqFh8uPViPsp2WYK6g,60
-livesync/folder.py,sha256=-LlFfZCvtTc_fPOyRCsFLaH1zIwgVo62QgYCRV4ELP4,3774
-livesync/livesync.py,sha256=g2rNyVDkwksr_9yKBcpxIJmu_iQCvlSZFGRcGw_UtfM,2895
-livesync/mutex.py,sha256=C3Az3Exfgj1ohKnhWl77TDvuJlv3q2qieSgtJF__Wdc,1646
-LiveSync-0.2.2.dist-info/LICENSE,sha256=QcBlwggRQYhvfTAE481AAMFQfMS_N6Bj8Svh1T6dsnI,1072
-LiveSync-0.2.2.dist-info/METADATA,sha256=fq3iID0leIkx9zWyZgkQ9-N72Ff7iGYR4SQxTnNPodc,4031
-LiveSync-0.2.2.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
-LiveSync-0.2.2.dist-info/entry_points.txt,sha256=4dn5YR27lUlJWea3yqLKLqR4MwqjcqzMR5Q4jVFnytI,52
-LiveSync-0.2.2.dist-info/top_level.txt,sha256=mLwExc6wTUGqxvUkYMio5rxGS1h8bvxpNsR2ebfjSL4,9
-LiveSync-0.2.2.dist-info/RECORD,,