Update module interface...

core/base.py

@@ -259,20 +259,20 @@ class Base:
             self.logs.error(err)
             return False
 
-    def db_update_core_config(self, module_name:str, dataclassObj: object, param_key:str, param_value: str) -> bool:
+    def db_update_core_config(self, module_name:str, dataclass_obj: object, param_key:str, param_value: str) -> bool:
 
         core_table = self.Config.TABLE_CONFIG
         # Check if the param exist
-        if not hasattr(dataclassObj, param_key):
+        if not hasattr(dataclass_obj, param_key):
             self.logs.error(f"Le parametre {param_key} n'existe pas dans la variable global")
             return False
 
         mes_donnees = {'module_name': module_name, 'param_key': param_key, 'param_value': param_value}
         search_param_query = f"SELECT id FROM {core_table} WHERE module_name = :module_name AND param_key = :param_key"
         result = self.db_execute_query(search_param_query, mes_donnees)
-        isParamExist = result.fetchone()
+        is_param_exist = result.fetchone()
 
-        if not isParamExist is None:
+        if not is_param_exist is None:
             mes_donnees = {'datetime': self.Utils.get_sdatetime(),
                            'module_name': module_name,
                            'param_key': param_key,
@@ -282,14 +282,14 @@ class Base:
             update = self.db_execute_query(query, mes_donnees)
             updated_rows = update.rowcount
             if updated_rows > 0:
-                setattr(dataclassObj, param_key, self.int_if_possible(param_value))
+                setattr(dataclass_obj, param_key, self.int_if_possible(param_value))
                 self.logs.debug(f'Parameter updated : {param_key} - {param_value} | Module: {module_name}')
             else:
                 self.logs.error(f'Parameter NOT updated : {param_key} - {param_value} | Module: {module_name}')
         else:
             self.logs.error(f'Parameter and Module do not exist: Param ({param_key}) - Value ({param_value}) | Module ({module_name})')
 
-        self.logs.debug(dataclassObj)
+        self.logs.debug(dataclass_obj)
 
         return True
 
@@ -362,7 +362,7 @@ class Base:
         except Exception as err:
             self.logs.error(err, exc_info=True)
 
-    def create_asynctask(self, func: Callable, *, async_name: str = None, run_once: bool = False) -> asyncio.Task:
+    def create_asynctask(self, func: Any, *, async_name: str = None, run_once: bool = False) -> asyncio.Task:
         """Create a new asynchrone and store it into running_asynctasks variable
 
         Args:

core/classes/interfaces/imodule.py

@@ -1,5 +1,5 @@
 from abc import ABC, abstractmethod
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING, Optional, Union
 from dataclasses import dataclass
 
 if TYPE_CHECKING:
@@ -15,74 +15,38 @@ class IModule(ABC):
 
     def __init__(self, uplink: 'Loader') -> None:
 
+        # import the context
+        self.ctx = uplink
+
         # Module name (Mandatory)
         self.module_name = 'mod_' + str(self.__class__.__name__).lower()
 
-        # Add Irc Object to the module (Mandatory)
-        self.Irc = uplink.Irc
-
-        # Add Loader object to the module (Mandatory)
-        self.Loader = uplink
-
-        # Add Protocol to the module (Mandatory)
-        self.Protocol = uplink.Irc.Protocol
-
-        # Add Global Configuration to the module (Mandatory)
-        self.Config = uplink.Config
-
-        # Add Settings to the module (Mandatory)
-        self.Settings = uplink.Settings
-
-        # Add Base object to the module (Mandatory)
-        self.Base = uplink.Base
-
-        # Add Main Utils (Mandatory)
-        self.MainUtils = uplink.Utils
-
-        # Add logs object to the module (Mandatory)
-        self.Logs = uplink.Logs
-
-        # Add User object to the module (Mandatory)
-        self.User = uplink.User
-
-        # Add Client object to the module (Mandatory)
-        self.Client = uplink.Client
-
-        # Add Admin object to the module (Mandatory)
-        self.Admin = uplink.Admin
-
-        # Add Channel object to the module (Mandatory)
-        self.Channel = uplink.Channel
-
-        # Add Reputation object to the module (Optional)
-        self.Reputation = uplink.Reputation
-
         # Log the module
-        self.Logs.debug(f'Loading Module {self.module_name} ...')
+        self.ctx.Logs.debug(f'Loading Module {self.module_name} ...')
 
     def init(self) -> None:
         self.load()
-        self.inspect_class()
         self.create_tables()
 
         # Sync the configuration with core configuration (Mandatory)
-        self.Base.db_sync_core_config(self.module_name, self.ModConfig)
+        self.ctx.Base.db_sync_core_config(self.module_name, self.mod_config)
         return None
 
-    def inspect_class(self):
-        if not hasattr(self, 'ModConfig'):
-            raise AttributeError("The Module must init ModConfig attribute in the load method!")
-        if not hasattr(self, 'MOD_HEADER'):
-            raise NotImplementedError(f"You must declare the header of the module in {self.__class__.__name__}!")
-
-    def update_configuration(self, param_key: str, param_value: str) -> None:
+    def update_configuration(self, param_key: str, param_value: Union[str, int]) -> None:
         """Update the local and core configuration
 
         Args:
             param_key (str): The parameter key
             param_value (str): The parameter value
         """
-        self.Base.db_update_core_config(self.module_name, self.ModConfig, param_key, param_value)
+        self.ctx.Base.db_update_core_config(self.module_name, self.mod_config, param_key, param_value)
+
+    @property
+    @abstractmethod
+    def mod_config(self) -> ModConfModel:
+        """
+        The module configuration model
+        """
 
     @abstractmethod
     def create_tables(self) -> None: