remarkablesync 2.0.1__tar.gz → 2.0.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remarkablesync
-Version: 2.0.1
+Version: 2.0.2
 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.2/remarkablesync.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remarkablesync
-Version: 2.0.1
+Version: 2.0.2
 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.2}/remarkablesync.egg-info/SOURCES.txt

@@ -48,6 +48,7 @@ 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

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

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

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

@@ -298,7 +298,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
@@ -373,7 +373,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])
 
@@ -527,34 +527,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 +543,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.2}/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)

{remarkablesync-2.0.1 → remarkablesync-2.0.2}/src/commands/config_command.py

@@ -102,13 +102,11 @@ def run_config_command() -> int:
                 click.echo("    5. Re-run this wizard with the IP ready")
                 return 1
 
-        # Let user confirm/change the IP (pre-filled from device or config)
-        default_ip = wifi_host or current.get("wifi_host", "") or "192.168.1."
+        # Let user confirm/change the IP (pre-filled from device or config; blank if unknown)
+        default_ip = wifi_host or current.get("wifi_host", "") or ""
         wifi_host = inquirer.text(
             message="Tablet WiFi IP address:",
             default=default_ip,
-            validate=lambda x: len(x.strip()) > 0,
-            invalid_message="IP address cannot be empty.",
         ).execute()
 
         if wifi_host is None:
@@ -163,24 +161,36 @@ def run_config_command() -> int:
         backup_dir = _default_backup_dir()
         click.echo(f"  Using default: {backup_dir}")
 
-    # 5. Sync actions
-    current_actions = current.get("sync_actions", ["backup", "pdf"])
-    action_choices = [
-        {"name": display, "value": value, "enabled": value in current_actions}
-        for value, display in SYNC_ACTIONS
-    ]
+    # 5. Sync actions — later steps imply earlier ones (backup → pdf → ocr)
+    action_order = [value for value, _ in SYNC_ACTIONS]
+    current_actions = current.get("sync_actions", ["backup", "pdf", "ocr"])
+    if not current_actions:
+        current_actions = action_order
+
+    # Build cascade choices: each option enables all steps up to and including it
+    cascade_labels = {
+        "backup": "Backup only",
+        "pdf": "Backup + PDF Conversion",
+        "ocr": "Backup + PDF Conversion + AI OCR & Markdown Export",
+    }
+    highest_current = max(
+        (action_order.index(a) for a in current_actions if a in action_order), default=0
+    )
+    default_action = action_order[highest_current]
 
-    sync_actions = inquirer.checkbox(
+    chosen = inquirer.select(
         message="What to do on sync:",
-        choices=action_choices,
-        validate=lambda result: len(result) >= 1,
-        invalid_message="Select at least one sync action.",
+        choices=[{"name": cascade_labels[value], "value": value} for value, _ in SYNC_ACTIONS],
+        default=default_action,
     ).execute()
 
-    if sync_actions is None:
+    if chosen is None:
         click.echo("Configuration cancelled.")
         return 0
 
+    # Cascade: all steps up to and including the chosen step
+    sync_actions = action_order[: action_order.index(chosen) + 1]
+
     # 6. PDF output directory (if PDF or OCR selected)
     from src.config import _default_documents_dir
 
@@ -412,7 +422,7 @@ def run_config_command() -> int:
         click.echo(f"  Images:  {'yes (_images/ folder)' if embed_images else 'no'}")
         click.echo(f"  AI:      {ai_provider} ({ai_model})")
         has_token = bool(github_token or claude_api_key)
-        click.echo(f"  Token:   {'[OK] saved in keyring' if has_token else '(not set)'}")
+        click.echo(f"  Token:   {'OK - saved in keyring' if has_token else '(not set)'}")
     click.echo()
 
     return 0
@@ -456,14 +466,14 @@ def _enable_wifi_ssh(password: str) -> str:
     try:
         from src.backup.connection import USB_HOST, ReMarkableConnection
     except ImportError:
-        click.echo("  [WARN] Could not import connection module.")
+        click.echo("  WRN - Could not import connection module.")
         return ""
 
     conn = ReMarkableConnection(password=password, host=USB_HOST)
     click.echo("  Connecting via USB...")
 
     if not conn.connect():
-        click.echo("  [WARN] Could not connect via USB. Is the tablet plugged in?")
+        click.echo("  WRN - Could not connect via USB. Is the tablet plugged in?")
         return ""
 
     try:
@@ -471,7 +481,7 @@ def _enable_wifi_ssh(password: str) -> str:
         click.echo("  Enabling WiFi SSH...")
         stdout, stderr, exit_code = conn.execute_command("rm-ssh-over-wlan on")
         if exit_code != 0:
-            click.echo(f"  [WARN] Command failed: {stderr.strip() or stdout.strip()}")
+            click.echo(f"  WRN - Command failed: {stderr.strip() or stdout.strip()}")
             return ""
 
         click.echo("  WiFi SSH enabled!")
@@ -487,11 +497,11 @@ def _enable_wifi_ssh(password: str) -> str:
                 click.echo(f"  Tablet WiFi IP: {ip}")
                 return ip
 
-        click.echo("  [WARN] Could not determine WiFi IP. Is the tablet on WiFi?")
+        click.echo("  WRN - Could not determine WiFi IP. Is the tablet on WiFi?")
         return ""
 
     except Exception as exc:
-        click.echo(f"  [WARN] Error enabling WiFi SSH: {exc}")
+        click.echo(f"  WRN - Error enabling WiFi SSH: {exc}")
         return ""
     finally:
         conn.disconnect()
@@ -522,7 +532,7 @@ def _get_folder_choices_live(
     )
 
     if not conn.connect():
-        click.echo("  [WARN] Could not connect to tablet.")
+        click.echo("  WRN - Could not connect to tablet.")
         return []
 
     try:
@@ -536,7 +546,7 @@ def _get_folder_choices_live(
             f"done"
         )
         if exit_code != 0:
-            click.echo("  [WARN] Failed to read metadata from tablet.")
+            click.echo("  WRN - Failed to read metadata from tablet.")
             return []
 
         # Parse the output — each metadata block starts with FILE: line
@@ -566,7 +576,7 @@ def _get_folder_choices_live(
 
     except Exception as exc:
         logging.debug("Failed to list folders from tablet: %s", exc)
-        click.echo(f"  [WARN] Error reading folders: {exc}")
+        click.echo(f"  WRN - Error reading folders: {exc}")
         return []
     finally:
         conn.disconnect()

{remarkablesync-2.0.1 → remarkablesync-2.0.2}/src/commands/pipeline.py

@@ -14,6 +14,7 @@ from typing import Dict, List, Optional
 from ..backup import ReMarkableBackup
 from ..backup.connection import USB_HOST
 from ..rm_pdf_converter import run_conversion
+from ..utils import write_manifest
 from ..utils.console import print_error, print_success, print_warn
 from ..utils.logging import setup_logging
 
@@ -67,7 +68,8 @@ def run_pipeline(
     """
     import time as _time
 
-    setup_logging(log_level, log_dir=backup_dir)
+    log_dir = backup_dir.parent
+    setup_logging(log_level, log_dir=log_dir)
     _start_time = _time.monotonic()
 
     from ..config import load_config
@@ -115,13 +117,18 @@ def run_pipeline(
         try:
             success, updated_uuids, updated_pages = backup_tool.backup_files()
             if not success:
-                print_error("  [ERR] Backup failed.")
+                print_error("  ERR - Backup failed.")
                 return 1
             backup_tool.backup_templates()
-            print_success(f"  [OK] Backed up ({len(updated_uuids)} notebooks updated)")
+            print_success(f"  OK - Backed up ({len(updated_uuids)} notebooks updated)")
+            write_manifest(
+                backup_dir.parent / "updated_notebooks.txt",
+                sorted(updated_uuids),
+                "updated_notebooks",
+            )
         except Exception as exc:  # noqa: BLE001
             logging.error("Backup error: %s", exc)
-            print_error(f"  [ERR] Backup failed: {exc}")
+            print_error(f"  ERR - Backup failed: {exc}")
             return 1
     else:
         print("\n[1/3] Backup skipped (--skip-backup)")
@@ -133,29 +140,27 @@ def run_pipeline(
 
     if not skip_convert:
         print("\n[2/3] Converting notebooks to PDF...")
-        updated_list_file: Optional[Path] = None
-
-        if not force_convert and updated_uuids is not None and not skip_backup:
-            updated_list_file = backup_dir / "updated_notebooks.txt"
-            try:
-                updated_list_file.write_text("\n".join(sorted(updated_uuids)), encoding="utf-8")
-            except OSError as exc:
-                logging.warning("Could not write updated notebooks list: %s", exc)
-                updated_list_file = None
 
         try:
-            _ok, converted_pages = run_conversion(
+            _ok, converted_pages, merged_pdfs = run_conversion(
                 backup_dir=backup_dir,
                 output_dir=pdf_output_dir,
                 verbose=log_level,
-                updated_only=updated_list_file,
+                updated_uuids=updated_uuids if not force_convert and not skip_backup else None,
                 updated_pages=updated_pages,
                 folder_filter=folder_filter,
             )
-            print_success("  [OK] PDF conversion done")
+            print_success("  OK - PDF conversion done")
+            all_page_pdfs = sorted(p for pages in converted_pages.values() for p in pages)
+            write_manifest(
+                backup_dir.parent / "updated_pdf_pages.txt", all_page_pdfs, "updated_pdf_pages"
+            )
+            write_manifest(
+                backup_dir.parent / "updated_pdfs.txt", sorted(merged_pdfs), "updated_pdfs"
+            )
         except Exception as exc:  # noqa: BLE001
             logging.error("Conversion error: %s", exc)
-            print_error(f"  [ERR] PDF conversion failed: {exc}")
+            print_error(f"  ERR - PDF conversion failed: {exc}")
             return 1
     else:
         print("\n[2/3] PDF conversion skipped (--skip-convert)")
@@ -185,13 +190,13 @@ def run_pipeline(
                 print(f"  AI OCR provider: {ai_provider} ({provider.model})")
             else:
                 print_warn(
-                    f"  [WRN] AI provider '{ai_provider}' not available "
+                    f"  WRN - AI provider '{ai_provider}' not available "
                     "(missing API key or package). OCR skipped."
                 )
         except (ValueError, ImportError) as exc:
             logging.warning("Could not initialise AI provider: %s", exc)
     elif use_ai_ocr:
-        print_warn("  [WRN] --use-ai-ocr set but no --ai-provider given. OCR skipped.")
+        print_warn("  WRN - --use-ai-ocr set but no --ai-provider given. OCR skipped.")
 
     tag_list = [t.strip() for t in tags.split(",") if t.strip()] if tags else ["remarkable"]
 
@@ -241,9 +246,9 @@ def run_pipeline(
 
     if not notebooks:
         print("  No notebooks to export — skipping")
-        exported, skipped = 0, 0
+        exported, skipped, exported_dirs = 0, 0, []
     else:
-        exported, skipped = exporter.export_all(
+        exported, skipped, exported_dirs = exporter.export_all(
             notebooks=notebooks,
             pdf_output_dir=pdf_output_dir,
             force=force_export,
@@ -251,6 +256,7 @@ def run_pipeline(
             page_filter=page_filter,
             updated_pages=updated_pages,
         )
+        write_manifest(backup_dir.parent / "updated_md.txt", sorted(exported_dirs), "updated_md")
 
     # ------------------------------------------------------------------
     # Summary

{remarkablesync-2.0.1 → remarkablesync-2.0.2}/src/commands/sync_command.py

@@ -41,7 +41,8 @@ def run_sync_command(
     """
     import time as _time
 
-    setup_logging(log_level, log_dir=backup_dir)
+    log_dir = backup_dir.parent
+    setup_logging(log_level, log_dir=log_dir)
     _start_time = _time.monotonic()
 
     print("ReMarkable Sync (Backup + Convert)")

{remarkablesync-2.0.1 → remarkablesync-2.0.2}/src/commands/watch_command.py

@@ -330,7 +330,7 @@ class _WatchTray:
 
     def _on_open_log(self, icon, item):
         if self._backup_dir:
-            log_file = self._backup_dir / "remarkablesync.log"
+            log_file = self._backup_dir.parent / "remarkablesync.log"
             if log_file.exists():
                 self._open_file(log_file)
 

{remarkablesync-2.0.1 → remarkablesync-2.0.2}/src/config.py

@@ -49,7 +49,7 @@ DEFAULT_CONFIG: Dict[str, Any] = {
     "wifi_host": "",
     "password": "",
     "folders": [],
-    "sync_actions": ["pdf"],
+    "sync_actions": ["backup", "pdf", "ocr"],
     "ocr_enabled": False,
     "ocr_output_dir": "",
     "output_dir": "",
@@ -83,6 +83,16 @@ def load_config() -> Dict[str, Any]:
         # Merge with defaults so new keys are always present
         merged = dict(DEFAULT_CONFIG)
         merged.update(data)
+
+        # Cascade-normalize sync_actions: if a later step is present,
+        # all earlier steps must be too (e.g. "pdf" implies "backup").
+        _action_order = [a for a, _ in SYNC_ACTIONS]
+        actions = merged.get("sync_actions", [])
+        valid = [a for a in actions if a in _action_order]
+        if valid:
+            highest = max(_action_order.index(a) for a in valid)
+            merged["sync_actions"] = _action_order[: highest + 1]
+
         return merged
     except (json.JSONDecodeError, OSError):
         return dict(DEFAULT_CONFIG)

{remarkablesync-2.0.1 → remarkablesync-2.0.2}/src/hybrid_converter.py

@@ -16,6 +16,7 @@ This module provides:
 - Detection and reporting for v4/v3 files (limited support)
 """
 
+import hashlib
 import json
 import logging
 import shutil
@@ -27,11 +28,23 @@ from typing import Dict, List, Optional
 # Import modular converter classes
 from .converters import V4Converter, V5Converter, V6Converter
 from .template_renderer import TemplateRenderer
+from .utils import sanitize_name
 
 # Suppress warnings from third-party libraries to reduce output noise
 warnings.filterwarnings("ignore")
 
 
+def _hash_file(path: Path) -> str:
+    """Return MD5 hex-digest of *path*, or empty string if it doesn't exist."""
+    if not path.exists():
+        return ""
+    h = hashlib.md5()
+    with open(path, "rb") as fh:
+        for chunk in iter(lambda: fh.read(65536), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
 def setup_logging(verbose: bool = False):
     """Configure logging with appropriate levels and formatting.
 
@@ -291,14 +304,12 @@ def organize_notebooks_by_structure(notebooks: List[Dict], backup_dir: Path) ->
 
     for item in notebooks:
         if item["type"] == "DocumentType":
-            # This is a notebook to convert
             hierarchy = get_folder_hierarchy(item, backup_dir)
-            folder_path = "/".join(hierarchy) if hierarchy else ""
-
-            item["folder_path"] = folder_path
+            item["folder_path"] = "/".join(name for name, _ in hierarchy)
+            item["folder_hierarchy"] = hierarchy
             documents_to_convert.append(item)
 
-            # Ensure folder exists in structure
+            folder_path = item["folder_path"]
             if folder_path not in folder_structure:
                 folder_structure[folder_path] = []
             folder_structure[folder_path].append(item)
@@ -306,8 +317,12 @@ def organize_notebooks_by_structure(notebooks: List[Dict], backup_dir: Path) ->
     return {"folder_structure": folder_structure, "documents_to_convert": documents_to_convert}
 
 
-def get_folder_hierarchy(notebook: Dict, backup_dir: Path) -> List[str]:
-    """Get the folder hierarchy for a notebook by following parent UUIDs."""
+def get_folder_hierarchy(notebook: Dict, backup_dir: Path) -> List[tuple]:
+    """Get the folder hierarchy for a notebook by following parent UUIDs.
+
+    Returns a list of ``(raw_name, uuid)`` tuples ordered from root to
+    immediate parent, e.g. ``[("1:1", "abc..."), ("L65+", "def...")]``.
+    """
     hierarchy = []
     current_uuid = notebook.get("parent")
     files_dir = backup_dir / "Notebooks"
@@ -319,12 +334,8 @@ def get_folder_hierarchy(notebook: Dict, backup_dir: Path) -> List[str]:
                 with open(metadata_file, "r", encoding="utf-8") as f:
                     metadata = json.load(f)
                 folder_name = metadata.get("visibleName", "Unknown")
-                # Create safe folder name
-                safe_folder = "".join(
-                    c for c in folder_name if c.isalnum() or c in (" ", "-", "_")
-                ).strip()
-                if safe_folder:
-                    hierarchy.insert(0, safe_folder)  # Insert at beginning to build path
+                if folder_name:
+                    hierarchy.insert(0, (folder_name, current_uuid))
                 current_uuid = metadata.get("parent")
             else:
                 break
@@ -447,6 +458,7 @@ def convert_notebook(
     changed_page_ids: Optional[set] = None,
     on_page_done: Optional[callable] = None,
     on_page_start: Optional[callable] = None,
+    registry=None,
 ) -> Dict:
     """Convert a notebook using appropriate tools for each file type.
 
@@ -465,20 +477,25 @@ def convert_notebook(
             When *None* all pages are (re-)converted.
         on_page_done: Callback ``(cached: bool)`` called after each page.
             *cached* is True when the page was served from cache.
+        registry: Optional :class:`~src.utils.name_registry.NameRegistry`
+            for stable, deduplicated output path names.
     """
-    # Create safe filename
-    safe_name = "".join(c for c in notebook["name"] if c.isalnum() or c in (" ", "-", "_")).rstrip()
-    if not safe_name:
-        safe_name = f"notebook_{notebook['uuid'][:8]}"
-
-    # Use pre-computed folder path from organization
-    folder_path = notebook.get("folder_path", "")
-
-    # Create output directory with folder structure
+    # Build output directory using registry if available, else plain sanitize
+    hierarchy = notebook.get("folder_hierarchy", [])
     output_notebook_dir = output_dir
-    if folder_path:
-        for folder in folder_path.split("/"):
-            output_notebook_dir = output_notebook_dir / folder
+    if registry:
+        for i, (folder_name, folder_uuid) in enumerate(hierarchy):
+            parent_uuid = hierarchy[i - 1][1] if i > 0 else ""
+            output_notebook_dir = output_notebook_dir / registry.get_or_assign(
+                folder_uuid, folder_name, parent_uuid
+            )
+        parent_uuid = hierarchy[-1][1] if hierarchy else ""
+        safe_name = registry.get_or_assign(notebook["uuid"], notebook["name"], parent_uuid)
+    else:
+        for folder_name, _ in hierarchy:
+            output_notebook_dir = output_notebook_dir / sanitize_name(folder_name)
+        safe_name = sanitize_name(notebook["name"]) or f"notebook_{notebook['uuid'][:8]}"
+
     output_notebook_dir.mkdir(parents=True, exist_ok=True)
 
     # Persistent page PDF cache directory
@@ -487,7 +504,7 @@ def convert_notebook(
 
     results = {
         "name": notebook["name"],
-        "folder_path": str(output_notebook_dir.relative_to(output_dir)) if folder_path else "",
+        "folder_path": str(output_notebook_dir.relative_to(output_dir)) if hierarchy else "",
         "page_cache_dir": page_cache_dir,
         "v5_converted": 0,
         "v6_converted": 0,
@@ -657,10 +674,13 @@ def convert_notebook(
         # Create merged PDF if we have any pages
         if page_pdfs:
             final_pdf = output_notebook_dir / f"{safe_name}.pdf"
+            pre_merge_hash = _hash_file(final_pdf)
+
             if merge_pdfs(page_pdfs, final_pdf):
                 results["output_files"].append(final_pdf)
+                results["pdf_changed"] = _hash_file(final_pdf) != pre_merge_hash
                 logging.info(
-                    f"[OK] {notebook['name']}: Merged {len(page_pdfs)} pages into {final_pdf.name}"
+                    f"OK - {notebook['name']}: Merged {len(page_pdfs)} pages into {final_pdf.name}"
                 )
             else:
                 logging.warning(