LiveSync 0.3.3__py3-none-any.whl → 0.4.0__py3-none-any.whl

livesync/folder.py

@@ -13,7 +13,7 @@ from .run_subprocess import run_subprocess
 
 
 class Folder:
-    DEFAULT_IGNORES = ['.git/', '__pycache__/', '.DS_Store', '*.tmp', '.env']
+    DEFAULT_IGNORES = ['.git/', '.jj/', '__pycache__/', '.DS_Store', '*.tmp', '.env', '.venv']
     DEFAULT_RSYNC_ARGS = ['--prune-empty-dirs', '--delete', '-a', '-v', '-z', '--checksum', '--no-t']
 
     def __init__(self,
@@ -79,18 +79,18 @@ class Folder:
                                                    watch_filter=lambda _, filepath: not self._ignore_spec.match_file(filepath)):
                 for change, filepath in changes:
                     print('?+U-'[change], filepath)
-                self.sync()
+                await self.sync()
         except RuntimeError as e:
             if 'Already borrowed' not in str(e):
                 raise
 
-    def sync(self) -> None:
+    async 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)
+        await 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}"')
+            await 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

@@ -14,12 +14,13 @@ def main():
     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('--no-watch', action='store_true', help='do not watch for changes')
     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)
+    sync(folder, mutex_interval=args.mutex_interval, ignore_mutex=args.ignore_mutex, watch=not args.no_watch)
 
 
 if __name__ == '__main__':

livesync/mutex.py

@@ -1,6 +1,6 @@
+import asyncio
 import logging
 import socket
-import subprocess
 from datetime import datetime, timedelta
 from typing import Optional
 
@@ -14,10 +14,10 @@ class Mutex:
         self.occupant: Optional[str] = None
         self.user_id = socket.gethostname()
 
-    def is_free(self) -> bool:
+    async def is_free(self) -> bool:
         try:
             command = f'[ -f {self.DEFAULT_FILEPATH} ] && cat {self.DEFAULT_FILEPATH} || echo'
-            output = self._run_ssh_command(command).strip()
+            output = (await self._run_ssh_command(command)).strip()
             if not output:
                 return True
             words = output.splitlines()[0].strip().split()
@@ -30,13 +30,13 @@ class Mutex:
             logging.exception('Could not access target system')
             return False
 
-    def set(self, info: str) -> bool:
-        if not self.is_free():
+    async def set(self, info: str) -> bool:
+        if not await self.is_free():
             return False
         try:
-            self._run_ssh_command(f'echo "{self.tag}\n{info}" > {self.DEFAULT_FILEPATH}')
+            await self._run_ssh_command(f'echo "{self.tag}\n{info}" > {self.DEFAULT_FILEPATH}')
             return True
-        except subprocess.CalledProcessError:
+        except RuntimeError:
             print('Could not write mutex file')
             return False
 
@@ -44,6 +44,13 @@ class Mutex:
     def tag(self) -> str:
         return f'{self.user_id} {datetime.now().isoformat()}'
 
-    def _run_ssh_command(self, command: str) -> str:
-        ssh_command = ['ssh', self.host, '-p', str(self.port), command]
-        return subprocess.check_output(ssh_command, stderr=subprocess.DEVNULL).decode()
+    async def _run_ssh_command(self, command: str) -> str:
+        process = await asyncio.create_subprocess_exec(
+            'ssh', self.host, '-p', str(self.port), command,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.DEVNULL,
+        )
+        stdout, _ = await process.communicate()
+        if process.returncode != 0:
+            raise RuntimeError(f'SSH command failed with return code {process.returncode}')
+        return stdout.decode()

livesync/run_subprocess.py

@@ -1,11 +1,16 @@
+import asyncio
 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
+async def run_subprocess(command: str, *, quiet: bool = False) -> None:
+    process = await asyncio.create_subprocess_shell(
+        command,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.STDOUT,
+    )
+    stdout, _ = await process.communicate()
+    if process.returncode != 0:
+        print(stdout.decode())
+        raise subprocess.CalledProcessError(process.returncode, command, stdout)
+    if not quiet:
+        print(stdout.decode())

livesync/sync.py

@@ -1,6 +1,6 @@
 import asyncio
 import sys
-from typing import Iterable
+from typing import Iterable, List, Tuple
 
 from .folder import Folder
 from .mutex import Mutex
@@ -10,38 +10,51 @@ 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:
+async def run_folder_tasks(
+        folders: Iterable[Folder],
+        mutex_interval: float, ignore_mutex: bool = False, watch: bool = True) -> 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):
+                if not await 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):
+            await folder.sync()
+
+        if watch:
+            tasks: List[Tuple[Folder, asyncio.Task]] = []
+            for folder in folders:
+                print(f'Watch folder {folder.source_path}', flush=True)
+                tasks.append((folder, asyncio.create_task(folder.watch())))
+
+            while True:
+                if not ignore_mutex:
+                    summary = get_summary(folders)
+
+                    for host in list(mutexes):
+                        if await mutexes[host].set(summary):
+                            continue
+                        print(f'Target {host} is in use by {mutexes[host].occupant}, stopping watch tasks', flush=True)
+                        [task.cancel() for folder, task in tasks if folder.host == host]
+                        tasks = [(folder, task) for folder, task in tasks if folder.host != host]
+                        del mutexes[host]
+
+                    if not tasks:
+                        print('No more folders to watch, exiting', flush=True)
                         break
-            await asyncio.sleep(mutex_interval)
+                await asyncio.sleep(mutex_interval)
     except Exception as e:
         print(e)
 
 
-def sync(*folders: Folder, mutex_interval: float = 10, ignore_mutex: bool = False) -> None:
+def sync(*folders: Folder, mutex_interval: float = 10, ignore_mutex: bool = False, watch: bool = True) -> None:
     try:
-        asyncio.run(run_folder_tasks(folders, mutex_interval, ignore_mutex=ignore_mutex))
+        asyncio.run(run_folder_tasks(folders, mutex_interval, ignore_mutex=ignore_mutex, watch=watch))
     except KeyboardInterrupt:
         print('Bye!')

{LiveSync-0.3.3.dist-info → livesync-0.4.0.dist-info}/METADATA

@@ -1,17 +1,28 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: LiveSync
-Version: 0.3.3
+Version: 0.4.0
 Summary: Repeatedly synchronize local workspace with a (slow) remote machine
 Home-page: https://github.com/zauberzeug/livesync
 Author: Zauberzeug GmbH
 Author-email: info@zauberzeug.com
 License: MIT
 Keywords: sync remote watch filesystem development deploy live hot reload
-Requires-Python: >=3.7
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: pathspec
 Requires-Dist: watchfiles
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 # LiveSync
 
@@ -64,6 +75,8 @@ Options:
   interval in which mutex is updated (default: 10 seconds)
 - `--ignore-mutex`
   ignore mutex (use with caution) (default: False)
+- `--no-watch`
+  don't keep watching the copied folders for changes after the sync (default: False)
 
 ### Python
 
@@ -79,6 +92,7 @@ sync(
 ```
 
 The `sync` call will block until the script is aborted.
+Only if `watch=False` is used, the `sync` call will end after copying the folders to the target once.
 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.
 

livesync-0.4.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+livesync/__init__.py,sha256=tZrvnAIpVuo9cQHMCvi6l2vup66NXPxRwyR5UBNtCTs,50
+livesync/folder.py,sha256=pl73eVZM5myiTtwRwkBYnHGutIUYgO7DMTiNcOmOUYg,4392
+livesync/livesync.py,sha256=_Y44zSuqZ6ZvwobNBdwGCqEYAU7n0lVoAHfDoBF6zPY,1411
+livesync/mutex.py,sha256=vNiuMSAW_KMKHvY5AHsm1cYvGUUalsWdx2ep40BPpJY,2024
+livesync/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+livesync/run_subprocess.py,sha256=9bUQ4EhErfBAdX5N3_NkZ4n1lJzy8vBOV2HiKnubhm0,502
+livesync/sync.py,sha256=xYJ4GR8HsqncRGjMHVC_kYJf1E7w2wg0pMMNTCYlJEI,2373
+livesync-0.4.0.dist-info/licenses/LICENSE,sha256=QcBlwggRQYhvfTAE481AAMFQfMS_N6Bj8Svh1T6dsnI,1072
+livesync-0.4.0.dist-info/METADATA,sha256=AMbyPkkg_maqytXg57Uo1em-KpwAKwyaVJpRdKEPdyM,5772
+livesync-0.4.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+livesync-0.4.0.dist-info/entry_points.txt,sha256=4dn5YR27lUlJWea3yqLKLqR4MwqjcqzMR5Q4jVFnytI,52
+livesync-0.4.0.dist-info/top_level.txt,sha256=mLwExc6wTUGqxvUkYMio5rxGS1h8bvxpNsR2ebfjSL4,9
+livesync-0.4.0.dist-info/RECORD,,

{LiveSync-0.3.3.dist-info → livesync-0.4.0.dist-info}/WHEEL

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

LiveSync-0.3.3.dist-info/RECORD

@@ -1,12 +0,0 @@
-livesync/__init__.py,sha256=tZrvnAIpVuo9cQHMCvi6l2vup66NXPxRwyR5UBNtCTs,50
-livesync/folder.py,sha256=E_HWXLW40fhoCW_NQh6liEe3gSW9ckIga6rYdQ3DEzc,4351
-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.3.dist-info/LICENSE,sha256=QcBlwggRQYhvfTAE481AAMFQfMS_N6Bj8Svh1T6dsnI,1072
-LiveSync-0.3.3.dist-info/METADATA,sha256=cke14IwKy3EKV267y4lceiPRLvyWqjBIY_f-0_7ZG-g,5335
-LiveSync-0.3.3.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-LiveSync-0.3.3.dist-info/entry_points.txt,sha256=4dn5YR27lUlJWea3yqLKLqR4MwqjcqzMR5Q4jVFnytI,52
-LiveSync-0.3.3.dist-info/top_level.txt,sha256=mLwExc6wTUGqxvUkYMio5rxGS1h8bvxpNsR2ebfjSL4,9
-LiveSync-0.3.3.dist-info/RECORD,,