🔍 Code Extractor

A standalone PDF uploader class that manages uploading PDF documents to reMarkable cloud storage using authenticated sessions and temporary database storage.

Purpose

This class provides a high-level interface for uploading PDF files to reMarkable devices/cloud. It handles authentication, temporary database creation for upload sessions, folder listing, and PDF document uploads. It wraps the RemarkableUploadManager with a simplified API and manages the lifecycle of temporary resources needed for uploads.

Source Code

class RemarkablePDFUploader:
    """Standalone PDF uploader using proven upload_manager logic"""
    
    def __init__(self):
        # Create a temporary database for this upload session
        self.temp_dir = tempfile.mkdtemp(prefix="remarkable_upload_")
        temp_db = os.path.join(self.temp_dir, "temp_upload.db")
        
        print(f"🔧 Initializing upload manager with temp DB: {temp_db}")
        
        # Import and create session (following upload_manager pattern)
        from cloudtest.auth import RemarkableAuth
        
        # Create authenticated session
        auth = RemarkableAuth()
        session = auth.get_authenticated_session()
        
        if not session:
            raise Exception("Authentication failed")
        
        # Initialize the proven upload manager
        self.upload_manager = RemarkableUploadManager(session, temp_db)
        
    def list_folders(self):
        """List available folders for upload target selection"""
        try:
            # Get the folder structure from the upload manager
            folders = {}
            replica = self.upload_manager.get_replica()
            
            for uuid, doc in replica.items():
                if doc.get('Type') == 'CollectionType':
                    name = doc.get('VissibleName', 'Unnamed Folder')
                    folders[uuid] = name
                    
            return folders
        except Exception as e:
            print(f"⚠️ Error listing folders: {e}")
            return {}
    
    def upload_pdf(self, pdf_path, document_name, parent_uuid=None):
        """
        Upload a PDF using the proven upload_manager logic
        
        Args:
            pdf_path: Path to the PDF file
            document_name: Name for the document on reMarkable
            parent_uuid: UUID of parent folder (None for root)
            
        Returns:
            bool: True if upload successful, False otherwise
        """
        try:
            pdf_file = Path(pdf_path)
            if not pdf_file.exists():
                print(f"❌ PDF file not found: {pdf_path}")
                return False
                
            if not pdf_file.suffix.lower() == '.pdf':
                print(f"❌ File is not a PDF: {pdf_path}")
                return False
                
            print(f"📄 Uploading: {pdf_file.name}")
            print(f"📝 Document name: {document_name}")
            if parent_uuid:
                print(f"📁 Target folder: {parent_uuid}")
            else:
                print("📁 Target: Root folder")
                
            # Use the proven upload manager to handle the upload
            print(f"\n🔧 Using proven upload_manager.py for upload...")
            
            # Call the working upload method
            success = self.upload_manager.upload_pdf_document(
                pdf_path=str(pdf_file),
                name=document_name,
                parent_uuid=parent_uuid
            )
            
            if success:
                print("✅ Upload successful!")
                return True
            else:
                print("❌ Upload failed!")
                return False
                
        except Exception as e:
            print(f"❌ Upload error: {e}")
            return False
    
    def cleanup(self):
        """Clean up temporary resources"""
        try:
            import shutil
            if hasattr(self, 'temp_dir') and os.path.exists(self.temp_dir):
                shutil.rmtree(self.temp_dir)
                print(f"🧹 Cleaned up temp directory: {self.temp_dir}")
        except Exception as e:
            print(f"⚠️ Cleanup warning: {e}")

Parameters

Parameter Details

__init__: No parameters required. The constructor automatically creates a temporary directory and database, authenticates with reMarkable services, and initializes the upload manager.

Return Value

Instantiation returns a RemarkablePDFUploader object. The upload_pdf method returns a boolean (True for successful upload, False otherwise). The list_folders method returns a dictionary mapping folder UUIDs to folder names. The cleanup method has no return value.

Class Interface

Methods

Attributes

Dependencies

• tempfile
• os
• pathlib
• shutil
• cloudtest.auth
• cloudtest.upload_manager

Required Imports

import sys
import os
import tempfile
from pathlib import Path
from cloudtest.upload_manager import RemarkableUploadManager

Conditional/Optional Imports

These imports are only needed under specific conditions:

from cloudtest.auth import RemarkableAuth

import shutil

Usage Example

# Create uploader instance
uploader = RemarkablePDFUploader()

# List available folders
folders = uploader.list_folders()
for uuid, name in folders.items():
    print(f'{name}: {uuid}')

# Upload PDF to root folder
success = uploader.upload_pdf(
    pdf_path='/path/to/document.pdf',
    document_name='My Document',
    parent_uuid=None
)

# Upload PDF to specific folder
success = uploader.upload_pdf(
    pdf_path='/path/to/document.pdf',
    document_name='My Document',
    parent_uuid='folder-uuid-here'
)

# Clean up temporary resources
uploader.cleanup()

Best Practices

• Always call cleanup() method after finishing uploads to remove temporary directories and databases
• Check that PDF files exist and have .pdf extension before calling upload_pdf
• Handle authentication failures during instantiation with try-except blocks
• Use list_folders() to get valid parent_uuid values before uploading to specific folders
• The class creates temporary resources in __init__, so instantiate only when needed
• Each instance creates its own temporary database, so reuse the same instance for multiple uploads in a session
• The upload_pdf method returns boolean for success/failure - always check the return value
• Parent_uuid=None uploads to root folder, use a valid UUID to upload to a specific folder

Tags

Similar Components

AI-powered semantic similarity - components with related functionality:

• class RemarkablePDFUploader 94.1% similar

  A wrapper class that provides a simplified interface for uploading PDF documents to a reMarkable tablet using a temporary database session.

  From: /tf/active/vicechatdev/e-ink-llm/cloudtest/upload_pdf_new.py

• class RemarkableUploadManager_v1 78.1% similar

  Manages uploads to reMarkable cloud

  From: /tf/active/vicechatdev/e-ink-llm/cloudtest/upload_manager_old.py

• class SimplePDFUploadTest 77.6% similar

  A test class for validating PDF upload functionality to reMarkable cloud, including raw content upload and complete document creation with metadata.

  From: /tf/active/vicechatdev/e-ink-llm/cloudtest/test_simple_pdf_upload.py

• class RemarkableUploadManager 77.5% similar

  Manages uploads to reMarkable cloud

  From: /tf/active/vicechatdev/e-ink-llm/cloudtest/upload_manager.py

• function main_v15 70.5% similar

  A test function that uploads a PDF document to reMarkable cloud, syncs the local replica, and validates the upload with detailed logging and metrics.

  From: /tf/active/vicechatdev/e-ink-llm/cloudtest/test_raw_upload.py