fixed imports again

videoarchiver/ffmpeg/verification_manager.py

@@ -6,22 +6,23 @@ import subprocess
 from pathlib import Path
 from typing import Dict, List, Optional
 
-try:
-    # Try relative imports first
-    from .exceptions import (
-        TimeoutError,
-        VerificationError,
-        EncodingError,
-        handle_ffmpeg_error
-    )
-except ImportError:
-    # Fall back to absolute imports if relative imports fail
-    # from videoarchiver.ffmpeg.exceptions import (
-        TimeoutError,
-        VerificationError,
-        EncodingError,
-        handle_ffmpeg_error
-    )
+# try:
+# Try relative imports first
+from .exceptions import (
+    TimeoutError,
+    VerificationError,
+    EncodingError,
+    handle_ffmpeg_error,
+)
+
+# except ImportError:
+# Fall back to absolute imports if relative imports fail
+# from videoarchiver.ffmpeg.exceptions import (
+#     TimeoutError,
+#     VerificationError,
+#     EncodingError,
+#     handle_ffmpeg_error
+# )
 
 logger = logging.getLogger("FFmpegVerification")
 
@@ -33,18 +34,15 @@ class VerificationManager:
         self.process_manager = process_manager
 
     def verify_ffmpeg(
-        self,
-        ffmpeg_path: Path,
-        ffprobe_path: Path,
-        gpu_info: Dict[str, bool]
+        self, ffmpeg_path: Path, ffprobe_path: Path, gpu_info: Dict[str, bool]
     ) -> None:
         """Verify FFmpeg functionality with comprehensive checks
-        
+
         Args:
             ffmpeg_path: Path to FFmpeg binary
             ffprobe_path: Path to FFprobe binary
             gpu_info: Dictionary of GPU availability
-            
+
         Raises:
             VerificationError: If verification fails
             TimeoutError: If verification times out
@@ -53,13 +51,13 @@ class VerificationManager:
         try:
             # Check FFmpeg version
             self._verify_ffmpeg_version(ffmpeg_path)
-            
+
             # Check FFprobe version
             self._verify_ffprobe_version(ffprobe_path)
-            
+
             # Check FFmpeg capabilities
             self._verify_ffmpeg_capabilities(ffmpeg_path, gpu_info)
-            
+
             logger.info("FFmpeg verification completed successfully")
 
         except Exception as e:
@@ -72,8 +70,7 @@ class VerificationManager:
         """Verify FFmpeg version"""
         try:
             result = self._execute_command(
-                [str(ffmpeg_path), "-version"],
-                "FFmpeg version check"
+                [str(ffmpeg_path), "-version"], "FFmpeg version check"
             )
             logger.info(f"FFmpeg version: {result.stdout.split()[2]}")
         except Exception as e:
@@ -83,34 +80,32 @@ class VerificationManager:
         """Verify FFprobe version"""
         try:
             result = self._execute_command(
-                [str(ffprobe_path), "-version"],
-                "FFprobe version check"
+                [str(ffprobe_path), "-version"], "FFprobe version check"
             )
             logger.info(f"FFprobe version: {result.stdout.split()[2]}")
         except Exception as e:
             raise VerificationError(f"FFprobe version check failed: {e}")
 
     def _verify_ffmpeg_capabilities(
-        self,
-        ffmpeg_path: Path,
-        gpu_info: Dict[str, bool]
+        self, ffmpeg_path: Path, gpu_info: Dict[str, bool]
     ) -> None:
         """Verify FFmpeg capabilities and encoders"""
         try:
             result = self._execute_command(
                 [str(ffmpeg_path), "-hide_banner", "-encoders"],
-                "FFmpeg capabilities check"
+                "FFmpeg capabilities check",
             )
 
             # Verify required encoders
             required_encoders = self._get_required_encoders(gpu_info)
             available_encoders = result.stdout.lower()
-            
+
             missing_encoders = [
-                encoder for encoder in required_encoders
+                encoder
+                for encoder in required_encoders
                 if encoder not in available_encoders
             ]
-            
+
             if missing_encoders:
                 logger.warning(f"Missing encoders: {', '.join(missing_encoders)}")
                 if "libx264" in missing_encoders:
@@ -122,17 +117,12 @@ class VerificationManager:
             raise VerificationError(f"FFmpeg capabilities check failed: {e}")
 
     def _execute_command(
-        self,
-        command: List[str],
-        operation: str,
-        timeout: int = 10
+        self, command: List[str], operation: str, timeout: int = 10
     ) -> subprocess.CompletedProcess:
         """Execute a command with proper error handling"""
         try:
             result = self.process_manager.execute_command(
-                command,
-                timeout=timeout,
-                check=False
+                command, timeout=timeout, check=False
             )
 
             if result.returncode != 0:
@@ -152,14 +142,14 @@ class VerificationManager:
     def _get_required_encoders(self, gpu_info: Dict[str, bool]) -> List[str]:
         """Get list of required encoders based on GPU availability"""
         required_encoders = ["libx264"]
-        
+
         if gpu_info["nvidia"]:
             required_encoders.append("h264_nvenc")
         elif gpu_info["amd"]:
             required_encoders.append("h264_amf")
         elif gpu_info["intel"]:
             required_encoders.append("h264_qsv")
-            
+
         return required_encoders
 
     def verify_binary_permissions(self, binary_path: Path) -> None: