remarkablesync 2.0.1__tar.gz → 2.0.3__tar.gz

{remarkablesync-2.0.1/remarkablesync.egg-info → remarkablesync-2.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remarkablesync
-Version: 2.0.1
+Version: 2.0.3
 Summary: Backup and convert reMarkable tablet notebooks to PDF
 Home-page: https://github.com/JeffSteinbok/RemarkableSync
 Author: Jeff Steinbok

{remarkablesync-2.0.1 → remarkablesync-2.0.3}/RemarkableSync.py

@@ -590,7 +590,13 @@ def main():
 
     if not has_command and '--version' not in sys.argv and '--help' not in sys.argv:
         # Load config to decide which pipeline to run
-        from src.config import load_config
+        from src.config import get_config_path, load_config
+
+        if not get_config_path().exists():
+            script_name = Path(sys.argv[0]).name or "RemarkableSync.py"
+            click.echo("[ERROR] No configuration found.", err=True)
+            click.echo(f"Run: python {script_name} config", err=True)
+            sys.exit(1)
 
         cfg = load_config()
         actions = cfg.get("sync_actions", [])
@@ -638,4 +644,3 @@ def main():
 
 if __name__ == "__main__":
     main()
-

{remarkablesync-2.0.1 → remarkablesync-2.0.3/remarkablesync.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remarkablesync
-Version: 2.0.1
+Version: 2.0.3
 Summary: Backup and convert reMarkable tablet notebooks to PDF
 Home-page: https://github.com/JeffSteinbok/RemarkableSync
 Author: Jeff Steinbok

{remarkablesync-2.0.1 → remarkablesync-2.0.3}/remarkablesync.egg-info/SOURCES.txt

@@ -48,15 +48,18 @@ src/ocr/ocr_engine.py
 src/utils/__init__.py
 src/utils/console.py
 src/utils/logging.py
+src/utils/name_registry.py
 tests/__init__.py
 tests/conftest.py
 tests/generate_test_assets.py
 tests/mock_ai_provider.py
 tests/mock_connection.py
+tests/test_agent_issues.py
 tests/test_ai_providers.py
 tests/test_auth_device_flow.py
 tests/test_basic.py
 tests/test_config.py
+tests/test_config_command.py
 tests/test_console.py
 tests/test_hybrid_converter.py
 tests/test_keyring_store.py

{remarkablesync-2.0.1 → remarkablesync-2.0.3}/src/__version__.py

@@ -1,4 +1,4 @@
 """Version information for RemarkableSync."""
 
-__version__ = "2.0.1"
+__version__ = "2.0.3"
 __repository__ = "https://github.com/JeffSteinbok/RemarkableSync"

{remarkablesync-2.0.1 → remarkablesync-2.0.3}/src/backup/backup_manager.py

@@ -48,6 +48,8 @@ class ReMarkableBackup:  # pylint: disable=too-many-instance-attributes
         host: str = "10.11.99.1",
         use_wifi: bool = False,
         wifi_host: str = "",
+        pre_sync_command: str = "",
+        post_sync_command: str = "",
     ):
         """Initialize backup orchestrator.
 
@@ -57,22 +59,24 @@ class ReMarkableBackup:  # pylint: disable=too-many-instance-attributes
             host: Tablet IP/hostname (USB default: 10.11.99.1)
             use_wifi: Connect via Wi-Fi instead of USB
             wifi_host: Wi-Fi IP/hostname (auto-discovered if empty)
+            pre_sync_command: Shell command to run before SSH connects.
+            post_sync_command: Shell command to run after SSH disconnects.
         """
         self.backup_dir = backup_dir
-        self.files_dir = backup_dir / "Notebooks"  # Clean folder name
-        self.templates_dir = backup_dir / "Templates"  # Clean folder name
+        self.files_dir = backup_dir / "Notebooks"
+        self.templates_dir = backup_dir / "Templates"
         self.metadata_file = backup_dir / "sync_metadata.json"
 
-        # Create directories
         self.files_dir.mkdir(parents=True, exist_ok=True)
         self.templates_dir.mkdir(parents=True, exist_ok=True)
 
-        # Initialize components
         self.connection = ReMarkableConnection(
             password=password,
             host=host,
             use_wifi=use_wifi,
             wifi_host=wifi_host,
+            pre_sync_command=pre_sync_command,
+            post_sync_command=post_sync_command,
         )
         self.metadata = FileMetadata(self.metadata_file)
 
@@ -173,23 +177,13 @@ class ReMarkableBackup:  # pylint: disable=too-many-instance-attributes
         print(f"  Found {len(allowed)} notebooks in selected folders")
         return allowed
 
-    def backup_files(
+    def _do_backup_files(
         self,
     ) -> Tuple[bool, Set[str], Dict[str, Set[str]]]:  # pylint: disable=too-many-branches
-        """Backup files from ReMarkable tablet.
-
-        Returns:
-            Tuple of (success, set of notebook UUIDs that were updated,
-            dict mapping notebook UUID to set of changed page IDs)
-        """
+        """Backup files from ReMarkable tablet. Assumes connection is already open."""
         logging.info("Starting file backup...")
-        print("  Connecting to tablet...")
-
-        if not self.connection.connect():
-            return False, set(), {}
 
         try:
-            # Resolve folder filter before listing files
             allowed_uuids = self._resolve_allowed_uuids()
 
             # Get list of remote files
@@ -298,7 +292,7 @@ class ReMarkableBackup:  # pylint: disable=too-many-instance-attributes
                         progress.update(task, advance=1, description=local_path.name[:40])
 
                     except (OSError, SCPException) as e:
-                        print_error(f"  [ERR] Failed to download {remote_file['path']}: {e}")
+                        print_error(f"  ERR - Failed to download {remote_file['path']}: {e}")
                         progress.update(task, advance=1)
 
             # Save metadata
@@ -316,23 +310,10 @@ class ReMarkableBackup:  # pylint: disable=too-many-instance-attributes
             logging.error("Backup failed: %s", e)
             return False, set(), {}
 
-        finally:
-            self.connection.disconnect()
-
-    def backup_templates(self) -> bool:
-        """Backup template files from ReMarkable tablet.
-
-        Templates are stored in /usr/share/remarkable/templates/ and include
-        PNG/SVG template images and a templates.json configuration file.
-
-        Returns:
-            bool: True if successful, False otherwise
-        """
+    def _do_backup_templates(self) -> bool:
+        """Backup template files from ReMarkable tablet. Assumes connection is already open."""
         logging.info("Starting template backup...")
 
-        if not self.connection.connect():
-            return False
-
         try:
             # Get list of template files
             remote_files = self.connection.list_files(self.remote_templates_dir)
@@ -373,7 +354,7 @@ class ReMarkableBackup:  # pylint: disable=too-many-instance-attributes
                         self.metadata.update_file_metadata(remote_file, local_path)
 
                     except (OSError, SCPException) as e:
-                        print_error(f"  [ERR] Failed to download {remote_file['path']}: {e}")
+                        print_error(f"  ERR - Failed to download {remote_file['path']}: {e}")
 
                     progress.update(task, advance=1, description=local_path.name[:40])
 
@@ -387,9 +368,6 @@ class ReMarkableBackup:  # pylint: disable=too-many-instance-attributes
             logging.error("Template backup failed: %s", e)
             return False
 
-        finally:
-            self.connection.disconnect()
-
     def find_notebooks(self) -> List[Dict]:
         """Find and parse notebook metadata.
 
@@ -465,7 +443,7 @@ class ReMarkableBackup:  # pylint: disable=too-many-instance-attributes
         force_convert_all: bool = False,
         convert_to_pdf: bool = False,
         backup_templates: bool = True,
-    ) -> bool:
+    ) -> Tuple[bool, Set[str], Dict[str, Set[str]]]:
         """Run complete backup process with optional PDF conversion.
 
         Args:
@@ -474,27 +452,34 @@ class ReMarkableBackup:  # pylint: disable=too-many-instance-attributes
             backup_templates: If True, backup template files from the tablet (default: True)
 
         Returns:
-            bool: True if backup successful, False otherwise
+            Tuple of (success, updated_notebook_uuids, updated_pages)
         """
         logging.info("Starting ReMarkable backup process")
 
-        # Backup files and get list of updated notebooks
-        success, updated_notebook_uuids, updated_pages = self.backup_files()
-        if not success:
-            return False
+        if not self.connection.connect():
+            return False, set(), {}
 
-        # Backup templates if requested
-        if backup_templates:
-            templates_success = self.backup_templates()
-            if not templates_success:
-                logging.warning("Template backup failed, but continuing with main backup")
+        updated_notebook_uuids: Set[str] = set()
+        updated_pages: Dict[str, Set[str]] = {}
+
+        try:
+            success, updated_notebook_uuids, updated_pages = self._do_backup_files()
+            if not success:
+                return False, set(), {}
+
+            if backup_templates:
+                templates_success = self._do_backup_templates()
+                if not templates_success:
+                    logging.warning("Template backup failed, but continuing with main backup")
+        finally:
+            self.connection.disconnect()
 
-        # Automatic PDF conversion using hybrid converter
         if convert_to_pdf:
-            return self.run_pdf_conversion(updated_notebook_uuids, force_convert_all, updated_pages)
+            ok = self.run_pdf_conversion(updated_notebook_uuids, force_convert_all, updated_pages)
+            return ok, updated_notebook_uuids, updated_pages
 
         logging.info("Backup process completed successfully")
-        return True
+        return True, updated_notebook_uuids, updated_pages
 
     def run_pdf_conversion(
         self,
@@ -527,34 +512,15 @@ class ReMarkableBackup:  # pylint: disable=too-many-instance-attributes
             output_dir = self.backup_dir / "PDF"
             logging.warning("No pdf_dir configured, falling back to %s", output_dir)
 
-        # Determine conversion strategy
-        updated_only_file = None
-        if force_convert_all:
-            logging.info("Force conversion enabled - converting all notebooks to PDF")
-        elif updated_notebook_uuids:
-            # Create a temporary file list of updated notebooks for selective conversion
-            updated_list_file = self.backup_dir / "updated_notebooks.txt"
-            try:
-                with open(updated_list_file, "w", encoding="utf-8") as f:
-                    for uuid in sorted(updated_notebook_uuids):
-                        f.write(f"{uuid}\n")
-
-                updated_only_file = updated_list_file
-                logging.info("Converting %d updated notebooks to PDF", len(updated_notebook_uuids))
-            except OSError as e:
-                logging.error("Failed to create updated notebooks list: %s", e)
-                return False
-        else:
+        if not updated_notebook_uuids and not force_convert_all:
             logging.info("No notebooks were updated - skipping PDF conversion")
             return True
 
-        # Load folder filter from config
         from ..config import load_config
 
         config = load_config()
         folder_filter = config.get("folders", []) or None
 
-        # Run conversion
         try:
             success, _converted = run_conversion(
                 backup_dir=self.backup_dir,
@@ -562,18 +528,11 @@ class ReMarkableBackup:  # pylint: disable=too-many-instance-attributes
                 verbose="INF",
                 sample=None,
                 notebook_filter=None,
-                updated_only=updated_only_file,
+                updated_uuids=updated_notebook_uuids if not force_convert_all else None,
                 updated_pages=updated_pages,
                 folder_filter=folder_filter,
             )
 
-            # Clean up temporary file if created
-            if updated_only_file and updated_only_file.exists():
-                try:
-                    updated_only_file.unlink()
-                except OSError:
-                    pass  # Ignore cleanup errors
-
             if success:
                 logging.info("PDF conversion completed successfully")
             else:

{remarkablesync-2.0.1 → remarkablesync-2.0.3}/src/backup/connection.py

@@ -19,6 +19,14 @@ import click
 import paramiko
 from scp import SCPClient
 
+from ..utils.console import print_error, print_success, print_warn
+
+# Suppress paramiko noise regardless of when setup_logging is called
+for _n in ("paramiko", "paramiko.transport", "paramiko.auth", "paramiko.channel"):
+    _l = logging.getLogger(_n)
+    _l.setLevel(logging.CRITICAL)
+    _l.propagate = False
+
 try:
     import keyring  # type: ignore
 
@@ -76,6 +84,8 @@ class ReMarkableConnection:
         password: str | None = None,
         use_wifi: bool = False,
         wifi_host: str = "",
+        pre_sync_command: str = "",
+        post_sync_command: str = "",
     ):
         """Initialize connection parameters.
 
@@ -89,6 +99,8 @@ class ReMarkableConnection:
                       Falls back to USB if *wifi_host* is empty.
             wifi_host: IP address or hostname of the tablet on the local
                        network.  Ignored when *use_wifi* is False.
+            pre_sync_command: Shell command to run before SSH connects.
+            post_sync_command: Shell command to run after SSH disconnects.
         """
         # Resolve effective host
         if use_wifi:
@@ -107,6 +119,8 @@ class ReMarkableConnection:
         self.scp_client = None
         self.password = password
         self.password_saved = False
+        self.pre_sync_command = pre_sync_command.strip()
+        self.post_sync_command = post_sync_command.strip()
 
     def get_saved_password(self) -> str | None:
         """Get saved password from system keyring.
@@ -188,13 +202,22 @@ class ReMarkableConnection:
     def connect(self) -> bool:
         """Establish SSH connection to ReMarkable tablet.
 
-        Attempts multiple connection strategies with different timeout values
-        to handle various network conditions and tablet responsiveness.
-        Handles password retry logic if saved password fails.
+        Runs the pre-sync command (if configured) before opening the SSH
+        connection, and the post-sync command (if configured) in disconnect().
 
         Returns:
             bool: True if connection successful, False otherwise
         """
+        if self.pre_sync_command:
+            from ..utils import run_shell_command
+
+            print(f"  Running pre-sync: {self.pre_sync_command}")
+            rc = run_shell_command(self.pre_sync_command)
+            if rc != 0:
+                print_error(f"  ERR - Pre-sync command failed (exit {rc})")
+                return False
+            print_success("  OK - Pre-sync done")
+
         max_password_retries = 3
         password_attempt = 0
         used_saved_password = False
@@ -246,7 +269,7 @@ class ReMarkableConnection:
                         logging.warning("Authentication failed on attempt %d: %s", i + 1, e)
                         # Authentication failed - might be wrong password
                         if used_saved_password:
-                            print("\nSaved password appears to be incorrect.")
+                            print_warn("  WRN - Saved password appears to be incorrect.")
                             if click.confirm(
                                 "Would you like to enter a new password?", default=True
                             ):
@@ -263,13 +286,14 @@ class ReMarkableConnection:
                                 else:
                                     return False
                         else:
-                            # User-entered password was wrong
-                            print("\nAuthentication failed. Please check your password.")
+                            print_error(
+                                "  ERR - Authentication failed. Please check your password."
+                            )
                             self.password = None
                             password_attempt += 1
                             break
                     except (paramiko.SSHException, OSError) as e:
-                        logging.warning("Connection attempt %d failed: %s", i + 1, e)
+                        logging.debug("Connection attempt %d failed: %s", i + 1, e)
                         if self.ssh_client:
                             try:
                                 self.ssh_client.close()
@@ -278,28 +302,44 @@ class ReMarkableConnection:
                             self.ssh_client = paramiko.SSHClient()
                             self.ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
 
-                logging.error("All connection attempts failed")
+                logging.debug("All connection attempts failed")
+
+                print_error(
+                    f"  ERR - Connection to {self.host} failed. "
+                    "Check that the tablet is connected and try again."
+                )
                 return False
 
             except (paramiko.SSHException, OSError) as e:
-                logging.error("Failed to connect to ReMarkable: %s", e)
+                logging.debug("Failed to connect to ReMarkable: %s", e)
+                print_error(
+                    f"  ERR - Connection to {self.host} failed. "
+                    "Check that the tablet is connected and try again."
+                )
                 return False
 
-        print("\nMaximum password retry attempts reached.")
+        print_error("  ERR - Maximum password retry attempts reached.")
         return False
 
     def disconnect(self):
-        """Close SSH and SCP connections to ReMarkable tablet.
-
-        Safely closes both SCP and SSH client connections,
-        ensuring clean disconnection from the tablet.
-        """
+        """Close SSH and SCP connections to ReMarkable tablet."""
+        print("  Disconnecting...")
         if self.scp_client:
             self.scp_client.close()
         if self.ssh_client:
             self.ssh_client.close()
         logging.info("Disconnected from ReMarkable tablet")
 
+        if self.post_sync_command:
+            from ..utils import run_shell_command
+
+            print(f"  Running post-sync: {self.post_sync_command}")
+            rc = run_shell_command(self.post_sync_command)
+            if rc != 0:
+                print_error(f"  ERR - Post-sync command failed (exit {rc})")
+            else:
+                print_success("  OK - Post-sync done")
+
     def execute_command(self, command: str) -> Tuple[str, str, int]:
         """Execute command on ReMarkable tablet via SSH.
 

{remarkablesync-2.0.1 → remarkablesync-2.0.3}/src/commands/backup_command.py

@@ -34,7 +34,8 @@ def run_backup_command(
     Returns:
         Exit code (0 for success, 1 for failure)
     """
-    setup_logging(log_level, log_dir=backup_dir)
+    log_dir = backup_dir.parent
+    setup_logging(log_level, log_dir=log_dir)
 
     print("ReMarkable Tablet Backup")
     print("=" * 70)