fixed imports again

videoarchiver/config_manager.py

@@ -3,23 +3,24 @@
 import logging
 import asyncio
 from typing import Dict, Any, Optional, List, Union
-import discord # type: ignore
-from redbot.core import Config # type: ignore
+import discord  # type: ignore
+from redbot.core import Config  # type: ignore
 
-try:
-    # Try relative imports first
-    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
-except ImportError:
-    # Fall back to absolute imports if relative imports fail
-    # 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
+# try:
+# Try relative imports first
+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
+
+# except ImportError:
+# Fall back to absolute imports if relative imports fail
+# 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")
 
@@ -55,13 +56,13 @@ class ConfigManager:
         """Initialize configuration managers"""
         self.config = bot_config
         self.config.register_guild(**self.default_guild)
-        
+
         # Initialize managers
         self.validation_manager = ValidationManager()
         self.settings_formatter = SettingsFormatter()
         self.channel_manager = ChannelManager(self)
         self.role_manager = RoleManager(self)
-        
+
         # Thread safety
         self._config_locks: Dict[int, asyncio.Lock] = {}
 
@@ -80,108 +81,95 @@ class ConfigManager:
             logger.error(f"Failed to get guild settings for {guild_id}: {e}")
             raise ConfigError(f"Failed to get guild settings: {str(e)}")
 
-    async def update_setting(
-        self,
-        guild_id: int,
-        setting: str,
-        value: Any
-    ) -> None:
+    async def update_setting(self, guild_id: int, setting: str, value: Any) -> None:
         """Update a specific setting for a guild"""
         try:
             if setting not in self.default_guild:
                 raise ConfigError(f"Invalid setting: {setting}")
-            
+
             # Validate setting
             self.validation_manager.validate_setting(setting, value)
-            
+
             async with await self._get_guild_lock(guild_id):
                 await self.config.guild_from_id(guild_id).set_raw(setting, value=value)
-                
+
         except Exception as e:
-            logger.error(f"Failed to update setting {setting} for guild {guild_id}: {e}")
+            logger.error(
+                f"Failed to update setting {setting} for guild {guild_id}: {e}"
+            )
             raise ConfigError(f"Failed to update setting: {str(e)}")
 
-    async def get_setting(
-        self,
-        guild_id: int,
-        setting: str
-    ) -> Any:
+    async def get_setting(self, guild_id: int, setting: str) -> Any:
         """Get a specific setting for a guild"""
         try:
             if setting not in self.default_guild:
                 raise ConfigError(f"Invalid setting: {setting}")
-            
+
             async with await self._get_guild_lock(guild_id):
                 return await self.config.guild_from_id(guild_id).get_raw(setting)
-                
+
         except Exception as e:
             logger.error(f"Failed to get setting {setting} for guild {guild_id}: {e}")
             raise ConfigError(f"Failed to get setting: {str(e)}")
 
-    async def toggle_setting(
-        self,
-        guild_id: int,
-        setting: str
-    ) -> bool:
+    async def toggle_setting(self, guild_id: int, setting: str) -> bool:
         """Toggle a boolean setting for a guild"""
         try:
             if setting not in self.default_guild:
                 raise ConfigError(f"Invalid setting: {setting}")
-            
+
             async with await self._get_guild_lock(guild_id):
                 current = await self.get_setting(guild_id, setting)
                 if not isinstance(current, bool):
                     raise ConfigError(f"Setting {setting} is not a boolean")
-                
+
                 await self.update_setting(guild_id, setting, not current)
                 return not current
-                
+
         except Exception as e:
-            logger.error(f"Failed to toggle setting {setting} for guild {guild_id}: {e}")
+            logger.error(
+                f"Failed to toggle setting {setting} for guild {guild_id}: {e}"
+            )
             raise ConfigError(f"Failed to toggle setting: {str(e)}")
 
-    async def add_to_list(
-        self,
-        guild_id: int,
-        setting: str,
-        value: Any
-    ) -> None:
+    async def add_to_list(self, guild_id: int, setting: str, value: Any) -> None:
         """Add a value to a list setting"""
         try:
             if setting not in self.default_guild:
                 raise ConfigError(f"Invalid setting: {setting}")
-            
+
             async with await self._get_guild_lock(guild_id):
-                async with self.config.guild_from_id(guild_id).get_attr(setting)() as items:
+                async with self.config.guild_from_id(guild_id).get_attr(
+                    setting
+                )() as items:
                     if not isinstance(items, list):
                         raise ConfigError(f"Setting {setting} is not a list")
                     if value not in items:
                         items.append(value)
-                        
+
         except Exception as e:
             logger.error(f"Failed to add to list {setting} for guild {guild_id}: {e}")
             raise ConfigError(f"Failed to add to list: {str(e)}")
 
-    async def remove_from_list(
-        self,
-        guild_id: int,
-        setting: str,
-        value: Any
-    ) -> None:
+    async def remove_from_list(self, guild_id: int, setting: str, value: Any) -> None:
         """Remove a value from a list setting"""
         try:
             if setting not in self.default_guild:
                 raise ConfigError(f"Invalid setting: {setting}")
-            
+
             async with await self._get_guild_lock(guild_id):
-                async with self.config.guild_from_id(guild_id).get_attr(setting)() as items:
+                async with self.config.guild_from_id(guild_id).get_attr(
+                    setting
+                )() as items:
                     if not isinstance(items, list):
                         raise ConfigError(f"Setting {setting} is not a list")
                     if value in items:
                         items.remove(value)
-                        
+
         except Exception as e:
-            logger.error(f"Failed to remove from list {setting} for guild {guild_id}: {e}")
+            logger.error(
+                f"Failed to remove from list {setting} for guild {guild_id}: {e}"
+            )
             raise ConfigError(f"Failed to remove from list: {str(e)}")
 
     async def format_settings_embed(self, guild: discord.Guild) -> discord.Embed:
@@ -194,11 +182,15 @@ class ConfigManager:
             raise ConfigError(f"Failed to format settings: {str(e)}")
 
     # Channel management delegated to channel_manager
-    async def get_channel(self, guild: discord.Guild, channel_type: str) -> Optional[discord.TextChannel]:
+    async def get_channel(
+        self, guild: discord.Guild, channel_type: str
+    ) -> Optional[discord.TextChannel]:
         """Get a channel by type"""
         return await self.channel_manager.get_channel(guild, channel_type)
 
-    async def get_monitored_channels(self, guild: discord.Guild) -> List[discord.TextChannel]:
+    async def get_monitored_channels(
+        self, guild: discord.Guild
+    ) -> List[discord.TextChannel]:
         """Get all monitored channels for a guild"""
         return await self.channel_manager.get_monitored_channels(guild)