LiveSync 0.3.1__tar.gz → 0.3.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: LiveSync
-Version: 0.3.1
+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,8 +26,9 @@ 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
@@ -59,10 +60,12 @@ Options:
   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:
+Simple example (where `robot` is the ssh hostname of the target system):
 
 ```py
 from livesync import Folder, sync
@@ -73,14 +76,25 @@ sync(
 )
 ```
 
+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('.', 'robot:~/navigation', on_change='touch ~/navigation/main.py'),
-    Folder('../rosys', 'robot:~/rosys', ssh_port=2222).rsync_args(add='-L', remove='--checksum'),
+    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,
 )
 ```

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: LiveSync
-Version: 0.3.1
+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,8 +26,9 @@ 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
@@ -59,10 +60,12 @@ Options:
   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:
+Simple example (where `robot` is the ssh hostname of the target system):
 
 ```py
 from livesync import Folder, sync
@@ -73,14 +76,25 @@ sync(
 )
 ```
 
+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('.', 'robot:~/navigation', on_change='touch ~/navigation/main.py'),
-    Folder('../rosys', 'robot:~/rosys', ssh_port=2222).rsync_args(add='-L', remove='--checksum'),
+    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,
 )
 ```

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

@@ -13,8 +13,9 @@ 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
@@ -46,10 +47,12 @@ Options:
   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:
+Simple example (where `robot` is the ssh hostname of the target system):
 
 ```py
 from livesync import Folder, sync
@@ -60,14 +63,25 @@ sync(
 )
 ```
 
+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('.', 'robot:~/navigation', on_change='touch ~/navigation/main.py'),
-    Folder('../rosys', 'robot:~/rosys', ssh_port=2222).rsync_args(add='-L', remove='--checksum'),
+    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,
 )
 ```

{LiveSync-0.3.1 → LiveSync-0.3.2}/livesync/folder.py

@@ -59,15 +59,13 @@ class Folder:
 
     def get_summary(self) -> str:
         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.source_path).decode()
             cmd = ['git', 'status', '--short', '--branch']
             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) -> None:
@@ -86,7 +84,7 @@ class Folder:
         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)
+        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):

{LiveSync-0.3.1 → LiveSync-0.3.2}/livesync/livesync.py

@@ -13,12 +13,13 @@ def main():
     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)
+    sync(folder, mutex_interval=args.mutex_interval, ignore_mutex=args.ignore_mutex)
 
 
 if __name__ == '__main__':

{LiveSync-0.3.1 → LiveSync-0.3.2}/livesync/sync.py

@@ -10,15 +10,16 @@ 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:
+async def run_folder_tasks(folders: Iterable[Folder], mutex_interval: float, ignore_mutex: bool = False) -> 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)
+        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)
@@ -29,17 +30,18 @@ async def run_folder_tasks(folders: Iterable[Folder], mutex_interval: float) ->
             asyncio.create_task(folder.watch())
 
         while True:
-            summary = get_summary(folders)
-            for mutex in mutexes.values():
-                if not mutex.set(summary):
-                    break
+            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) -> None:
+def sync(*folders: Folder, mutex_interval: float = 10, ignore_mutex: bool = False) -> None:
     try:
-        asyncio.run(run_folder_tasks(folders, mutex_interval))
+        asyncio.run(run_folder_tasks(folders, mutex_interval, ignore_mutex=ignore_mutex))
     except KeyboardInterrupt:
         print('Bye!')