Merge remote-tracking branch 'upstream/smell/too-many-instance-attributes' into smell/too-many-branches_and_too-many-statements

Author: saviosoaresUFC

bot/exts/filtering/_filters/filter.py

@@ -31,7 +31,7 @@ class Filter(FieldRequiring):
     # If a subclass uses extra fields, it should assign the pydantic model type to this variable.
     extra_fields_type = None
 
-    def __init__(self, filter_data: dict, defaults: Defaults | None = None):
+    def __init__(self, filter_data: dict, defaults: Defaults | None=None):
         self.id = filter_data["id"]
         self.content = filter_data["content"]
         self.description = filter_data["description"]
@@ -90,6 +90,15 @@ async def process_input(cls, content: str, description: str) -> tuple[str, str]:
         A BadArgument should be raised if the content can't be used.
         """
         return content, description
+    
+    
+    @property
+    def created_at(self) -> arrow.Arrow:
+        return self.timestamps.created_at
+
+    @property
+    def updated_at(self) -> arrow.Arrow:
+        return self.timestamps.updated_at
 
     def __str__(self) -> str:
         """A string representation of the filter."""

bot/exts/filtering/_ui/filter.py

@@ -1,4 +1,5 @@
 from collections.abc import Callable
+from dataclasses import dataclass
 from typing import Any
 
 import discord
@@ -110,6 +111,35 @@ async def on_submit(self, interaction: Interaction) -> None:
         await self.embed_view.apply_template(self.template.value, self.message, interaction)
 
 
+@dataclass
+class FilterTarget:
+    """The filter being edited and its context."""
+    filter_list: FilterList
+    list_type: ListType
+    filter_type: type[Filter]
+
+
+@dataclass
+class FilterContent:
+    """Content and description of the filter being edited."""
+    content: str | None
+    description: str | None
+
+
+def build_type_per_setting_name(
+    filter_type: type[Filter],
+    loaded_settings: dict,
+    loaded_filter_settings: dict,
+) -> dict:
+    """Build the type_per_setting_name dict from the loaded settings."""
+    type_per_setting_name = {setting: info[2] for setting, info in loaded_settings.items()}
+    type_per_setting_name.update({
+        f"{filter_type.name}/{name}": type_
+        for name, (_, _, type_) in loaded_filter_settings.get(filter_type.name, {}).items()
+    })
+    return type_per_setting_name
+
+
 class FilterEditView(EditBaseView):
     """A view used to edit a filter's settings before updating the database."""
 
@@ -118,11 +148,8 @@ class _REMOVE:
 
     def __init__(
         self,
-        filter_list: FilterList,
-        list_type: ListType,
-        filter_type: type[Filter],
-        content: str | None,
-        description: str | None,
+        filter_target: FilterTarget,
+        filter_content: FilterContent,
         settings_overrides: dict,
         filter_settings_overrides: dict,
         loaded: LoadedTypes,
@@ -131,19 +158,17 @@ def __init__(
         confirm_callback: Callable
     ):
         super().__init__(author)
-        self.filter_list = filter_list
-        self.list_type = list_type
-        self.filter_type = filter_type
-        self.content = content
-        self.description = description
+        self.filter_target = filter_target
+        self.filter_content = filter_content
         self.settings_overrides = settings_overrides
         self.filter_settings_overrides = filter_settings_overrides
         self.loaded = loaded
         self.embed = embed
         self.confirm_callback = confirm_callback
 
         all_settings_repr_dict = build_filter_repr_dict(
-            filter_list, list_type, filter_type, settings_overrides, filter_settings_overrides
+            filter_target.filter_list, filter_target.list_type, filter_target.filter_type,
+            settings_overrides, filter_settings_overrides
         )
         populate_embed_from_dict(embed, all_settings_repr_dict)
 
@@ -156,14 +181,15 @@ def __init__(
         add_select = CustomCallbackSelect(
             self._prompt_new_value,
             placeholder="Select a setting to edit",
-            options=[SelectOption(label=name) for name in sorted(self.type_per_setting_name)],
+            options=[SelectOption(label=name) for name in sorted(type_per_setting_name)],
             row=1
         )
         self.add_item(add_select)
 
         if settings_overrides or filter_settings_overrides:
             override_names = (
-                list(settings_overrides) + [f"{filter_list.name}/{setting}" for setting in filter_settings_overrides]
+                list(settings_overrides)
+                + [f"{filter_target.filter_list.name}/{setting}" for setting in filter_settings_overrides]
             )
             remove_select = CustomCallbackSelect(
                 self._remove_override,
@@ -199,21 +225,21 @@ async def enter_template(self, interaction: Interaction, button: discord.ui.Butt
     @discord.ui.button(label="✅ Confirm", style=discord.ButtonStyle.green, row=4)
     async def confirm(self, interaction: Interaction, button: discord.ui.Button) -> None:
         """Confirm the content, description, and settings, and update the filters database."""
-        if self.content is None:
+        if self.filter_content.content is None:
             await interaction.response.send_message(
                 ":x: Cannot add a filter with no content.", ephemeral=True, reference=interaction.message
             )
-        if self.description is None:
-            self.description = ""
+        if self.filter_content.description is None:
+            self.filter_content.description = ""
         await interaction.response.edit_message(view=None)  # Make sure the interaction succeeds first.
         try:
             await self.confirm_callback(
                 interaction.message,
-                self.filter_list,
-                self.list_type,
-                self.filter_type,
-                self.content,
-                self.description,
+                self.filter_target.filter_list,
+                self.filter_target.list_type,
+                self.filter_target.filter_type,
+                self.filter_content.content,
+                self.filter_content.description,
                 self.settings_overrides,
                 self.filter_settings_overrides
             )
@@ -348,7 +374,7 @@ async def apply_template(self, template_id: str, embed_message: discord.Message,
         """Replace any non-overridden settings with overrides from the given filter."""
         try:
             settings, filter_settings = template_settings(
-                template_id, self.filter_list, self.list_type, self.filter_type
+                template_id, self.filter_target.filter_list, self.filter_target.list_type, self.filter_target.filter_type
             )
         except BadArgument as e:  # The interaction object is necessary to send an ephemeral message.
             await interaction.response.send_message(f":x: {e}", ephemeral=True)
@@ -373,11 +399,15 @@ async def _remove_override(self, interaction: Interaction, select: discord.ui.Se
     def copy(self) -> FilterEditView:
         """Create a copy of this view."""
         return FilterEditView(
-            self.filter_list,
-            self.list_type,
-            self.filter_type,
-            self.content,
-            self.description,
+            FilterTarget(
+                self.filter_target.filter_list,
+                self.filter_target.list_type,
+                self.filter_target.filter_type,
+            ),
+            FilterContent(
+                self.filter_content.content,
+                self.filter_content.description,
+            ),
             self.settings_overrides,
             self.filter_settings_overrides,
             self.loaded,

bot/exts/filtering/_ui/filter_list.py

@@ -88,8 +88,8 @@ def __init__(
         self.embed = embed
         self.confirm_callback = confirm_callback
 
-        self.settings_repr_dict = {name: to_serializable(value) for name, value in settings.items()}
-        populate_embed_from_dict(embed, self.settings_repr_dict)
+        settings_repr_dict = {name: to_serializable(value) for name, value in settings.items()}
+        populate_embed_from_dict(embed, settings_repr_dict)
 
         self.type_per_setting_name = {setting: info[2] for setting, info in loaded.settings.items()}
 
@@ -189,8 +189,8 @@ def __init__(
         self.embed = embed
         self.confirm_callback = confirm_callback
 
-        self.settings_repr_dict = build_filterlist_repr_dict(filter_list, list_type, new_settings)
-        populate_embed_from_dict(embed, self.settings_repr_dict)
+        settings_repr_dict = build_filterlist_repr_dict(filter_list, list_type, new_settings)
+        populate_embed_from_dict(embed, settings_repr_dict)
 
         self.type_per_setting_name = {setting: info[2] for setting, info in loaded.settings.items()}
 
@@ -221,11 +221,11 @@ async def cancel(self, interaction: Interaction, button: discord.ui.Button) -> N
         self.stop()
 
     def current_value(self, setting_name: str) -> Any:
-        """Get the current value stored for the setting or MISSING if none found."""
         if setting_name in self.settings:
             return self.settings[setting_name]
-        if setting_name in self.settings_repr_dict:
-            return self.settings_repr_dict[setting_name]
+        settings_repr_dict = build_filterlist_repr_dict(self.filter_list, self.list_type, self.settings)
+        if setting_name in settings_repr_dict:
+            return settings_repr_dict[setting_name]
         return MISSING
 
     async def update_embed(

bot/exts/filtering/_ui/search.py

@@ -1,4 +1,5 @@
 from collections.abc import Callable
+from dataclasses import dataclass
 from typing import Any
 
 import discord
@@ -298,7 +299,7 @@ async def apply_template(self, template_id: str, embed_message: discord.Message,
         """Set any unset criteria with settings values from the given filter."""
         try:
             settings, filter_settings, self.filter_type = template_settings(
-                template_id, self.loaded_filter_lists, self.filter_type
+                template_id, self.filter_resources.filter_lists, self.filter_type
             )
         except BadArgument as e:  # The interaction object is necessary to send an ephemeral message.
             await interaction.response.send_message(f":x: {e}", ephemeral=True)