pacnpal/Pac-cogs
1
0
Fork 0
mirror of https://github.com/pacnpal/Pac-cogs.git synced 2025-12-20 02:41:06 -05:00
Code Issues Packages Projects Releases Wiki Activity

videoarchiver/config/validation_manager.py

Browse Source 
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
This commit is contained in:
pacnpal
2024-11-17 06:12:41 +00:00
parent 973714e281
commit c830be2841
53 changed files with 226 additions and 236 deletions
Download Patch File Download Diff File Expand all files Collapse all files

32
videoarchiver/__init__.py
View File

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

2
videoarchiver/commands.py
View File

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

10
videoarchiver/config/__init__.py
View File

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

132
videoarchiver/config/channel_manager.py
View File

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

2
videoarchiver/config/role_manager.py
View File

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

2
videoarchiver/config/settings_formatter.py
View File

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

2
videoarchiver/config/validation_manager.py
View File

@@ -2,7 +2,7 @@
import logging import logging
from typing import Any, Dict, List, Union 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") logger = logging.getLogger("ConfigValidation")

10
videoarchiver/config_manager.py
View File

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

2
videoarchiver/core/__init__.py
View File

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

2
videoarchiver/core/commands.py
View File

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

6
videoarchiver/core/commands/__init__.py
View File

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

8
videoarchiver/database/__init__.py
View File

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

2
videoarchiver/database/connection_manager.py
View File

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

2
videoarchiver/database/schema_manager.py
View File

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

6
videoarchiver/database/video_archive_db.py
View File

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

2
videoarchiver/exceptions.py
View File

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

12
videoarchiver/ffmpeg/__init__.py
View File

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

6
videoarchiver/ffmpeg/binary_manager.py
View File

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

2
videoarchiver/ffmpeg/encoder_params.py
View File

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

2
videoarchiver/ffmpeg/ffmpeg_downloader.py
View File

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

14
videoarchiver/ffmpeg/ffmpeg_manager.py
View File

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

2
videoarchiver/ffmpeg/verification_manager.py
View File

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

2
videoarchiver/processor.py
View File

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

14
videoarchiver/processor/__init__.py
View File

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

20
videoarchiver/processor/core.py
View File

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

14
videoarchiver/processor/message_handler.py
View File

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

2
videoarchiver/processor/message_validator.py
View File

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

2
videoarchiver/processor/queue_handler.py
View File

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

4
videoarchiver/processor/reactions.py
View File

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

10
videoarchiver/queue/__init__.py
View File

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

6
videoarchiver/queue/cleaners/__init__.py
View File

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

3
videoarchiver/queue/cleaners/guild_cleaner.py
View File

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

2
videoarchiver/queue/cleaners/history_cleaner.py
View File

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

2
videoarchiver/queue/cleaners/tracking_cleaner.py
View File

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

8
videoarchiver/queue/cleanup.py
View File

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

14
videoarchiver/queue/manager.py
View File

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

4
videoarchiver/queue/monitoring.py
View File

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

2
videoarchiver/queue/persistence.py
View File

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

6
videoarchiver/queue/processor.py
View File

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

3
videoarchiver/queue/recovery_manager.py
View File

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

2
videoarchiver/queue/state_manager.py
View File

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

2
videoarchiver/update_checker.py
View File

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

18
videoarchiver/utils/__init__.py
View File

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

10
videoarchiver/utils/compression_handler.py
View File

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

10
videoarchiver/utils/compression_manager.py
View File

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

4
videoarchiver/utils/directory_manager.py
View File

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

12
videoarchiver/utils/download_core.py
View File

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

6
videoarchiver/utils/download_manager.py
View File

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

2
videoarchiver/utils/file_deletion.py
View File

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

4
videoarchiver/utils/file_operations.py
View File

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

8
videoarchiver/utils/file_ops.py
View File

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

4
videoarchiver/utils/path_manager.py
View File

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

2
videoarchiver/utils/permission_manager.py
View File

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