dwipe 2.0.0__py3-none-any.whl → 2.0.1__py3-none-any.whl

dwipe/DeviceInfo.py

@@ -1,6 +1,8 @@
 """
 DeviceInfo class for device discovery and information management
 """
+import os
+import re
 import json
 import subprocess
 import time
@@ -36,6 +38,7 @@ class DeviceInfo:
                                dflt=dflt,         # default run-time state
                                label='',       # blkid
                                fstype='',      # blkid
+                               type='',        # device type (disk, part)
                                model='',       # /sys/class/block/{name}/device/vendor|model
                                size_bytes=size_bytes,  # /sys/block/{name}/...
                                marker='',      #  persistent status
@@ -45,10 +48,59 @@ class DeviceInfo:
                                job=None,         # if zap running
                                uuid='',        # filesystem UUID or PARTUUID
                                serial='',      # disk serial number (for whole disks)
+                               port='',        # port (for whole disks)
                                )
 
+    def _get_port_from_sysfs(self, device_name):
+        try:
+            sysfs_path = f'/sys/class/block/{device_name}'
+            if not os.path.exists(sysfs_path):
+                return ''
+
+            real_path = os.path.realpath(sysfs_path).lower()
+
+            # 1. USB - Format: USB:1-1.4
+            if '/usb' in real_path:
+                usb_match = re.search(r'/(\d+-\d+(?:\.\d+)*):', real_path)
+                if usb_match:
+                    return f"USB:{usb_match.group(1)}"
+
+            # 2. SATA - Format: SATA:1
+            elif '/ata' in real_path:
+                ata_match = re.search(r'ata(\d+)', real_path)
+                if ata_match:
+                    return f"SATA:{ata_match.group(1)}"
+
+            # 3. NVMe - Format: PCI:1b.0 (Stripped of 0000:00: noise)
+            elif '/nvme' in real_path:
+                # This regex ignores the 4-digit domain and the first 2-digit bus
+                pci_match = re.search(r'0000:[0-9a-f]{2}:([0-9a-f]{2}\.[0-9a-f])', real_path)
+                if pci_match:
+                    return f"PCI:{pci_match.group(1)}"
+                return "NVMe"
+
+            # 4. MMC/eMMC - Format: MMC:0 or PCI:1a.0 (if PCI-attached)
+            elif '/mmc' in real_path:
+                # Try to extract mmc host number
+                mmc_match = re.search(r'/mmc_host/mmc(\d+)', real_path)
+                if mmc_match:
+                    return f"MMC:{mmc_match.group(1)}"
+                # Fallback: try to get PCI address if available
+                pci_match = re.search(r'0000:[0-9a-f]{2}:([0-9a-f]{2}\.[0-9a-f])', real_path)
+                if pci_match:
+                    return f"PCI:{pci_match.group(1)}"
+                return "MMC"
+
+        except Exception as e:
+            # Log exception to file for debugging
+            with open('/tmp/dwipe_port_debug.log', 'a', encoding='utf-8') as f:
+                import traceback
+                f.write(f"Exception in _get_port_from_sysfs({device_name}): {e}\n")
+                traceback.print_exc(file=f)
+        return ''
+
     @staticmethod
-    def get_device_vendor_model(device_name):
+    def _get_device_vendor_model(device_name):
         """Gets the vendor and model for a given device from the /sys/class/block directory.
         - Args: - device_name: The device name, such as 'sda', 'sdb', etc.
         - Returns: A string containing the vendor and model information.
@@ -156,20 +208,51 @@ class DeviceInfo:
         # Parse each block device and its properties
         for device in parsed_data['blockdevices']:
             parent = eat_one(device)
-            parent.fstype = self.get_device_vendor_model(parent.name)
             entries[parent.name] = parent
             for child in device.get('children', []):
                 entry = eat_one(child)
                 entries[entry.name] = entry
                 entry.parent = parent.name
                 parent.minors.append(entry.name)
-                if not parent.fstype:
-                    parent.fstype = 'DISK'
                 self.disk_majors.add(entry.major)
                 if entry.mounts:
                     entry.state = 'Mnt'
                     parent.state = 'Mnt'
 
+
+        # Final pass: Identify disks, assign ports, and handle superfloppies
+        final_entries = {}
+        for name, entry in entries.items():
+            final_entries[name] = entry
+            
+            # Only process top-level physical disks
+            if entry.parent is None:
+                # Hardware Info Gathering
+                entry.model = self._get_device_vendor_model(entry.name)
+                entry.port = self._get_port_from_sysfs(entry.name)
+                
+                # The Split (Superfloppy Case)
+                # If it has children, the children already hold the data.
+                # If it has NO children but HAS data, we create the '----' child.
+                if not entry.minors and (entry.fstype or entry.label or entry.mounts):
+                    v_key = f"{name}_data"
+                    v_child = self._make_partition_namespace(entry.major, name, entry.size_bytes, dflt)
+                    v_child.name = "----"
+                    v_child.fstype = entry.fstype
+                    v_child.label = entry.label
+                    v_child.mounts = entry.mounts
+                    v_child.parent = name
+
+                    final_entries[v_key] = v_child
+                    entry.minors.append(v_key)
+                    
+                # Clean the hardware row of data-specific strings
+                entry.fstype = entry.model if entry.model else 'DISK'
+                entry.label = ''
+                entry.mounts = []
+
+        entries = final_entries
+
         if self.DB:
             print('\n\nDB: --->>> after parse_lsblk:')
             for entry in entries.values():
@@ -237,21 +320,38 @@ class DeviceInfo:
             DeviceInfo.set_one_state(nss, ns)
 
     def get_disk_partitions(self, nss):
-        """Filter out virtual/pseudo devices (zram, loop, etc.) while keeping physical drives.
-        Keeps: sd*, nvme*, vd*, hd*, mmcblk* (physical and USB drives)
-        Excludes: zram*, loop*, dm-*, sr*, ram*
-        """
-        # Virtual/pseudo device prefixes to exclude
-        exclude_prefixes = ('zram', 'loop', 'dm-', 'sr', 'ram')
+        """Filter to only wipeable physical storage using positive criteria.
 
+        Keeps devices that:
+        - Are type 'disk' or 'part' (from lsblk)
+        - Are writable (not read-only)
+        - Are real block devices (not virtual)
+
+        This automatically excludes:
+        - Virtual devices (zram, loop, dm-*, etc.)
+        - Read-only devices (CD-ROMs, eMMC boot partitions)
+        - Special partitions (boot loaders)
+        """
         ok_nss = {}
         for name, ns in nss.items():
             # Must be disk or partition type
             if ns.type not in ('disk', 'part'):
                 continue
 
-            # Exclude virtual/pseudo devices by name prefix
-            if any(name.startswith(prefix) for prefix in exclude_prefixes):
+            # Must be writable (excludes CD-ROMs, eMMC boot partitions, etc.)
+            ro_path = f'/sys/class/block/{name}/ro'
+            try:
+                with open(ro_path, 'r', encoding='utf-8') as f:
+                    if f.read().strip() != '0':
+                        continue  # Skip read-only devices
+            except (FileNotFoundError, Exception):
+                # If we can't read ro flag, skip this device to be safe
+                continue
+
+            # Exclude common virtual device prefixes as a safety net
+            # (most should already be filtered by ro check or missing sysfs)
+            virtual_prefixes = ('zram', 'loop', 'dm-', 'ram')
+            if any(name.startswith(prefix) for prefix in virtual_prefixes):
                 continue
 
             # Include this device
@@ -405,6 +505,7 @@ class DeviceInfo:
             if new_ns:
                 if prev_ns.job:
                     new_ns.job = prev_ns.job
+                # Note: Do NOT preserve port - use fresh value from current scan
                 new_ns.dflt = prev_ns.dflt
                 # Preserve the "wiped this session" flag
                 if hasattr(prev_ns, 'wiped_this_session'):

dwipe/DiskWipe.py

@@ -187,6 +187,7 @@ class DiskWipe:
         line += f' [P]ass={self.opts.passes}'
         # Show verification percentage spinner with key
         line += f' [V]pct={self.opts.verify_pct}%'
+        line += f' [p]ort'
         line += '  '
         if self.opts.dry_run:
             line += ' DRY-RUN'
@@ -295,6 +296,7 @@ class DiskWipe:
         spin = self.spin = OptionSpinner(stack=self.stack)
         spin.default_obj = self.opts
         spin.add_key('dense', 'D - dense/spaced view', vals=[False, True])
+        spin.add_key('port_serial', 'p - disk port info', vals=[False, True])
         spin.add_key('slowdown_stop', 'L - stop if disk slows Nx', vals=[16, 64, 256, 0, 4])
         spin.add_key('stall_timeout', 'T - stall timeout (sec)', vals=[60, 120, 300, 600, 0,])
         spin.add_key('verify_pct', 'V - verification %', vals=[0, 2, 5, 10, 25, 50, 100])
@@ -372,6 +374,11 @@ class DiskWipeScreen(Screen):
 class MainScreen(DiskWipeScreen):
     """Main device list screen"""
 
+    def _port_serial_line(self, port, serial):
+        wids = self.app.wids
+        wid = wids.state if wids else 5
+        sep = '  '
+        return f'{"":>{wid}}{sep}│   └────── {port:<12} {serial}'
 
     def draw_screen(self):
         """Draw the main device list"""
@@ -612,6 +619,9 @@ class MainScreen(DiskWipeScreen):
             ctx = Context(genre='disk' if partition.parent is None else 'partition',
                          partition=partition)
             app.win.add_body(partition.line, attr=attr, context=ctx)
+            if partition.parent is None and app.opts.port_serial:
+                line = self._port_serial_line(partition.port, partition.serial)
+                app.win.add_body(line, attr=attr, context=Context(genre='DECOR'))
 
             # Show inline confirmation prompt if this is the partition being confirmed
             if app.confirmation.active and app.confirmation.partition_name == partition.name:

dwipe/PersistentState.py

@@ -25,12 +25,13 @@ class PersistentState:
         self.state = {
             'theme': 'default',
             'wipe_mode': 'Zero',  # 'Rand' or 'Zero' or +V
-            'passes': 1,  # 1, 2, or 4 wipe passes
+            'passes': 1,  # 1, 2, or 4 wipe pass
             'confirmation': 'YES',  # 'Y', 'y', 'YES', 'yes', 'device'
             'verify_pct': 2,  # 0, 2, 5, 10, 25, 50, 100
             'dense': False,  # True = compact view, False = blank lines between disks
             'slowdown_stop': 16,
             'stall_timeout': 60,
+            'port_serial': False,
             'devices': {}  # device_id -> {locked, last_seen, last_name, size_bytes}
         }
         self.dirty = False
@@ -61,15 +62,6 @@ class PersistentState:
             try:
                 with open(self.config_path, 'r', encoding='utf-8') as f:
                     loaded = json.load(f)
-                    # Migrate old mode values to new format
-#                   if 'mode' in loaded:
-#                       old_mode = loaded['mode']
-#                       if old_mode in ('random', 'Random', 'RANDOM'):
-#                           loaded['mode'] = 'Rand'
-#                           self.dirty = True  # Save migrated value
-#                       elif old_mode in ('zero', 'zeros', 'Zero', 'ZERO'):
-#                           loaded['mode'] = 'Zero'
-#                           self.dirty = True  # Save migrated value
                     self.state.update(loaded)
             except (json.JSONDecodeError, IOError) as e:
                 print(f'Warning: Could not load state from {self.config_path}: {e}')

dwipe/ToolManager.py

@@ -0,0 +1,637 @@
+#!/usr/bin/env python3
+"""
+Hardware Secure Erase Module for dwipe
+Provides pre-checks, execution, monitoring, and fallback for hardware-level wipes
+"""
+
+import subprocess
+import shutil
+import os
+import time
+import threading
+import sys
+from typing import Dict, List, Optional, Tuple, Callable
+from enum import Enum
+from dataclasses import dataclass
+
+# ============================================================================
+# Part 1: Tool Manager (Dependency Management)
+# ============================================================================
+
+class ToolManager:
+    """Manages tool dependencies (hdparm, nvme-cli)"""
+    
+    TOOL_PACKAGES = {
+        'hdparm': {
+            'apt': ['hdparm'],
+            'dnf': ['hdparm'],
+            'yum': ['hdparm'],
+            'pacman': ['hdparm'],
+            'zypper': ['hdparm'],
+            'apk': ['hdparm'],
+            'brew': ['hdparm'],
+        },
+        'nvme': {
+            'apt': ['nvme-cli'],
+            'dnf': ['nvme-cli'],
+            'yum': ['nvme-cli'],
+            'pacman': ['nvme-cli'],
+            'zypper': ['nvme-cli'],
+            'apk': ['nvme-cli'],
+            'brew': ['nvme-cli'],
+        }
+    }
+    
+    def __init__(self, auto_install: bool = False, verbose: bool = False):
+        self.auto_install = auto_install
+        self.verbose = verbose
+        self.package_manager = self._detect_package_manager()
+    
+    def _detect_package_manager(self) -> Optional[str]:
+        package_managers = {
+            'apt': ['apt-get', 'apt'],
+            'dnf': ['dnf'],
+            'yum': ['yum'],
+            'pacman': ['pacman'],
+            'zypper': ['zypper'],
+            'apk': ['apk'],
+            'brew': ['brew'],
+        }
+        
+        for pm, binaries in package_managers.items():
+            for binary in binaries:
+                if shutil.which(binary):
+                    return pm
+        return None
+    
+    def tool_available(self, tool_name: str) -> bool:
+        return shutil.which(tool_name) is not None
+    
+    def ensure_tool(self, tool_name: str, critical: bool = True) -> bool:
+        if self.tool_available(tool_name):
+            return True
+        
+        if self.auto_install and self._install_tool(tool_name):
+            return True
+        
+        if critical:
+            print(f"ERROR: Required tool '{tool_name}' not found")
+            packages = self.TOOL_PACKAGES.get(tool_name, {}).get(self.package_manager, [])
+            if packages:
+                print(f"Install with: sudo {self.package_manager} install {packages[0]}")
+        return False
+    
+    def _install_tool(self, tool_name: str) -> bool:
+        """Install tool using package manager"""
+        # Simplified - use the installation logic from earlier if needed
+        return False  # Placeholder
+    
+    def get_tool_path(self, tool_name: str) -> Optional[str]:
+        return shutil.which(tool_name)
+
+# ============================================================================
+# Part 2: Drive Pre-Checks
+# ============================================================================
+
+class EraseStatus(Enum):
+    NOT_STARTED = "not_started"
+    STARTING = "starting"
+    IN_PROGRESS = "in_progress"
+    COMPLETE = "complete"
+    FAILED = "failed"
+    UNKNOWN = "unknown"
+
+@dataclass
+class PreCheckResult:
+    compatible: bool = False
+    tool: Optional[str] = None
+    frozen: bool = False
+    locked: bool = False
+    enhanced_supported: bool = False
+    issues: List[str] = None
+    recommendation: Optional[str] = None
+    
+    def __post_init__(self):
+        if self.issues is None:
+            self.issues = []
+
+class DrivePreChecker:
+    """Pre-check drive before attempting secure erase"""
+    
+    def __init__(self, timeout: int = 10):
+        self.timeout = timeout
+    
+    def is_usb_attached(self, device: str) -> bool:
+        """Check if device is USB-attached"""
+        dev_name = os.path.basename(device)
+        
+        # Check via sysfs
+        sys_path = f'/sys/block/{dev_name}'
+        if os.path.exists(sys_path):
+            try:
+                # Check if in USB hierarchy
+                real_path = os.path.realpath(sys_path)
+                if 'usb' in real_path.lower():
+                    return True
+                
+                # Check via udev
+                udev_info = subprocess.run(
+                    ['udevadm', 'info', '-q', 'property', '-n', device],
+                    capture_output=True,
+                    text=True,
+                    timeout=5
+                )
+                if udev_info.returncode == 0 and 'ID_BUS=usb' in udev_info.stdout:
+                    return True
+            except:
+                pass
+        
+        return False
+    
+    def check_nvme_drive(self, device: str) -> PreCheckResult:
+        """Check if NVMe secure erase will likely work"""
+        result = PreCheckResult(tool='nvme')
+        
+        try:
+            # Check if device exists
+            if not os.path.exists(device):
+                result.issues.append(f"Device {device} does not exist")
+                return result
+            
+            # Check USB attachment
+            if self.is_usb_attached(device):
+                result.issues.append("NVMe is USB-attached - hardware erase unreliable")
+                result.recommendation = "Use software wipe"
+                return result
+            
+            # Check if NVMe device responds
+            id_ctrl = subprocess.run(
+                ['nvme', 'id-ctrl', device],
+                capture_output=True,
+                text=True,
+                timeout=self.timeout
+            )
+            
+            if id_ctrl.returncode != 0:
+                result.issues.append(f"Not an NVMe device: {id_ctrl.stderr}")
+                return result
+            
+            # Check format support
+            if 'Format NVM' not in id_ctrl.stdout:
+                result.issues.append("Drive doesn't support Format NVM command")
+            
+            # Check for write protection
+            id_ns = subprocess.run(
+                ['nvme', 'id-ns', device],
+                capture_output=True,
+                text=True,
+                timeout=self.timeout
+            )
+            
+            if id_ns.returncode == 0 and 'Write Protected' in id_ns.stdout:
+                result.issues.append("Namespace is write protected")
+            
+            result.compatible = len(result.issues) == 0
+            result.recommendation = "Proceed with hardware erase" if result.compatible else "Use software wipe"
+            
+        except subprocess.TimeoutExpired:
+            result.issues.append(f"Command timed out after {self.timeout}s")
+        except Exception as e:
+            result.issues.append(f"Unexpected error: {e}")
+        
+        return result
+    
+    def check_ata_drive(self, device: str) -> PreCheckResult:
+        """Check if ATA secure erase will likely work"""
+        result = PreCheckResult(tool='hdparm')
+        
+        try:
+            if not os.path.exists(device):
+                result.issues.append(f"Device {device} does not exist")
+                return result
+            
+            # Check USB attachment
+            if self.is_usb_attached(device):
+                result.issues.append("Drive is USB-attached - hardware erase unreliable")
+                result.recommendation = "Use software wipe"
+                return result
+            
+            # Get drive info
+            info = subprocess.run(
+                ['hdparm', '-I', device],
+                capture_output=True,
+                text=True,
+                timeout=self.timeout
+            )
+            
+            if info.returncode != 0:
+                result.issues.append(f"Drive not responsive: {info.stderr}")
+                return result
+            
+            output = info.stdout
+            
+            # Check if frozen
+            if 'frozen' in output.lower():
+                result.frozen = True
+                result.issues.append("Drive is FROZEN - will hang on erase")
+            
+            # Check if locked/enabled
+            if 'enabled' in output and 'not' not in output:
+                result.locked = True
+                result.issues.append("Security is ENABLED - needs password")
+            
+            # Check enhanced erase support
+            if 'supported: enhanced erase' in output:
+                result.enhanced_supported = True
+            
+            # Check ATA device and erase support
+            if 'ATA' not in output and 'SATA' not in output:
+                result.issues.append("Not an ATA/SATA device")
+            
+            if 'SECURITY ERASE UNIT' not in output:
+                result.issues.append("Drive doesn't support SECURITY ERASE UNIT")
+            
+            result.compatible = len(result.issues) == 0
+            
+            if result.compatible:
+                result.recommendation = "Proceed with hardware erase"
+            elif result.frozen:
+                result.recommendation = "Thaw drive first or use software wipe"
+            elif result.locked:
+                result.recommendation = "Disable security first or use software wipe"
+            else:
+                result.recommendation = "Use software wipe"
+            
+        except subprocess.TimeoutExpired:
+            result.issues.append(f"Command timed out after {self.timeout}s")
+        except Exception as e:
+            result.issues.append(f"Unexpected error: {e}")
+        
+        return result
+    
+    def can_use_hardware_erase(self, device: str) -> PreCheckResult:
+        """
+        Determine if hardware erase will work.
+        Returns comprehensive pre-check result.
+        """
+        if not os.path.exists(device):
+            return PreCheckResult(issues=[f"Device {device} does not exist"])
+        
+        if 'nvme' in device:
+            return self.check_nvme_drive(device)
+        elif device.startswith('/dev/sd'):
+            return self.check_ata_drive(device)
+        else:
+            return PreCheckResult(issues=[f"Unsupported device type: {device}"])
+
+# ============================================================================
+# Part 3: Drive Eraser with Monitoring
+# ============================================================================
+
+class DriveEraser:
+    """Execute and monitor hardware secure erase"""
+    
+    def __init__(self, progress_callback: Optional[Callable] = None):
+        self.status = EraseStatus.NOT_STARTED
+        self.start_time = None
+        self.progress_callback = progress_callback
+        self.monitor_thread = None
+        self.current_process = None
+        
+    def start_nvme_erase(self, device: str) -> bool:
+        """Start NVMe secure erase (non-blocking)"""
+        try:
+            self.current_process = subprocess.Popen(
+                ['nvme', 'format', device, '--ses=1'],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True
+            )
+            
+            self.status = EraseStatus.STARTING
+            self.start_time = time.time()
+            self._start_monitoring(device, 'nvme')
+            return True
+            
+        except Exception as e:
+            print(f"Failed to start NVMe erase: {e}")
+            self.status = EraseStatus.FAILED
+            return False
+    
+    def start_ata_erase(self, device: str, enhanced: bool = True) -> bool:
+        """Start ATA secure erase (non-blocking)"""
+        try:
+            # Build command
+            cmd = ['hdparm', '--user-master', 'u']
+            if enhanced:
+                cmd.extend(['--security-erase-enhanced', 'NULL'])
+            else:
+                cmd.extend(['--security-erase', 'NULL'])
+            cmd.append(device)
+            
+            self.current_process = subprocess.Popen(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True
+            )
+            
+            self.status = EraseStatus.STARTING
+            self.start_time = time.time()
+            self._start_monitoring(device, 'ata')
+            return True
+            
+        except Exception as e:
+            print(f"Failed to start ATA erase: {e}")
+            self.status = EraseStatus.FAILED
+            return False
+    
+    def _start_monitoring(self, device: str, drive_type: str):
+        """Start background monitoring thread"""
+        def monitor():
+            time.sleep(3)  # Let command start
+            self.status = EraseStatus.IN_PROGRESS
+            
+            check_interval = 5
+            max_checks = 7200  # 10 hours max
+            
+            for _ in range(max_checks):
+                # Check if process completed
+                if self.current_process and self.current_process.poll() is not None:
+                    if self.current_process.returncode == 0:
+                        self.status = EraseStatus.COMPLETE
+                    else:
+                        self.status = EraseStatus.FAILED
+                    break
+                
+                # Update progress callback
+                if self.progress_callback:
+                    elapsed = time.time() - self.start_time
+                    progress = self._estimate_progress(elapsed, drive_type)
+                    self.progress_callback(progress, elapsed, self.status)
+                
+                time.sleep(check_interval)
+            else:
+                self.status = EraseStatus.FAILED
+        
+        self.monitor_thread = threading.Thread(target=monitor, daemon=True)
+        self.monitor_thread.start()
+    
+    def _estimate_progress(self, elapsed_seconds: float, drive_type: str) -> float:
+        """Estimate fake progress based on typical times"""
+        if drive_type == 'nvme':
+            progress = min(1.0, elapsed_seconds / 30)
+        elif drive_type == 'ata':
+            # Very rough estimate - would need drive size for better guess
+            progress = min(1.0, elapsed_seconds / 3600)
+        else:
+            progress = 0.0
+        
+        return progress * 100
+    
+    def get_status(self) -> Dict:
+        """Get current status info"""
+        elapsed = time.time() - self.start_time if self.start_time else 0
+        
+        return {
+            'status': self.status.value,
+            'elapsed_seconds': elapsed,
+            'monitor_alive': self.monitor_thread and self.monitor_thread.is_alive(),
+            'process_active': self.current_process and self.current_process.poll() is None
+        }
+    
+    def wait_for_completion(self, timeout: Optional[float] = None) -> bool:
+        """Wait for erase to complete"""
+        if not self.current_process:
+            return False
+        
+        try:
+            return_code = self.current_process.wait(timeout=timeout)
+            return return_code == 0
+        except subprocess.TimeoutExpired:
+            return False
+
+# ============================================================================
+# Part 4: Main Wipe Controller (Integration Point)
+# ============================================================================
+
+class HardwareWipeController:
+    """
+    Main controller for hardware wiping.
+    This is what you'd integrate into dwipe.
+    """
+    
+    def __init__(self, auto_install_tools: bool = False, verbose: bool = False):
+        self.tool_mgr = ToolManager(auto_install=auto_install_tools, verbose=verbose)
+        self.pre_checker = DrivePreChecker(timeout=15)
+        self.eraser = None
+        self.verbose = verbose
+    
+    def _log(self, message: str):
+        if self.verbose:
+            print(f"[HardwareWipe] {message}")
+    
+    def prepare(self) -> bool:
+        """Ensure required tools are available"""
+        if not self.tool_mgr.ensure_tool('hdparm', critical=True):
+            return False
+        if not self.tool_mgr.ensure_tool('nvme', critical=True):
+            return False
+        return True
+    
+    def pre_check(self, device: str) -> PreCheckResult:
+        """Perform comprehensive pre-check"""
+        self._log(f"Pre-checking {device}...")
+        result = self.pre_checker.can_use_hardware_erase(device)
+        
+        if self.verbose:
+            print(f"Pre-check for {device}:")
+            print(f"  Compatible: {result.compatible}")
+            print(f"  Tool: {result.tool}")
+            if result.issues:
+                print(f"  Issues: {', '.join(result.issues)}")
+            if result.recommendation:
+                print(f"  Recommendation: {result.recommendation}")
+        
+        return result
+    
+    def wipe(self, device: str, fallback_callback: Optional[Callable] = None) -> bool:
+        """
+        Execute hardware wipe with automatic fallback.
+        
+        Args:
+            device: Device path (/dev/sda, /dev/nvme0n1, etc.)
+            fallback_callback: Function to call if hardware wipe fails
+                               Should accept device path and return bool
+        
+        Returns:
+            True if wipe succeeded (hardware or software), False otherwise
+        """
+        if not self.prepare():
+            print("Required tools not available")
+            return False
+        
+        # Step 1: Pre-check
+        pre_check = self.pre_check(device)
+        
+        if not pre_check.compatible:
+            print(f"Hardware erase not compatible for {device}:")
+            for issue in pre_check.issues:
+                print(f"  - {issue}")
+            
+            if fallback_callback:
+                self._log("Falling back to software wipe...")
+                return fallback_callback(device)
+            return False
+        
+        # Step 2: Show user what to expect
+        tool_name = pre_check.tool
+        print(f"Using {tool_name} for hardware secure erase...")
+        print("Note: Drive erases in firmware - tool will exit immediately.")
+        
+        if tool_name == 'nvme':
+            print("Expected time: 2-10 seconds")
+        elif tool_name == 'hdparm' and pre_check.enhanced_supported:
+            print("Expected time: 10-60 seconds (enhanced erase)")
+        elif tool_name == 'hdparm':
+            print("Expected time: 1-3 hours per TB (normal erase)")
+        
+        # Step 3: Start erase
+        self.eraser = DriveEraser(progress_callback=self._progress_update)
+        
+        try:
+            if tool_name == 'nvme':
+                success = self.eraser.start_nvme_erase(device)
+            else:  # hdparm
+                enhanced = pre_check.enhanced_supported
+                success = self.eraser.start_ata_erase(device, enhanced)
+            
+            if not success:
+                raise RuntimeError("Failed to start erase")
+            
+            # Step 4: Monitor with timeout
+            timeout = self._get_timeout(tool_name, device)
+            print(f"Waiting up to {timeout//60} minutes for completion...")
+            
+            # Simple spinner while waiting
+            spinner = ['|', '/', '-', '\\']
+            i = 0
+            
+            while True:
+                status = self.eraser.get_status()
+                
+                if status['status'] == EraseStatus.COMPLETE.value:
+                    print(f"\nHardware secure erase completed successfully!")
+                    return True
+                
+                elif status['status'] == EraseStatus.FAILED.value:
+                    print(f"\nHardware secure erase failed")
+                    break
+                
+                # Show spinner and elapsed time
+                elapsed = status['elapsed_seconds']
+                print(f"\r{spinner[i % 4]} Erasing... {int(elapsed)}s elapsed", end='')
+                i += 1
+                
+                # Check timeout
+                if elapsed > timeout:
+                    print(f"\nTimeout after {timeout} seconds")
+                    break
+                
+                time.sleep(0.5)
+            
+            # If we get here, hardware failed
+            if fallback_callback:
+                print("Falling back to software wipe...")
+                return fallback_callback(device)
+            
+            return False
+            
+        except Exception as e:
+            print(f"Error during hardware erase: {e}")
+            if fallback_callback:
+                return fallback_callback(device)
+            return False
+    
+    def _progress_update(self, progress: float, elapsed: float, status: EraseStatus):
+        """Callback for progress updates"""
+        if self.verbose:
+            print(f"[Progress] {progress:.1f}% - {elapsed:.0f}s - {status.value}")
+    
+    def _get_timeout(self, tool: str, device: str) -> int:
+        """Get appropriate timeout based on drive type"""
+        if tool == 'nvme':
+            return 30  # 30 seconds for NVMe
+        elif tool == 'hdparm':
+            # Try to get drive size for better timeout
+            try:
+                size_gb = self._get_drive_size_gb(device)
+                # 2 hours per TB, minimum 30 minutes
+                hours = max(0.5, (size_gb / 1024) * 2)
+                return int(hours * 3600)
+            except:
+                return 7200  # 2 hours default
+        return 3600  # 1 hour default
+    
+    def _get_drive_size_gb(self, device: str) -> float:
+        """Get drive size in GB"""
+        try:
+            # Use blockdev to get size
+            result = subprocess.run(
+                ['blockdev', '--getsize64', device],
+                capture_output=True,
+                text=True,
+                timeout=5
+            )
+            if result.returncode == 0:
+                size_bytes = int(result.stdout.strip())
+                return size_bytes / (1024**3)  # Convert to GB
+        except:
+            pass
+        return 500  # Default guess
+
+# ============================================================================
+# Part 5: Example Usage & Integration Helper
+# ============================================================================
+
+def example_software_wipe(device: str) -> bool:
+    """Example fallback function for software wipe"""
+    print(f"[Software] Would wipe {device} with dd/scrub/etc.")
+    # Implement your existing software wipe here
+    return True
+
+def main():
+    """Example standalone usage"""
+    import argparse
+    
+    parser = argparse.ArgumentParser(description='Hardware Secure Erase Test')
+    parser.add_argument('device', help='Device to wipe (e.g., /dev/sda)')
+    parser.add_argument('--auto-install', action='store_true', 
+                       help='Automatically install missing tools')
+    parser.add_argument('--verbose', '-v', action='store_true',
+                       help='Verbose output')
+    parser.add_argument('--no-fallback', action='store_true',
+                       help='Don\'t fall back to software wipe')
+    args = parser.parse_args()
+    
+    # Create controller
+    controller = HardwareWipeController(
+        auto_install_tools=args.auto_install,
+        verbose=args.verbose
+    )
+    
+    # Define fallback
+    fallback = None if args.no_fallback else example_software_wipe
+    
+    # Execute wipe
+    success = controller.wipe(args.device, fallback_callback=fallback)
+    
+    if success:
+        print(f"\n✓ Wipe completed successfully")
+        return 0
+    else:
+        print(f"\n✗ Wipe failed")
+        return 1
+
+if __name__ == '__main__':
+    sys.exit(main())

{dwipe-2.0.0.dist-info → dwipe-2.0.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dwipe
-Version: 2.0.0
+Version: 2.0.1
 Summary: A tool to wipe disks and partitions for Linux
 Keywords: disk,partition,wipe,clean,scrub
 Author-email: Joe Defen <joedef@google.com>
@@ -10,7 +10,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: POSIX :: Linux
 License-File: LICENSE
-Requires-Dist: console-window >= 1.0.0
+Requires-Dist: console-window == 1.3.2
 Project-URL: Bug Tracker, https://github.com/joedefen/dwipe/issues
 Project-URL: Homepage, https://github.com/joedefen/dwipe
 
@@ -60,6 +60,9 @@ Project-URL: Homepage, https://github.com/joedefen/dwipe
 * **Direct I/O to Disk** - Wiping is done with direct I/O which is fast and avoid polluting your page cache. Writer threads are given lower than normal I/O priority to play nice with other apps.  This makes stopping jobs fast and certain.
 * **Improved Handling of Bad Disks.** Now detects (sometimes corrects) write failures, slowdowns, excessive no progress, and reports/aborts hopeless or hopelessly slow wipes.
 
+## **V2.x Features**
+Features added since V2 deployed (may not be in latest demo):
+* **Port and Serial number**.  Press `p` to toggle whether port and serial number is show; it adds another line per disk and you may want to use it selectively.
 ## Requirements
 - **Linux operating system** (uses `/dev/`, `/sys/`, `/proc/` interfaces)
 - **Python 3.8 or higher**

dwipe-2.0.1.dist-info/RECORD

@@ -0,0 +1,14 @@
+dwipe/DeviceInfo.py,sha256=7ZgtLDT1z5QwMWVwEb9Q3-wonvuPyAWgl7Xl5o14XbY,25777
+dwipe/DiskWipe.py,sha256=SVfcGDMZccGBocpS5U8JXI-Y2UzRix3jAzzaYPVRCDc,40161
+dwipe/PersistentState.py,sha256=FZydQs_-VYiq-Gw0hvcWPeuWOU5VFgI-FvrUsbT92RQ,6339
+dwipe/ToolManager.py,sha256=EpG_588Q76IzFfjrTM5LSnhTUC1CoBeCUdqtR0duliY,23371
+dwipe/Utils.py,sha256=Cuq8Usamrq1DWUk8EtjTuD6lSLXYGY0x-pDcoLJBR8M,7714
+dwipe/WipeJob.py,sha256=bjv_hVuH5DBDgY5-y3Mv11URhsBu1t1iu8lx76dmAhE,54486
+dwipe/WipeJobFuture.py,sha256=urkrASHtqELsKQ5c7OMc_LxpgIiYAIOeb1ZixQYmp74,8746
+dwipe/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dwipe/main.py,sha256=Zyw9LFBGqWYxga1H9qTdQGHLyCsxZUg3tm_Ylj20FG4,1841
+dwipe-2.0.1.dist-info/entry_points.txt,sha256=SZHFezmse2c-jxG-BJ0TXy_TZ8vVFf0lPJWs0cdxz6Y,41
+dwipe-2.0.1.dist-info/licenses/LICENSE,sha256=qB9OdnyyF6WYHiEIXVm0rOSdcf8e2ctorrtWs6CC5lU,1062
+dwipe-2.0.1.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+dwipe-2.0.1.dist-info/METADATA,sha256=kcykkG3kr9kyZ0T6nUN_dGCxbC3E2fh26HovbCnqGD4,21957
+dwipe-2.0.1.dist-info/RECORD,,

dwipe-2.0.0.dist-info/RECORD

@@ -1,13 +0,0 @@
-dwipe/DeviceInfo.py,sha256=MKoxZ5iDzKdJwIRWn2Sjpdl28tbqsW5_O3SRctpYXRE,21395
-dwipe/DiskWipe.py,sha256=nmnK4gGxvzvKV5Z4i_Ef4eENyTt-Ld0G_mfk-0dPHzg,39611
-dwipe/PersistentState.py,sha256=-2jcq5lOo6wFMUxCYR5Vxwgs4gk8KXasH-RVNSCymPY,6847
-dwipe/Utils.py,sha256=Cuq8Usamrq1DWUk8EtjTuD6lSLXYGY0x-pDcoLJBR8M,7714
-dwipe/WipeJob.py,sha256=bjv_hVuH5DBDgY5-y3Mv11URhsBu1t1iu8lx76dmAhE,54486
-dwipe/WipeJobFuture.py,sha256=urkrASHtqELsKQ5c7OMc_LxpgIiYAIOeb1ZixQYmp74,8746
-dwipe/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dwipe/main.py,sha256=Zyw9LFBGqWYxga1H9qTdQGHLyCsxZUg3tm_Ylj20FG4,1841
-dwipe-2.0.0.dist-info/entry_points.txt,sha256=SZHFezmse2c-jxG-BJ0TXy_TZ8vVFf0lPJWs0cdxz6Y,41
-dwipe-2.0.0.dist-info/licenses/LICENSE,sha256=qB9OdnyyF6WYHiEIXVm0rOSdcf8e2ctorrtWs6CC5lU,1062
-dwipe-2.0.0.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
-dwipe-2.0.0.dist-info/METADATA,sha256=PIIIZRcbEsmmd2c3noJyGVACbQyqIgUZZiv3IW618ko,21713
-dwipe-2.0.0.dist-info/RECORD,,