clean up code

app/migration/copy.py

@@ -1,268 +1,129 @@
-"""Copy-based migration strategy"""
 import shutil
 from pathlib import Path
 from typing import Optional
 import os
-
 from ..shared.logger import ProgressLogger
 
-
 class CopyMigrationStrategy:
-    """Copy files to destination with verification"""
 
-    def __init__(
-        self,
-        logger: Optional[ProgressLogger] = None,
-        preserve_metadata: bool = True,
-        verify_checksums: bool = True
-    ):
-        """Initialize copy migration strategy
-
-        Args:
-            logger: Optional progress logger
-            preserve_metadata: Whether to preserve file metadata
-            verify_checksums: Whether to verify checksums after copy
-        """
+    def __init__(self, logger: Optional[ProgressLogger]=None, preserve_metadata: bool=True, verify_checksums: bool=True):
         self.logger = logger
         self.preserve_metadata = preserve_metadata
         self.verify_checksums = verify_checksums
 
-    def migrate(
-        self,
-        source: Path,
-        destination: Path,
-        verify: bool = True
-    ) -> bool:
-        """Migrate file by copying
-
-        Args:
-            source: Source file path
-            destination: Destination file path
-            verify: Whether to verify the operation
-
-        Returns:
-            True if migration successful
-        """
+    def migrate(self, source: Path, destination: Path, verify: bool=True) -> bool:
         if not source.exists():
             if self.logger:
-                self.logger.error(f"Source file does not exist: {source}")
+                self.logger.error(f'Source file does not exist: {source}')
             return False
-
-        # Create destination directory
         destination.parent.mkdir(parents=True, exist_ok=True)
-
         try:
-            # Copy file
             if self.preserve_metadata:
                 shutil.copy2(source, destination)
             else:
                 shutil.copy(source, destination)
-
-            # Verify if requested
             if verify and self.verify_checksums:
                 if not self._verify_copy(source, destination):
                     if self.logger:
-                        self.logger.error(f"Verification failed: {source} -> {destination}")
+                        self.logger.error(f'Verification failed: {source} -> {destination}')
                     destination.unlink()
                     return False
-
             return True
-
         except Exception as e:
             if self.logger:
-                self.logger.error(f"Copy failed: {source} -> {destination}: {e}")
+                self.logger.error(f'Copy failed: {source} -> {destination}: {e}')
             return False
 
     def _verify_copy(self, source: Path, destination: Path) -> bool:
-        """Verify copied file
-
-        Args:
-            source: Source file path
-            destination: Destination file path
-
-        Returns:
-            True if verification successful
-        """
-        # Check size
         source_size = source.stat().st_size
         dest_size = destination.stat().st_size
-
         if source_size != dest_size:
             return False
-
-        # Compare checksums for files larger than 1MB
         if source_size > 1024 * 1024:
             from ..deduplication.chunker import hash_file
-
             source_hash = hash_file(source)
             dest_hash = hash_file(destination)
-
             return source_hash == dest_hash
-
-        # For small files, compare content directly
         with open(source, 'rb') as f1, open(destination, 'rb') as f2:
             return f1.read() == f2.read()
 
     def can_migrate(self, source: Path, destination: Path) -> bool:
-        """Check if migration is possible
-
-        Args:
-            source: Source file path
-            destination: Destination file path
-
-        Returns:
-            True if migration is possible
-        """
         if not source.exists():
             return False
-
-        # Check if destination directory is writable
         dest_dir = destination.parent
         if dest_dir.exists():
             return os.access(dest_dir, os.W_OK)
-
-        # Check if parent directory exists and is writable
         parent = dest_dir.parent
         while not parent.exists() and parent != parent.parent:
             parent = parent.parent
-
         return parent.exists() and os.access(parent, os.W_OK)
 
     def estimate_time(self, source: Path) -> float:
-        """Estimate migration time in seconds
-
-        Args:
-            source: Source file path
-
-        Returns:
-            Estimated time in seconds
-        """
         if not source.exists():
             return 0.0
-
         size = source.stat().st_size
-
-        # Estimate based on typical copy speed (100 MB/s)
-        typical_speed = 100 * 1024 * 1024  # bytes per second
+        typical_speed = 100 * 1024 * 1024
         return size / typical_speed
 
     def cleanup(self, source: Path) -> bool:
-        """Cleanup source file after successful migration
-
-        Args:
-            source: Source file path
-
-        Returns:
-            True if cleanup successful
-        """
         try:
             if source.exists():
                 source.unlink()
             return True
         except Exception as e:
             if self.logger:
-                self.logger.warning(f"Failed to cleanup {source}: {e}")
+                self.logger.warning(f'Failed to cleanup {source}: {e}')
             return False
 
-
 class FastCopyStrategy(CopyMigrationStrategy):
-    """Fast copy strategy without verification"""
-
-    def __init__(self, logger: Optional[ProgressLogger] = None):
-        """Initialize fast copy strategy"""
-        super().__init__(
-            logger=logger,
-            preserve_metadata=True,
-            verify_checksums=False
-        )
 
+    def __init__(self, logger: Optional[ProgressLogger]=None):
+        super().__init__(logger=logger, preserve_metadata=True, verify_checksums=False)
 
 class SafeCopyStrategy(CopyMigrationStrategy):
-    """Safe copy strategy with full verification"""
-
-    def __init__(self, logger: Optional[ProgressLogger] = None):
-        """Initialize safe copy strategy"""
-        super().__init__(
-            logger=logger,
-            preserve_metadata=True,
-            verify_checksums=True
-        )
 
+    def __init__(self, logger: Optional[ProgressLogger]=None):
+        super().__init__(logger=logger, preserve_metadata=True, verify_checksums=True)
 
 class ReferenceCopyStrategy:
-    """Create reference copy using reflinks (CoW) if supported"""
 
-    def __init__(self, logger: Optional[ProgressLogger] = None):
-        """Initialize reflink copy strategy"""
+    def __init__(self, logger: Optional[ProgressLogger]=None):
         self.logger = logger
 
-    def migrate(
-        self,
-        source: Path,
-        destination: Path,
-        verify: bool = True
-    ) -> bool:
-        """Migrate using reflink (copy-on-write)
-
-        Args:
-            source: Source file path
-            destination: Destination file path
-            verify: Whether to verify the operation
-
-        Returns:
-            True if migration successful
-        """
+    def migrate(self, source: Path, destination: Path, verify: bool=True) -> bool:
         if not source.exists():
             if self.logger:
-                self.logger.error(f"Source file does not exist: {source}")
+                self.logger.error(f'Source file does not exist: {source}')
             return False
-
-        # Create destination directory
         destination.parent.mkdir(parents=True, exist_ok=True)
-
         try:
-            # Try reflink copy (works on btrfs, xfs, etc.)
             import subprocess
-
-            result = subprocess.run(
-                ['cp', '--reflink=auto', str(source), str(destination)],
-                capture_output=True,
-                check=False
-            )
-
+            result = subprocess.run(['cp', '--reflink=auto', str(source), str(destination)], capture_output=True, check=False)
             if result.returncode != 0:
-                # Fallback to regular copy
                 shutil.copy2(source, destination)
-
             return True
-
         except Exception as e:
             if self.logger:
-                self.logger.error(f"Reflink copy failed: {source} -> {destination}: {e}")
+                self.logger.error(f'Reflink copy failed: {source} -> {destination}: {e}')
             return False
 
     def can_migrate(self, source: Path, destination: Path) -> bool:
-        """Check if migration is possible"""
         if not source.exists():
             return False
-
         dest_dir = destination.parent
         if dest_dir.exists():
             return os.access(dest_dir, os.W_OK)
-
         return True
 
     def estimate_time(self, source: Path) -> float:
-        """Estimate migration time (reflinks are fast)"""
-        return 0.1  # Reflinks are nearly instant
+        return 0.1
 
     def cleanup(self, source: Path) -> bool:
-        """Cleanup source file"""
         try:
             if source.exists():
                 source.unlink()
             return True
         except Exception as e:
             if self.logger:
-                self.logger.warning(f"Failed to cleanup {source}: {e}")
+                self.logger.warning(f'Failed to cleanup {source}: {e}')
             return False