videoarchiver/config/validation_manager.py

videoarchiver/config/role_manager.py
videoarchiver/database/connection_manager.py
videoarchiver/database/schema_manager.py
videoarchiver/queue/cleaners/tracking_cleaner.py
videoarchiver/exceptions.py
videoarchiver/processor.py
videoarchiver/commands.py
videoarchiver/update_checker.py
videoarchiver/utils/path_manager.py
videoarchiver/utils/file_ops.py
videoarchiver/processor/message_validator.py
videoarchiver/utils/download_manager.py

videoarchiver/__init__.py

@@ -28,21 +28,21 @@ for module in modules_to_reload:
         del sys.modules[module]
 
 # Import and reload utils
-from . import utils
-importlib.reload(utils)
+import videoarchiver.utils
+importlib.reload(videoarchiver.utils)
 
 # Import and reload processor
-from . import processor
-importlib.reload(processor)
+import videoarchiver.processor
+importlib.reload(videoarchiver.processor)
 
 # Import and reload queue
-from . import queue
-importlib.reload(queue)
+import videoarchiver.queue
+importlib.reload(videoarchiver.queue)
 
-from .core.base import VideoArchiver
-from .core.initialization import initialize_cog, init_callback
-from .core.cleanup import cleanup_resources
-from .utils.exceptions import (
+from videoarchiver.core.base import VideoArchiver
+from videoarchiver.core.initialization import initialize_cog, init_callback
+from videoarchiver.core.cleanup import cleanup_resources
+from videoarchiver.utils.exceptions import (
     VideoArchiverError,
     CommandError,
     EventError,
@@ -51,12 +51,12 @@ from .utils.exceptions import (
     ErrorSeverity,
     ProcessingError
 )
-from .database import VideoArchiveDB
-from .ffmpeg import FFmpegManager
-from .queue import EnhancedVideoQueueManager
-from .processor import VideoProcessor
-from .config_manager import ConfigManager
-from .update_checker import UpdateChecker
+from videoarchiver.database import VideoArchiveDB
+from videoarchiver.ffmpeg import FFmpegManager
+from videoarchiver.queue import EnhancedVideoQueueManager
+from videoarchiver.processor import VideoProcessor
+from videoarchiver.config_manager import ConfigManager
+from videoarchiver.update_checker import UpdateChecker
 
 logger = logging.getLogger("VideoArchiver")
 

videoarchiver/commands.py

@@ -1,4 +1,4 @@
 """Re-export commands from core.base"""
-from .core.base import VideoArchiver
+from videoarchiver.core.base import VideoArchiver
 
 __all__ = ['VideoArchiver']

videoarchiver/config/__init__.py

@@ -1,6 +1,6 @@
 """Configuration management module"""
 
-from .exceptions import (
+from videoarchiver.config.exceptions import (
     ConfigurationError,
     ValidationError,
     PermissionError,
@@ -10,10 +10,10 @@ from .exceptions import (
     SchemaError,
     DiscordAPIError,
 )
-from .channel_manager import ChannelManager
-from .role_manager import RoleManager
-from .settings_formatter import SettingsFormatter
-from .validation_manager import ValidationManager
+from videoarchiver.config.channel_manager import ChannelManager
+from videoarchiver.config.role_manager import RoleManager
+from videoarchiver.config.settings_formatter import SettingsFormatter
+from videoarchiver.config.validation_manager import ValidationManager
 
 __all__ = [
     'ConfigurationError',

videoarchiver/config/channel_manager.py

@@ -4,10 +4,14 @@ import logging
 from typing import Dict, List, Optional, Tuple
 import discord
 
-from .exceptions import ConfigurationError as ConfigError, DiscordAPIError
+from videoarchiver.config.exceptions import (
+    ConfigurationError as ConfigError,
+    DiscordAPIError,
+)
 
 logger = logging.getLogger("ChannelManager")
 
+
 class ChannelManager:
     """Manages Discord channel configurations"""
 
@@ -15,19 +19,17 @@ class ChannelManager:
         self.config_manager = config_manager
 
     async def get_channel(
-        self,
-        guild: discord.Guild,
-        channel_type: str
+        self, guild: discord.Guild, channel_type: str
     ) -> Optional[discord.TextChannel]:
         """Get a channel by type
-        
+
         Args:
             guild: Discord guild
             channel_type: Type of channel (archive, notification, log)
-            
+
         Returns:
             Optional[discord.TextChannel]: Channel if found and valid
-            
+
         Raises:
             ConfigError: If channel type is invalid
             DiscordAPIError: If channel exists but is invalid type
@@ -35,159 +37,150 @@ class ChannelManager:
         try:
             if channel_type not in ["archive", "notification", "log"]:
                 raise ConfigError(f"Invalid channel type: {channel_type}")
-            
+
             settings = await self.config_manager.get_guild_settings(guild.id)
             channel_id = settings.get(f"{channel_type}_channel")
-            
+
             if channel_id is None:
                 return None
-            
+
             channel = guild.get_channel(channel_id)
             if channel is None:
                 logger.warning(f"Channel {channel_id} not found in guild {guild.id}")
                 return None
-            
+
+                return None
+
             if not isinstance(channel, discord.TextChannel):
                 raise DiscordAPIError(f"Channel {channel_id} is not a text channel")
-            
+
             return channel
-            
+
         except Exception as e:
-            logger.error(f"Failed to get {channel_type} channel for guild {guild.id}: {e}")
+            logger.error(
+                f"Failed to get {channel_type} channel for guild {guild.id}: {e}"
+            )
             raise ConfigError(f"Failed to get channel: {str(e)}")
 
     async def get_monitored_channels(
-        self,
-        guild: discord.Guild
+        self, guild: discord.Guild
     ) -> List[discord.TextChannel]:
         """Get all monitored channels for a guild
-        
+
         Args:
             guild: Discord guild
-            
+
         Returns:
             List[discord.TextChannel]: List of monitored channels
-            
+
         Raises:
             ConfigError: If channel retrieval fails
         """
         try:
             settings = await self.config_manager.get_guild_settings(guild.id)
             monitored_channel_ids = settings["monitored_channels"]
-            
+
             # If no channels are set to be monitored, return all text channels
             if not monitored_channel_ids:
                 return [
-                    channel for channel in guild.channels 
+                    channel
+                    for channel in guild.channels
                     if isinstance(channel, discord.TextChannel)
                 ]
-            
+
             # Otherwise, return only the specified channels
             channels: List[discord.TextChannel] = []
             invalid_channels: List[int] = []
-            
+
             for channel_id in monitored_channel_ids:
                 channel = guild.get_channel(channel_id)
                 if channel and isinstance(channel, discord.TextChannel):
                     channels.append(channel)
                 else:
                     invalid_channels.append(channel_id)
-                    logger.warning(f"Invalid monitored channel {channel_id} in guild {guild.id}")
-            
+                    logger.warning(
+                        f"Invalid monitored channel {channel_id} in guild {guild.id}"
+                    )
+
             # Clean up invalid channels if found
             if invalid_channels:
                 await self._remove_invalid_channels(guild.id, invalid_channels)
-            
+
             return channels
-            
+
         except Exception as e:
             logger.error(f"Failed to get monitored channels for guild {guild.id}: {e}")
             raise ConfigError(f"Failed to get monitored channels: {str(e)}")
 
     async def verify_channel_permissions(
-        self,
-        channel: discord.TextChannel,
-        required_permissions: List[str]
+        self, channel: discord.TextChannel, required_permissions: List[str]
     ) -> Tuple[bool, List[str]]:
         """Verify bot has required permissions in a channel
-        
+
         Args:
             channel: Channel to check
             required_permissions: List of required permission names
-            
+
         Returns:
             Tuple[bool, List[str]]: (Has all permissions, List of missing permissions)
         """
         try:
             bot_member = channel.guild.me
             channel_perms = channel.permissions_for(bot_member)
-            
+
             missing_perms = [
-                perm for perm in required_permissions
+                perm
+                for perm in required_permissions
                 if not getattr(channel_perms, perm, False)
             ]
-            
+
             return not bool(missing_perms), missing_perms
-            
+
         except Exception as e:
             logger.error(f"Error checking channel permissions: {e}")
             return False, ["Failed to check permissions"]
 
-    async def add_monitored_channel(
-        self,
-        guild_id: int,
-        channel_id: int
-    ) -> None:
+    async def add_monitored_channel(self, guild_id: int, channel_id: int) -> None:
         """Add a channel to monitored channels
-        
+
         Args:
             guild_id: Guild ID
             channel_id: Channel ID to add
-            
+
         Raises:
             ConfigError: If channel cannot be added
         """
         try:
             await self.config_manager.add_to_list(
-                guild_id,
-                "monitored_channels",
-                channel_id
+                guild_id, "monitored_channels", channel_id
             )
         except Exception as e:
             logger.error(f"Failed to add monitored channel {channel_id}: {e}")
             raise ConfigError(f"Failed to add monitored channel: {str(e)}")
 
-    async def remove_monitored_channel(
-        self,
-        guild_id: int,
-        channel_id: int
-    ) -> None:
+    async def remove_monitored_channel(self, guild_id: int, channel_id: int) -> None:
         """Remove a channel from monitored channels
-        
+
         Args:
             guild_id: Guild ID
             channel_id: Channel ID to remove
-            
+
         Raises:
             ConfigError: If channel cannot be removed
         """
         try:
             await self.config_manager.remove_from_list(
-                guild_id,
-                "monitored_channels",
-                channel_id
+                guild_id, "monitored_channels", channel_id
             )
         except Exception as e:
             logger.error(f"Failed to remove monitored channel {channel_id}: {e}")
             raise ConfigError(f"Failed to remove monitored channel: {str(e)}")
 
     async def _remove_invalid_channels(
-        self,
-        guild_id: int,
-        channel_ids: List[int]
+        self, guild_id: int, channel_ids: List[int]
     ) -> None:
         """Remove invalid channels from monitored channels
-        
+
         Args:
             guild_id: Guild ID
             channel_ids: List of invalid channel IDs to remove
@@ -199,27 +192,22 @@ class ChannelManager:
             logger.error(f"Error removing invalid channels: {e}")
 
     async def get_channel_info(
-        self,
-        guild: discord.Guild
+        self, guild: discord.Guild
     ) -> Dict[str, Optional[discord.TextChannel]]:
         """Get all configured channels for a guild
-        
+
         Args:
             guild: Discord guild
-            
+
         Returns:
             Dict[str, Optional[discord.TextChannel]]: Dictionary of channel types to channels
         """
         try:
             return {
-                'archive': await self.get_channel(guild, "archive"),
-                'notification': await self.get_channel(guild, "notification"),
-                'log': await self.get_channel(guild, "log")
+                "archive": await self.get_channel(guild, "archive"),
+                "notification": await self.get_channel(guild, "notification"),
+                "log": await self.get_channel(guild, "log"),
             }
         except Exception as e:
             logger.error(f"Error getting channel info: {e}")
-            return {
-                'archive': None,
-                'notification': None,
-                'log': None
-            }
+            return {"archive": None, "notification": None, "log": None}

videoarchiver/config/role_manager.py

@@ -4,7 +4,7 @@ import logging
 from typing import Dict, List, Set, Tuple, Optional, Any
 import discord
 
-from .exceptions import ConfigurationError as ConfigError
+from videoarchiver.config.exceptions import ConfigurationError as ConfigError
 
 logger = logging.getLogger("RoleManager")
 

videoarchiver/config/settings_formatter.py

@@ -5,7 +5,7 @@ from typing import Dict, Any, List
 from datetime import datetime
 import discord
 
-from .exceptions import ConfigurationError as ConfigError
+from videoarchiver.config.exceptions import ConfigurationError as ConfigError
 
 logger = logging.getLogger("SettingsFormatter")
 

videoarchiver/config/validation_manager.py

@@ -2,7 +2,7 @@
 
 import logging
 from typing import Any, Dict, List, Union
-from .exceptions import ConfigurationError as ConfigError
+from videoarchiver.config.exceptions import ConfigurationError as ConfigError
 
 logger = logging.getLogger("ConfigValidation")
 

videoarchiver/config_manager.py

@@ -6,11 +6,11 @@ from typing import Dict, Any, Optional, List, Union
 import discord
 from redbot.core import Config
 
-from .config.validation_manager import ValidationManager
-from .config.settings_formatter import SettingsFormatter
-from .config.channel_manager import ChannelManager
-from .config.role_manager import RoleManager
-from .utils.exceptions import ConfigurationError as ConfigError
+from videoarchiver.config.validation_manager import ValidationManager
+from videoarchiver.config.settings_formatter import SettingsFormatter
+from videoarchiver.config.channel_manager import ChannelManager
+from videoarchiver.config.role_manager import RoleManager
+from videoarchiver.utils.exceptions import ConfigurationError as ConfigError
 
 logger = logging.getLogger("VideoArchiver")
 

videoarchiver/core/__init__.py

@@ -1,5 +1,5 @@
 """Core module for VideoArchiver cog"""
 
-from .base import VideoArchiver
+from videoarchiver.core.base import VideoArchiver
 
 __all__ = ["VideoArchiver"]

videoarchiver/core/commands.py

@@ -6,7 +6,7 @@
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from .base import VideoArchiver
+    from videoarchiver.core.base import VideoArchiver
 
 def setup_commands(cog: "VideoArchiver") -> None:
     """Command setup is now handled in the VideoArchiver class"""

videoarchiver/core/commands/__init__.py

@@ -1,8 +1,8 @@
 """Command handlers for VideoArchiver"""
 
-from .archiver_commands import setup_archiver_commands
-from .database_commands import setup_database_commands
-from .settings_commands import setup_settings_commands
+from videoarchiver.core.commands.archiver_commands import setup_archiver_commands
+from videoarchiver.core.commands.database_commands import setup_database_commands
+from videoarchiver.core.commands.settings_commands import setup_settings_commands
 
 __all__ = [
     'setup_archiver_commands',

videoarchiver/database/__init__.py

@@ -1,9 +1,9 @@
 """Database management package for video archiving"""
 
-from .connection_manager import DatabaseConnectionManager
-from .query_manager import DatabaseQueryManager
-from .schema_manager import DatabaseSchemaManager
-from .video_archive_db import VideoArchiveDB
+from videoarchiver.database.connection_manager import DatabaseConnectionManager
+from videoarchiver.database.query_manager import DatabaseQueryManager
+from videoarchiver.database.schema_manager import DatabaseSchemaManager
+from videoarchiver.database.video_archive_db import VideoArchiveDB
 
 __all__ = [
     'DatabaseConnectionManager',

videoarchiver/database/connection_manager.py

@@ -10,7 +10,7 @@ import threading
 from queue import Queue, Empty
 from datetime import datetime
 
-from ..utils.exceptions import (
+from videoarchiver.utils.exceptions import (
     DatabaseError,
     ErrorContext,
     ErrorSeverity

videoarchiver/database/schema_manager.py

@@ -7,7 +7,7 @@ from typing import List, Dict, Any, Optional, TypedDict, ClassVar, Union
 from enum import Enum, auto
 from datetime import datetime
 
-from ..utils.exceptions import DatabaseError, ErrorContext, ErrorSeverity
+from videoarchiver.utils.exceptions import DatabaseError, ErrorContext, ErrorSeverity
 
 logger = logging.getLogger("DBSchemaManager")
 

videoarchiver/database/video_archive_db.py

@@ -4,9 +4,9 @@ import logging
 from pathlib import Path
 from typing import Optional, Dict, Any, List
 
-from .schema_manager import DatabaseSchemaManager
-from .query_manager import DatabaseQueryManager
-from .connection_manager import DatabaseConnectionManager
+from videoarchiver.database.schema_manager import DatabaseSchemaManager
+from videoarchiver.database.query_manager import DatabaseQueryManager
+from videoarchiver.database.connection_manager import DatabaseConnectionManager
 
 logger = logging.getLogger("VideoArchiverDB")
 

videoarchiver/exceptions.py

@@ -1,6 +1,6 @@
 """Base exceptions for VideoArchiver"""
 
-from .utils.exceptions import (
+from videoarchiver.utils.exceptions import (
     VideoArchiverError,
     ConfigurationError,
     VideoVerificationError,

videoarchiver/ffmpeg/__init__.py

@@ -18,12 +18,12 @@ logging.basicConfig(
 logger = logging.getLogger("VideoArchiver")
 
 # Import components after logging is configured
-from .ffmpeg_manager import FFmpegManager
-from .video_analyzer import VideoAnalyzer
-from .gpu_detector import GPUDetector
-from .encoder_params import EncoderParams
-from .ffmpeg_downloader import FFmpegDownloader
-from .exceptions import (
+from videoarchiver.ffmpeg.ffmpeg_manager import FFmpegManager
+from videoarchiver.ffmpeg.video_analyzer import VideoAnalyzer
+from videoarchiver.ffmpeg.gpu_detector import GPUDetector
+from videoarchiver.ffmpeg.encoder_params import EncoderParams
+from videoarchiver.ffmpeg.ffmpeg_downloader import FFmpegDownloader
+from videoarchiver.ffmpeg.exceptions import (
     FFmpegError,
     DownloadError,
     VerificationError,

videoarchiver/ffmpeg/binary_manager.py

@@ -5,15 +5,15 @@ import os
 from pathlib import Path
 from typing import Dict, Optional
 
-from .exceptions import (
+from videoarchiver.ffmpeg.exceptions import (
     FFmpegError,
     DownloadError,
     VerificationError,
     PermissionError,
     FFmpegNotFoundError
 )
-from .ffmpeg_downloader import FFmpegDownloader
-from .verification_manager import VerificationManager
+from videoarchiver.ffmpeg.ffmpeg_downloader import FFmpegDownloader
+from videoarchiver.ffmpeg.verification_manager import VerificationManager
 
 logger = logging.getLogger("FFmpegBinaryManager")
 

videoarchiver/ffmpeg/encoder_params.py

@@ -3,7 +3,7 @@
 import os
 import logging
 from typing import Dict, Any
-from .exceptions import CompressionError, QualityError, BitrateError
+from videoarchiver.ffmpeg.exceptions import CompressionError, QualityError, BitrateError
 
 logger = logging.getLogger("VideoArchiver")
 

videoarchiver/ffmpeg/ffmpeg_downloader.py

@@ -16,7 +16,7 @@ from typing import Optional, Dict, List
 import time
 import lzma
 
-from .exceptions import DownloadError
+from videoarchiver.ffmpeg.exceptions import DownloadError
 
 logger = logging.getLogger("VideoArchiver")
 

videoarchiver/ffmpeg/ffmpeg_manager.py

@@ -6,17 +6,17 @@ import multiprocessing
 from pathlib import Path
 from typing import Dict, Any, Optional
 
-from .exceptions import (
+from videoarchiver.ffmpeg.exceptions import (
     FFmpegError,
     AnalysisError,
     FFmpegNotFoundError
 )
-from .gpu_detector import GPUDetector
-from .video_analyzer import VideoAnalyzer
-from .encoder_params import EncoderParams
-from .process_manager import ProcessManager
-from .verification_manager import VerificationManager
-from .binary_manager import BinaryManager
+from videoarchiver.ffmpeg.gpu_detector import GPUDetector
+from videoarchiver.ffmpeg.video_analyzer import VideoAnalyzer
+from videoarchiver.ffmpeg.encoder_params import EncoderParams
+from videoarchiver.ffmpeg.process_manager import ProcessManager
+from videoarchiver.ffmpeg.verification_manager import VerificationManager
+from videoarchiver.ffmpeg.binary_manager import BinaryManager
 
 logger = logging.getLogger("VideoArchiver")
 

videoarchiver/ffmpeg/verification_manager.py

@@ -6,7 +6,7 @@ import subprocess
 from pathlib import Path
 from typing import Dict, List, Optional
 
-from .exceptions import (
+from videoarchiver.ffmpeg.exceptions import (
     TimeoutError,
     VerificationError,
     EncodingError,

videoarchiver/processor.py

@@ -1,6 +1,6 @@
 """Re-export video processing components from processor module"""
 
-from .processor import (
+from videoarchiver.processor import (
     VideoProcessor,
     REACTIONS,
     MessageHandler,

videoarchiver/processor/__init__.py

@@ -3,8 +3,8 @@
 from typing import Dict, Any, Optional, Union, List, Tuple
 import discord
 
-from .core import VideoProcessor
-from .constants import (
+from videoarchiver.processor.core import VideoProcessor
+from videoarchiver.processor.constants import (
     REACTIONS,
     ReactionType,
     ReactionEmojis,
@@ -12,7 +12,7 @@ from .constants import (
     get_reaction,
     get_progress_emoji
 )
-from .url_extractor import (
+from videoarchiver.processor.url_extractor import (
     URLExtractor,
     URLMetadata,
     URLPattern,
@@ -21,7 +21,7 @@ from .url_extractor import (
     URLValidator,
     URLMetadataExtractor
 )
-from .message_validator import (
+from videoarchiver.processor.message_validator import (
     MessageValidator,
     ValidationContext,
     ValidationRule,
@@ -32,9 +32,9 @@ from .message_validator import (
     ValidationCacheEntry,
     ValidationError
 )
-from .message_handler import MessageHandler
-from .queue_handler import QueueHandler
-from .reactions import (
+from videoarchiver.processor.message_handler import MessageHandler
+from videoarchiver.processor.queue_handler import QueueHandler
+from videoarchiver.processor.reactions import (
     handle_archived_reaction,
     update_queue_position_reaction,
     update_progress_reaction,

videoarchiver/processor/core.py

@@ -8,17 +8,17 @@ from datetime import datetime, timedelta
 import discord
 from discord.ext import commands
 
-from .message_handler import MessageHandler
-from .queue_handler import QueueHandler
+from videoarchiver.processor.message_handler import MessageHandler
+from videoarchiver.processor.queue_handler import QueueHandler
 from videoarchiver.utils import progress_tracker
-from .status_display import StatusDisplay
-from .cleanup_manager import CleanupManager, CleanupStrategy
-from .constants import REACTIONS
-from ..queue.manager import EnhancedVideoQueueManager
-from ..ffmpeg.ffmpeg_manager import FFmpegManager
-from ..database.video_archive_db import VideoArchiveDB
-from ..config_manager import ConfigManager
-from ..utils.exceptions import ProcessorError
+from videoarchiver.processor.status_display import StatusDisplay
+from videoarchiver.processor.cleanup_manager import CleanupManager, CleanupStrategy
+from videoarchiver.processor.constants import REACTIONS
+from videoarchiver.queue.manager import EnhancedVideoQueueManager
+from videoarchiver.ffmpeg.ffmpeg_manager import FFmpegManager
+from videoarchiver.database.video_archive_db import VideoArchiveDB
+from videoarchiver.config_manager import ConfigManager
+from videoarchiver.utils.exceptions import ProcessorError
 
 logger = logging.getLogger("VideoArchiver")
 

videoarchiver/processor/message_handler.py

@@ -8,13 +8,13 @@ from datetime import datetime, timedelta
 import discord
 from discord.ext import commands
 
-from .url_extractor import URLExtractor, URLMetadata
-from .message_validator import MessageValidator, ValidationError
-from .queue_processor import QueueProcessor, QueuePriority
-from .constants import REACTIONS
-from ..queue.manager import EnhancedVideoQueueManager
-from ..config_manager import ConfigManager
-from ..utils.exceptions import MessageHandlerError
+from videoarchiver.processor.url_extractor import URLExtractor, URLMetadata
+from videoarchiver.processor.message_validator import MessageValidator, ValidationError
+from videoarchiver.processor.queue_processor import QueueProcessor, QueuePriority
+from videoarchiver.processor.constants import REACTIONS
+from videoarchiver.queue.manager import EnhancedVideoQueueManager
+from videoarchiver.config_manager import ConfigManager
+from videoarchiver.utils.exceptions import MessageHandlerError
 
 logger = logging.getLogger("VideoArchiver")
 

videoarchiver/processor/message_validator.py

@@ -7,7 +7,7 @@ from typing import Dict, Optional, Tuple, List, Any, Callable, Set, TypedDict, C
 from datetime import datetime
 import discord
 
-from ..utils.exceptions import ValidationError
+from videoarchiver.utils.exceptions import ValidationError
 
 logger = logging.getLogger("VideoArchiver")
 

videoarchiver/processor/queue_handler.py

@@ -15,7 +15,7 @@ from videoarchiver.utils.message_manager import MessageManager
 from videoarchiver.utils.exceptions import QueueHandlerError
 from videoarchiver.queue.models import QueueItem
 from videoarchiver.config_manager import ConfigManager
-from .constants import REACTIONS
+from videoarchiver.processor.constants import REACTIONS
 
 logger = logging.getLogger("VideoArchiver")
 

videoarchiver/processor/reactions.py

@@ -7,8 +7,8 @@ from typing import List, Optional
 import discord
 from urllib.parse import urlparse
 
-from .constants import REACTIONS, ReactionType, get_reaction, get_progress_emoji
-from ..database.video_archive_db import VideoArchiveDB
+from videoarchiver.processor.constants import REACTIONS, ReactionType, get_reaction, get_progress_emoji
+from videoarchiver.database.video_archive_db import VideoArchiveDB
 
 logger = logging.getLogger("VideoArchiver")
 

videoarchiver/queue/__init__.py

@@ -1,10 +1,10 @@
 """Queue management package for video processing"""
 
-from .models import QueueItem, QueueMetrics
-from .manager import EnhancedVideoQueueManager
-from .persistence import QueuePersistenceManager, QueueError
-from .monitoring import QueueMonitor, MonitoringError
-from .cleanup import QueueCleaner, CleanupError
+from videoarchiver.queue.models import QueueItem, QueueMetrics
+from videoarchiver.queue.manager import EnhancedVideoQueueManager
+from videoarchiver.queue.persistence import QueuePersistenceManager, QueueError
+from videoarchiver.queue.monitoring import QueueMonitor, MonitoringError
+from videoarchiver.queue.cleanup import QueueCleaner, CleanupError
 
 __all__ = [
     'QueueItem',

videoarchiver/queue/cleaners/__init__.py

@@ -1,8 +1,8 @@
 """Queue cleaning functionality"""
 
-from .guild_cleaner import GuildCleaner
-from .history_cleaner import HistoryCleaner
-from .tracking_cleaner import TrackingCleaner
+from videoarchiver.queue.cleaners.guild_cleaner import GuildCleaner
+from videoarchiver.queue.cleaners.history_cleaner import HistoryCleaner
+from videoarchiver.queue.cleaners.tracking_cleaner import TrackingCleaner
 
 __all__ = [
     'GuildCleaner',

videoarchiver/queue/cleaners/guild_cleaner.py

@@ -1,12 +1,13 @@
 """Module for cleaning guild-specific queue items"""
 
 import logging
+import asyncio
 from enum import Enum
 from dataclasses import dataclass, field
 from typing import Dict, List, Set, Tuple, Any, Optional
 from datetime import datetime
 
-from ..models import QueueItem
+from videoarchiver.queue.models import QueueItem
 
 logger = logging.getLogger("GuildCleaner")
 

videoarchiver/queue/cleaners/history_cleaner.py

@@ -6,7 +6,7 @@ from dataclasses import dataclass, field
 from typing import Dict, Optional, List, Any, Set
 from datetime import datetime, timedelta
 
-from ..models import QueueItem
+from videoarchiver.queue.models import QueueItem
 
 logger = logging.getLogger("HistoryCleaner")
 

videoarchiver/queue/cleaners/tracking_cleaner.py

@@ -7,7 +7,7 @@ from dataclasses import dataclass, field
 from typing import Dict, List, Set, Tuple, Any, Optional
 from datetime import datetime
 
-from ..models import QueueItem
+from videoarchiver.queue.models import QueueItem
 
 logger = logging.getLogger("TrackingCleaner")
 

videoarchiver/queue/cleanup.py

@@ -7,16 +7,16 @@ from dataclasses import dataclass, field
 from typing import Dict, List, Set, Optional, Any, Tuple
 from datetime import datetime, timedelta
 
-from .models import QueueItem, QueueMetrics
-from .cleaners.history_cleaner import (
+from videoarchiver.queue.models import QueueItem, QueueMetrics
+from videoarchiver.queue.cleaners.history_cleaner import (
     HistoryCleaner,
     CleanupStrategy as HistoryStrategy
 )
-from .cleaners.guild_cleaner import (
+from videoarchiver.queue.cleaners.guild_cleaner import (
     GuildCleaner,
     GuildCleanupStrategy
 )
-from .cleaners.tracking_cleaner import (
+from videoarchiver.queue.cleaners.tracking_cleaner import (
     TrackingCleaner,
     TrackingCleanupStrategy
 )

videoarchiver/queue/manager.py

@@ -7,13 +7,13 @@ from dataclasses import dataclass, field
 from typing import Optional, Tuple, Dict, Any, List, Set, Callable
 from datetime import datetime, timedelta
 
-from .state_manager import QueueStateManager
-from .processor import QueueProcessor
-from .metrics_manager import QueueMetricsManager
-from .persistence import QueuePersistenceManager
-from .monitoring import QueueMonitor, MonitoringLevel
-from .cleanup import QueueCleaner
-from .models import QueueItem, QueueError, CleanupError
+from videoarchiver.queue.state_manager import QueueStateManager
+from videoarchiver.queue.processor import QueueProcessor
+from videoarchiver.queue.metrics_manager import QueueMetricsManager
+from videoarchiver.queue.persistence import QueuePersistenceManager
+from videoarchiver.queue.monitoring import QueueMonitor, MonitoringLevel
+from videoarchiver.queue.cleanup import QueueCleaner
+from videoarchiver.queue.models import QueueItem, QueueError, CleanupError
 
 logger = logging.getLogger("QueueManager")
 

videoarchiver/queue/monitoring.py

@@ -8,8 +8,8 @@ from dataclasses import dataclass, field
 from typing import Optional, Dict, Any, List, Set
 from datetime import datetime, timedelta
 
-from .health_checker import HealthChecker, HealthStatus, HealthCategory
-from .recovery_manager import RecoveryManager, RecoveryStrategy
+from videoarchiver.queue.health_checker import HealthChecker, HealthStatus, HealthCategory
+from videoarchiver.queue.recovery_manager import RecoveryManager, RecoveryStrategy
 
 logger = logging.getLogger("QueueMonitoring")
 

videoarchiver/queue/persistence.py

@@ -8,7 +8,7 @@ import fcntl
 import asyncio
 from datetime import datetime, timedelta
 from typing import Dict, Any, Optional
-from .models import QueueItem, QueueMetrics
+from videoarchiver.queue.models import QueueItem, QueueMetrics
 
 # Configure logging
 logging.basicConfig(

videoarchiver/queue/processor.py

@@ -8,9 +8,9 @@ from dataclasses import dataclass
 from typing import Callable, Optional, Tuple, List, Set, Dict, Any
 from datetime import datetime, timedelta
 
-from .models import QueueItem
-from .state_manager import QueueStateManager, ItemState
-from .monitoring import QueueMonitor
+from videoarchiver.queue.models import QueueItem
+from videoarchiver.queue.state_manager import QueueStateManager, ItemState
+from videoarchiver.queue.monitoring import QueueMonitor
 
 logger = logging.getLogger("QueueProcessor")
 

videoarchiver/queue/recovery_manager.py

@@ -1,12 +1,13 @@
 """Module for handling queue item recovery operations"""
 
 import logging
+import asyncio
 from enum import Enum
 from dataclasses import dataclass, field
 from typing import List, Tuple, Dict, Optional, Any, Set
 from datetime import datetime, timedelta
 
-from .models import QueueItem
+from videoarchiver.queue.models import QueueItem
 
 logger = logging.getLogger("QueueRecoveryManager")
 

videoarchiver/queue/state_manager.py

@@ -7,7 +7,7 @@ from dataclasses import dataclass
 from typing import Dict, Set, List, Optional, Any
 from datetime import datetime
 
-from .models import QueueItem, QueueMetrics
+from videoarchiver.queue.models import QueueItem, QueueMetrics
 
 logger = logging.getLogger("QueueStateManager")
 

videoarchiver/update_checker.py

@@ -15,7 +15,7 @@ import tempfile
 import os
 import shutil
 
-from .exceptions import UpdateError
+from videoarchiver.exceptions import UpdateError
 
 logger = logging.getLogger('VideoArchiver')
 

videoarchiver/utils/__init__.py

@@ -2,27 +2,27 @@
 
 from typing import Dict, Optional, Any, Union, List
 
-from .file_ops import (
+from videoarchiver.utils.file_ops import (
     cleanup_downloads,
     ensure_directory,
     get_file_size,
     is_valid_path,
     safe_delete
 )
-from .file_deletion import FileDeleter
-from .directory_manager import DirectoryManager
-from .permission_manager import PermissionManager
-from .download_manager import DownloadManager
-from .compression_manager import CompressionManager
-from .progress_tracker import (
+from videoarchiver.utils.file_deletion import FileDeleter
+from videoarchiver.utils.directory_manager import DirectoryManager
+from videoarchiver.utils.permission_manager import PermissionManager
+from videoarchiver.utils.download_manager import DownloadManager
+from videoarchiver.utils.compression_manager import CompressionManager
+from videoarchiver.utils.progress_tracker import (
     ProgressTracker,
     ProgressStatus,
     DownloadProgress,
     CompressionProgress,
     CompressionParams
 )
-from .path_manager import PathManager
-from .exceptions import (
+from videoarchiver.utils.path_manager import PathManager
+from videoarchiver.utils.exceptions import (
     # Base exception
     VideoArchiverError,
     ErrorSeverity,

videoarchiver/utils/compression_handler.py

@@ -7,11 +7,11 @@ import subprocess
 from datetime import datetime
 from typing import Dict, Optional, Callable, Set, Tuple
 
-from ..ffmpeg.ffmpeg_manager import FFmpegManager
-from ..ffmpeg.exceptions import CompressionError
-from .exceptions import VideoVerificationError
-from .file_operations import FileOperations
-from .progress_handler import ProgressHandler
+from videoarchiver.ffmpeg.ffmpeg_manager import FFmpegManager
+from videoarchiver.ffmpeg.exceptions import CompressionError
+from videoarchiver.utils.exceptions import VideoVerificationError
+from videoarchiver.utils.file_operations import FileOperations
+from videoarchiver.utils.progress_handler import ProgressHandler
 
 logger = logging.getLogger("VideoArchiver")
 

videoarchiver/utils/compression_manager.py

@@ -7,11 +7,11 @@ import subprocess
 from datetime import datetime
 from typing import Dict, Any, Optional, Callable, List, Set, Tuple
 
-from ..processor import _compression_progress
-from .compression_handler import CompressionHandler
-from .progress_handler import ProgressHandler
-from .file_operations import FileOperations
-from .exceptions import CompressionError, VideoVerificationError
+from videoarchiver.processor import _compression_progress
+from videoarchiver.utils.compression_handler import CompressionHandler
+from videoarchiver.utils.progress_handler import ProgressHandler
+from videoarchiver.utils.file_operations import FileOperations
+from videoarchiver.utils.exceptions import CompressionError, VideoVerificationError
 
 logger = logging.getLogger("VideoArchiver")
 

videoarchiver/utils/directory_manager.py

@@ -6,8 +6,8 @@ import asyncio
 from pathlib import Path
 from typing import List, Optional, Tuple
 
-from .exceptions import FileCleanupError
-from .file_deletion import SecureFileDeleter
+from videoarchiver.utils.exceptions import FileCleanupError
+from videoarchiver.utils.file_deletion import SecureFileDeleter
 
 logger = logging.getLogger("DirectoryManager")
 

videoarchiver/utils/download_core.py

@@ -7,12 +7,12 @@ import yt_dlp
 from typing import Dict, Optional, Callable, Tuple
 from pathlib import Path
 
-from .url_validator import check_url_support
-from .progress_handler import ProgressHandler, CancellableYTDLLogger
-from .file_operations import FileOperations
-from .compression_handler import CompressionHandler
-from .process_manager import ProcessManager
-from ..ffmpeg.ffmpeg_manager import FFmpegManager
+from videoarchiver.utils.url_validator import check_url_support
+from videoarchiver.utils.progress_handler import ProgressHandler, CancellableYTDLLogger
+from videoarchiver.utils.file_operations import FileOperations
+from videoarchiver.utils.compression_handler import CompressionHandler
+from videoarchiver.utils.process_manager import ProcessManager
+from videoarchiver.ffmpeg.ffmpeg_manager import FFmpegManager
 
 logger = logging.getLogger("VideoArchiver")
 

videoarchiver/utils/download_manager.py

@@ -9,9 +9,9 @@ from concurrent.futures import ThreadPoolExecutor
 from typing import Dict, List, Optional, Tuple, Callable, Any
 from pathlib import Path
 
-from .verification_manager import VideoVerificationManager
-from .compression_manager import CompressionManager
-from . import progress_tracker
+from videoarchiver.utils.verification_manager import VideoVerificationManager
+from videoarchiver.utils.compression_manager import CompressionManager
+from videoarchiver.utils import progress_tracker
 
 logger = logging.getLogger("DownloadManager")
 

videoarchiver/utils/file_deletion.py

@@ -7,7 +7,7 @@ import logging
 from pathlib import Path
 from typing import Optional
 
-from .exceptions import FileCleanupError
+from videoarchiver.utils.exceptions import FileCleanupError
 
 logger = logging.getLogger("FileDeleter")
 

videoarchiver/utils/file_operations.py

@@ -9,8 +9,8 @@ import subprocess
 from typing import Tuple
 from pathlib import Path
 
-from .exceptions import VideoVerificationError
-from .file_deletion import secure_delete_file
+from videoarchiver.utils.exceptions import VideoVerificationError
+from videoarchiver.utils.file_deletion import secure_delete_file
 
 logger = logging.getLogger("VideoArchiver")
 

videoarchiver/utils/file_ops.py

@@ -4,10 +4,10 @@ import logging
 from pathlib import Path
 from typing import List, Tuple, Optional
 
-from .exceptions import FileCleanupError
-from .file_deletion import SecureFileDeleter
-from .directory_manager import DirectoryManager
-from .permission_manager import PermissionManager
+from videoarchiver.utils.exceptions import FileCleanupError
+from videoarchiver.utils.file_deletion import SecureFileDeleter
+from videoarchiver.utils.directory_manager import DirectoryManager
+from videoarchiver.utils.permission_manager import PermissionManager
 
 logger = logging.getLogger("VideoArchiver")
 

videoarchiver/utils/path_manager.py

@@ -10,8 +10,8 @@ import time
 from typing import Generator, List, Optional
 from pathlib import Path
 
-from .exceptions import FileCleanupError
-from .permission_manager import PermissionManager
+from videoarchiver.utils.exceptions import FileCleanupError
+from videoarchiver.utils.permission_manager import PermissionManager
 
 logger = logging.getLogger("PathManager")
 

videoarchiver/utils/permission_manager.py

@@ -6,7 +6,7 @@ import logging
 from pathlib import Path
 from typing import Optional, Union, List
 
-from .exceptions import FileCleanupError
+from videoarchiver.utils.exceptions import FileCleanupError
 
 logger = logging.getLogger("PermissionManager")