livesync 0.5.0__py3-none-any.whl

livesync/__init__.py

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

livesync/folder.py

@@ -0,0 +1,130 @@
+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:
+    """Represents a folder to be synchronized with a remote target via rsync over SSH."""
+    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,
+                 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:
+        """Add, remove, or replace rsync arguments for this 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))
+        ignores = [line.strip() for line in path.read_text().splitlines() if not line.startswith('#')]
+        ignores += [ignore.rstrip('/\\') for ignore in ignores if ignore.endswith('/') or ignore.endswith('\\')]
+        return ignores
+
+    def get_summary(self) -> str:
+        """Return a summary of the folder's source and target paths, along with git revision information if applicable."""
+        summary = f'{self.source_path} --> {self.target}\n'
+        try:
+            cmd = ['git', 'rev-parse', '--is-inside-work-tree']
+            subprocess.run(cmd, check=True, cwd=self.source_path, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        except (subprocess.CalledProcessError, FileNotFoundError):
+            pass  # not a git repo or git is not installed
+        else:
+            if version := self._build_version():
+                summary += f'[{version}]\n'
+            cmd = ['git', 'status', '--short', '--branch']
+            summary += subprocess.check_output(cmd, cwd=self.source_path).decode().strip() + '\n'
+        return summary
+
+    def _build_version(self) -> str:
+        """Build a dunamai-style version string from git, e.g. `0.1.0.post43.dev0+3f6ee0e`.
+
+        The nearest tag is the base version, the number of commits since then is `.post<distance>.dev0`,
+        and the short commit hash is appended as `+<hash>` (always, so the exact revision is included
+        even when sitting right on a tag: `<base>.post0.dev0+<hash>`). With no tag the base is `0.0.0`
+        and the distance is the total number of commits. Returns '' if the repo has no commit yet.
+        No dunamai dependency; uncommon cases (custom tag patterns, pre-releases, epochs, dirty
+        markers) are not replicated.
+        """
+        try:
+            cmd = ['git', 'rev-parse', '--short', 'HEAD']
+            commit = subprocess.check_output(cmd, cwd=self.source_path, stderr=subprocess.PIPE).decode().strip()
+        except subprocess.CalledProcessError:
+            return ''  # no commit yet
+        try:
+            cmd = ['git', 'describe', '--tags', '--abbrev=0']
+            tag = subprocess.check_output(cmd, cwd=self.source_path, stderr=subprocess.PIPE).decode().strip()
+            base = tag.removeprefix('v') if tag[1:2].isdigit() else tag
+            cmd = ['git', 'rev-list', f'refs/tags/{tag}..HEAD', '--count']
+        except subprocess.CalledProcessError:
+            base = '0.0.0'  # no tags -> 0.0.0 with the total commit count as distance
+            cmd = ['git', 'rev-list', 'HEAD', '--count']
+        try:
+            distance = subprocess.check_output(cmd, cwd=self.source_path, stderr=subprocess.PIPE).decode().strip()
+        except subprocess.CalledProcessError:
+            return ''  # e.g. a shallow clone where the found tag is not reachable
+        return f'{base}.post{distance}.dev0+{commit}'
+
+    async def watch(self) -> None:
+        """Watch the source folder for changes and synchronize to the target when changes occur."""
+        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)
+                await self.sync()
+        except RuntimeError as e:
+            if 'Already borrowed' not in str(e):
+                raise
+
+    async def sync(self) -> None:
+        """Synchronize the source folder to the target using rsync over SSH, and run the on_change command if specified."""
+        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
+        await run_subprocess(f'rsync {args} "{self.source_path}/" "{self.target}/"', quiet=True)
+        if isinstance(self.on_change, str):
+            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

@@ -0,0 +1,28 @@
+#!/usr/bin/env python3
+import argparse
+
+from livesync import Folder, sync
+
+
+def main():
+    """Main entry point for the livesync command-line tool."""
+    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('--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, watch=not args.no_watch)
+
+
+if __name__ == '__main__':
+    main()

livesync/mutex.py

@@ -0,0 +1,61 @@
+import asyncio
+import logging
+import socket
+from datetime import datetime, timedelta
+from typing import Optional
+
+
+class Mutex:
+    """A simple mutex mechanism to prevent concurrent synchronization to the same target host."""
+    DEFAULT_FILEPATH = '~/.livesync_mutex'
+
+    def __init__(self, host: str, port: int) -> None:
+        self.host = host
+        self.port = port
+        self.occupant: Optional[str] = None
+        self.user_id = socket.gethostname()
+
+    @property
+    def tag(self) -> str:
+        """Unique tag for this mutex, based on the user ID and current timestamp."""
+        return f'{self.user_id} {datetime.now().isoformat()}'
+
+    async def set(self, info: str) -> bool:
+        """Attempt to set the mutex on the target host with the given info and return whether successful."""
+        if not await self._is_free():
+            return False
+        try:
+            # NOTE: pass the content via stdin so the remote shell does not interpret it
+            await self._run_ssh_command(f'cat > {self.DEFAULT_FILEPATH}', stdin=f'{self.tag}\n{info}\n')
+            return True
+        except RuntimeError:
+            print('Could not write mutex file')
+            return False
+
+    async def _is_free(self) -> bool:
+        try:
+            command = f'[ -f {self.DEFAULT_FILEPATH} ] && cat {self.DEFAULT_FILEPATH} || echo'
+            output = (await 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])
+            mutex_expired = datetime.now() - mutex_datetime > timedelta(seconds=15)
+            return occupant_ok or mutex_expired
+        except Exception:  # pylint: disable=broad-except
+            logging.exception('Could not access target system')
+            return False
+
+    async def _run_ssh_command(self, command: str, stdin: Optional[str] = None) -> str:
+        process = await asyncio.create_subprocess_exec(
+            'ssh', self.host, '-p', str(self.port), command,
+            stdin=asyncio.subprocess.PIPE if stdin is not None else None,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.DEVNULL,
+        )
+        stdout, _ = await process.communicate(stdin.encode() if stdin is not None else None)
+        if process.returncode != 0:
+            raise RuntimeError(f'SSH command failed with return code {process.returncode}')
+        return stdout.decode()

livesync/run_subprocess.py

@@ -0,0 +1,18 @@
+import asyncio
+import subprocess
+
+
+async def run_subprocess(command: str, *, quiet: bool = False) -> None:
+    """Run a subprocess asynchronously, capturing its output and raising an exception on failure."""
+    process = await asyncio.create_subprocess_shell(
+        command,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.STDOUT,
+    )
+    stdout, _ = await process.communicate()
+    assert process.returncode is not None  # the process has terminated after communicate()
+    if process.returncode != 0:
+        print(stdout.decode())
+        raise subprocess.CalledProcessError(process.returncode, command, stdout)
+    if not quiet:
+        print(stdout.decode())

livesync/sync.py

@@ -0,0 +1,70 @@
+import asyncio
+import sys
+from typing import Dict, Iterable, List, Tuple
+
+from .folder import Folder
+from .mutex import Mutex
+
+
+def sync(*folders: Folder, mutex_interval: float = 10, ignore_mutex: bool = False, watch: bool = True) -> None:
+    """Synchronize one or more folders, optionally watching for changes."""
+    try:
+        asyncio.run(_run_folder_tasks(folders, mutex_interval, ignore_mutex=ignore_mutex, watch=watch))
+    except KeyboardInterrupt:
+        print('Bye!')
+
+
+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 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)
+            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:
+                    tasks = await _renew_mutexes(folders, mutexes, tasks)
+                    if not tasks:
+                        print('No more folders to watch, exiting', flush=True)
+                        break
+                await asyncio.sleep(mutex_interval)
+    except Exception as e:  # pylint: disable=broad-except
+        print(e)
+
+
+async def _renew_mutexes(
+    folders: Iterable[Folder],
+    mutexes: Dict[str, Mutex],
+    tasks: List[Tuple[Folder, asyncio.Task]],
+) -> List[Tuple[Folder, asyncio.Task]]:
+    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)
+        for folder, task in tasks:
+            if folder.host == host:
+                task.cancel()
+        tasks = [(folder, task) for folder, task in tasks if folder.host != host]
+        del mutexes[host]
+    return tasks
+
+
+def _get_summary(folders: Iterable[Folder]) -> str:
+    return '\n'.join(folder.get_summary() for folder in folders).replace('"', '\'')

livesync-0.5.0.dist-info/METADATA

@@ -0,0 +1,186 @@
+Metadata-Version: 2.4
+Name: livesync
+Version: 0.5.0
+Summary: Repeatedly synchronize local workspace with a (slow) remote machine
+License-Expression: MIT
+License-File: LICENSE
+Keywords: sync,remote,watch,filesystem,development,deploy,live,hot,reload
+Author: Zauberzeug GmbH
+Author-email: info@zauberzeug.com
+Requires-Python: >=3.10
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: pathspec
+Requires-Dist: watchfiles
+Project-URL: Repository, https://github.com/zauberzeug/livesync
+Description-Content-Type: text/markdown
+
+# LiveSync
+
+Repeatedly synchronize local workspace with a (slow) remote machine.
+It is available as [PyPI package](https://pypi.org/project/livesync/) and hosted on [GitHub](https://github.com/zauberzeug/livesync).
+
+[![PyPI version](https://badge.fury.io/py/livesync.svg)](https://pypi.org/project/livesync/)
+[![PyPI - Downloads](https://img.shields.io/pypi/dm/livesync)](https://pypi.org/project/livesync/)
+[![GitHub commit activity](https://img.shields.io/github/commit-activity/m/zauberzeug/livesync)](https://github.com/zauberzeug/livesync/graphs/commit-activity)
+[![GitHub issues](https://img.shields.io/github/issues/zauberzeug/livesync)](https://github.com/zauberzeug/livesync/issues)
+[![GitHub license](https://img.shields.io/github/license/zauberzeug/livesync)](https://github.com/zauberzeug/livesync/blob/main/LICENSE)
+
+## Use Case
+
+[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, 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>
+```
+
+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)
+- `--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
+
+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.
+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.
+
+#### Version in the mutex
+
+The mutex file (`~/.livesync_mutex`) on the target contains, per folder, a block with the source path, the current git revision in brackets and the `git status`.
+If the source repository has git tags, LiveSync derives a [dunamai](https://github.com/mtkennerly/dunamai)-style version from them and writes it **into the brackets** instead of the bare commit hash, so the remote side can tell which revision it currently holds:
+
+```
+/path/to/navigation --> robot:~/navigation
+[0.1.0.post43.dev0+3f6ee0e]
+## main
+```
+
+The format is always `[<base>.post<N>.dev0+<short-hash>]`:
+
+- `<base>` is the latest tag (a leading `v` directly followed by a digit is stripped, as in `v1.2.3`), `<N>` the number of commits since that tag, and `<short-hash>` the current commit — so the exact revision is always included, even sitting right on a tag (`[0.1.0.post0.dev0+3f6ee0e]`).
+- Without any tag the base is `0.0.0` and the distance is the total number of commits, e.g. `[0.0.0.post12.dev0+63e867f]`.
+- A repository without any commit yet, or a source that is not a git repository, gets no revision brackets at all.
+
+The version is recomputed from git on every mutex update (roughly every `mutex_interval` seconds), so it stays live while syncing.
+It is derived purely from `git` (no extra dependency): this is close to dunamai's PEP 440 output but not identical (dunamai drops the `.post0.dev0+<hash>` suffix on an exact tag, and does not replicate custom tag patterns, pre-releases, epochs or dirty markers).
+The string contains no `"` characters, so it survives the `"`→`'` replacement LiveSync applies across the whole summary.
+
+**Parser contract for the target side:** read the content of the `[...]` brackets on the revision line of each folder block; it is `<base>.post<N>.dev0+<short-hash>`.
+If you only need the bare commit hash, take the part after the last `+`.
+
+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
+
+- 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.
+- 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`.
+
+## Installation
+
+```bash
+python3 -m pip install livesync
+```
+
+## Development
+
+For development we use [uv](https://docs.astral.sh/uv/):
+
+```bash
+git clone git@github.com:zauberzeug/livesync.git
+cd livesync
+uv sync
+```
+
+This creates a virtual environment in `.venv` with LiveSync installed in editable mode.
+Now you can change the code and run the `livesync` command with the modified code via `uv run livesync ...` (or activate the environment with `source .venv/bin/activate`).
+
+To run the unit tests:
+
+```bash
+uv run pytest
+```
+
+We use [pre-commit](https://pre-commit.com/) to keep `uv.lock` in sync with `pyproject.toml` and to run formatting (autopep8, isort) and linting (mypy, pylint).
+Install the git hooks once with:
+
+```bash
+uv run pre-commit install
+```
+
+## Testing
+
+We have build a small testing infrastructure with two docker containers.
+See [tests/README.md](https://github.com/zauberzeug/livesync/blob/main/tests/README.md) for details.
+
+## Releases
+
+Just create and push a new tag with the new version name (v0.2.1 for example).
+After a successful build a new release will be created.
+This should be edited to describe the changes in the release notes.
+

livesync-0.5.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+livesync/__init__.py,sha256=tZrvnAIpVuo9cQHMCvi6l2vup66NXPxRwyR5UBNtCTs,50
+livesync/folder.py,sha256=7lRQsud-nLDqJTtwmRqCPovEK-0_MfLKrLJl0lGOtqk,6653
+livesync/livesync.py,sha256=C1I-fDUcJ6w7AEweGETRK30MdoVWlbJF67rHK5q5oHo,1474
+livesync/mutex.py,sha256=CKZw357mhdHoa3Ib8VdIHWWvrhwCnIKx5Uer5Vu-A2c,2596
+livesync/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+livesync/run_subprocess.py,sha256=xpAAuc7u7vDeYFLFeQJccz4JVwpXg3IvroyU4EkfZbU,695
+livesync/sync.py,sha256=55kOp3Rw-sFEreiD22mnuCiF6Ku-8UVAddDvCM_edEA,2657
+livesync-0.5.0.dist-info/METADATA,sha256=icnRWHyKwUppzjvzPAhXHXY49eSMQ3E0epUcHZS9X6U,8057
+livesync-0.5.0.dist-info/WHEEL,sha256=eY7nduwzv-ldUxpzbRlxwvC693Hg6PX8bWDjEHjZ_dk,88
+livesync-0.5.0.dist-info/entry_points.txt,sha256=V6J1eEls4AAZ1oE5bE8T39OpCRIYBfij1ptnOs5M7U8,51
+livesync-0.5.0.dist-info/licenses/LICENSE,sha256=QcBlwggRQYhvfTAE481AAMFQfMS_N6Bj8Svh1T6dsnI,1072
+livesync-0.5.0.dist-info/RECORD,,

livesync-0.5.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.4.1
+Root-Is-Purelib: true
+Tag: py3-none-any

livesync-0.5.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+livesync=livesync.livesync:main
+

livesync-0.5.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Zauberzeug GmbH
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.