dfsync 0.4.8__tar.gz → 0.4.10__tar.gz

{dfsync-0.4.8 → dfsync-0.4.10}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: dfsync
-Version: 0.4.8
+Version: 0.4.10
 Summary: 
 Author: Mihai Balint
 Author-email: balint.mihai@gmail.com
@@ -11,6 +11,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: black (==24.3.0)
 Requires-Dist: click (>=8,<9)
 Requires-Dist: click-default-group (>=1.2.2,<2.0.0)

{dfsync-0.4.8 → dfsync-0.4.10}/dfsync/filters.py

@@ -1,4 +1,5 @@
-import black, fnmatch
+import black
+import fnmatch
 import os.path
 import git.exc
 import subprocess
@@ -111,6 +112,10 @@ class UntrackedGitFilesFilter(LoggingFilter):
         self._repos = {}
         self._is_repo_initialized = {}
         self._untracked_and_ignored_files = {}
+        self._should_filter_untracked_files = True
+
+    def set_should_filter_untracked_files(self, should_filter_untracked_files: bool = True):
+        self._should_filter_untracked_files = should_filter_untracked_files
 
     def get_untracked_and_ignored_files(self):
         flat_files = []
@@ -175,13 +180,17 @@ class UntrackedGitFilesFilter(LoggingFilter):
             self._ignore(src_file_path, "GIT repo internals")
             return True
 
-        for rel_file_path in repo.untracked_files:
-            abs_file_path = os.path.join(repo.working_dir, rel_file_path)
-            if src_abs_path == abs_file_path:
-                self._ignore(src_file_path, "Untracked GIT file")
-                return True
+        if self._should_filter_untracked_files and self._is_untracked_file(repo, src_abs_path):
+            self._ignore(src_file_path, "Untracked GIT file")
+            return True
+
         return False
 
+    def _is_untracked_file(self, repo, src_abs_path):
+        return any(
+            src_abs_path == os.path.join(repo.working_dir, rel_file_path) for rel_file_path in repo.untracked_files
+        )
+
 
 USER_FILTERS = [EmacsBufferFilter(), PythonBlackFilter()]
 GIT_FILTER = UntrackedGitFilesFilter()
@@ -215,3 +224,7 @@ def add_user_filter(f: LoggingFilter):
 
 def add_user_ignored_patterns_filter(patterns: [str]):
     add_user_filter(UserConfigFilter(patterns))
+
+
+def set_ignore_untracked_files(should_ignore_untracked_files: bool):
+    GIT_FILTER.set_should_filter_untracked_files(should_ignore_untracked_files)

dfsync-0.4.10/dfsync/lib.py

@@ -0,0 +1,101 @@
+from enum import Enum
+import platform
+import subprocess
+import time
+import threading
+
+
+class ThreadedOperationsManager:
+    def __init__(self):
+        self.threads = []
+
+    def stop(self, *args, **kwargs):
+        for thread in self.threads:
+            thread.stop(*args, **kwargs)
+
+    def register_threaded_operation(self, op):
+        self.threads.append(op)
+
+
+thread_manager = ThreadedOperationsManager()
+
+
+class ControlledThreadedOperation:
+    def __init__(self):
+        self._running = False
+        self._thread = threading.Thread(target=self.run)
+        thread_manager.register_threaded_operation(self)
+
+    def start(self):
+        self._running = True
+        self._thread.start()
+
+    def stop(self, *args, **kwargs):
+        self._running = False
+
+    @property
+    def is_running(self):
+        return self._running
+
+    @property
+    def is_completed(self):
+        return self._running is False
+
+    def run(self):
+        while self._running:
+            try:
+                self._run_once()
+            except Exception:
+                time.sleep(0.001)
+
+    def _run_once(self):
+        time.sleep(0.001)
+
+
+class RsyncFlavour(Enum):
+    SAMBA_RSYNC = "SAMBA_RSYNC"
+    OPEN_RSYNC = "OPENRSYNC"
+
+    @property
+    def executable(self):
+        if platform.system() == "Darwin":  # Check if running on macOS
+            if self == RsyncFlavour.SAMBA_RSYNC:
+                return "/opt/homebrew/bin/rsync"
+            elif self == RsyncFlavour.OPEN_RSYNC:
+                return "/usr/bin/rsync"
+
+        # Default fallback for other platforms or if paths don't exist
+        return "rsync"
+
+    @property
+    def exists_installed(self):
+        try:
+            # Check if the executable exists and is executable
+            result = subprocess.run(
+                ["which", self.executable], stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=False
+            )
+            if result.returncode != 0:
+                return False
+
+            # Additionally verify it can be executed
+            result = subprocess.run(
+                [self.executable, "--version"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=False
+            )
+            return result.returncode == 0
+        except Exception:
+            return False
+
+
+def check_rsync() -> RsyncFlavour:
+    try:
+        result = subprocess.run(["rsync", "--version"], capture_output=True, text=True)
+        version_text = result.stdout
+
+        if "rsync.samba.org/" in version_text:
+            return RsyncFlavour.SAMBA_RSYNC
+        else:
+            # Default to OpenRsync if we can't positively identify Samba rsync
+            return RsyncFlavour.OPEN_RSYNC
+    except (subprocess.SubprocessError, FileNotFoundError):
+        # If rsync isn't available or fails, default to Samba rsync
+        return RsyncFlavour.SAMBA_RSYNC

{dfsync-0.4.8 → dfsync-0.4.10}/dfsync/monitor.py

@@ -12,6 +12,8 @@ from functools import partial
 from watchdog.observers import Observer
 from watchdog.events import FileSystemEventHandler
 
+import dfsync.filters as filters
+import dfsync.lib as lib
 from dfsync.backends import rsync_backend, kube_backend
 from dfsync.distribution import (
     get_installed_version,
@@ -21,11 +23,9 @@ from dfsync.distribution import (
     is_installed_in_editable_mode,
     update_package,
 )
-from dfsync.filters import add_user_ignored_patterns_filter, ALL_FILTERS
 from dfsync.config import read_config
 from dfsync.char_ui import KeyController
 from dfsync.kube_credentials import contextualize_kube_credentials, update_local_kube_config, normalized_k8s_url
-from dfsync.lib import ControlledThreadedOperation, thread_manager
 
 logging.basicConfig(level=logging.WARN)
 
@@ -44,7 +44,11 @@ class RelatedLocationsError(ValueError):
     pass
 
 
-class FileChangedEventHandler(ControlledThreadedOperation, FileSystemEventHandler):
+class UnsupportedRsyncError(ValueError):
+    pass
+
+
+class FileChangedEventHandler(lib.ControlledThreadedOperation, FileSystemEventHandler):
     def __init__(
         self,
         backend: str = "log",
@@ -54,7 +58,7 @@ class FileChangedEventHandler(ControlledThreadedOperation, FileSystemEventHandle
         **kwargs,
     ):
         super().__init__()
-        self.filters = [*ALL_FILTERS]
+        self.filters = [*filters.ALL_FILTERS]
 
         self.backend = backend
         self.backend_options = kwargs
@@ -258,11 +262,15 @@ def main():
     pass
 
 
-@main.command()
+@main.command(add_help_option=False)
 def version():
     """
     Print the currently installed version
     """
+    _version()
+
+
+def _version():
     installed_version = get_installed_version()
     click.echo(f"{installed_version}")
 
@@ -275,7 +283,16 @@ def version():
         click.echo(f"Latest version is {latest_version}, please update using `dfsync self-update`")
 
 
-@main.command()
+@main.command(name="help", add_help_option=False)
+def help():
+    """
+    Print the usage/help for dfsync
+    """
+    with click.Context(sync, info_name="dfsync", max_content_width=999) as ctx:
+        click.echo(sync.get_help(ctx))
+
+
+@main.command(add_help_option=False)
 def self_update():
     """
     Update dfsync to the latest version published on pypi
@@ -309,11 +326,15 @@ def import_kube_host(kube_host=None, credentials=None):
 @main.command()
 @click.argument("source", nargs=-1)
 @click.argument("destination", default="", nargs=1)
-@click.option("--supervisor/--no-supervisor", default=False, help="Try to install supervisor in container", type=bool)
+@click.option("--supervisor", is_flag=True, default=False, help="Try to install supervisor in container")
 @click.option("--kube-host", default=None, help="Kubernetes api host server address/hostname", type=str)
 @click.option("--pod-timeout", default=30, help="Pod reconfiguration timeout (default is 30 seconds)", type=int)
 @click.option("--full-sync/--no-full-sync", default=True, help="On startup, sync all files to destination", type=bool)
-def sync(source, destination, supervisor, kube_host, pod_timeout, full_sync):
+@click.option("--version", is_flag=True, default=False, help="Print the currently installed version")
+@click.option(
+    "--sync-git-untracked", is_flag=True, default=False, help="Sync git-untracked files instead of ignoring them"
+)
+def sync(source, destination, supervisor, kube_host, pod_timeout, full_sync, version, sync_git_untracked):
     """
     Watches a folder for changes and propagates all file changes to a destination.
 
@@ -353,7 +374,14 @@ def sync(source, destination, supervisor, kube_host, pod_timeout, full_sync):
 
     paths = ["."] if len(source) == 0 else source
     config = read_config(destination, *paths)
-    add_user_ignored_patterns_filter(config.ignore_files)
+    filters.add_user_ignored_patterns_filter(config.ignore_files)
+
+    if sync_git_untracked:
+        filters.set_ignore_untracked_files(False)
+
+    if version:
+        _version()
+        return
 
     destination_dir = destination
     if len(source) == 0 and config.destination and not has_destination_optics(destination):
@@ -370,6 +398,11 @@ def sync(source, destination, supervisor, kube_host, pod_timeout, full_sync):
         elif len(missing) > 0:
             click.echo(f"Using source file/dirs {', '.join(paths)}")
 
+        installed_rsync = lib.check_rsync()
+        click.echo(f"Installed: {installed_rsync.executable}")
+        if installed_rsync != lib.RsyncFlavour.SAMBA_RSYNC:
+            raise UnsupportedRsyncError()
+
         backend_options = dict(
             destination_dir=destination_dir,
             supervisor=supervisor,
@@ -398,6 +431,14 @@ def sync(source, destination, supervisor, kube_host, pod_timeout, full_sync):
         click.echo(str(e))
         return -1
 
+    except UnsupportedRsyncError:
+        click.echo(
+            "\nStarting from Mac OSX Sequoia 15.4, Apple are shipping openrsync instead of the GPL-licensed rsync from Samba"
+            "\nThe Apple version of rsync has less features and is currently not supported by dfsync"
+            "\nPlease use homebrew to install the GPL-licensed rsync from Samba with this command `brew install rsync`."
+        )
+        return -1
+
     except ValueError as e:
         click.echo(
             "Trying {} from source: {} to destination: '{}'\n".format(
@@ -430,7 +471,7 @@ def sync(source, destination, supervisor, kube_host, pod_timeout, full_sync):
     controller.on_key(
         "x",
         description="to exit",
-        action=partial(thread_manager.stop, "Exiting."),
+        action=partial(lib.thread_manager.stop, "Exiting."),
     )
 
     try:
@@ -456,16 +497,16 @@ def sync(source, destination, supervisor, kube_host, pod_timeout, full_sync):
             controller.raise_exceptions()
 
     except KeyboardInterrupt:
-        thread_manager.stop()
+        lib.thread_manager.stop()
         click.echo("Received [Ctrl-C], exiting.")
 
     except:
-        thread_manager.stop()
+        lib.thread_manager.stop()
         raise
 
     finally:
         observer.stop()
-        thread_manager.stop()
+        lib.thread_manager.stop()
         backend_engine.on_monitor_exit(**backend_options)
         if observer.ident is not None:
             # only join the observer if it was previously started

{dfsync-0.4.8 → dfsync-0.4.10}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "dfsync"
-version = "0.4.8"
+version = "0.4.10"
 description = ""
 authors = ["Mihai Balint <balint.mihai@gmail.com>"]
 

dfsync-0.4.8/dfsync/lib.py

@@ -1,49 +0,0 @@
-import time
-import threading
-
-
-class ThreadedOperationsManager:
-    def __init__(self):
-        self.threads = []
-
-    def stop(self, *args, **kwargs):
-        for thread in self.threads:
-            thread.stop(*args, **kwargs)
-
-    def register_threaded_operation(self, op):
-        self.threads.append(op)
-
-
-thread_manager = ThreadedOperationsManager()
-
-
-class ControlledThreadedOperation:
-    def __init__(self):
-        self._running = False
-        self._thread = threading.Thread(target=self.run)
-        thread_manager.register_threaded_operation(self)
-
-    def start(self):
-        self._running = True
-        self._thread.start()
-
-    def stop(self, *args, **kwargs):
-        self._running = False
-
-    @property
-    def is_running(self):
-        return self._running
-
-    @property
-    def is_completed(self):
-        return self._running is False
-
-    def run(self):
-        while self._running:
-            try:
-                self._run_once()
-            except Exception:
-                time.sleep(0.001)
-
-    def _run_once(self):
-        time.sleep(0.001)