Update on_version method

core/base.py

@@ -194,14 +194,19 @@ class Base:
         file_hanlder = logging.FileHandler(f'logs{self.Config.OS_SEP}defender.log',encoding='UTF-8')
         file_hanlder.setLevel(self.Config.DEBUG_LEVEL)
 
+        stdout_handler = logging.StreamHandler()
+        stdout_handler.setLevel(50)
+
         # Define log format
         formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(filename)s - %(lineno)d - %(funcName)s - %(message)s')
 
         # Apply log format
         file_hanlder.setFormatter(formatter)
+        stdout_handler.setFormatter(formatter)
 
         # Add handler to logs
         self.logs.addHandler(file_hanlder)
+        self.logs.addHandler(stdout_handler)
 
         # Apply the filter
         self.logs.addFilter(self.replace_filter)
@@ -721,6 +726,23 @@ class Base:
         except TypeError:
             return value
 
+    def convert_to_int(self, value: any) -> Union[int, None]:
+        """Convert a value to int
+
+        Args:
+            value (any): Value to convert to int if possible
+
+        Returns:
+            Union[int, None]: Return the int value or None if not possible
+        """
+        try:
+            response = int(value)
+            return response
+        except ValueError:
+            return None
+        except TypeError:
+            return None
+
     def is_valid_ip(self, ip_to_control:str) -> bool:
 
         try:

core/classes/channel.py

@@ -2,6 +2,8 @@ from re import findall
 from typing import Union, Literal, TYPE_CHECKING
 from dataclasses import asdict
 
+from core.classes import user
+
 if TYPE_CHECKING:
     from core.definition import MChannel
     from core.base import Base
@@ -31,6 +33,10 @@ class Channel:
         result = False
         exist = False
 
+        if not self.Is_Channel(newChan.name):
+            self.Logs.error(f"The channel {newChan.name} is not valid, channel must start with #")
+            return False
+
         for record in self.UID_CHANNEL_DB:
             if record.name.lower() == newChan.name.lower():
                 # If the channel exist, update the user list and do not go further
@@ -129,6 +135,29 @@ class Channel:
         except Exception as err:
             self.Logs.error(f'{err}')
 
+    def is_user_present_in_channel(self, channel_name: str, uid: str) -> bool:
+        """Check if a user is present in the channel
+
+        Args:
+            channel_name (str): The channel to check
+            uid (str): The UID
+
+        Returns:
+            bool: True if the user is present in the channel
+        """
+        user_found = False
+        chan = self.get_Channel(channel_name=channel_name)
+        if chan is None:
+            return user_found
+
+        clean_uid = self.Base.clean_uid(uid=uid)
+        for chan_uid in chan.uids:
+            if self.Base.clean_uid(chan_uid) == clean_uid:
+                user_found = True
+                break
+
+        return user_found
+
     def clean_channel(self) -> None:
         """Remove Channels if empty
         """

core/classes/protocols/inspircd.py

@@ -46,7 +46,7 @@ class Inspircd:
         except AttributeError as ae:
             self.__Base.logs.critical(f"Attribute Error: {ae}")
 
-    def sendPrivMsg(self, nick_from: str, msg: str, channel: str = None, nick_to: str = None):
+    def send_priv_msg(self, nick_from: str, msg: str, channel: str = None, nick_to: str = None):
         """Sending PRIVMSG to a channel or to a nickname by batches
         could be either channel or nickname not both together
         Args:
@@ -76,7 +76,7 @@ class Inspircd:
         except Exception as err:
             self.__Base.logs.error(f"General Error: {err}")
 
-    def sendNotice(self, nick_from: str, nick_to: str, msg: str) -> None:
+    def send_notice(self, nick_from: str, nick_to: str, msg: str) -> None:
         """Sending NOTICE by batches
 
         Args:
@@ -179,7 +179,7 @@ class Inspircd:
         self.__Irc.Channel.insert(self.__Irc.Loader.Definition.MChannel(name=channel, uids=[self.__Config.SERVICE_ID]))
         return None
 
-    def sendQuit(self, uid: str, reason: str, print_log: True) -> None:
+    def send_quit(self, uid: str, reason: str, print_log: True) -> None:
         """Send quit message
 
         Args:
@@ -205,7 +205,7 @@ class Inspircd:
 
         return None
 
-    def sendUID(self, nickname:str, username: str, hostname: str, uid:str, umodes: str, vhost: str, remote_ip: str, realname: str, print_log: bool = True) -> None:
+    def send_uid(self, nickname:str, username: str, hostname: str, uid:str, umodes: str, vhost: str, remote_ip: str, realname: str, print_log: bool = True) -> None:
         """Send UID to the server
 
         Args:
@@ -243,7 +243,7 @@ class Inspircd:
         except Exception as err:
             self.__Base.logs.error(f"{__name__} - General Error: {err}")
 
-    def sendChanJoin(self, uidornickname: str, channel: str, password: str = None, print_log: bool = True) -> None:
+    def send_join_chan(self, uidornickname: str, channel: str, password: str = None, print_log: bool = True) -> None:
         """Joining a channel
 
         Args:
@@ -269,7 +269,7 @@ class Inspircd:
         self.__Irc.Channel.insert(self.__Irc.Loader.Definition.MChannel(name=channel, uids=[userObj.uid]))
         return None
 
-    def sendChanPart(self, uidornickname:str, channel: str, print_log: bool = True) -> None:
+    def send_part_chan(self, uidornickname:str, channel: str, print_log: bool = True) -> None:
         """Part from a channel
 
         Args:
@@ -633,7 +633,7 @@ class Inspircd:
                 ping_response = current_unixtime - recieved_unixtime
 
                 # self.__Irc.send2socket(f':{dnickname} NOTICE {nickname} :\x01PING {ping_response} secs\x01')
-                self.sendNotice(
+                self.send_notice(
                     nick_from=dnickname,
                     nick_to=nickname,
                     msg=f"\x01PING {ping_response} secs\x01"

core/classes/protocols/unreal6.py

@@ -1,8 +1,7 @@
-from re import match, findall
+from re import match, findall, search
 from datetime import datetime
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Union
 from ssl import SSLEOFError, SSLError
-from dataclasses import dataclass
 
 if TYPE_CHECKING:
     from core.irc import Irc
@@ -17,6 +16,12 @@ class Unrealircd6:
         self.__Base = ircInstance.Base
         self.__Settings = ircInstance.Base.Settings
 
+        self.known_protocol = ['SJOIN', 'UID', 'MD', 'QUIT', 'SQUIT',
+                               'EOS', 'PRIVMSG', 'MODE', 'UMODE2', 
+                               'VERSION', 'REPUTATION', 'SVS2MODE', 
+                               'SLOG', 'NICK', 'PART', 'PONG'
+                               ]
+
         self.__Base.logs.info(f"** Loading protocol [{__name__}]")
 
     def send2socket(self, message: str, print_log: bool = True) -> None:
@@ -48,7 +53,7 @@ class Unrealircd6:
         except AttributeError as ae:
             self.__Base.logs.critical(f"Attribute Error: {ae}")
 
-    def sendPrivMsg(self, nick_from: str, msg: str, channel: str = None, nick_to: str = None):
+    def send_priv_msg(self, nick_from: str, msg: str, channel: str = None, nick_to: str = None):
         """Sending PRIVMSG to a channel or to a nickname by batches
         could be either channel or nickname not both together
         Args:
@@ -80,7 +85,7 @@ class Unrealircd6:
             self.__Base.logs.error(f"General Error: {err}")
             self.__Base.logs.error(f"General Error: {nick_from} - {channel} - {nick_to}")
 
-    def sendNotice(self, nick_from: str, nick_to: str, msg: str) -> None:
+    def send_notice(self, nick_from: str, nick_to: str, msg: str) -> None:
         """Sending NOTICE by batches
 
         Args:
@@ -104,6 +109,40 @@ class Unrealircd6:
         except Exception as err:
             self.__Base.logs.error(f"General Error: {err}")
 
+    def parse_server_msg(self, server_msg: list[str]) -> Union[str, None]:
+        """Parse the server message and return the command
+
+        Args:
+            server_msg (list[str]): The Original server message >>
+
+        Returns:
+            Union[str, None]: Return the command protocol name
+        """
+        protocol_exception = ['PING', 'SERVER', 'PROTOCTL']
+        increment = 0
+        server_msg_copy = server_msg.copy()
+        first_index = 0
+        second_index = 0
+        for index, element in enumerate(server_msg_copy):
+            # Handle the protocol exceptions ex. ping, server ....
+            if element in protocol_exception and index == 0:
+                return element
+
+            if element.startswith(':'):
+                increment += 1
+                first_index = index + 1 if increment == 1 else first_index
+                second_index = index if increment == 2 else second_index
+
+        second_index = len(server_msg_copy) if second_index == 0 else second_index
+
+        parsed_msg = server_msg_copy[first_index:second_index]
+
+        for cmd in parsed_msg:
+            if cmd in self.known_protocol:
+                return cmd
+
+        return None
+
     def link(self):
         """Créer le link et envoyer les informations nécessaires pour la 
         connexion au serveur.
@@ -206,7 +245,7 @@ class Unrealircd6:
         self.__Irc.Channel.insert(self.__Irc.Loader.Definition.MChannel(name=channel, uids=[self.__Config.SERVICE_ID]))
         return None
 
-    def sendSapart(self, nick_to_sapart: str, channel_name: str) -> None:
+    def send_sapart(self, nick_to_sapart: str, channel_name: str) -> None:
         """_summary_
 
         Args:
@@ -231,7 +270,7 @@ class Unrealircd6:
         except Exception as err:
             self.__Base.logs.error(f"{__name__} - General Error: {err}")
 
-    def sendSajoin(self, nick_to_sajoin: str, channel_name: str) -> None:
+    def send_sajoin(self, nick_to_sajoin: str, channel_name: str) -> None:
         """_summary_
 
         Args:
@@ -268,7 +307,7 @@ class Unrealircd6:
         except Exception as err:
             self.__Base.logs.error(f"{__name__} - General Error: {err}")
 
-    def sendSvsmode(self, nickname: str, user_mode: str) -> None:
+    def send_svs_mode(self, nickname: str, user_mode: str) -> None:
         try:
 
             userObj = self.__Irc.User.get_User(uidornickname=nickname)
@@ -287,7 +326,7 @@ class Unrealircd6:
         except Exception as err:
                 self.__Base.logs.error(f"{__name__} - General Error: {err}")
 
-    def sendQuit(self, uid: str, reason: str, print_log: True) -> None:
+    def send_quit(self, uid: str, reason: str, print_log: True) -> None:
         """Send quit message
         - Delete uid from User object
         - Delete uid from Clone object
@@ -316,7 +355,7 @@ class Unrealircd6:
 
         return None
 
-    def sendUID(self, nickname:str, username: str, hostname: str, uid:str, umodes: str, vhost: str, remote_ip: str, realname: str, print_log: bool = True) -> None:
+    def send_uid(self, nickname:str, username: str, hostname: str, uid:str, umodes: str, vhost: str, remote_ip: str, realname: str, print_log: bool = True) -> None:
         """Send UID to the server
         - Insert User to User Object
         Args:
@@ -354,7 +393,7 @@ class Unrealircd6:
         except Exception as err:
             self.__Base.logs.error(f"{__name__} - General Error: {err}")
 
-    def sendChanJoin(self, uidornickname: str, channel: str, password: str = None, print_log: bool = True) -> None:
+    def send_join_chan(self, uidornickname: str, channel: str, password: str = None, print_log: bool = True) -> None:
         """Joining a channel
 
         Args:
@@ -383,7 +422,7 @@ class Unrealircd6:
         self.__Irc.Channel.insert(self.__Irc.Loader.Definition.MChannel(name=channel, uids=[userObj.uid]))
         return None
 
-    def sendChanPart(self, uidornickname:str, channel: str, print_log: bool = True) -> None:
+    def send_part_chan(self, uidornickname:str, channel: str, print_log: bool = True) -> None:
         """Part from a channel
 
         Args:
@@ -408,6 +447,43 @@ class Unrealircd6:
         self.__Irc.Channel.delete_user_from_channel(channel, userObj.uid)
         return None
 
+    def on_svs2mode(self, serverMsg: list[str]) -> None:
+        """Handle svs2mode coming from a server
+
+        Args:
+            serverMsg (list[str]): Original server message
+        """
+        try:
+            # >> [':00BAAAAAG', 'SVS2MODE', '001U01R03', '-r']
+
+            uid_user_to_edit = serverMsg[2]
+            umode = serverMsg[3]
+
+            userObj = self.__Irc.User.get_User(uid_user_to_edit)
+
+            if userObj is None:
+                return None
+
+            if self.__Irc.User.update_mode(userObj.uid, umode):
+                return None
+
+            return None
+        except IndexError as ie:
+            self.__Base.logs.error(f"{__name__} - Index Error: {ie}")
+        except Exception as err:
+            self.__Base.logs.error(f"{__name__} - General Error: {err}")
+
+    def on_mode(self, serverMsg: list[str]) -> None:
+        """Handle mode coming from a server
+
+        Args:
+            serverMsg (list[str]): Original server message
+        """
+        #['@msgid=d0ySx56Yd0nc35oHts2SkC-/J9mVUA1hfM6...', ':001', 'MODE', '#a', '+nt', '1723207536']
+        #['@unrealircd.org/userhost=adator@localhost;...', ':001LQ0L0C', 'MODE', '#services', '-l']
+
+        return None
+
     def on_umode2(self, serverMsg: list[str]) -> None:
         """Handle umode2 coming from a server
 
@@ -490,12 +566,32 @@ class Unrealircd6:
             serverMsg (list[str]): Original server message
         """
         # ['PROTOCTL', 'CHANMODES=beI,fkL,lFH,cdimnprstzCDGKMNOPQRSTVZ', 'USERMODES=diopqrstwxzBDGHIRSTWZ', 'BOOTED=1728815798', 'PREFIX=(qaohv)~&@%+', 'SID=001', 'MLOCK', 'TS=1730662755', 'EXTSWHOIS']
-        if len(serverMsg) > 5:
-            if '=' in serverMsg[5]:
-                serveur_hosting_id = str(serverMsg[5]).split('=')
-                self.__Config.HSID = serveur_hosting_id[1]
-            if 'USERMODES=' in serverMsg[2]:
-                self.__Settings.USER_MODES = list(serverMsg[2].split('=')[1])
+        user_modes: str = None
+        prefix: str = None
+        host_server_id: str = None
+
+        for msg in serverMsg:
+            pattern = None
+            if msg.startswith('PREFIX='):
+                pattern = r'^PREFIX=\((.*)\).*$'
+                find_match = match(pattern, msg)
+                prefix = find_match.group(1) if find_match else None
+                if find_match:
+                    prefix = find_match.group(1)
+
+            elif msg.startswith('USERMODES='):
+                pattern = r'^USERMODES=(.*)$'
+                find_match = match(pattern, msg)
+                user_modes = find_match.group(1) if find_match else None
+            elif msg.startswith('SID='):
+                host_server_id = msg.split('=')[1]
+
+        if user_modes is None or prefix is None or host_server_id is None:
+            return None
+
+        self.__Config.HSID = host_server_id
+        self.__Settings.PROTOCTL_USER_MODES = list(user_modes)
+        self.__Settings.PROTOCTL_PREFIX = list(prefix)
 
         return None
 
@@ -534,8 +630,11 @@ class Unrealircd6:
             # ':001T6VU3F', '001JGWB2K', '@11ZAAAAAB', 
             # '001F16WGR', '001X9YMGQ', '*+001DYPFGP', '@00BAAAAAJ', '001AAGOG9', '001FMFVG8', '001DAEEG7', 
             # '&~G:unknown-users', '"~G:websocket-users', '"~G:known-users', '"~G:webirc-users']
+            # [':00B', 'SJOIN', '1731872579', '#services', '+', ':00BAAAAAB']
             serverMsg_copy = serverMsg.copy()
+            if serverMsg_copy[0].startswith('@'):
                 serverMsg_copy.pop(0)
+
             channel = str(serverMsg_copy[3]).lower()
             len_cmd = len(serverMsg_copy)
             list_users:list = []
@@ -592,6 +691,105 @@ class Unrealircd6:
         except Exception as err:
             self.__Base.logs.error(f"{__name__} - General Error: {err}")
 
+    def on_eos(self, serverMsg: list[str]) -> None:
+        """Handle EOS coming from a server
+
+        Args:
+            serverMsg (list[str]): Original server message
+        """
+        try:
+            # [':001', 'EOS']
+            server_msg_copy = serverMsg.copy()
+            hsid = str(server_msg_copy[0]).replace(':','')
+            if hsid == self.__Config.HSID:
+                if self.__Config.DEFENDER_INIT == 1:
+                    current_version = self.__Config.CURRENT_VERSION
+                    latest_version = self.__Config.LATEST_VERSION
+                    if self.__Base.check_for_new_version(False):
+                        version = f'{current_version} >>> {latest_version}'
+                    else:
+                        version = f'{current_version}'
+
+                    print(f"################### DEFENDER ###################")
+                    print(f"#               SERVICE CONNECTE                ")
+                    print(f"# SERVEUR  :    {self.__Config.SERVEUR_IP}        ")
+                    print(f"# PORT     :    {self.__Config.SERVEUR_PORT}      ")
+                    print(f"# SSL      :    {self.__Config.SERVEUR_SSL}       ")
+                    print(f"# SSL VER  :    {self.__Config.SSL_VERSION}       ")
+                    print(f"# NICKNAME :    {self.__Config.SERVICE_NICKNAME}  ")
+                    print(f"# CHANNEL  :    {self.__Config.SERVICE_CHANLOG}   ")
+                    print(f"# VERSION  :    {version}                       ")
+                    print(f"################################################")
+
+                    self.__Base.logs.info(f"################### DEFENDER ###################")
+                    self.__Base.logs.info(f"#               SERVICE CONNECTE                ")
+                    self.__Base.logs.info(f"# SERVEUR  :    {self.__Config.SERVEUR_IP}        ")
+                    self.__Base.logs.info(f"# PORT     :    {self.__Config.SERVEUR_PORT}      ")
+                    self.__Base.logs.info(f"# SSL      :    {self.__Config.SERVEUR_SSL}       ")
+                    self.__Base.logs.info(f"# SSL VER  :    {self.__Config.SSL_VERSION}       ")
+                    self.__Base.logs.info(f"# NICKNAME :    {self.__Config.SERVICE_NICKNAME}  ")
+                    self.__Base.logs.info(f"# CHANNEL  :    {self.__Config.SERVICE_CHANLOG}   ")
+                    self.__Base.logs.info(f"# VERSION  :    {version}                       ")
+                    self.__Base.logs.info(f"################################################")
+
+                    if self.__Base.check_for_new_version(False):
+                        self.send_priv_msg(
+                            nick_from=self.__Config.SERVICE_NICKNAME,
+                            msg=f" New Version available {version}",
+                            channel=self.__Config.SERVICE_CHANLOG
+                        )
+
+                # Initialisation terminé aprés le premier PING
+                self.send_priv_msg(
+                    nick_from=self.__Config.SERVICE_NICKNAME,
+                    msg=f"[{self.__Config.COLORS.green}INFORMATION{self.__Config.COLORS.nogc}] >> Defender is ready",
+                    channel=self.__Config.SERVICE_CHANLOG
+                )
+                self.__Config.DEFENDER_INIT = 0
+
+                # Send EOF to other modules
+                for classe_name, classe_object in self.__Irc.loaded_classes.items():
+                    classe_object.cmd(server_msg_copy)
+
+                return None
+        except IndexError as ie:
+            self.__Base.logs.error(f"{__name__} - Key Error: {ie}")
+        except KeyError as ke:
+            self.__Base.logs.error(f"{__name__} - Key Error: {ke}")
+        except Exception as err:
+            self.__Base.logs.error(f"{__name__} - General Error: {err}")
+
+    def on_reputation(self, serverMsg: list[str]) -> None:
+        """Handle REPUTATION coming from a server
+
+        Args:
+            serverMsg (list[str]): Original server message
+        """
+        try:
+            # :001 REPUTATION 127.0.0.1 118
+            server_msg_copy = serverMsg.copy()
+            self.__Irc.first_connexion_ip = server_msg_copy[2]
+            self.__Irc.first_score = 0
+
+            if str(server_msg_copy[3]).find('*') != -1:
+                # If * available, it means that an ircop changed the repurtation score
+                # means also that the user exist will try to update all users with same IP
+                self.__Irc.first_score = int(str(server_msg_copy[3]).replace('*',''))
+                for user in self.__Irc.User.UID_DB:
+                    if user.remote_ip == self.__Irc.first_connexion_ip:
+                        user.score_connexion = self.first_score
+            else:
+                self.__Irc.first_score = int(server_msg_copy[3])
+
+            # Possibilité de déclancher les bans a ce niveau.
+        except IndexError as ie:
+            self.Logs.error(f'Index Error {__name__}: {ie}')
+        except ValueError as ve:
+            self.__Irc.first_score = 0
+            self.Logs.error(f'Value Error {__name__}: {ve}')
+        except Exception as err:
+            self.__Base.logs.error(f"{__name__} - General Error: {err}")
+
     def on_uid(self, serverMsg: list[str]) -> None:
         """Handle uid message coming from the server
 
@@ -630,7 +828,7 @@ class Unrealircd6:
             else:
                 geoip = None
 
-            score_connexion = 0
+            score_connexion = self.__Irc.first_score
 
             self.__Irc.User.insert(
                 self.__Irc.Loader.Definition.MUser(
@@ -655,6 +853,101 @@ class Unrealircd6:
         except Exception as err:
             self.__Base.logs.error(f"{__name__} - General Error: {err}")
 
+    def on_privmsg(self, serverMsg: list[str]) -> None:
+        """Handle PRIVMSG message coming from the server
+
+        Args:
+            serverMsg (list[str]): Original server message
+        """
+        try:
+            srv_msg = serverMsg.copy()
+
+            cmd = serverMsg.copy()
+            # Supprimer la premiere valeur si MTAGS activé
+            if cmd[0].startswith('@'):
+                cmd.pop(0)
+
+            # Hide auth logs
+            if len(cmd) == 7:
+                if cmd[2] == 'PRIVMSG' and cmd[4] == ':auth':
+                    data_copy = cmd.copy()
+                    data_copy[6] = '**********'
+                    self.__Base.logs.debug(f">> {data_copy}")
+                else:
+                    self.__Base.logs.debug(f">> {cmd}")
+            else:
+                self.__Base.logs.debug(f">> {cmd}")
+
+            get_uid_or_nickname = str(cmd[0].replace(':',''))
+            user_trigger = self.__Irc.User.get_nickname(get_uid_or_nickname)
+            dnickname = self.__Config.SERVICE_NICKNAME
+
+            pattern = fr'(:\{self.__Config.SERVICE_PREFIX})(.*)$'
+            hcmds = search(pattern, ' '.join(cmd)) # va matcher avec tout les caractéres aprés le .
+
+            if hcmds: # Commande qui commencent par le point
+                liste_des_commandes = list(hcmds.groups())
+                convert_to_string = ' '.join(liste_des_commandes)
+                arg = convert_to_string.split()
+                arg.remove(f':{self.__Config.SERVICE_PREFIX}')
+                if not arg[0].lower() in self.__Irc.commands:
+                    self.__Base.logs.debug(f"This command {arg[0]} is not available")
+                    self.send_notice(
+                        nick_from=self.__Config.SERVICE_NICKNAME,
+                        nick_to=user_trigger,
+                        msg=f"This command [{self.__Config.COLORS.bold}{arg[0]}{self.__Config.COLORS.bold}] is not available"
+                    )
+                    return None
+
+                cmd_to_send = convert_to_string.replace(':','')
+                self.__Base.log_cmd(user_trigger, cmd_to_send)
+
+                fromchannel = str(cmd[2]).lower() if self.__Irc.Channel.Is_Channel(cmd[2]) else None
+                self.__Irc.hcmds(user_trigger, fromchannel, arg, cmd)
+
+            if cmd[2] == self.__Config.SERVICE_ID:
+                pattern = fr'^:.*?:(.*)$'
+                hcmds = search(pattern, ' '.join(cmd))
+
+                if hcmds: # par /msg defender [commande]
+                    liste_des_commandes = list(hcmds.groups())
+                    convert_to_string = ' '.join(liste_des_commandes)
+                    arg = convert_to_string.split()
+
+                    # Réponse a un CTCP VERSION
+                    if arg[0] == '\x01VERSION\x01':
+                        self.on_version(srv_msg)
+                        return False
+
+                    # Réponse a un TIME
+                    if arg[0] == '\x01TIME\x01':
+                        self.on_time(srv_msg)
+                        return False
+
+                    # Réponse a un PING
+                    if arg[0] == '\x01PING':
+                        self.on_ping(srv_msg)
+                        return False
+
+                    if not arg[0].lower() in self.__Irc.commands:
+                        self.__Base.logs.debug(f"This command {arg[0]} sent by {user_trigger} is not available")
+                        return False
+
+                    cmd_to_send = convert_to_string.replace(':','')
+                    self.__Base.log_cmd(user_trigger, cmd_to_send)
+
+                    fromchannel = None
+                    if len(arg) >= 2:
+                        fromchannel = str(arg[1]).lower() if self.__Irc.Channel.Is_Channel(arg[1]) else None
+
+                    self.__Irc.hcmds(user_trigger, fromchannel, arg, cmd)
+            return None
+
+        except KeyError as ke:
+            self.__Base.logs.error(f"Key Error: {ke}")
+        except Exception as err:
+            self.__Base.logs.error(f"General Error: {err}")
+
     def on_server_ping(self, serverMsg: list[str]) -> None:
         """Send a PONG message to the server
 
@@ -662,7 +955,7 @@ class Unrealircd6:
             serverMsg (list[str]): List of str coming from the server
         """
         try:
-
+            # 
             pong = str(serverMsg[1]).replace(':','')
             self.send2socket(f"PONG :{pong}", print_log=False)
 
@@ -742,7 +1035,7 @@ class Unrealircd6:
                 ping_response = current_unixtime - recieved_unixtime
 
                 # self.__Irc.send2socket(f':{dnickname} NOTICE {nickname} :\x01PING {ping_response} secs\x01')
-                self.sendNotice(
+                self.send_notice(
                     nick_from=dnickname,
                     nick_to=nickname,
                     msg=f"\x01PING {ping_response} secs\x01"
@@ -754,7 +1047,7 @@ class Unrealircd6:
 
     def on_version_msg(self, serverMsg: list[str]) -> None:
         """Handle version coming from the server
-
+        \n ex. /version Defender
         Args:
             serverMsg (list[str]): Original message from the server
         """
@@ -776,7 +1069,7 @@ class Unrealircd6:
             response_005 = ' | '.join(modules)
             self.send2socket(f':{self.__Config.SERVICE_HOST} 005 {getUser.nickname} {response_005} are supported by this server')
 
-            response_005 = ''.join(self.__Settings.USER_MODES)
+            response_005 = ''.join(self.__Settings.PROTOCTL_USER_MODES)
             self.send2socket(f":{self.__Config.SERVICE_HOST} 005 {getUser.nickname} {response_005} are supported by this server")
 
             return None

core/classes/settings.py

@@ -11,4 +11,5 @@ class Settings:
 
     CONSOLE: bool                   = False
 
-    USER_MODES: list[str]           = []
+    PROTOCTL_USER_MODES: list[str]   = []
+    PROTOCTL_PREFIX: list[str]       = []

core/classes/user.py

@@ -92,7 +92,7 @@ class User:
             return False
 
         liste_umodes = list(umodes)
-        final_umodes_liste = [x for x in self.Base.Settings.USER_MODES if x in liste_umodes]
+        final_umodes_liste = [x for x in self.Base.Settings.PROTOCTL_USER_MODES if x in liste_umodes]
         final_umodes = ''.join(final_umodes_liste)
 
         userObj.umodes = f"+{final_umodes}"

core/irc.py

@@ -1,3 +1,5 @@
+from ast import parse
+from http import server
 import sys
 import socket
 import threading
@@ -9,6 +11,8 @@ import traceback
 from ssl import SSLSocket
 from datetime import datetime, timedelta
 from typing import Union
+
+from websockets import serve
 from core.loader import Loader
 from core.classes.protocol import Protocol
 
@@ -73,10 +77,13 @@ class Irc:
         self.autolimit_started: bool = False
         """This variable is to make sure the thread is not running"""
 
-        self.first_score: int = 100
+        # define first reputation score to 0
+        self.first_score: int = 0
 
+        # Define the dict that will contain all loaded modules
         self.loaded_classes:dict[str, 'Irc'] = {}           # Definir la variable qui contiendra la liste modules chargés
 
+        # Define the IrcSocket object
         self.IrcSocket:Union[socket.socket, SSLSocket] = None
 
         # Liste des commandes internes du bot
@@ -408,7 +415,7 @@ class Irc:
                 self.Logs.info('module name = ' + module_name)
                 if class_name in self.loaded_classes:
                     # Si le module existe dans la variable globale retourne False
-                    self.Protocol.sendPrivMsg(
+                    self.Protocol.send_priv_msg(
                         nick_from=self.Config.SERVICE_NICKNAME,
                         msg=f"Le module {module_name} est déja chargé ! si vous souhaiter le recharge tapez {self.Config.SERVICE_PREFIX}reload {module_name}",
                         channel=self.Config.SERVICE_CHANLOG
@@ -425,7 +432,7 @@ class Irc:
                 if not init:
                     self.Base.db_record_module(fromuser, module_name)
 
-                self.Protocol.sendPrivMsg(
+                self.Protocol.send_priv_msg(
                         nick_from=self.Config.SERVICE_NICKNAME,
                         msg=f"Module {module_name} chargé",
                         channel=self.Config.SERVICE_CHANLOG
@@ -439,7 +446,7 @@ class Irc:
             create_instance_of_the_class = my_class(self.ircObject)             # Créer une nouvelle instance de la classe
 
             if not hasattr(create_instance_of_the_class, 'cmd'):
-                self.Protocol.sendPrivMsg(
+                self.Protocol.send_priv_msg(
                         nick_from=self.Config.SERVICE_NICKNAME,
                         msg=f"Module {module_name} ne contient pas de méthode cmd",
                         channel=self.Config.SERVICE_CHANLOG
@@ -455,7 +462,7 @@ class Irc:
             if not init:
                 self.Base.db_record_module(fromuser, module_name)
 
-            self.Protocol.sendPrivMsg(
+            self.Protocol.send_priv_msg(
                         nick_from=self.Config.SERVICE_NICKNAME,
                         msg=f"Module {module_name} chargé",
                         channel=self.Config.SERVICE_CHANLOG
@@ -467,7 +474,7 @@ class Irc:
 
         except ModuleNotFoundError as moduleNotFound:
             self.Logs.error(f"MODULE_NOT_FOUND: {moduleNotFound}")
-            self.Protocol.sendPrivMsg(
+            self.Protocol.send_priv_msg(
                         nick_from=self.Config.SERVICE_NICKNAME,
                         msg=f"[ {self.Config.COLORS.red}MODULE_NOT_FOUND{self.Config.COLORS.black} ]: {moduleNotFound}",
                         channel=self.Config.SERVICE_CHANLOG
@@ -475,7 +482,7 @@ class Irc:
             self.Base.db_delete_module(module_name)
         except Exception as err:
             self.Logs.error(f"Something went wrong with a module you want to load : {err}")
-            self.Protocol.sendPrivMsg(
+            self.Protocol.send_priv_msg(
                         nick_from=self.Config.SERVICE_NICKNAME,
                         msg=f"[ {self.Config.COLORS.red}ERROR{self.Config.COLORS.black} ]: {err}",
                         channel=self.Config.SERVICE_CHANLOG
@@ -508,7 +515,7 @@ class Irc:
                 # Supprimer le module de la base de données
                 self.Base.db_delete_module(module_name)
 
-                self.Protocol.sendPrivMsg(
+                self.Protocol.send_priv_msg(
                         nick_from=self.Config.SERVICE_NICKNAME,
                         msg=f"Module {module_name} supprimé",
                         channel=self.Config.SERVICE_CHANLOG
@@ -547,14 +554,14 @@ class Irc:
                 self.loaded_classes[class_name] = new_instance
 
                 self.Base.db_update_module(from_user, mod_name)
-                self.Protocol.sendPrivMsg(
+                self.Protocol.send_priv_msg(
                         nick_from=self.Config.SERVICE_NICKNAME,
                         msg=f"Module {module_name} rechargé",
                         channel=self.Config.SERVICE_CHANLOG
                     )
                 return False
             else:
-                self.Protocol.sendPrivMsg(
+                self.Protocol.send_priv_msg(
                         nick_from=self.Config.SERVICE_NICKNAME,
                         msg=f"Module {module_name} n'est pas chargé !",
                         channel=self.Config.SERVICE_CHANLOG
@@ -562,7 +569,7 @@ class Irc:
 
         except TypeError as te:
             self.Logs.error(f"A TypeError raised: {te}")
-            self.Protocol.sendPrivMsg(
+            self.Protocol.send_priv_msg(
                         nick_from=self.Config.SERVICE_NICKNAME,
                         msg=f"A TypeError raised: {te}",
                         channel=self.Config.SERVICE_CHANLOG
@@ -570,7 +577,7 @@ class Irc:
             self.Base.db_delete_module(module_name)
         except AttributeError as ae:
             self.Logs.error(f"Missing Attribute: {ae}")
-            self.Protocol.sendPrivMsg(
+            self.Protocol.send_priv_msg(
                         nick_from=self.Config.SERVICE_NICKNAME,
                         msg=f"Missing Attribute: {ae}",
                         channel=self.Config.SERVICE_CHANLOG
@@ -578,7 +585,7 @@ class Irc:
             self.Base.db_delete_module(module_name)
         except KeyError as ke:
             self.Logs.error(f"Key Error: {ke}")
-            self.Protocol.sendPrivMsg(
+            self.Protocol.send_priv_msg(
                         nick_from=self.Config.SERVICE_NICKNAME,
                         msg=f"Key Error: {ke}",
                         channel=self.Config.SERVICE_CHANLOG
@@ -586,7 +593,7 @@ class Irc:
             self.Base.db_delete_module(module_name)
         except Exception as e:
             self.Logs.error(f"Something went wrong with a module you want to reload: {e}")
-            self.Protocol.sendPrivMsg(
+            self.Protocol.send_priv_msg(
                         nick_from=self.Config.SERVICE_NICKNAME,
                         msg=f"Something went wrong with the module: {e}",
                         channel=self.Config.SERVICE_CHANLOG
@@ -623,20 +630,30 @@ class Irc:
 
     def create_defender_user(self, nickname: str, level: int, password: str) -> str:
 
+        # > addaccess [nickname] [level] [password]
+
         get_user = self.User.get_User(nickname)
+        level = self.Base.convert_to_int(level)
+        password = password
+
         if get_user is None:
             response = f'This nickname {nickname} does not exist, it is not possible to create this user'
             self.Logs.warning(response)
             return response
 
-        nickname = get_user.nickname
-        response = ''
+        if level is None:
+            response = f'The level [{level}] must be a number from 1 to 4'
+            self.Logs.warning(response)
+            return response
 
         if level > 4:
             response = "Impossible d'ajouter un niveau > 4"
             self.Logs.warning(response)
             return response
 
+        nickname = get_user.nickname
+        response = ''
+
         hostname = get_user.hostname
         vhost = get_user.vhost
         spassword = self.Base.crypt_password(password)
@@ -654,12 +671,12 @@ class Irc:
                     (:datetime, :user, :password, :hostname, :vhost, :level)
                     ''', mes_donnees)
             response = f"{nickname} ajouté en tant qu'administrateur de niveau {level}"
-            self.Protocol.sendNotice(nick_from=self.Config.SERVICE_NICKNAME, nick_to=nickname, msg=response)
+            self.Protocol.send_notice(nick_from=self.Config.SERVICE_NICKNAME, nick_to=nickname, msg=response)
             self.Logs.info(response)
             return response
         else:
             response = f'{nickname} Existe déjà dans les users enregistrés'
-            self.Protocol.sendNotice(nick_from=self.Config.SERVICE_NICKNAME, nick_to=nickname, msg=response)
+            self.Protocol.send_notice(nick_from=self.Config.SERVICE_NICKNAME, nick_to=nickname, msg=response)
             self.Logs.info(response)
             return response
 
@@ -706,10 +723,10 @@ class Irc:
         dnickname = self.Config.SERVICE_NICKNAME
 
         if self.Base.check_for_new_version(True):
-            self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" New Version available : {self.Config.CURRENT_VERSION} >>> {self.Config.LATEST_VERSION}")
-            self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=" Please run (git pull origin main) in the current folder")
+            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" New Version available : {self.Config.CURRENT_VERSION} >>> {self.Config.LATEST_VERSION}")
+            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=" Please run (git pull origin main) in the current folder")
         else:
-            self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=" You have the latest version of defender")
+            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=" You have the latest version of defender")
 
         return None
 
@@ -721,10 +738,8 @@ class Irc:
         """
         try:
             original_response: list[str] = data.copy()
-
             interm_response: list[str] = data.copy()
             """This the original without first value"""
-
             interm_response.pop(0)
 
             if len(original_response) == 0 or len(original_response) == 1:
@@ -741,179 +756,22 @@ class Irc:
             else:
                 self.Logs.debug(f">> {original_response}")
 
-            match original_response[0]:
+            parsed_protocol = self.Protocol.parse_server_msg(original_response.copy())
+
+            match parsed_protocol:
 
                 case 'PING':
-                    # Sending PONG response to the serveur
-                    self.Protocol.on_server_ping(original_response)
+                    self.Protocol.on_server_ping(serverMsg=original_response)
+                    self.Logs.debug(f"** handle {parsed_protocol}")
                     return None
 
-                case 'PROTOCTL':
-                    #['PROTOCTL', 'CHANMODES=beI,fkL,lFH,cdimnprstzCDGKMNOPQRSTVZ', 'USERMODES=diopqrstwxzBDGHIRSTWZ', 'BOOTED=1702138935', 
-                    # 'PREFIX=(qaohv)~&@%+', 'SID=001', 'MLOCK', 'TS=1703793941', 'EXTSWHOIS']
-
-                    # GET SERVER ID HOST
-                    self.Protocol.on_protoctl(serverMsg=original_response)
-
-                    return None
-
-                case _:
-                    pass
-
-            if len(original_response) < 2:
-                return False
-
-            match original_response[1]:
-                
-                case 'PING':
-                    # Sending PONG response to the serveur
-                    self.Protocol.on_server_ping(original_response)
-                    return None
-                
-                case 'SLOG':
-                    # self.Base.scan_ports(cmd[7])
-                    # if self.Config.ABUSEIPDB == 1:
-                    #     self.Base.create_thread(self.abuseipdb_scan, (cmd[7], ))
-                    pass
-
-                case 'VERSION':
-                    self.Protocol.on_version_msg(original_response)
-
-                case 'UMODE2':
-                    # [':adator_', 'UMODE2', '-i']
-                    self.Protocol.on_umode2(serverMsg=original_response)
-
-                case 'SQUIT':
-
-                    self.Protocol.on_squit(serverMsg=original_response)
-
-                case 'REPUTATION':
-                    # :001 REPUTATION 127.0.0.1 118
-                    try:
-                        self.first_connexion_ip = original_response[2]
-
-                        self.first_score = 0
-                        if str(original_response[3]).find('*') != -1:
-                            # If * available, it means that an ircop changed the repurtation score
-                            # means also that the user exist will try to update all users with same IP
-                            self.first_score = int(str(original_response[3]).replace('*',''))
-                            for user in self.User.UID_DB:
-                                if user.remote_ip == self.first_connexion_ip:
-                                    user.score_connexion = self.first_score
-                        else:
-                            self.first_score = int(original_response[3])
-
-                        # Possibilité de déclancher les bans a ce niveau.
-                    except IndexError as ie:
-                        self.Logs.error(f'{ie}')
-                    except ValueError as ve:
-                        self.first_score = 0
-                        self.Logs.error(f'Impossible to convert first_score: {ve}')
-
-                case '320':
-                    #:irc.deb.biz.st 320 PyDefender IRCParis07 :is in security-groups: known-users,webirc-users,tls-and-known-users,tls-users
-                    pass
-
-                case '318':
-                    #:irc.deb.biz.st 318 PyDefender IRCParis93 :End of /WHOIS list.
-                    pass
-
-                case 'MD':
-                    # [':001', 'MD', 'client', '001CG0TG7', 'webirc', ':2']
-                    pass
-
-                case 'EOS':
-
-                    hsid = str(original_response[0]).replace(':','')
-                    if hsid == self.Config.HSID:
-                        if self.Config.DEFENDER_INIT == 1:
-                            current_version = self.Config.CURRENT_VERSION
-                            latest_version = self.Config.LATEST_VERSION
-                            if self.Base.check_for_new_version(False):
-                                version = f'{current_version} >>> {latest_version}'
-                            else:
-                                version = f'{current_version}'
-
-                            print(f"################### DEFENDER ###################")
-                            print(f"#               SERVICE CONNECTE                ")
-                            print(f"# SERVEUR  :    {self.Config.SERVEUR_IP}        ")
-                            print(f"# PORT     :    {self.Config.SERVEUR_PORT}      ")
-                            print(f"# SSL      :    {self.Config.SERVEUR_SSL}       ")
-                            print(f"# SSL VER  :    {self.Config.SSL_VERSION}       ")
-                            print(f"# NICKNAME :    {self.Config.SERVICE_NICKNAME}  ")
-                            print(f"# CHANNEL  :    {self.Config.SERVICE_CHANLOG}   ")
-                            print(f"# VERSION  :    {version}                       ")
-                            print(f"################################################")
-
-                            self.Logs.info(f"################### DEFENDER ###################")
-                            self.Logs.info(f"#               SERVICE CONNECTE                ")
-                            self.Logs.info(f"# SERVEUR  :    {self.Config.SERVEUR_IP}        ")
-                            self.Logs.info(f"# PORT     :    {self.Config.SERVEUR_PORT}      ")
-                            self.Logs.info(f"# SSL      :    {self.Config.SERVEUR_SSL}       ")
-                            self.Logs.info(f"# SSL VER  :    {self.Config.SSL_VERSION}       ")
-                            self.Logs.info(f"# NICKNAME :    {self.Config.SERVICE_NICKNAME}  ")
-                            self.Logs.info(f"# CHANNEL  :    {self.Config.SERVICE_CHANLOG}   ")
-                            self.Logs.info(f"# VERSION  :    {version}                       ")
-                            self.Logs.info(f"################################################")
-
-                            if self.Base.check_for_new_version(False):
-                                self.Protocol.sendPrivMsg(
-                                    nick_from=self.Config.SERVICE_NICKNAME,
-                                    msg=f" New Version available {version}",
-                                    channel=self.Config.SERVICE_CHANLOG
-                                )
-
-                        # Initialisation terminé aprés le premier PING
-                        self.Protocol.sendPrivMsg(
-                            nick_from=self.Config.SERVICE_NICKNAME,
-                            msg=f"[{self.Config.COLORS.green}INFORMATION{self.Config.COLORS.nogc}] >> Defender is ready",
-                            channel=self.Config.SERVICE_CHANLOG
-                        )
-                        self.Config.DEFENDER_INIT = 0
-
-                        # Send EOF to other modules
-                        for classe_name, classe_object in self.loaded_classes.items():
-                            classe_object.cmd(original_response)
-
-                        # Stop here When EOS
-                        return None
-
-                case _:
-                    pass
-
-            if len(original_response) < 3:
-                return False
-
-            match original_response[2]:
-
-                case 'VERSION':
-                    self.Protocol.on_version_msg(original_response)
-
-                case 'QUIT':
-
-                    self.Protocol.on_quit(serverMsg=original_response)
-
-                case 'PONG':
-                    # ['@msgid=aTNJhp17kcPboF5diQqkUL;time=2023-12-28T20:35:58.411Z', ':irc.deb.biz.st', 'PONG', 'irc.deb.biz.st', ':Dev-PyDefender']
-                    self.Base.execute_periodic_action()
-
-                case 'NICK':
-
-                    self.Protocol.on_nick(original_response)
-
-                case 'MODE':
-                    #['@msgid=d0ySx56Yd0nc35oHts2SkC-/J9mVUA1hfM6+Z4494xWUg;time=2024-08-09T12:45:36.651Z', 
-                    # ':001', 'MODE', '#a', '+nt', '1723207536']
-                    # [':adator_', 'UMODE2', '-i']
-                    pass
-
                 case 'SJOIN':
-
                     self.Protocol.on_sjoin(serverMsg=original_response)
+                    self.Logs.debug(f"** handle {parsed_protocol}")
 
-                case 'PART':
-
-                    self.Protocol.on_part(serverMsg=original_response)
+                case 'EOS':
+                    self.Protocol.on_eos(serverMsg=original_response)
+                    self.Logs.debug(f"** handle {parsed_protocol}")
 
                 case 'UID':
                     try:
@@ -922,95 +780,79 @@ class Irc:
                         for classe_name, classe_object in self.loaded_classes.items():
                             classe_object.cmd(original_response)
 
+                        self.Logs.debug(f"** handle {parsed_protocol}")
+
                     except Exception as err:
                         self.Logs.error(f'General Error: {err}')
 
+                case 'QUIT':
+                    self.Protocol.on_quit(serverMsg=original_response)
+                    self.Logs.debug(f"** handle {parsed_protocol}")
+
+                case 'PROTOCTL':
+                    self.Protocol.on_protoctl(serverMsg=original_response)
+                    self.Logs.debug(f"** handle {parsed_protocol}")
+
+                case 'SVS2MODE':
+                    # >> [':00BAAAAAG', 'SVS2MODE', '001U01R03', '-r']
+                    self.Protocol.on_svs2mode(serverMsg=original_response)
+                    self.Logs.debug(f"** handle {parsed_protocol}")
+
+                case 'SQUIT':
+                    self.Protocol.on_squit(serverMsg=original_response)
+                    self.Logs.debug(f"** handle {parsed_protocol}")
+
+                case 'PART':
+                    self.Protocol.on_part(serverMsg=parsed_protocol)
+                    self.Logs.debug(f"** handle {parsed_protocol}")
+
+                case 'VERSION':
+                    self.Protocol.on_version_msg(serverMsg=original_response)
+                    self.Logs.debug(f"** handle {parsed_protocol}")
+
+                case 'UMODE2':
+                    # [':adator_', 'UMODE2', '-i']
+                    self.Protocol.on_umode2(serverMsg=original_response)
+                    self.Logs.debug(f"** handle {parsed_protocol}")
+
+                case 'NICK':
+                    self.Protocol.on_nick(serverMsg=original_response)
+                    self.Logs.debug(f"** handle {parsed_protocol}")
+
+                case 'REPUTATION':
+                    self.Protocol.on_reputation(serverMsg=original_response)
+                    self.Logs.debug(f"** handle {parsed_protocol}")
+
+                case 'SLOG': # TODO
+                    self.Logs.debug(f"** handle {parsed_protocol}")
+
+                case 'MD': # TODO
+                    self.Logs.debug(f"** handle {parsed_protocol}")
+
                 case 'PRIVMSG':
-                    try:
-                        # Supprimer la premiere valeur
-                        cmd = interm_response.copy()
+                    self.Protocol.on_privmsg(serverMsg=original_response)
+                    self.Logs.debug(f"** handle {parsed_protocol}")
 
-                        get_uid_or_nickname = str(cmd[0].replace(':',''))
-                        user_trigger = self.User.get_nickname(get_uid_or_nickname)
-                        dnickname = self.Config.SERVICE_NICKNAME
+                case 'PONG': # TODO
+                    self.Logs.debug(f"** handle {parsed_protocol}")
 
-                        if len(cmd) == 6:
-                            if cmd[1] == 'PRIVMSG' and str(cmd[3]).replace(self.Config.SERVICE_PREFIX,'') == ':auth':
-                                cmd_copy = cmd.copy()
-                                cmd_copy[5] = '**********'
-                                self.Logs.info(f'>> {cmd_copy}')
-                            else:
-                                self.Logs.info(f'>> {cmd}')
-                        else:
-                            self.Logs.info(f'>> {cmd}')
+                case 'MODE': # TODO
+                    #['@msgid=d0ySx56Yd0nc35oHts2SkC-/J9mVUA1hfM6...', ':001', 'MODE', '#a', '+nt', '1723207536']
+                    #['@unrealircd.org/userhost=adator@localhost;...', ':001LQ0L0C', 'MODE', '#services', '-l']
+                    self.Logs.debug(f"** handle {parsed_protocol}")
 
-                        pattern = fr'(:\{self.Config.SERVICE_PREFIX})(.*)$'
-                        hcmds = re.search(pattern, ' '.join(cmd)) # va matcher avec tout les caractéres aprés le .
+                case '320': # TODO
+                    #:irc.deb.biz.st 320 PyDefender IRCParis07 :is in security-groups: known-users,webirc-users,tls-and-known-users,tls-users
+                    self.Logs.debug(f"** handle {parsed_protocol}")
 
-                        if hcmds: # Commande qui commencent par le point
-                            liste_des_commandes = list(hcmds.groups())
-                            convert_to_string = ' '.join(liste_des_commandes)
-                            arg = convert_to_string.split()
-                            arg.remove(f':{self.Config.SERVICE_PREFIX}')
-                            if not arg[0].lower() in self.commands:
-                                self.Logs.debug(f"This command {arg[0]} is not available")
-                                self.Protocol.sendNotice(
-                                    nick_from=self.Config.SERVICE_NICKNAME,
-                                    nick_to=user_trigger,
-                                    msg=f"This command [{self.Config.COLORS.bold}{arg[0]}{self.Config.COLORS.bold}] is not available"
-                                )
-                                return None
+                case '318': # TODO
+                    #:irc.deb.biz.st 318 PyDefender IRCParis93 :End of /WHOIS list.
+                    self.Logs.debug(f"** handle {parsed_protocol}")
 
-                            cmd_to_send = convert_to_string.replace(':','')
-                            self.Base.log_cmd(user_trigger, cmd_to_send)
-
-                            fromchannel = str(cmd[2]).lower() if self.Channel.Is_Channel(cmd[2]) else None
-                            self._hcmds(user_trigger, fromchannel, arg, cmd)
-
-                        if cmd[2] == self.Config.SERVICE_ID:
-                            pattern = fr'^:.*?:(.*)$'
-
-                            hcmds = re.search(pattern, ' '.join(cmd))
-
-                            if hcmds: # par /msg defender [commande]
-                                liste_des_commandes = list(hcmds.groups())
-                                convert_to_string = ' '.join(liste_des_commandes)
-                                arg = convert_to_string.split()
-
-                                # Réponse a un CTCP VERSION
-                                if arg[0] == '\x01VERSION\x01':
-                                    self.Protocol.on_version(original_response)
-                                    return False
-
-                                # Réponse a un TIME
-                                if arg[0] == '\x01TIME\x01':
-                                    self.Protocol.on_time(original_response)
-                                    return False
-
-                                # Réponse a un PING
-                                if arg[0] == '\x01PING':
-                                    self.Protocol.on_ping(original_response)
-                                    return False
-
-                                if not arg[0].lower() in self.commands:
-                                    self.Logs.debug(f"This command {arg[0]} sent by {user_trigger} is not available")
-                                    return False
-
-                                cmd_to_send = convert_to_string.replace(':','')
-                                self.Base.log_cmd(user_trigger, cmd_to_send)
-
-                                fromchannel = None
-                                if len(arg) >= 2:
-                                    fromchannel = str(arg[1]).lower() if self.Channel.Is_Channel(arg[1]) else None
-
-                                self._hcmds(user_trigger, fromchannel, arg, cmd)
-
-                    except IndexError as io:
-                        self.Logs.error(f'{io}')
-
-                case _:
-                    pass
+                case None:
+                    self.Logs.debug(f"** TO BE HANDLE {original_response}")
 
+            if len(original_response) > 2:
                 if original_response[2] != 'UID':
                     # Envoyer la commande aux classes dynamiquement chargées
                     for classe_name, classe_object in self.loaded_classes.items():
@@ -1022,8 +864,8 @@ class Irc:
             self.Logs.error(f"General Error: {err}")
             self.Logs.error(f"General Error: {traceback.format_exc()}")
 
-    def _hcmds(self, user: str, channel: Union[str, None], cmd: list, fullcmd: list = []) -> None:
-        """_summary_
+    def hcmds(self, user: str, channel: Union[str, None], cmd: list, fullcmd: list = []) -> None:
+        """Create
 
         Args:
             user (str): The user who sent the query
@@ -1054,20 +896,20 @@ class Irc:
         # Envoyer la commande aux classes dynamiquement chargées
         if command != 'notallowed':
             for classe_name, classe_object in self.loaded_classes.items():
-                classe_object._hcmds(user, channel, cmd, fullcmd)
+                classe_object.hcmds(user, channel, cmd, fullcmd)
 
         match command:
 
             case 'notallowed':
                 try:
                     current_command = cmd[0]
-                    self.Protocol.sendPrivMsg(
+                    self.Protocol.send_priv_msg(
                         msg=f'[ {self.Config.COLORS.red}{current_command}{self.Config.COLORS.black} ] - Accès Refusé à {self.User.get_nickname(fromuser)}',
                         nick_from=dnickname,
                         channel=dchanlog
                         )
 
-                    self.Protocol.sendNotice(
+                    self.Protocol.send_notice(
                         nick_from=dnickname,
                         nick_to=fromuser,
                         msg=f'Accès Refusé'
@@ -1082,7 +924,7 @@ class Irc:
                 uid_to_deauth = self.User.get_uid(fromuser)
                 self.delete_db_admin(uid_to_deauth)
 
-                self.Protocol.sendPrivMsg(
+                self.Protocol.send_priv_msg(
                         msg=f"[ {self.Config.COLORS.red}{str(current_command).upper()} ]{self.Config.COLORS.black} - {self.User.get_nickname(fromuser)} est désormais déconnecter de {dnickname}",
                         nick_from=dnickname,
                         channel=dchanlog
@@ -1099,7 +941,7 @@ class Irc:
                 result_db = result.fetchone()
 
                 if result_db[0] > 0:
-                    self.Protocol.sendNotice(
+                    self.Protocol.send_notice(
                         nick_from=dnickname,
                         nick_to=fromuser,
                         msg=f"You can't use this command anymore ! Please use [{self.Config.SERVICE_PREFIX}auth] instead"
@@ -1120,7 +962,7 @@ class Irc:
 
                 if current_nickname != cmd_owner:
                     self.Logs.critical(f"The current nickname [{fromuser}] is different than the nickname sent [{cmd_owner}] !")
-                    self.Protocol.sendNotice(
+                    self.Protocol.send_notice(
                         nick_from=dnickname,
                         nick_to=fromuser,
                         msg=f"The current nickname [{fromuser}] is different than the nickname sent [{cmd_owner}] !"
@@ -1129,7 +971,7 @@ class Irc:
 
                 if current_nickname != config_owner:
                     self.Logs.critical(f"The current nickname [{current_nickname}] is different than the configuration owner [{config_owner}] !")
-                    self.Protocol.sendNotice(
+                    self.Protocol.send_notice(
                         nick_from=dnickname,
                         nick_to=fromuser,
                         msg=f"The current nickname [{current_nickname}] is different than the configuration owner [{config_owner}] !"
@@ -1138,7 +980,7 @@ class Irc:
 
                 if cmd_owner != config_owner:
                     self.Logs.critical(f"The nickname sent [{cmd_owner}] is different than the configuration owner [{config_owner}] !")
-                    self.Protocol.sendNotice(
+                    self.Protocol.send_notice(
                         nick_from=dnickname,
                         nick_to=fromuser,
                         msg=f"The nickname sent [{cmd_owner}] is different than the configuration owner [{config_owner}] !"
@@ -1148,25 +990,25 @@ class Irc:
                 if cmd_owner == config_owner and cmd_password == config_password:
                     self.Base.db_create_first_admin()
                     self.insert_db_admin(current_uid, 5)
-                    self.Protocol.sendPrivMsg(
+                    self.Protocol.send_priv_msg(
                         msg=f"[ {self.Config.COLORS.green}{str(current_command).upper()} ]{self.Config.COLORS.black} - {self.User.get_nickname(fromuser)} est désormais connecté a {dnickname}",
                         nick_from=dnickname,
                         channel=dchanlog
                         )
 
-                    self.Protocol.sendNotice(
+                    self.Protocol.send_notice(
                         nick_from=dnickname,
                         nick_to=fromuser,
                         msg=f"Connexion a {dnickname} réussie!"
                         )
                 else:
-                    self.Protocol.sendPrivMsg(
+                    self.Protocol.send_priv_msg(
                         msg=f"[ {self.Config.COLORS.red}{str(current_command).upper()} ]{self.Config.COLORS.black} - {self.User.get_nickname(fromuser)} a tapé un mauvais mot de pass",
                         nick_from=dnickname,
                         channel=dchanlog
                         )
 
-                    self.Protocol.sendNotice(
+                    self.Protocol.send_notice(
                         nick_from=dnickname,
                         nick_to=fromuser,
                         msg=f"Mot de passe incorrecte"
@@ -1174,13 +1016,17 @@ class Irc:
 
             case 'auth':
                 # ['auth', 'adator', 'password']
+                if len(cmd) != 3:
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} {command.upper()} [nickname] [password]")
+                    return None
+
                 current_command = cmd[0]
                 user_to_log = self.User.get_nickname(cmd[1])
                 password = cmd[2]
 
                 if fromuser != user_to_log:
                     # If the current nickname is different from the nickname you want to log in with
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"Your current nickname is different from the nickname you want to log in with")
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"Your current nickname is different from the nickname you want to log in with")
                     return False
 
                 if not user_to_log is None:
@@ -1192,25 +1038,25 @@ class Irc:
                     if not user_from_db is None:
                         uid_user = self.User.get_uid(user_to_log)
                         self.insert_db_admin(uid_user, user_from_db[1])
-                        self.Protocol.sendPrivMsg(nick_from=dnickname, 
+                        self.Protocol.send_priv_msg(nick_from=dnickname, 
                                                   msg=f"[ {self.Config.COLORS.green}{str(current_command).upper()} ]{self.Config.COLORS.nogc} - {self.User.get_nickname(fromuser)} est désormais connecté a {dnickname}",
                                                   channel=dchanlog)
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"Connexion a {dnickname} réussie!")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"Connexion a {dnickname} réussie!")
                     else:
-                        self.Protocol.sendPrivMsg(nick_from=dnickname, 
+                        self.Protocol.send_priv_msg(nick_from=dnickname, 
                                                   msg=f"[ {self.Config.COLORS.red}{str(current_command).upper()} ]{self.Config.COLORS.nogc} - {self.User.get_nickname(fromuser)} a tapé un mauvais mot de pass",
                                                   channel=dchanlog)
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"Mot de passe incorrecte")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"Mot de passe incorrecte")
 
                 else:
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"L'utilisateur {user_to_log} n'existe pas")
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"L'utilisateur {user_to_log} n'existe pas")
 
             case 'addaccess':
                 try:
                     # .addaccess adator 5 password
                     if len(cmd) < 4:
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"Right command : /msg {dnickname} addaccess [nickname] [level] [password]")
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"level: from 1 to 4")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"Right command : /msg {dnickname} addaccess [nickname] [level] [password]")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"level: from 1 to 4")
 
                     newnickname = cmd[1]
                     newlevel = self.Base.int_if_possible(cmd[2])
@@ -1218,38 +1064,43 @@ class Irc:
 
                     response = self.create_defender_user(newnickname, newlevel, password)
 
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"{response}")
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"{response}")
                     self.Logs.info(response)
 
                 except IndexError as ie:
                     self.Logs.error(f'_hcmd addaccess: {ie}')
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} addaccess [nickname] [level] [password]")
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} addaccess [nickname] [level] [password]")
                 except TypeError as te:
                     self.Logs.error(f'_hcmd addaccess: out of index : {te}')
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} addaccess [nickname] [level] [password]")
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} addaccess [nickname] [level] [password]")
 
             case 'editaccess':
                 # .editaccess [USER] [PASSWORD] [LEVEL]
                 try:
-                    user_to_edit = cmd[1]
-                    user_new_level = int(cmd[3])
-                    user_password = self.Base.crypt_password(cmd[2])
-
-                    if len(cmd) < 4 or len(cmd) > 4:
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"{self.Config.SERVICE_PREFIX}editaccess [USER] [NEWPASSWORD] [NEWLEVEL]")
+                    if len(cmd) < 3:
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"Right command : /msg {dnickname} editaccess [nickname] [NEWPASSWORD] [NEWLEVEL]")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"level: from 1 to 4")
                         return None
 
+                    user_to_edit = cmd[1]
+                    user_password = self.Base.crypt_password(cmd[2])
+
                     get_admin = self.Admin.get_Admin(fromuser)
                     if get_admin is None:
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" This user {fromuser} has no Admin access")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"This user {fromuser} has no Admin access")
                         return None
 
                     current_user = self.User.get_nickname(fromuser)
                     current_uid = self.User.get_uid(fromuser)
                     current_user_level = get_admin.level
 
+                    user_new_level = int(cmd[3]) if len(cmd) == 4 else get_admin.level
+
+                    if current_user == fromuser:
+                        user_new_level = get_admin.level
+
                     if user_new_level > 5:
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" Maximum authorized level is 5")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg="Maximum authorized level is 5")
                         return None
 
                     # Rechercher le user dans la base de données.
@@ -1261,11 +1112,11 @@ class Irc:
                     if not isUserExist is None:
 
                         if current_user_level < int(isUserExist[1]):
-                            self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" You are not allowed to edit this access")
+                            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg="You are not allowed to edit this access")
                             return None
 
                         if current_user_level == int(isUserExist[1]) and current_user != user_to_edit:
-                            self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" You can't edit access of a user with same level")
+                            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" You can't edit access of a user with same level")
                             return None
 
                         # Le user existe dans la base de données
@@ -1273,16 +1124,16 @@ class Irc:
                         sql_update = f"UPDATE {self.Config.TABLE_ADMIN} SET level = :level, password = :password WHERE user = :user"
                         exec_query = self.Base.db_execute_query(sql_update, data_to_update)
                         if exec_query.rowcount > 0:
-                            self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" User {user_to_edit} has been modified with level {str(user_new_level)}")
+                            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" User {user_to_edit} has been modified with level {str(user_new_level)}")
                             self.Admin.update_level(user_to_edit, user_new_level)
                         else:
-                            self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" Impossible de modifier l'utilisateur {str(user_new_level)}")
+                            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" Impossible de modifier l'utilisateur {str(user_new_level)}")
 
                 except TypeError as te:
                     self.Logs.error(f"Type error : {te}")
                 except ValueError as ve:
                     self.Logs.error(f"Value Error : {ve}")
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" {self.Config.SERVICE_PREFIX}editaccess [USER] [NEWPASSWORD] [NEWLEVEL]")
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" {self.Config.SERVICE_PREFIX}editaccess [USER] [NEWPASSWORD] [NEWLEVEL]")
 
             case 'delaccess':
                 # .delaccess [USER] [CONFIRMUSER]
@@ -1290,18 +1141,18 @@ class Irc:
                 user_confirmation = cmd[2]
 
                 if user_to_del != user_confirmation:
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"Les user ne sont pas les mêmes, tu dois confirmer le user que tu veux supprimer")
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"Les user ne sont pas les mêmes, tu dois confirmer le user que tu veux supprimer")
                     self.Logs.warning(f':{dnickname} NOTICE {fromuser} : Les user ne sont pas les mêmes, tu dois confirmer le user que tu veux supprimer')
                     return None
 
                 if len(cmd) < 3:
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"{self.Config.SERVICE_PREFIX}delaccess [USER] [CONFIRMUSER]")
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"{self.Config.SERVICE_PREFIX}delaccess [USER] [CONFIRMUSER]")
                     return None
 
                 get_admin = self.Admin.get_Admin(fromuser)
 
                 if get_admin is None:
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"This user {fromuser} has no admin access")
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"This user {fromuser} has no admin access")
                     return None
 
                 current_user = self.User.get_nickname(fromuser)
@@ -1317,7 +1168,7 @@ class Irc:
                 if not info_user is None:
                     level_user_to_del = info_user[1]
                     if current_user_level <= level_user_to_del:
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"You are not allowed to delete this access")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"You are not allowed to delete this access")
                         self.Logs.warning(f':{dnickname} NOTICE {fromuser} : You are not allowed to delete this access')
                         return None
 
@@ -1325,10 +1176,10 @@ class Irc:
                     sql_delete = f"DELETE FROM {self.Config.TABLE_ADMIN} WHERE user = :user"
                     exec_query = self.Base.db_execute_query(sql_delete, data_to_delete)
                     if exec_query.rowcount > 0:
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"User {user_to_del} has been deleted !")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"User {user_to_del} has been deleted !")
                         self.Admin.delete(user_to_del)
                     else:
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"Impossible de supprimer l'utilisateur.")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"Impossible de supprimer l'utilisateur.")
                         self.Logs.warning(f":{dnickname} NOTICE {fromuser} : Impossible de supprimer l'utilisateur.")
 
             case 'help':
@@ -1340,13 +1191,13 @@ class Irc:
                 else:
                     user_level = 0
 
-                self.Protocol.sendNotice(nick_from=dnickname,nick_to=fromuser,msg=f" ***************** LISTE DES COMMANDES *****************")
-                self.Protocol.sendNotice(nick_from=dnickname,nick_to=fromuser,msg=f" ")
+                self.Protocol.send_notice(nick_from=dnickname,nick_to=fromuser,msg=f" ***************** LISTE DES COMMANDES *****************")
+                self.Protocol.send_notice(nick_from=dnickname,nick_to=fromuser,msg=f" ")
                 for levDef in self.commands_level:
 
                     if int(user_level) >= int(count_level_definition):
 
-                        self.Protocol.sendNotice(nick_from=dnickname,nick_to=fromuser,
+                        self.Protocol.send_notice(nick_from=dnickname,nick_to=fromuser,
                                                  msg=f" ***************** {self.Config.COLORS.nogc}[ {self.Config.COLORS.green}LEVEL {str(levDef)} {self.Config.COLORS.nogc}] *****************"
                                                  )
 
@@ -1354,13 +1205,13 @@ class Irc:
                         for i in range(0, len(self.commands_level[count_level_definition]), batch):
                             groupe = self.commands_level[count_level_definition][i:i + batch]  # Extraire le groupe
                             batch_commands = ' | '.join(groupe)
-                            self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" {batch_commands}")
+                            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" {batch_commands}")
 
-                        self.Protocol.sendNotice(nick_from=dnickname,nick_to=fromuser,msg=f" ")
+                        self.Protocol.send_notice(nick_from=dnickname,nick_to=fromuser,msg=f" ")
 
                     count_level_definition += 1
 
-                self.Protocol.sendNotice(nick_from=dnickname,nick_to=fromuser,msg=f" ***************** FIN DES COMMANDES *****************")
+                self.Protocol.send_notice(nick_from=dnickname,nick_to=fromuser,msg=f" ***************** FIN DES COMMANDES *****************")
 
             case 'load':
                 try:
@@ -1387,7 +1238,7 @@ class Irc:
                     self.reload_module(from_user=fromuser, mod_name=module_name)
                 except Exception as e:
                     self.Logs.error(f"Something went wrong with a module you want to reload: {e}")
-                    self.Protocol.sendPrivMsg(
+                    self.Protocol.send_priv_msg(
                         nick_from=dnickname,
                         msg=f"Something went wrong with the module: {e}",
                         channel=dchanlog
@@ -1403,7 +1254,7 @@ class Irc:
                     self.Base.shutdown()
                     self.Base.execute_periodic_action()
 
-                    self.Protocol.sendNotice(
+                    self.Protocol.send_notice(
                         nick_from=dnickname,
                         nick_to=fromuser,
                         msg=f"Arrêt du service {dnickname}"
@@ -1422,7 +1273,7 @@ class Irc:
                     reason.append(cmd[i])
                 final_reason = ' '.join(reason)
 
-                self.Protocol.sendNotice(
+                self.Protocol.send_notice(
                     nick_from=dnickname,
                     nick_to=fromuser,
                     msg=f"Redémarrage du service {dnickname}"
@@ -1476,7 +1327,7 @@ class Irc:
 
                 for key, value in conf_bkp_dict.items():
                     if config_dict[key] != value:
-                        self.Protocol.sendPrivMsg(
+                        self.Protocol.send_priv_msg(
                             nick_from=self.Config.SERVICE_NICKNAME,
                             msg=f'[{key}]: {value} ==> {config_dict[key]}', 
                             channel=self.Config.SERVICE_CHANLOG
@@ -1489,7 +1340,7 @@ class Irc:
 
                 if restart_flag:
                     self.Config.SERVEUR_ID = serveur_id
-                    self.Protocol.sendPrivMsg(nick_from=self.Config.SERVICE_NICKNAME, msg='You need to restart defender !', channel=self.Config.SERVICE_CHANLOG)
+                    self.Protocol.send_priv_msg(nick_from=self.Config.SERVICE_NICKNAME, msg='You need to restart defender !', channel=self.Config.SERVICE_CHANLOG)
 
                 self.Base.delete_logger(self.Config.LOGGING_NAME)
                 self.Base = self.Loader.BaseModule.Base(self.Config, self.Settings)
@@ -1500,7 +1351,7 @@ class Irc:
                 self.Protocol = Protocol(self.Config.SERVEUR_PROTOCOL, self.ircObject).Protocol
 
                 for mod in mods:
-                    self.Protocol.sendPrivMsg(
+                    self.Protocol.send_priv_msg(
                         nick_from=self.Config.SERVICE_NICKNAME,
                         msg=f'> Module [{mod}] reloaded', 
                         channel=self.Config.SERVICE_CHANLOG
@@ -1525,14 +1376,14 @@ class Irc:
                             loaded = True
 
                     if loaded:
-                        self.Protocol.sendNotice(
+                        self.Protocol.send_notice(
                             nick_from=dnickname,
                             nick_to=fromuser,
                             msg=f"{module} - {self.Config.COLORS.green}Loaded{self.Config.COLORS.nogc} by {loaded_user} on {loaded_datetime}"
                         )
                         loaded = False
                     else:
-                        self.Protocol.sendNotice(
+                        self.Protocol.send_notice(
                             nick_from=dnickname,
                             nick_to=fromuser,
                             msg=f"{module} - {self.Config.COLORS.red}Not Loaded{self.Config.COLORS.nogc}"
@@ -1542,13 +1393,13 @@ class Irc:
 
                 if self.Base.running_timers:
                     for the_timer in self.Base.running_timers:
-                        self.Protocol.sendNotice(
+                        self.Protocol.send_notice(
                             nick_from=dnickname,
                             nick_to=fromuser,
                             msg=f">> {the_timer.getName()} - {the_timer.is_alive()}"
                         )
                 else:
-                    self.Protocol.sendNotice(
+                    self.Protocol.send_notice(
                             nick_from=dnickname,
                             nick_to=fromuser,
                             msg="Aucun timers en cours d'execution"
@@ -1557,7 +1408,7 @@ class Irc:
             case 'show_threads':
 
                 for thread in self.Base.running_threads:
-                    self.Protocol.sendNotice(
+                    self.Protocol.send_notice(
                         nick_from=dnickname,
                         nick_to=fromuser,
                         msg=f">> {thread.getName()} ({thread.is_alive()})"
@@ -1572,7 +1423,7 @@ class Irc:
                         parsed_UID = re.sub(pattern, '', uid)
                         list_nicknames.append(self.User.get_nickname(parsed_UID))
 
-                    self.Protocol.sendNotice(
+                    self.Protocol.send_notice(
                         nick_from=dnickname,
                         nick_to=fromuser,
                         msg=f"Channel: {chan.name} - Users: {list_nicknames}"
@@ -1580,9 +1431,9 @@ class Irc:
 
             case 'show_users':
                 count_users = len(self.User.UID_DB)
-                self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"Total Connected Users: {count_users}")
+                self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"Total Connected Users: {count_users}")
                 for db_user in self.User.UID_DB:
-                    self.Protocol.sendNotice(
+                    self.Protocol.send_notice(
                         nick_from=dnickname,
                         nick_to=fromuser,
                         msg=f"UID : {db_user.uid} - isWebirc: {db_user.isWebirc} - isWebSocket: {db_user.isWebsocket} - Nickname: {db_user.nickname} - Connection: {db_user.connexion_datetime}"
@@ -1591,7 +1442,7 @@ class Irc:
             case 'show_admins':
 
                 for db_admin in self.Admin.UID_ADMIN_DB:
-                    self.Protocol.sendNotice(
+                    self.Protocol.send_notice(
                         nick_from=dnickname,
                         nick_to=fromuser,
                         msg=f"UID : {db_admin.uid} - Nickname: {db_admin.nickname} - Level: {db_admin.level} - Connection: {db_admin.connexion_datetime}"
@@ -1602,22 +1453,22 @@ class Irc:
                 config_dict = self.Config.__dict__
 
                 for key, value in config_dict.items():
-                    self.Protocol.sendNotice(
+                    self.Protocol.send_notice(
                         nick_from=dnickname,
                         nick_to=fromuser,
-                        msg=f'{key} > {value}'
+                        msg=f'{key} = {value}'
                         )
 
             case 'uptime':
                 uptime = self.get_defender_uptime()
-                self.Protocol.sendNotice(
+                self.Protocol.send_notice(
                     nick_from=dnickname,
                     nick_to=fromuser,
                     msg=f"{uptime}"
                 )
 
             case 'copyright':
-                self.Protocol.sendNotice(
+                self.Protocol.send_notice(
                     nick_from=dnickname,
                     nick_to=fromuser,
                     msg=f"# Defender V.{self.Config.CURRENT_VERSION} Developped by adator® #"

core/utils.py

@@ -0,0 +1,74 @@
+from typing import Literal, Union
+from datetime import datetime
+from time import time
+from random import choice
+from hashlib import md5, sha3_512
+
+def convert_to_int(value: any) -> Union[int, None]:
+    """Convert a value to int
+
+    Args:
+        value (any): Value to convert to int if possible
+
+    Returns:
+        Union[int, None]: Return the int value or None if not possible
+    """
+    try:
+        value_to_int = int(value)
+        return value_to_int
+    except ValueError:
+        return None
+    except Exception:
+        return None
+
+def get_unixtime() -> int:
+    """Cette fonction retourne un UNIXTIME de type 12365456
+
+    Returns:
+        int: Current time in seconds since the Epoch (int)
+    """
+    return int(time())
+
+def get_datetime() -> str:
+    """Retourne une date au format string (24-12-2023 20:50:59)
+
+    Returns:
+        str: Current datetime in this format %d-%m-%Y %H:%M:%S
+    """
+    currentdate = datetime.now().strftime('%d-%m-%Y %H:%M:%S')
+    return currentdate
+
+def generate_random_string(lenght: int) -> str:
+    """Retourn une chaîne aléatoire en fonction de la longueur spécifiée.
+    
+    Returns:
+        str: The random string 
+    """
+    caracteres = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
+    randomize = ''.join(choice(caracteres) for _ in range(lenght))
+
+    return randomize
+
+def hash(password: str, algorithm: Literal["md5, sha3_512"] = 'md5') -> str:
+    """Retourne un mot de passe chiffré en fonction de l'algorithme utilisé
+
+    Args:
+        password (str): Le password en clair
+        algorithm (str): L'algorithm a utilisé
+
+    Returns:
+        str: Le password haché
+    """
+
+    match algorithm:
+        case 'md5':
+            password = md5(password.encode()).hexdigest()
+            return password
+
+        case 'sha3_512':
+            password = sha3_512(password.encode()).hexdigest()
+            return password
+
+        case _:
+            password = md5(password.encode()).hexdigest()
+            return password

mods/mod_clone.py

@@ -73,7 +73,7 @@ class Clone():
         self.__load_module_configuration()
 
         self.Channel.db_query_channel(action='add', module_name=self.module_name, channel_name=self.Config.CLONE_CHANNEL)
-        self.Protocol.sendChanJoin(self.Config.SERVICE_NICKNAME, self.Config.CLONE_CHANNEL)
+        self.Protocol.send_join_chan(self.Config.SERVICE_NICKNAME, self.Config.CLONE_CHANNEL)
 
         self.Protocol.send2socket(f":{self.Config.SERVICE_NICKNAME} SAMODE {self.Config.CLONE_CHANNEL} +o {self.Config.SERVICE_NICKNAME}")
         self.Protocol.send2socket(f":{self.Config.SERVICE_NICKNAME} MODE {self.Config.CLONE_CHANNEL} +nts")
@@ -140,7 +140,7 @@ class Clone():
         self.Channel.db_query_channel(action='del', module_name=self.module_name, channel_name=self.Config.CLONE_CHANNEL)
         self.Protocol.send2socket(f":{self.Config.SERVICE_NICKNAME} MODE {self.Config.CLONE_CHANNEL} -nts")
         self.Protocol.send2socket(f":{self.Config.SERVICE_NICKNAME} MODE {self.Config.CLONE_CHANNEL} -k {self.Config.CLONE_CHANNEL_PASSWORD}")
-        self.Protocol.sendChanPart(self.Config.SERVICE_NICKNAME, self.Config.CLONE_CHANNEL)
+        self.Protocol.send_part_chan(self.Config.SERVICE_NICKNAME, self.Config.CLONE_CHANNEL)
 
         return None
 
@@ -244,8 +244,8 @@ class Clone():
                 break
 
             if not clone.connected:
-                self.Protocol.sendUID(clone.nickname, clone.username, clone.hostname, clone.uid, clone.umodes, clone.vhost, clone.remote_ip, clone.realname, print_log=False)
-                self.Protocol.sendChanJoin(uidornickname=clone.uid, channel=self.Config.CLONE_CHANNEL, password=self.Config.CLONE_CHANNEL_PASSWORD, print_log=False)
+                self.Protocol.send_uid(clone.nickname, clone.username, clone.hostname, clone.uid, clone.umodes, clone.vhost, clone.remote_ip, clone.realname, print_log=False)
+                self.Protocol.send_join_chan(uidornickname=clone.uid, channel=self.Config.CLONE_CHANNEL, password=self.Config.CLONE_CHANNEL_PASSWORD, print_log=False)
 
             time.sleep(interval)
             clone.connected = True
@@ -257,7 +257,7 @@ class Clone():
             clone_to_kill.append(clone.uid)
 
         for clone_uid in clone_to_kill:
-            self.Protocol.sendQuit(clone_uid, 'Gooood bye', print_log=False)
+            self.Protocol.send_quit(clone_uid, 'Gooood bye', print_log=False)
 
         del clone_to_kill
 
@@ -297,7 +297,7 @@ class Clone():
 
                         if getClone.uid != self.Config.SERVICE_ID:
                             final_message = f"{senderObj.nickname}!{senderObj.username}@{senderObj.hostname} > {senderMsg.lstrip(':')}"
-                            self.Protocol.sendPrivMsg(
+                            self.Protocol.send_priv_msg(
                                 nick_from=getClone.uid,
                                 msg=final_message,
                                 channel=self.Config.CLONE_CHANNEL
@@ -306,7 +306,7 @@ class Clone():
         except Exception as err:
             self.Logs.error(f'General Error: {err}')
 
-    def _hcmds(self, user:str, channel: any, cmd: list, fullcmd: list = []) -> None:
+    def hcmds(self, user:str, channel: any, cmd: list, fullcmd: list = []) -> None:
 
         try:
             command = str(cmd[0]).lower()
@@ -319,11 +319,11 @@ class Clone():
                 case 'clone':
 
                     if len(cmd) == 1:
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} clone connect NUMBER GROUP_NAME INTERVAL")
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} clone kill [all | nickname]")
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} clone join [all | nickname] #channel")
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} clone part [all | nickname] #channel")
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} clone list")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} clone connect NUMBER GROUP_NAME INTERVAL")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} clone kill [all | nickname]")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} clone join [all | nickname] #channel")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} clone part [all | nickname] #channel")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} clone list")
 
                     option = str(cmd[1]).lower()
 
@@ -344,8 +344,8 @@ class Clone():
 
                             except Exception as err:
                                 self.Logs.error(f'{err}')
-                                self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} clone connect [number of clone you want to connect] [Group]")
-                                self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"Exemple /msg {dnickname} clone connect 6 Ambiance")
+                                self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} clone connect [number of clone you want to connect] [Group]")
+                                self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"Exemple /msg {dnickname} clone connect 6 Ambiance")
 
                         case 'kill':
                             try:
@@ -360,12 +360,12 @@ class Clone():
                                 else:
                                     cloneObj = self.Clone.get_Clone(clone_name)
                                     if not cloneObj is None:
-                                        self.Protocol.sendQuit(cloneObj.uid, 'Goood bye', print_log=False)
+                                        self.Protocol.send_quit(cloneObj.uid, 'Goood bye', print_log=False)
 
                             except Exception as err:
                                 self.Logs.error(f'{err}')
-                                self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} clone kill all")
-                                self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} clone kill clone_nickname")
+                                self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} clone kill all")
+                                self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} clone kill clone_nickname")
 
                         case 'join':
                             try:
@@ -376,17 +376,17 @@ class Clone():
                                 if clone_name.lower() == 'all':
 
                                     for clone in self.Clone.UID_CLONE_DB:
-                                        self.Protocol.sendChanJoin(uidornickname=clone.uid, channel=clone_channel_to_join, print_log=False)
+                                        self.Protocol.send_join_chan(uidornickname=clone.uid, channel=clone_channel_to_join, print_log=False)
 
                                 else:
                                     if self.Clone.exists(clone_name):
                                         if not self.Clone.get_uid(clone_name) is None:
-                                            self.Protocol.sendChanJoin(uidornickname=clone_name, channel=clone_channel_to_join, print_log=False)
+                                            self.Protocol.send_join_chan(uidornickname=clone_name, channel=clone_channel_to_join, print_log=False)
 
                             except Exception as err:
                                 self.Logs.error(f'{err}')
-                                self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} clone join all #channel")
-                                self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} clone join clone_nickname #channel")
+                                self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} clone join all #channel")
+                                self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} clone join clone_nickname #channel")
 
                         case 'part':
                             try:
@@ -397,25 +397,25 @@ class Clone():
                                 if clone_name.lower() == 'all':
 
                                     for clone in self.Clone.UID_CLONE_DB:
-                                        self.Protocol.sendChanPart(uidornickname=clone.uid, channel=clone_channel_to_part, print_log=False)
+                                        self.Protocol.send_part_chan(uidornickname=clone.uid, channel=clone_channel_to_part, print_log=False)
 
                                 else:
                                     if self.Clone.exists(clone_name):
                                         clone_uid = self.Clone.get_uid(clone_name)
                                         if not clone_uid is None:
-                                            self.Protocol.sendChanPart(uidornickname=clone_uid, channel=clone_channel_to_part, print_log=False)
+                                            self.Protocol.send_part_chan(uidornickname=clone_uid, channel=clone_channel_to_part, print_log=False)
 
                             except Exception as err:
                                 self.Logs.error(f'{err}')
-                                self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} clone part all #channel")
-                                self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} clone part clone_nickname #channel")
+                                self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} clone part all #channel")
+                                self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} clone part clone_nickname #channel")
 
                         case 'list':
                             try:
                                 clone_count = len(self.Clone.UID_CLONE_DB)
-                                self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f">> Number of connected clones: {clone_count}")
+                                self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f">> Number of connected clones: {clone_count}")
                                 for clone_name in self.Clone.UID_CLONE_DB:
-                                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, 
+                                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, 
                                                              msg=f">> Nickname: {clone_name.nickname} | Username: {clone_name.username} | Realname: {clone_name.realname} | Vhost: {clone_name.vhost} | UID: {clone_name.uid} | Group: {clone_name.group} | Connected: {clone_name.connected}")
                             except Exception as err:
                                 self.Logs.error(f'{err}')
@@ -429,7 +429,7 @@ class Clone():
                                 final_message = ' '.join(cmd[4:])
 
                                 if clone_channel is None or not self.Clone.exists(clone_name):
-                                    self.Protocol.sendNotice(
+                                    self.Protocol.send_notice(
                                         nick_from=dnickname,
                                         nick_to=fromuser,
                                         msg=f"/msg {dnickname} clone say [clone_nickname] #channel message"
@@ -437,22 +437,22 @@ class Clone():
                                     return None
 
                                 if self.Clone.exists(clone_name):
-                                    self.Protocol.sendPrivMsg(nick_from=clone_name, msg=final_message, channel=clone_channel)
+                                    self.Protocol.send_priv_msg(nick_from=clone_name, msg=final_message, channel=clone_channel)
 
                             except Exception as err:
                                 self.Logs.error(f'{err}')
-                                self.Protocol.sendNotice(
+                                self.Protocol.send_notice(
                                         nick_from=dnickname,
                                         nick_to=fromuser,
                                         msg=f"/msg {dnickname} clone say [clone_nickname] #channel message"
                                     )
 
                         case _:
-                            self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} clone connect NUMBER GROUP_NAME INTERVAL")
-                            self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} clone kill [all | nickname]")
-                            self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} clone join [all | nickname] #channel")
-                            self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} clone part [all | nickname] #channel")
-                            self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} clone list")
+                            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} clone connect NUMBER GROUP_NAME INTERVAL")
+                            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} clone kill [all | nickname]")
+                            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} clone join [all | nickname] #channel")
+                            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} clone part [all | nickname] #channel")
+                            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} clone list")
 
         except IndexError as ie:
             self.Logs.error(f'Index Error: {ie}')

mods/mod_command.py

@@ -1,10 +1,12 @@
-from typing import TYPE_CHECKING
-from dataclasses import dataclass, fields
+from typing import Union, TYPE_CHECKING
+from dataclasses import dataclass
 
 if TYPE_CHECKING:
     from core.irc import Irc
+    from core.definition import MUser
+    from sqlalchemy import CursorResult, Row, Sequence
 
-class Command():
+class Command:
 
     @dataclass
     class ModConfModel:
@@ -20,6 +22,9 @@ class Command():
         # Add Irc Object to the module (Mandatory)
         self.Irc = ircInstance
 
+        # Add Loader Object to the module (Mandatory)
+        self.Loader = ircInstance.Loader
+
         # Add Protocol object to the module (Mandatory)
         self.Protocol = ircInstance.Protocol
 
@@ -42,12 +47,12 @@ class Command():
         self.commands_level = {
             1: ['join', 'part','owner', 'deowner', 'protect', 'deprotect', 'op',
                 'deop', 'halfop', 'dehalfop', 'voice','devoice', 'topic'],
-            2: ['opall', 'deopall', 'devoiceall', 'voiceall', 'ban', 
-                'unban','kick', 'kickban', 'umode', 'mode', 'get_mode', 'svsjoin', 'svspart', 'svsnick',
+            2: ['opall', 'deopall', 'devoiceall', 'voiceall', 'ban', 'automode',
+                'unban', 'kick', 'kickban', 'umode', 
+                'mode', 'get_mode', 'svsjoin', 'svspart', 'svsnick',
                 'wallops', 'globops','gnotice','whois', 'names', 'invite', 'inviteme',
-                'sajoin', 'sapart', 
-                'kill', 'gline', 'ungline', 'kline', 'unkline', 'shun', 'unshun', 
-                'glinelist', 'shunlist', 'klinelist'],
+                'sajoin', 'sapart', 'kill', 'gline', 'ungline', 'kline', 
+                'unkline', 'shun', 'unshun', 'glinelist', 'shunlist', 'klinelist'],
             3: ['map']
         }
 
@@ -82,7 +87,7 @@ class Command():
         """
         for level, com in commands.items():
             for c in commands[level]:
-                if not c in self.Irc.commands:
+                if c not in self.Irc.commands:
                     self.Irc.commands_level[level].append(c)
                     self.Irc.commands.append(c)
 
@@ -98,14 +103,17 @@ class Command():
             None: Aucun retour n'es attendu
         """
 
-        table_logs = '''CREATE TABLE IF NOT EXISTS test_logs (
+        table_automode = '''CREATE TABLE IF NOT EXISTS command_automode (
             id INTEGER PRIMARY KEY AUTOINCREMENT,
-            datetime TEXT,
-            server_msg TEXT
+            created_on TEXT,
+            updated_on TEXT,
+            nickname TEXT,
+            channel TEXT,
+            mode TEXT
             )
         '''
 
-        # self.Base.db_execute_query(table_logs)
+        self.Base.db_execute_query(table_automode)
         return None
 
     def __load_module_configuration(self) -> None:
@@ -136,11 +144,11 @@ class Command():
 
         return None
 
-    def cmd(self, data: list) -> None:
-
-        service_id = self.Config.SERVICE_ID
+    def cmd(self, data: list[str]) -> None:
+        try:
+            # service_id = self.Config.SERVICE_ID
             dnickname = self.Config.SERVICE_NICKNAME
-        dchanlog = self.Config.SERVICE_CHANLOG
+            # dchanlog = self.Config.SERVICE_CHANLOG
             red = self.Config.COLORS.red
             green = self.Config.COLORS.green
             bold = self.Config.COLORS.bold
@@ -155,7 +163,7 @@ class Command():
                 case '403' | '401':
                     try:
                         message = ' '.join(cmd[3:])
-                    self.Protocol.sendNotice(
+                        self.Protocol.send_notice(
                             nick_from=dnickname,
                             nick_to=self.user_to_notice,
                             msg=f"[{red}ERROR MSG{nogc}] {message}"
@@ -171,7 +179,7 @@ class Command():
                         # [':irc.deb.biz.st', '006', 'Dev-PyDefender', ':`-services.deb.biz.st', '------', '|', 'Users:', '9', '(47.37%)', '[00B]']
                         # [':irc.deb.biz.st', '018', 'Dev-PyDefender', ':4', 'servers', 'and', '19', 'users,', 'average', '4.75', 'users', 'per', 'server']
                         message = ' '.join(cmd[3:])
-                    self.Protocol.sendNotice(
+                        self.Protocol.send_notice(
                             nick_from=dnickname,
                             nick_to=self.user_to_notice,
                             msg=f"[{green}SERVER MSG{nogc}] {message}"
@@ -193,11 +201,11 @@ class Command():
 
                         match type_of_stats:
                             case 's':
-                            self.Protocol.sendNotice(nick_from=dnickname,nick_to=self.user_to_notice, msg="No shun")
+                                self.Protocol.send_notice(nick_from=dnickname,nick_to=self.user_to_notice, msg="No shun")
                             case 'G':
-                            self.Protocol.sendNotice(nick_from=dnickname,nick_to=self.user_to_notice, msg="No gline")
+                                self.Protocol.send_notice(nick_from=dnickname,nick_to=self.user_to_notice, msg="No gline")
                             case 'k':
-                            self.Protocol.sendNotice(nick_from=dnickname,nick_to=self.user_to_notice, msg="No kline")
+                                self.Protocol.send_notice(nick_from=dnickname,nick_to=self.user_to_notice, msg="No kline")
 
                     except KeyError as ke:
                         self.Logs.error(ke)
@@ -212,7 +220,7 @@ class Command():
                         author = str(cmd[7])
                         reason = ' '.join(cmd[8:])
 
-                    self.Protocol.sendNotice(nick_from=dnickname,nick_to=self.user_to_notice, 
+                        self.Protocol.send_notice(nick_from=dnickname,nick_to=self.user_to_notice,
                                                 msg=f"{bold}Author{nogc}: {author} - {bold}Host{nogc}: {host} - {bold}Reason{nogc}: {reason}"
                                                 )
 
@@ -224,19 +232,146 @@ class Command():
                 case _:
                     pass
 
+            if len(cmd) < 3:
                 return None
 
-    def _hcmds(self, user: str, channel: any, cmd: list, fullcmd: list = []) -> None:
+            match cmd[2]:
+
+                case 'SJOIN':
+                    # ['@msgid=yldTlbwAGbzCGUcCIHi3ku;time=2024-11-11T17:56:24.297Z', ':001', 'SJOIN', '1728815963', '#znc', ':001LQ0L0C']
+                    # Check if the user has an automode
+                    try:
+
+                        if len(cmd) < 6:
+                            return None
+
+                        user_uid = self.User.clean_uid(cmd[5])
+                        userObj: MUser = self.User.get_User(user_uid)
+                        channel_name = cmd[4] if self.Channel.Is_Channel(cmd[4]) else None
+
+                        if userObj is None:
+                            return None
+
+                        if 'r' not in userObj.umodes and 'o' not in userObj.umodes:
+                            return None
+
+                        db_data: dict[str, str] = {"nickname": userObj.nickname, "channel": channel_name}
+                        db_query = self.Base.db_execute_query("SELECT id, mode FROM command_automode WHERE nickname = :nickname AND channel = :channel", db_data)
+                        db_result = db_query.fetchone()
+                        if db_result is not None:
+                            id, mode = db_result
+                            self.Protocol.send2socket(f":{self.Config.SERVICE_ID} MODE {channel_name} {mode} {userObj.nickname}")
+                    except KeyError as ke:
+                        self.Logs.error(f"Key Error: {err}")
+
+        except Exception as err:
+            self.Logs.error(f"General Error: {err}")
+
+    def hcmds(self, uidornickname: str, channel_name: Union[str, None], cmd: list, fullcmd: list = []) -> None:
 
         command = str(cmd[0]).lower()
         dnickname = self.Config.SERVICE_NICKNAME
         service_id = self.Config.SERVICE_ID
         dchanlog = self.Config.SERVICE_CHANLOG
-        self.user_to_notice = user
-        fromuser = user
-        fromchannel = channel
+        self.user_to_notice = uidornickname
+        fromuser = uidornickname
+        fromchannel = channel_name
 
         match command:
+            case "automode":
+                # automode set nickname [+/-mode] #channel
+                # automode set adator +o #channel
+                try:
+                    option: str = str(cmd[1]).lower()
+                    match option:
+                        case 'set':
+                            allowed_modes: list[str] = self.Base.Settings.PROTOCTL_PREFIX # ['q','a','o','h','v']
+
+                            if len(cmd) < 5:
+                                self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} {command.upper()} [nickname] [+/-mode] [#channel]")
+                                self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"AutoModes available: {' / '.join(allowed_modes)}")
+                                return None
+
+                            # userObj: MUser = self.User.get_User(str(cmd[2]))
+                            nickname = str(cmd[2])
+                            mode = str(cmd[3])
+                            chan: str = str(cmd[4]).lower() if self.Channel.Is_Channel(cmd[4]) else None
+                            sign = mode[0] if mode.startswith( ('+', '-')) else None
+                            clean_mode = mode[1:] if len(mode) > 0 else None
+
+                            if sign is None:
+                                self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg="You must provide the flag mode + or -")
+                                return None
+
+                            if clean_mode not in allowed_modes:
+                                self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"You should use one of those modes {' / '.join(allowed_modes)}")
+                                return None
+
+                            if chan is None:
+                                self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"You should use one of those modes {' / '.join(allowed_modes)}")
+                                return None
+
+                            db_data: dict[str, str] = {"nickname": nickname, "channel": chan}
+                            db_query = self.Base.db_execute_query(query="SELECT id FROM command_automode WHERE nickname = :nickname and channel = :channel", params=db_data)
+                            db_result = db_query.fetchone()
+
+                            if db_result is not None:
+                                if sign == '+':
+                                    db_data = {"updated_on": self.Base.get_datetime(), "nickname": nickname, "channel": chan, "mode": mode}
+                                    db_result = self.Base.db_execute_query(query="UPDATE command_automode SET mode = :mode, updated_on = :updated_on WHERE nickname = :nickname and channel = :channel",
+                                                                    params=db_data)
+                                    if db_result.rowcount > 0:
+                                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"Automode {mode} edited for {nickname} in {chan}")
+                                elif sign == '-':
+                                    db_data = {"nickname": nickname, "channel": chan, "mode": f"+{clean_mode}"}
+                                    db_result = self.Base.db_execute_query(query="DELETE FROM command_automode WHERE nickname = :nickname and channel = :channel and mode = :mode",
+                                                                    params=db_data)
+                                    if db_result.rowcount > 0:
+                                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"Automode {mode} deleted for {nickname} in {chan}")
+                                    else:
+                                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"The mode [{mode}] has not been found for {nickname} in channel {chan}")
+
+                                return None
+
+                            # Instert a new automode
+                            if sign == '+':
+                                db_data = {"created_on": self.Base.get_datetime(), "updated_on": self.Base.get_datetime(), "nickname": nickname, "channel": chan, "mode": mode}
+                                db_query = self.Base.db_execute_query(
+                                    query="INSERT INTO command_automode (created_on, updated_on, nickname, channel, mode) VALUES (:created_on, :updated_on, :nickname, :channel, :mode)",
+                                    params=db_data
+                                )
+
+                                if db_query.rowcount > 0:
+                                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"Automode {mode} applied to {nickname} in {chan}")
+                                    if self.Channel.is_user_present_in_channel(chan, self.User.get_uid(nickname)):
+                                        self.Protocol.send2socket(f":{service_id} MODE {chan} {mode} {nickname}")
+                            else:
+                                self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"AUTOMODE {mode} cannot be added to {nickname} in {chan} because it doesn't exist")
+
+                        case 'list':
+                            db_query: CursorResult = self.Base.db_execute_query("SELECT nickname, channel, mode FROM command_automode")
+                            db_results: Sequence[Row] = db_query.fetchall()
+
+                            if not db_results:
+                                self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser,
+                                                          msg="There is no automode to display.")
+
+                            for db_result in db_results:
+                                db_nickname, db_channel, db_mode = db_result
+                                self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser,
+                                                          msg=f"Nickname: {db_nickname} | Channel: {db_channel} | Mode: {db_mode}")
+
+                        case _:
+                            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} {command.upper()} SET [nickname] [+/-mode] [#channel]")
+                            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} {command.upper()} LIST")
+                            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"[AUTOMODES AVAILABLE] are {' / '.join(allowed_modes)}")
+
+                except IndexError:
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} {command.upper()} SET [nickname] [+/-mode] [#channel]")
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} {command.upper()} LIST")
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"[AUTOMODES AVAILABLE] are {' / '.join(self.Base.Settings.PROTOCTL_PREFIX)}")
+                except Exception as err:
+                    self.Logs.error(f"General Error: {err}")
 
             case 'deopall':
                 try:
@@ -307,7 +442,7 @@ class Command():
                 # [':adator', 'PRIVMSG', '#services', ':.o', '#services', 'dktmb']
                 try:
                     if fromchannel is None:
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} op [#SALON] [NICKNAME]")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} op [#SALON] [NICKNAME]")
                         return False
 
                     if len(cmd) == 1:
@@ -325,7 +460,7 @@ class Command():
 
                 except IndexError as e:
                     self.Logs.warning(f'_hcmd OP: {str(e)}')
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} op [#SALON] [NICKNAME]")
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} op [#SALON] [NICKNAME]")
                 except Exception as err:
                     self.Logs.warning(f'Unknown Error: {str(err)}')
 
@@ -334,7 +469,7 @@ class Command():
                 # .deop #channel user
                 try:
                     if fromchannel is None:
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} deop [#SALON] [NICKNAME]")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} deop [#SALON] [NICKNAME]")
                         return False
 
                     if len(cmd) == 1:
@@ -352,7 +487,7 @@ class Command():
 
                 except IndexError as e:
                     self.Logs.warning(f'_hcmd DEOP: {str(e)}')
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} deop [#SALON] [NICKNAME]")
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} deop [#SALON] [NICKNAME]")
                 except Exception as err:
                     self.Logs.warning(f'Unknown Error: {str(err)}')
 
@@ -361,7 +496,7 @@ class Command():
                 # .owner #channel user
                 try:
                     if fromchannel is None:
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} owner [#SALON] [NICKNAME]")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} owner [#SALON] [NICKNAME]")
                         return False
 
                     if len(cmd) == 1:
@@ -379,7 +514,7 @@ class Command():
 
                 except IndexError as e:
                     self.Logs.warning(f'_hcmd OWNER: {str(e)}')
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} owner [#SALON] [NICKNAME]")
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} owner [#SALON] [NICKNAME]")
                 except Exception as err:
                     self.Logs.warning(f'Unknown Error: {str(err)}')
 
@@ -388,7 +523,7 @@ class Command():
                 # .deowner #channel user
                 try:
                     if fromchannel is None:
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} deowner [#SALON] [NICKNAME]")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} deowner [#SALON] [NICKNAME]")
                         return False
 
                     if len(cmd) == 1:
@@ -406,7 +541,7 @@ class Command():
 
                 except IndexError as e:
                     self.Logs.warning(f'_hcmd DEOWNER: {str(e)}')
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} deowner [#SALON] [NICKNAME]")
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} deowner [#SALON] [NICKNAME]")
                 except Exception as err:
                     self.Logs.warning(f'Unknown Error: {str(err)}')
 
@@ -415,7 +550,7 @@ class Command():
                 # .protect #channel user
                 try:
                     if fromchannel is None:
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} {command.upper()} [#SALON] [NICKNAME]")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} {command.upper()} [#SALON] [NICKNAME]")
                         return False
 
                     if len(cmd) == 1:
@@ -433,7 +568,7 @@ class Command():
 
                 except IndexError as e:
                     self.Logs.warning(f'_hcmd DEOWNER: {str(e)}')
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} {command.upper()} [#SALON] [NICKNAME]")
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} {command.upper()} [#SALON] [NICKNAME]")
                 except Exception as err:
                     self.Logs.warning(f'Unknown Error: {str(err)}')
 
@@ -442,7 +577,7 @@ class Command():
                 # .deprotect #channel user
                 try:
                     if fromchannel is None:
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} {command.upper()} [#SALON] [NICKNAME]")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} {command.upper()} [#SALON] [NICKNAME]")
                         return False
 
                     if len(cmd) == 1:
@@ -460,7 +595,7 @@ class Command():
 
                 except IndexError as e:
                     self.Logs.warning(f'_hcmd DEOWNER: {str(e)}')
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} {command.upper()} [#SALON] [NICKNAME]")
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} {command.upper()} [#SALON] [NICKNAME]")
                 except Exception as err:
                     self.Logs.warning(f'Unknown Error: {str(err)}')
 
@@ -469,7 +604,7 @@ class Command():
                 # .halfop #channel user
                 try:
                     if fromchannel is None:
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} halfop [#SALON] [NICKNAME]")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} halfop [#SALON] [NICKNAME]")
                         return False
 
                     if len(cmd) == 1:
@@ -487,7 +622,7 @@ class Command():
 
                 except IndexError as e:
                     self.Logs.warning(f'_hcmd halfop: {str(e)}')
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} halfop [#SALON] [NICKNAME]")
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} halfop [#SALON] [NICKNAME]")
                 except Exception as err:
                     self.Logs.warning(f'Unknown Error: {str(err)}')
 
@@ -496,7 +631,7 @@ class Command():
                 # .dehalfop #channel user
                 try:
                     if fromchannel is None:
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} dehalfop [#SALON] [NICKNAME]")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} dehalfop [#SALON] [NICKNAME]")
                         return False
 
                     if len(cmd) == 1:
@@ -514,7 +649,7 @@ class Command():
 
                 except IndexError as e:
                     self.Logs.warning(f'_hcmd DEHALFOP: {str(e)}')
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} dehalfop [#SALON] [NICKNAME]")
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} dehalfop [#SALON] [NICKNAME]")
                 except Exception as err:
                     self.Logs.warning(f'Unknown Error: {str(err)}')
 
@@ -523,7 +658,7 @@ class Command():
                 # .voice #channel user
                 try:
                     if fromchannel is None:
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} voice [#SALON] [NICKNAME]")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} voice [#SALON] [NICKNAME]")
                         return False
 
                     if len(cmd) == 1:
@@ -541,7 +676,7 @@ class Command():
 
                 except IndexError as e:
                     self.Logs.warning(f'_hcmd VOICE: {str(e)}')
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} voice [#SALON] [NICKNAME]")
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} voice [#SALON] [NICKNAME]")
                 except Exception as err:
                     self.Logs.warning(f'Unknown Error: {str(err)}')
 
@@ -550,7 +685,7 @@ class Command():
                 # .devoice #channel user
                 try:
                     if fromchannel is None:
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} devoice [#SALON] [NICKNAME]")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} devoice [#SALON] [NICKNAME]")
                         return False
 
                     if len(cmd) == 1:
@@ -568,7 +703,7 @@ class Command():
 
                 except IndexError as e:
                     self.Logs.warning(f'_hcmd DEVOICE: {str(e)}')
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} devoice [#SALON] [NICKNAME]")
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} devoice [#SALON] [NICKNAME]")
                 except Exception as err:
                     self.Logs.warning(f'Unknown Error: {str(err)}')
 
@@ -577,7 +712,7 @@ class Command():
                 try:
                     sentchannel = str(cmd[1]) if self.Channel.Is_Channel(cmd[1]) else None
                     if sentchannel is None:
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} {command.upper()} [#SALON] [NICKNAME]")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} {command.upper()} [#SALON] [NICKNAME]")
                         return False
 
                     nickname = cmd[2]
@@ -586,7 +721,7 @@ class Command():
                     self.Logs.debug(f'{fromuser} has banned {nickname} from {sentchannel}')
                 except IndexError as e:
                     self.Logs.warning(f'_hcmd BAN: {str(e)}')
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} {command.upper()} [#SALON] [NICKNAME]")
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} {command.upper()} [#SALON] [NICKNAME]")
                 except Exception as err:
                     self.Logs.warning(f'Unknown Error: {str(err)}')
 
@@ -595,7 +730,7 @@ class Command():
                 try:
                     sentchannel = str(cmd[1]) if self.Channel.Is_Channel(cmd[1]) else None
                     if sentchannel is None:
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} ban [#SALON] [NICKNAME]")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} ban [#SALON] [NICKNAME]")
                         return False
                     nickname = cmd[2]
 
@@ -604,7 +739,7 @@ class Command():
 
                 except IndexError as e:
                     self.Logs.warning(f'_hcmd UNBAN: {str(e)}')
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} unban [#SALON] [NICKNAME]")
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} unban [#SALON] [NICKNAME]")
                 except Exception as err:
                     self.Logs.warning(f'Unknown Error: {str(err)}')
 
@@ -613,7 +748,7 @@ class Command():
                 try:
                     sentchannel = str(cmd[1]) if self.Channel.Is_Channel(cmd[1]) else None
                     if sentchannel is None:
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} ban [#SALON] [NICKNAME]")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} ban [#SALON] [NICKNAME]")
                         return False
                     nickname = cmd[2]
                     final_reason = ' '.join(cmd[3:])
@@ -623,7 +758,7 @@ class Command():
 
                 except IndexError as e:
                     self.Logs.warning(f'_hcmd KICK: {str(e)}')
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} kick [#SALON] [NICKNAME] [REASON]")
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} kick [#SALON] [NICKNAME] [REASON]")
                 except Exception as err:
                     self.Logs.warning(f'Unknown Error: {str(err)}')
 
@@ -632,7 +767,7 @@ class Command():
                 try:
                     sentchannel = str(cmd[1]) if self.Channel.Is_Channel(cmd[1]) else None
                     if sentchannel is None:
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} ban [#SALON] [NICKNAME]")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} ban [#SALON] [NICKNAME]")
                         return False
                     nickname = cmd[2]
                     final_reason = ' '.join(cmd[3:])
@@ -643,7 +778,7 @@ class Command():
 
                 except IndexError as e:
                     self.Logs.warning(f'_hcmd KICKBAN: {str(e)}')
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} kickban [#SALON] [NICKNAME] [REASON]")
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} kickban [#SALON] [NICKNAME] [REASON]")
                 except Exception as err:
                     self.Logs.warning(f'Unknown Error: {str(err)}')
 
@@ -652,12 +787,12 @@ class Command():
                 try:
                     sent_channel = str(cmd[1]) if self.Channel.Is_Channel(cmd[1]) else None
                     if sent_channel is None:
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"{self.Config.SERVICE_PREFIX}JOIN #channel")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"{self.Config.SERVICE_PREFIX}JOIN #channel")
                         return False
 
                     # self.Protocol.send2socket(f':{service_id} JOIN {sent_channel}')
-                    self.Protocol.sendChanJoin(uidornickname=dnickname,channel=sent_channel)
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" {dnickname} JOINED {sent_channel}")
+                    self.Protocol.send_join_chan(uidornickname=dnickname,channel=sent_channel)
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" {dnickname} JOINED {sent_channel}")
                     self.Channel.db_query_channel('add', self.module_name, sent_channel)
 
                 except IndexError as ie:
@@ -670,15 +805,15 @@ class Command():
                 try:
                     sent_channel = str(cmd[1]) if self.Channel.Is_Channel(cmd[1]) else None
                     if sent_channel is None:
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"{self.Config.SERVICE_PREFIX}PART #channel")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"{self.Config.SERVICE_PREFIX}PART #channel")
                         return False
 
                     if sent_channel ==  dchanlog:
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" {dnickname} CAN'T LEFT {sent_channel} AS IT IS LOG CHANNEL")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" {dnickname} CAN'T LEFT {sent_channel} AS IT IS LOG CHANNEL")
                         return False
 
-                    self.Protocol.sendChanPart(uidornickname=dnickname, channel=sent_channel)
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" {dnickname} LEFT {sent_channel}")
+                    self.Protocol.send_part_chan(uidornickname=dnickname, channel=sent_channel)
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" {dnickname} LEFT {sent_channel}")
 
                     self.Channel.db_query_channel('del', self.module_name, sent_channel)
 
@@ -690,14 +825,14 @@ class Command():
             case 'topic':
                 try:
                     if len(cmd) == 1:
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} TOPIC #channel THE_TOPIC_MESSAGE")
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} TOPIC #channel THE_TOPIC_MESSAGE")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} TOPIC #channel THE_TOPIC_MESSAGE")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} TOPIC #channel THE_TOPIC_MESSAGE")
                         return None
 
                     chan = str(cmd[1])
                     if not self.Channel.Is_Channel(chan):
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"The channel must start with #")
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} TOPIC #channel THE_TOPIC_MESSAGE")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg="The channel must start with #")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} TOPIC #channel THE_TOPIC_MESSAGE")
                         return None
 
                     topic_msg = ' '.join(cmd[2:]).strip()
@@ -705,7 +840,7 @@ class Command():
                     if topic_msg:
                         self.Protocol.send2socket(f':{dnickname} TOPIC {chan} :{topic_msg}')
                     else:
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"You need to specify the topic")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg="You need to specify the topic")
 
                 except KeyError as ke:
                     self.Logs.error(ke)
@@ -715,7 +850,7 @@ class Command():
             case 'wallops':
                 try:
                     if len(cmd) == 1:
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} WALLOPS THE_WALLOPS_MESSAGE")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} WALLOPS THE_WALLOPS_MESSAGE")
                         return None
 
                     wallops_msg = ' '.join(cmd[1:]).strip()
@@ -723,7 +858,7 @@ class Command():
                     if wallops_msg:
                         self.Protocol.send2socket(f':{dnickname} WALLOPS {wallops_msg} ({dnickname})')
                     else:
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"You need to specify the wallops message")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg="You need to specify the wallops message")
 
                 except KeyError as ke:
                     self.Logs.error(ke)
@@ -733,7 +868,7 @@ class Command():
             case 'globops':
                 try:
                     if len(cmd) == 1:
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} GLOBOPS THE_GLOBOPS_MESSAGE")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} GLOBOPS THE_GLOBOPS_MESSAGE")
                         return None
 
                     globops_msg = ' '.join(cmd[1:]).strip()
@@ -741,7 +876,7 @@ class Command():
                     if globops_msg:
                         self.Protocol.send2socket(f':{dnickname} GLOBOPS {globops_msg} ({dnickname})')
                     else:
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"You need to specify the globops message")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg="You need to specify the globops message")
 
                 except KeyError as ke:
                     self.Logs.error(ke)
@@ -751,15 +886,15 @@ class Command():
             case 'gnotice':
                 try:
                     if len(cmd) == 1:
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} {str(cmd[0]).upper()} THE_GLOBAL_NOTICE_MESSAGE")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} {str(cmd[0]).upper()} THE_GLOBAL_NOTICE_MESSAGE")
                         return None
 
                     gnotice_msg = ' '.join(cmd[1:]).strip()
 
                     if gnotice_msg:
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to='$*.*', msg=f"[{self.Config.COLORS.red}GLOBAL NOTICE{self.Config.COLORS.nogc}] {gnotice_msg}")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to='$*.*', msg=f"[{self.Config.COLORS.red}GLOBAL NOTICE{self.Config.COLORS.nogc}] {gnotice_msg}")
                     else:
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"You need to specify the global notice message")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg="You need to specify the global notice message")
 
                 except KeyError as ke:
                     self.Logs.error(ke)
@@ -770,14 +905,14 @@ class Command():
                 try:
                     self.user_to_notice = fromuser
                     if len(cmd) == 1:
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} {str(cmd[0]).upper()} NICKNAME")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} {str(cmd[0]).upper()} NICKNAME")
                         return None
 
                     nickname = str(cmd[1])
 
                     if self.User.get_nickname(nickname) is None:
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"Nickname not found !")
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} {str(cmd[0]).upper()} NICKNAME")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg="Nickname not found !")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} {str(cmd[0]).upper()} NICKNAME")
                         return None
 
                     self.Protocol.send2socket(f':{dnickname} WHOIS {nickname}')
@@ -790,14 +925,14 @@ class Command():
             case 'names':
                 try:
                     if len(cmd) == 1:
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} {str(cmd[0]).upper()} #CHANNEL")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} {str(cmd[0]).upper()} #CHANNEL")
                         return None
 
                     chan = str(cmd[1])
 
                     if not self.Channel.Is_Channel(chan):
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"The channel must start with #")
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} {str(cmd[0]).upper()} #channel")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg="The channel must start with #")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} {str(cmd[0]).upper()} #channel")
                         return None
 
                     self.Protocol.send2socket(f':{dnickname} NAMES {chan}')
@@ -810,20 +945,20 @@ class Command():
             case 'invite':
                 try:
                     if len(cmd) < 3:
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} {str(cmd[0]).upper()} NICKNAME #CHANNEL")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} {str(cmd[0]).upper()} NICKNAME #CHANNEL")
                         return None
 
                     nickname = str(cmd[1])
                     chan = str(cmd[2])
 
                     if not self.Channel.Is_Channel(chan):
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"The channel must start with #")
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} {str(cmd[0]).upper()} NICKNAME #CHANNEL")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg="The channel must start with #")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} {str(cmd[0]).upper()} NICKNAME #CHANNEL")
                         return None
 
                     if self.User.get_nickname(nickname) is None:
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"Nickname not found !")
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} {str(cmd[0]).upper()} NICKNAME #CHANNEL")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg="Nickname not found !")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} {str(cmd[0]).upper()} NICKNAME #CHANNEL")
                         return None
 
                     self.Protocol.send2socket(f':{dnickname} INVITE {nickname} {chan}')
@@ -836,7 +971,7 @@ class Command():
             case 'inviteme':
                 try:
                     if len(cmd) == 0:
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} {str(cmd[0]).upper()}")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {dnickname} {str(cmd[0]).upper()}")
                         return None
 
                     self.Protocol.send2socket(f':{dnickname} INVITE {fromuser} {self.Config.SERVICE_CHANLOG}')
@@ -860,13 +995,13 @@ class Command():
                 try:
                     # .umode nickname +mode
                     if len(cmd) < 2:
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} {command.upper()} [NICKNAME] [+/-]mode")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} {command.upper()} [NICKNAME] [+/-]mode")
                         return None
 
                     nickname = str(cmd[1])
                     umode = str(cmd[2])
 
-                    self.Protocol.sendSvsmode(nickname=nickname, user_mode=umode)
+                    self.Protocol.send_svs_mode(nickname=nickname, user_mode=umode)
                 except KeyError as ke:
                     self.Logs.error(ke)
                 except Exception as err:
@@ -878,11 +1013,11 @@ class Command():
                 try:
 
                     if len(cmd) < 2:
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} {command.upper()} [#CHANNEL] [+/-]mode")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} {command.upper()} [#CHANNEL] [+/-]mode")
                         return None
 
                     if fromchannel is None:
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} {command.upper()} [#CHANNEL] [+/-]mode")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} {command.upper()} [#CHANNEL] [+/-]mode")
                         return None
 
                     if len(cmd) == 2:
@@ -890,7 +1025,7 @@ class Command():
                         if self.Channel.Is_Channel(fromchannel):
                             self.Protocol.send2socket(f":{dnickname} MODE {fromchannel} {channel_mode}")
                         else:
-                            self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : Channel [{fromchannel}] is not correct should start with #")
+                            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : Channel [{fromchannel}] is not correct should start with #")
                         return None
 
                     if len(cmd) == 3:
@@ -901,13 +1036,15 @@ class Command():
 
                 except IndexError as e:
                     self.Logs.warning(f'_hcmd OP: {str(e)}')
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} {command.upper()} [#CHANNEL] [+/-]mode")
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} {command.upper()} [#CHANNEL] [+/-]mode")
                 except Exception as err:
                     self.Logs.warning(f'Unknown Error: {str(err)}')
 
             case 'get_mode':
-
-                self.Protocol.send2socket(f'MODE {channel}')
+                try:
+                    self.Protocol.send2socket(f'MODE {fromchannel}')
+                except Exception as err:
+                    self.Logs.error(f"General Error {err}")
 
             case 'svsjoin':
                 try:
@@ -915,30 +1052,30 @@ class Command():
                     nickname = str(cmd[1])
                     channel = str(cmd[2])
                     if len(cmd) != 3:
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} SVSJOIN nickname #channel")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} SVSJOIN nickname #channel")
                         return None
 
                     self.Protocol.send2socket(f':{self.Config.SERVEUR_ID} SVSJOIN {nickname} {channel}')
                 except KeyError as ke:
                     self.Logs.error(ke)
                 except Exception as err:
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} SVSJOIN nickname #channel")
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} SVSJOIN nickname #channel")
                     self.Logs.warning(f'Unknown Error: {str(err)}')
 
             case 'svspart':
                 try:
-                    # .svspart nickname #channel
+                    # svspart nickname #channel
                     nickname = str(cmd[1])
                     channel = str(cmd[2])
                     if len(cmd) != 3:
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} SVSPART nickname #channel")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} SVSPART nickname #channel")
                         return None
 
                     self.Protocol.send2socket(f':{self.Config.SERVEUR_ID} SVSPART {nickname} {channel}')
                 except KeyError as ke:
                     self.Logs.error(ke)
                 except Exception as err:
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} SVSPART nickname #channel")
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} SVSPART nickname #channel")
                     self.Logs.warning(f'Unknown Error: {str(err)}')
 
             case 'sajoin':
@@ -947,15 +1084,15 @@ class Command():
                     nickname = str(cmd[1])
                     channel = str(cmd[2])
                     if len(cmd) < 3:
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} {command.upper()} nickname #channel")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} {command.upper()} nickname #channel")
                         return None
 
-                    self.Protocol.sendSajoin(nick_to_sajoin=nickname, channel_name=channel)
+                    self.Protocol.send_sajoin(nick_to_sajoin=nickname, channel_name=channel)
 
                 except KeyError as ke:
                     self.Logs.error(ke)
                 except Exception as err:
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} {command.upper()} nickname #channel")
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} {command.upper()} nickname #channel")
                     self.Logs.warning(f'Unknown Error: {str(err)}')
 
             case 'sapart':
@@ -964,14 +1101,14 @@ class Command():
                     nickname = str(cmd[1])
                     channel = str(cmd[2])
                     if len(cmd) < 3:
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} {command.upper()} nickname #channel")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} {command.upper()} nickname #channel")
                         return None
 
-                    self.Protocol.sendSapart(nick_to_sapart=nickname, channel_name=channel)
+                    self.Protocol.send_sapart(nick_to_sapart=nickname, channel_name=channel)
                 except KeyError as ke:
                     self.Logs.error(ke)
                 except Exception as err:
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} {command.upper()} nickname #channel")
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} {command.upper()} nickname #channel")
                     self.Logs.warning(f'Unknown Error: {str(err)}')
 
             case 'svsnick':
@@ -982,11 +1119,11 @@ class Command():
                     unixtime = self.Base.get_unixtime()
 
                     if self.User.get_nickname(nickname) is None:
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" This nickname do not exist")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" This nickname do not exist")
                         return None
 
                     if len(cmd) != 3:
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} {command.upper()} nickname newnickname")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} {command.upper()} nickname newnickname")
                         return None
 
                     self.Protocol.send2socket(f':{self.Config.SERVEUR_ID} SVSNICK {nickname} {newnickname} {unixtime}')
@@ -994,7 +1131,7 @@ class Command():
                 except KeyError as ke:
                     self.Logs.error(ke)
                 except Exception as err:
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} {command.upper()} nickname newnickname")
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} {command.upper()} nickname newnickname")
                     self.Logs.warning(f'Unknown Error: {str(err)}')
 
             case 'kill':
@@ -1002,7 +1139,7 @@ class Command():
                     # 'kill', 'gline', 'ungline', 'shun', 'unshun'
                     # .kill nickname reason
                     if len(cmd) < 3:
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} {command.upper()} nickname reason")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} {command.upper()} nickname reason")
                         return None
 
                     nickname = str(cmd[1])
@@ -1012,7 +1149,7 @@ class Command():
                 except KeyError as ke:
                     self.Logs.error(ke)
                 except Exception as err:
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} SVSNICK nickname newnickname")
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} SVSNICK nickname newnickname")
                     self.Logs.warning(f'Unknown Error: {str(err)}')
 
             case 'gline':
@@ -1020,7 +1157,7 @@ class Command():
                     # TKL + G user host set_by expire_timestamp set_at_timestamp :reason
                     # .gline [nickname] [host] [reason]
                     if len(cmd) < 4:
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} {command.upper()} nickname host reason")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} {command.upper()} nickname host reason")
                         return None
 
                     nickname = str(cmd[1])
@@ -1030,8 +1167,8 @@ class Command():
                     gline_reason = ' '.join(cmd[3:])
 
                     if nickname == '*' and hostname == '*':
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" You want to close the server ? i would recommand ./unrealircd stop :)")
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} {command.upper()} nickname host reason")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" You want to close the server ? i would recommand ./unrealircd stop :)")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} {command.upper()} nickname host reason")
                         return None
 
                     self.Protocol.gline(nickname=nickname, hostname=hostname, set_by=dnickname, expire_timestamp=expire_time, set_at_timestamp=set_at_timestamp, reason=gline_reason)
@@ -1039,7 +1176,7 @@ class Command():
                 except KeyError as ke:
                     self.Logs.error(ke)
                 except Exception as err:
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} {command.upper()} nickname host reason")
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} {command.upper()} nickname host reason")
                     self.Logs.warning(f'Unknown Error: {str(err)}')
 
             case 'ungline':
@@ -1048,7 +1185,7 @@ class Command():
                     # TKL + G user host set_by expire_timestamp set_at_timestamp :reason
                     # .ungline nickname host
                     if len(cmd) < 2:
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} {command.upper()} nickname hostname")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} {command.upper()} nickname hostname")
                         return None
 
                     nickname = str(cmd[1])
@@ -1060,7 +1197,7 @@ class Command():
                 except KeyError as ke:
                     self.Logs.error(ke)
                 except Exception as err:
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} {command.upper()} nickname hostname")
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} {command.upper()} nickname hostname")
                     self.Logs.warning(f'Unknown Error: {str(err)}')
 
             case 'kline':
@@ -1068,7 +1205,7 @@ class Command():
                     # TKL + k user host set_by expire_timestamp set_at_timestamp :reason
                     # .gline [nickname] [host] [reason]
                     if len(cmd) < 4:
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} {command.upper()} nickname host reason")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} {command.upper()} nickname host reason")
                         return None
 
                     nickname = str(cmd[1])
@@ -1078,8 +1215,8 @@ class Command():
                     gline_reason = ' '.join(cmd[3:])
 
                     if nickname == '*' and hostname == '*':
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" You want to close the server ? i would recommand ./unrealircd stop :)")
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} {command.upper()} nickname host reason")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" You want to close the server ? i would recommand ./unrealircd stop :)")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} {command.upper()} nickname host reason")
                         return None
 
                     self.Protocol.kline(nickname=nickname, hostname=hostname, set_by=dnickname, expire_timestamp=expire_time, set_at_timestamp=set_at_timestamp, reason=gline_reason)
@@ -1087,7 +1224,7 @@ class Command():
                 except KeyError as ke:
                     self.Logs.error(ke)
                 except Exception as err:
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} {command.upper()} nickname host reason")
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} {command.upper()} nickname host reason")
                     self.Logs.warning(f'Unknown Error: {str(err)}')
 
             case 'unkline':
@@ -1096,7 +1233,7 @@ class Command():
                     # TKL + G user host set_by expire_timestamp set_at_timestamp :reason
                     # .ungline nickname host
                     if len(cmd) < 2:
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} {command.upper()} nickname hostname")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} {command.upper()} nickname hostname")
                         return None
 
                     nickname = str(cmd[1])
@@ -1107,7 +1244,7 @@ class Command():
                 except KeyError as ke:
                     self.Logs.error(ke)
                 except Exception as err:
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} {command.upper()} nickname hostname")
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} {command.upper()} nickname hostname")
                     self.Logs.warning(f'Unknown Error: {str(err)}')
 
             case 'shun':
@@ -1116,7 +1253,7 @@ class Command():
                     # .shun [nickname] [host] [reason]
 
                     if len(cmd) < 4:
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} {command.upper()} nickname host reason")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} {command.upper()} nickname host reason")
                         return None
 
                     nickname = str(cmd[1])
@@ -1126,15 +1263,15 @@ class Command():
                     shun_reason = ' '.join(cmd[3:])
 
                     if nickname == '*' and hostname == '*':
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" You want to close the server ? i would recommand ./unrealircd stop :)")
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} {command.upper()} nickname host reason")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" You want to close the server ? i would recommand ./unrealircd stop :)")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} {command.upper()} nickname host reason")
                         return None
 
                     self.Protocol.send2socket(f":{self.Config.SERVEUR_ID} TKL + s {nickname} {hostname} {dnickname} {expire_time} {set_at_timestamp} :{shun_reason}")
                 except KeyError as ke:
                     self.Logs.error(ke)
                 except Exception as err:
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} {command.upper()} nickname host reason")
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} {command.upper()} nickname host reason")
                     self.Logs.warning(f'Unknown Error: {str(err)}')
 
             case 'unshun':
@@ -1143,7 +1280,7 @@ class Command():
                     # TKL + G user host set_by expire_timestamp set_at_timestamp :reason
                     # .unshun nickname host
                     if len(cmd) < 2:
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} {command.upper()} nickname hostname")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} {command.upper()} nickname hostname")
                         return None
 
                     nickname = str(cmd[1])
@@ -1154,7 +1291,7 @@ class Command():
                 except KeyError as ke:
                     self.Logs.error(ke)
                 except Exception as err:
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} {command.upper()} nickname hostname")
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} {command.upper()} nickname hostname")
                     self.Logs.warning(f'Unknown Error: {str(err)}')
 
             case 'glinelist':
@@ -1165,7 +1302,7 @@ class Command():
                 except KeyError as ke:
                     self.Logs.error(ke)
                 except Exception as err:
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} {command.upper()}")
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} {command.upper()}")
                     self.Logs.warning(f'Unknown Error: {str(err)}')
 
             case 'shunlist':
@@ -1176,7 +1313,7 @@ class Command():
                 except KeyError as ke:
                     self.Logs.error(ke)
                 except Exception as err:
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} {command.upper()}")
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} {command.upper()}")
                     self.Logs.warning(f'Unknown Error: {str(err)}')
 
             case 'klinelist':
@@ -1187,7 +1324,7 @@ class Command():
                 except KeyError as ke:
                     self.Logs.error(ke)
                 except Exception as err:
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} {command.upper()}")
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" /msg {dnickname} {command.upper()}")
                     self.Logs.warning(f'Unknown Error: {str(err)}')
 
             case _:

mods/mod_defender.py

@@ -4,10 +4,9 @@ import time
 import re
 import psutil
 import requests
-from dataclasses import dataclass, fields, field
+from dataclasses import dataclass
 from datetime import datetime
 from typing import Union, TYPE_CHECKING
-from sys import exit
 import core.definition as df
 
 #   Le module crée devra réspecter quelques conditions
@@ -19,7 +18,7 @@ import core.definition as df
 #           4 . Créer vos tables, en utilisant toujours le nom des votre classe en minuscule ==> defender_votre-table
 #       3. Methode suivantes:
 #           cmd(self, data:list)
-#           _hcmds(self, user:str, cmd: list)
+#           hcmds(self, user:str, cmd: list)
 #           unload(self)
 
 if TYPE_CHECKING:
@@ -141,6 +140,8 @@ class Defender():
         self.Base.create_thread(func=self.thread_local_scan)
         self.Base.create_thread(func=self.thread_psutil_scan)
         self.Base.create_thread(func=self.thread_reputation_timer)
+
+        if self.ModConfig.autolimit == 1:
             self.Base.create_thread(func=self.thread_autolimit)
 
         if self.ModConfig.reputation == 1:
@@ -157,7 +158,7 @@ class Defender():
         """
         for level, com in commands.items():
             for c in commands[level]:
-                if not c in self.Irc.commands:
+                if c not in self.Irc.commands:
                     self.Irc.commands_level[level].append(c)
                     self.Irc.commands.append(c)
 
@@ -173,31 +174,15 @@ class Defender():
             None: Aucun retour n'es attendu
         """
 
-        table_channel = '''CREATE TABLE IF NOT EXISTS def_channels (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            datetime TEXT,
-            channel TEXT
-            ) 
-        '''
+        # table_autoop = '''CREATE TABLE IF NOT EXISTS defender_autoop (
+        #     id INTEGER PRIMARY KEY AUTOINCREMENT,
+        #     datetime TEXT,
+        #     nickname TEXT,
+        #     channel TEXT
+        #     )
+        # '''
 
-        table_config = '''CREATE TABLE IF NOT EXISTS def_config (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            datetime TEXT,
-            parameter TEXT,
-            value TEXT
-            ) 
-        '''
-
-        table_trusted = '''CREATE TABLE IF NOT EXISTS def_trusted (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            datetime TEXT,
-            user TEXT,
-            host TEXT,
-            vhost TEXT
-            )
-        '''
-
-        # self.Base.db_execute_query(table_channel)
+        # self.Base.db_execute_query(table_autoop)
         # self.Base.db_execute_query(table_config)
         # self.Base.db_execute_query(table_trusted)
         return None
@@ -255,7 +240,7 @@ class Defender():
         exec_query = self.Base.db_execute_query(query, {"user": nickname})
         response = exec_query.fetchone()
 
-        if not response is None:
+        if response is not None:
             q_insert = "INSERT INTO def_trusted (datetime, user, host, vhost) VALUES (?, ?, ?, ?)"
             mes_donnees = {'datetime': self.Base.get_datetime(), 'user': nickname, 'host': '*', 'vhost': '*'}
             exec_query = self.Base.db_execute_query(q_insert, mes_donnees)
@@ -301,7 +286,8 @@ class Defender():
 
         # Convertir la date enregistrée dans UID_DB en un objet {datetime}
         connected_time_string = get_user.connexion_datetime
-        if type(connected_time_string) == datetime:
+
+        if isinstance(connected_time_string, datetime):
             connected_time = connected_time_string
         else:
             connected_time = datetime.strptime(connected_time_string, "%Y-%m-%d %H:%M:%S.%f")
@@ -351,12 +337,12 @@ class Defender():
             if not get_reputation.isWebirc:
                 # Si le user ne vient pas de webIrc
 
-                self.Protocol.sendSajoin(nick_to_sajoin=jailed_nickname, channel_name=salon_jail)
-                self.Protocol.sendPrivMsg(nick_from=self.Config.SERVICE_NICKNAME,
+                self.Protocol.send_sajoin(nick_to_sajoin=jailed_nickname, channel_name=salon_jail)
+                self.Protocol.send_priv_msg(nick_from=self.Config.SERVICE_NICKNAME,
                     msg=f" [{color_red} REPUTATION {nogc}] : Connexion de {jailed_nickname} ({jailed_score}) ==> {salon_jail}",
                     channel=salon_logs
                     )
-                self.Protocol.sendNotice(
+                self.Protocol.send_notice(
                         nick_from=self.Config.SERVICE_NICKNAME, 
                         nick_to=jailed_nickname,
                         msg=f"[{color_red} {jailed_nickname} {color_black}] : Merci de tapez la commande suivante {color_bold}{service_prefix}code {code}{color_bold}"
@@ -386,7 +372,6 @@ class Defender():
             service_id = self.Config.SERVICE_ID
             dchanlog = self.Config.SERVICE_CHANLOG
             color_red = self.Config.COLORS.red
-            color_black = self.Config.COLORS.black
             nogc = self.Config.COLORS.nogc
             salon_jail = self.Config.SALON_JAIL
 
@@ -400,7 +385,7 @@ class Defender():
             for user in self.Reputation.UID_REPUTATION_DB:
                 if not user.isWebirc: # Si il ne vient pas de WebIRC
                     if self.get_user_uptime_in_minutes(user.uid) >= reputation_timer and int(user.score_connexion) <= int(reputation_seuil):
-                        self.Protocol.sendPrivMsg(
+                        self.Protocol.send_priv_msg(
                             nick_from=service_id,
                             msg=f"[{color_red} REPUTATION {nogc}] : Action sur {user.nickname} aprés {str(reputation_timer)} minutes d'inactivité",
                             channel=dchanlog
@@ -480,7 +465,7 @@ class Defender():
         unixtime = self.Base.get_unixtime()
         get_diff_secondes = 0
 
-        if not get_detected_uid in self.flood_system:
+        if get_detected_uid not in self.flood_system:
             self.flood_system[get_detected_uid] = {
                     'nbr_msg': 0,
                     'first_msg_time': unixtime
@@ -495,7 +480,7 @@ class Defender():
 
         elif self.flood_system[get_detected_uid]['nbr_msg'] > flood_message:
             self.Irc.Base.logs.info('system de flood detecté')
-            self.Protocol.sendPrivMsg(
+            self.Protocol.send_priv_msg(
                 nick_from=dnickname,
                 msg=f"{color_red} {color_bold} Flood detected. Apply the +m mode (Ô_o)",
                 channel=channel
@@ -516,13 +501,13 @@ class Defender():
 
         for param in res.fetchall():
             if param[0] == 'reputation':
-                self.Protocol.sendPrivMsg(
+                self.Protocol.send_priv_msg(
                     nick_from=service_id,
                     msg=f" ===> {param[0]}",
                     channel=dchanlog
                 )
             else:
-                self.Protocol.sendPrivMsg(
+                self.Protocol.send_priv_msg(
                     nick_from=service_id,
                     msg=f"{param[0]}",
                     channel=dchanlog
@@ -555,7 +540,7 @@ class Defender():
                 connection = (remote_ip, self.Base.int_if_possible(port))
                 newSocket.connect(connection)
 
-                self.Protocol.sendPrivMsg(
+                self.Protocol.send_priv_msg(
                     nick_from=self.Config.SERVICE_NICKNAME,
                     msg=f"[ {self.Config.COLORS.red}PROXY_SCAN{self.Config.COLORS.nogc} ] {fullname} ({remote_ip}) :     Port [{str(port)}] ouvert sur l'adresse ip [{remote_ip}]",
                     channel=self.Config.SERVICE_CHANLOG
@@ -622,7 +607,7 @@ class Defender():
             self.Logs.info(f"Connexion of {fullname} ({remote_ip}) using ports : {str(matching_ports)}")
 
             if matching_ports:
-                self.Protocol.sendPrivMsg(
+                self.Protocol.send_priv_msg(
                         nick_from=self.Config.SERVICE_NICKNAME,
                         msg=f"[ {self.Config.COLORS.red}PSUTIL_SCAN{self.Config.COLORS.black} ] {fullname} ({remote_ip}) : is using ports {matching_ports}",
                         channel=self.Config.SERVICE_CHANLOG
@@ -694,7 +679,7 @@ class Defender():
             # Formatted output
             decodedResponse = json.loads(response.text)
 
-            if not 'data' in decodedResponse:
+            if 'data' not in decodedResponse:
                 return None
 
             result = {
@@ -707,13 +692,12 @@ class Defender():
             service_id = self.Config.SERVICE_ID
             service_chanlog = self.Config.SERVICE_CHANLOG
             color_red = self.Config.COLORS.red
-            color_black = self.Config.COLORS.black
             nogc = self.Config.COLORS.nogc
 
             # pseudo!ident@host
             fullname = f'{nickname}!{username}@{hostname}'
 
-            self.Protocol.sendPrivMsg(
+            self.Protocol.send_priv_msg(
                 nick_from=service_id,
                 msg=f"[ {color_red}ABUSEIPDB_SCAN{nogc} ] : Connexion de {fullname} ({remote_ip}) ==> Score: {str(result['score'])} | Country : {result['country']} | Tor : {str(result['isTor'])} | Total Reports : {str(result['totalReports'])}",
                 channel=service_chanlog
@@ -780,7 +764,6 @@ class Defender():
         service_id = self.Config.SERVICE_ID
         service_chanlog = self.Config.SERVICE_CHANLOG
         color_red = self.Config.COLORS.red
-        color_black = self.Config.COLORS.black
         nogc = self.Config.COLORS.nogc
 
         url = f'https://freeipapi.com/api/json/{remote_ip}'
@@ -797,7 +780,7 @@ class Defender():
 
             status_code = response.status_code
             if status_code == 429:
-                self.Logs.warning(f'Too Many Requests - The rate limit for the API has been exceeded.')
+                self.Logs.warning('Too Many Requests - The rate limit for the API has been exceeded.')
                 return None
             elif status_code != 200:
                 self.Logs.warning(f'status code = {str(status_code)}')
@@ -811,7 +794,7 @@ class Defender():
             # pseudo!ident@host
             fullname = f'{nickname}!{username}@{hostname}'
 
-            self.Protocol.sendPrivMsg(
+            self.Protocol.send_priv_msg(
                 nick_from=service_id,
                 msg=f"[ {color_red}FREEIPAPI_SCAN{nogc} ] : Connexion de {fullname} ({remote_ip}) ==> Proxy: {str(result['isProxy'])} | Country : {str(result['countryCode'])}",
                 channel=service_chanlog
@@ -873,10 +856,9 @@ class Defender():
         service_id = self.Config.SERVICE_ID
         service_chanlog = self.Config.SERVICE_CHANLOG
         color_red = self.Config.COLORS.red
-        color_black = self.Config.COLORS.black
         nogc = self.Config.COLORS.nogc
 
-        url = f"https://developers18334.cloudfilt.com/"
+        url = "https://developers18334.cloudfilt.com/"
 
         data = {
             'ip': remote_ip,
@@ -902,7 +884,7 @@ class Defender():
             # pseudo!ident@host
             fullname = f'{nickname}!{username}@{hostname}'
 
-            self.Protocol.sendPrivMsg(
+            self.Protocol.send_priv_msg(
                 nick_from=service_id,
                 msg=f"[ {color_red}CLOUDFILT_SCAN{nogc} ] : Connexion de {fullname} ({remote_ip}) ==> Host: {str(result['host'])} | country: {str(result['countryiso'])} | listed: {str(result['listed'])} | listed by : {str(result['listed_by'])}",
                 channel=service_chanlog
@@ -941,7 +923,7 @@ class Defender():
     def thread_autolimit(self) -> None:
 
         if self.ModConfig.autolimit == 0:
-            self.Logs.debug(f"autolimit deactivated ... canceling the thread")
+            self.Logs.debug("autolimit deactivated ... canceling the thread")
             return None
 
         while self.Irc.autolimit_started:
@@ -958,7 +940,7 @@ class Defender():
         while self.autolimit_isRunning:
 
             if self.ModConfig.autolimit == 0:
-                self.Logs.debug(f"autolimit deactivated ... stopping the current thread")
+                self.Logs.debug("autolimit deactivated ... stopping the current thread")
                 break
 
             for chan in self.Channel.UID_CHANNEL_DB:
@@ -967,14 +949,14 @@ class Defender():
                         self.Protocol.send2socket(f":{self.Config.SERVICE_ID} MODE {chan.name} +l {len(chan.uids) + self.ModConfig.autolimit_amount}")
                         chan_copy["uids_count"] = len(chan.uids)
 
-                if not chan.name in chan_list:
+                if chan.name not in chan_list:
                     chan_list.append(chan.name)
                     chanObj_copy.append({"name": chan.name, "uids_count": 0})
 
             # Verifier si un salon a été vidé
             current_chan_in_list = [d.name for d in self.Channel.UID_CHANNEL_DB]
             for c in chan_list:
-                if not c in current_chan_in_list:
+                if c not in current_chan_in_list:
                     chan_list.remove(c)
 
             # Si c'est la premiere execution
@@ -1000,7 +982,7 @@ class Defender():
 
         return None
 
-    def cmd(self, data: list) -> None:
+    def cmd(self, data: list[str]) -> None:
         try:
             service_id = self.Config.SERVICE_ID                 # Defender serveur id
             cmd = list(data).copy()
@@ -1008,7 +990,7 @@ class Defender():
             match cmd[1]:
 
                 case 'REPUTATION':
-                    # :001 REPUTATION 91.168.141.239 118
+                    # :001 REPUTATION 8.8.8.8 118
                     try:
                         self.reputation_first_connexion['ip'] = cmd[2]
                         self.reputation_first_connexion['score'] = cmd[3]
@@ -1059,12 +1041,12 @@ class Defender():
                     _User = self.User.get_User(str(cmd[7]))
 
                     # If user is not service or IrcOp then scan them
-                    if not re.match(fr'^.*[S|o?].*$', _User.umodes):
-                        self.abuseipdb_UserModel.append(_User) if self.ModConfig.abuseipdb_scan == 1 and not _User.remote_ip in self.Config.WHITELISTED_IP else None
-                        self.freeipapi_UserModel.append(_User) if self.ModConfig.freeipapi_scan == 1 and not _User.remote_ip in self.Config.WHITELISTED_IP else None
-                        self.cloudfilt_UserModel.append(_User) if self.ModConfig.cloudfilt_scan == 1 and not _User.remote_ip in self.Config.WHITELISTED_IP else None
-                        self.psutil_UserModel.append(_User) if self.ModConfig.psutil_scan == 1 and not _User.remote_ip in self.Config.WHITELISTED_IP else None
-                        self.localscan_UserModel.append(_User) if self.ModConfig.local_scan == 1 and not _User.remote_ip in self.Config.WHITELISTED_IP else None
+                    if not re.match(r'^.*[S|o?].*$', _User.umodes):
+                        self.abuseipdb_UserModel.append(_User) if self.ModConfig.abuseipdb_scan == 1 and _User.remote_ip not in self.Config.WHITELISTED_IP else None
+                        self.freeipapi_UserModel.append(_User) if self.ModConfig.freeipapi_scan == 1 and _User.remote_ip not in self.Config.WHITELISTED_IP else None
+                        self.cloudfilt_UserModel.append(_User) if self.ModConfig.cloudfilt_scan == 1 and _User.remote_ip not in self.Config.WHITELISTED_IP else None
+                        self.psutil_UserModel.append(_User) if self.ModConfig.psutil_scan == 1 and _User.remote_ip not in self.Config.WHITELISTED_IP else None
+                        self.localscan_UserModel.append(_User) if self.ModConfig.local_scan == 1 and _User.remote_ip not in self.Config.WHITELISTED_IP else None
 
                     if _User is None:
                         self.Logs.critical(f'This UID: [{cmd[7]}] is not available please check why')
@@ -1075,9 +1057,9 @@ class Defender():
 
                     if self.Config.DEFENDER_INIT == 0:
                         # Si le user n'es pas un service ni un IrcOP
-                        if not re.match(fr'^.*[S|o?].*$', _User.umodes):
+                        if not re.match(r'^.*[S|o?].*$', _User.umodes):
                             if reputation_flag == 1 and _User.score_connexion <= reputation_seuil:
-                                currentDateTime = self.Base.get_datetime()
+                                # currentDateTime = self.Base.get_datetime()
                                 self.Reputation.insert(
                                     self.Loader.Definition.MReputation(
                                         **_User.__dict__,
@@ -1107,12 +1089,12 @@ class Defender():
                                 self.Protocol.send2socket(f":{service_id} MODE {parsed_chan} +b ~security-group:unknown-users")
                                 self.Protocol.send2socket(f":{service_id} MODE {parsed_chan} +eee ~security-group:webirc-users ~security-group:known-users ~security-group:websocket-users")
 
-                            if not get_reputation is None:
+                            if get_reputation is not None:
                                 isWebirc = get_reputation.isWebirc
 
                                 if not isWebirc:
                                     if parsed_chan != self.Config.SALON_JAIL:
-                                        self.Protocol.sendSapart(nick_to_sapart=get_reputation.nickname, channel_name=parsed_chan)
+                                        self.Protocol.send_sapart(nick_to_sapart=get_reputation.nickname, channel_name=parsed_chan)
 
                                 if self.ModConfig.reputation_ban_all_chan == 1 and not isWebirc:
                                     if parsed_chan != self.Config.SALON_JAIL:
@@ -1187,7 +1169,7 @@ class Defender():
 
                     get_user_reputation = self.Reputation.get_Reputation(final_UID)
 
-                    if not get_user_reputation is None:
+                    if get_user_reputation is not None:
                         final_nickname = get_user_reputation.nickname
                         for chan in self.Channel.UID_CHANNEL_DB:
                             if chan.name != jail_salon and ban_all_chan == 1:
@@ -1201,7 +1183,7 @@ class Defender():
         except Exception as err:
             self.Logs.error(f"General Error: {err}")
 
-    def _hcmds(self, user:str, channel: any, cmd: list, fullcmd: list = []) -> None:
+    def hcmds(self, user:str, channel: any, cmd: list, fullcmd: list = []) -> None:
 
         command = str(cmd[0]).lower()
         fromuser = user
@@ -1231,12 +1213,12 @@ class Defender():
             case 'show_reputation':
 
                 if not self.Reputation.UID_REPUTATION_DB:
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=" No one is suspected")
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg="No one is suspected")
 
                 for suspect in self.Reputation.UID_REPUTATION_DB:
-                    self.Protocol.sendNotice(nick_from=dnickname, 
+                    self.Protocol.send_notice(nick_from=dnickname, 
                                              nick_to=fromuser, 
-                                             msg=f" Uid: {suspect.uid} | Nickname: {suspect.nickname} | Reputation: {suspect.score} | Secret code: {suspect.secret_code} | Connected on: {suspect.connected_datetime}")
+                                             msg=f" Uid: {suspect.uid} | Nickname: {suspect.nickname} | Reputation: {suspect.score_connexion} | Secret code: {suspect.secret_code} | Connected on: {suspect.connexion_datetime}")
 
             case 'code':
                 try:
@@ -1246,7 +1228,7 @@ class Defender():
                     get_reputation = self.Reputation.get_Reputation(jailed_UID)
 
                     if get_reputation is None:
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=" No code is requested ...")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=" No code is requested ...")
                         return False
 
                     jailed_IP = get_reputation.remote_ip
@@ -1260,7 +1242,7 @@ class Defender():
                     color_black = self.Config.COLORS.black
 
                     if release_code == get_reputation.secret_code:
-                        self.Protocol.sendPrivMsg(nick_from=dnickname, msg="Bon mot de passe. Allez du vent !", channel=jailed_salon)
+                        self.Protocol.send_priv_msg(nick_from=dnickname, msg="Bon mot de passe. Allez du vent !", channel=jailed_salon)
 
                         if self.ModConfig.reputation_ban_all_chan == 1:
                             for chan in self.Channel.UID_CHANNEL_DB:
@@ -1269,21 +1251,21 @@ class Defender():
 
                         self.Reputation.delete(jailed_UID)
                         self.Logs.debug(f'{jailed_UID} - {jailed_nickname} removed from REPUTATION_DB')
-                        self.Protocol.sendSapart(nick_to_sapart=jailed_nickname, channel_name=jailed_salon)
-                        self.Protocol.sendSajoin(nick_to_sajoin=jailed_nickname, channel_name=welcome_salon)
+                        self.Protocol.send_sapart(nick_to_sapart=jailed_nickname, channel_name=jailed_salon)
+                        self.Protocol.send_sajoin(nick_to_sajoin=jailed_nickname, channel_name=welcome_salon)
                         self.Protocol.send2socket(f":{link} REPUTATION {jailed_IP} {self.ModConfig.reputation_score_after_release}")
                         self.User.get_User(jailed_UID).score_connexion = reputation_seuil + 1
-                        self.Protocol.sendPrivMsg(nick_from=dnickname,
+                        self.Protocol.send_priv_msg(nick_from=dnickname,
                                                   msg=f"[{color_green} MOT DE PASS CORRECT {color_black}] : You have now the right to enjoy the network !", 
                                                   nick_to=jailed_nickname)
 
                     else:
-                        self.Protocol.sendPrivMsg(
+                        self.Protocol.send_priv_msg(
                                 nick_from=dnickname,
                                 msg="Mauvais password", 
                                 channel=jailed_salon
                             )
-                        self.Protocol.sendPrivMsg(
+                        self.Protocol.send_priv_msg(
                                 nick_from=dnickname,
                                 msg=f"[{color_green} MAUVAIS PASSWORD {color_black}] You have typed a wrong code. for recall your password is: {self.Config.SERVICE_PREFIX}code {get_reputation.secret_code}",
                                 nick_to=jailed_nickname
@@ -1291,7 +1273,7 @@ class Defender():
 
                 except IndexError as ie:
                     self.Logs.error(f'Index Error: {ie}')
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} code [code]")
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} code [code]")
                 except KeyError as ke:
                     self.Logs.error(f'_hcmd code: KeyError {ke}')
 
@@ -1299,6 +1281,10 @@ class Defender():
                 try:
                     # autolimit on
                     # autolimit set [amount] [interval]
+                    if len(cmd) < 2:
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {self.Config.SERVICE_NICKNAME} {command.upper()} ON")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {self.Config.SERVICE_NICKNAME} {command.upper()} SET [AMOUNT] [INTERVAL]")
+                        return None
 
                     arg = str(cmd[1]).lower()
 
@@ -1308,16 +1294,16 @@ class Defender():
                                 self.__update_configuration('autolimit', 1)
                                 self.autolimit_isRunning = True
                                 self.Base.create_thread(self.thread_autolimit)
-                                self.Protocol.sendPrivMsg(nick_from=dnickname, msg=f"[{self.Config.COLORS.green}AUTOLIMIT{self.Config.COLORS.nogc}] Activated", channel=self.Config.SERVICE_CHANLOG)
+                                self.Protocol.send_priv_msg(nick_from=dnickname, msg=f"[{self.Config.COLORS.green}AUTOLIMIT{self.Config.COLORS.nogc}] Activated", channel=self.Config.SERVICE_CHANLOG)
                             else:
-                                self.Protocol.sendPrivMsg(nick_from=dnickname, msg=f"[{self.Config.COLORS.red}AUTOLIMIT{self.Config.COLORS.nogc}] Already activated", channel=self.Config.SERVICE_CHANLOG)
+                                self.Protocol.send_priv_msg(nick_from=dnickname, msg=f"[{self.Config.COLORS.red}AUTOLIMIT{self.Config.COLORS.nogc}] Already activated", channel=self.Config.SERVICE_CHANLOG)
 
                         case 'off':
                             if self.ModConfig.autolimit == 1:
                                 self.__update_configuration('autolimit', 0)
-                                self.Protocol.sendPrivMsg(nick_from=dnickname, msg=f"[{self.Config.COLORS.green}AUTOLIMIT{self.Config.COLORS.nogc}] Deactivated", channel=self.Config.SERVICE_CHANLOG)
+                                self.Protocol.send_priv_msg(nick_from=dnickname, msg=f"[{self.Config.COLORS.green}AUTOLIMIT{self.Config.COLORS.nogc}] Deactivated", channel=self.Config.SERVICE_CHANLOG)
                             else:
-                                self.Protocol.sendPrivMsg(nick_from=dnickname, msg=f"[{self.Config.COLORS.red}AUTOLIMIT{self.Config.COLORS.nogc}] Already Deactivated", channel=self.Config.SERVICE_CHANLOG)
+                                self.Protocol.send_priv_msg(nick_from=dnickname, msg=f"[{self.Config.COLORS.red}AUTOLIMIT{self.Config.COLORS.nogc}] Already Deactivated", channel=self.Config.SERVICE_CHANLOG)
 
                         case 'set':
                             amount = int(cmd[2])
@@ -1325,19 +1311,19 @@ class Defender():
 
                             self.__update_configuration('autolimit_amount', amount)
                             self.__update_configuration('autolimit_interval', interval)
-                            self.Protocol.sendPrivMsg(
+                            self.Protocol.send_priv_msg(
                                 nick_from=dnickname,
                                 msg=f"[{self.Config.COLORS.green}AUTOLIMIT{self.Config.COLORS.nogc}] Amount set to ({amount}) | Interval set to ({interval})", 
                                 channel=self.Config.SERVICE_CHANLOG
                                 )
 
                         case _:
-                            self.Protocol.sendNotice(nick_from=dnickname, msg=f"/msg {self.Config.SERVICE_NICKNAME} {command.upper()} ON", nickname=fromuser)
-                            self.Protocol.sendNotice(nick_from=dnickname, msg=f"/msg {self.Config.SERVICE_NICKNAME} {command.upper()} SET [AMOUNT] [INTERVAL]", nickname=fromuser)
+                            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {self.Config.SERVICE_NICKNAME} {command.upper()} ON")
+                            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {self.Config.SERVICE_NICKNAME} {command.upper()} SET [AMOUNT] [INTERVAL]")
 
                 except Exception as err:
-                    self.Protocol.sendNotice(nick_from=dnickname, msg=f"/msg {self.Config.SERVICE_NICKNAME} {command.upper()} ON", nickname=fromuser)
-                    self.Protocol.sendNotice(nick_from=dnickname, msg=f"/msg {self.Config.SERVICE_NICKNAME} {command.upper()} SET [AMOUNT] [INTERVAL]", nickname=fromuser)
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {self.Config.SERVICE_NICKNAME} {command.upper()} ON")
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"/msg {self.Config.SERVICE_NICKNAME} {command.upper()} SET [AMOUNT] [INTERVAL]")
                     self.Logs.error(f"Value Error -> {err}")
 
             case 'reputation':
@@ -1355,15 +1341,15 @@ class Defender():
                         if activation == 'on':
 
                             if self.ModConfig.reputation == 1:
-                                self.Protocol.sendPrivMsg(nick_from=dnickname, msg=f"[ {self.Config.COLORS.green}REPUTATION{self.Config.COLORS.black} ] : Already activated", channel=dchanlog)
+                                self.Protocol.send_priv_msg(nick_from=dnickname, msg=f"[ {self.Config.COLORS.green}REPUTATION{self.Config.COLORS.black} ] : Already activated", channel=dchanlog)
                                 return False
 
                             # self.update_db_configuration('reputation', 1)
                             self.__update_configuration(key, 1)
 
-                            self.Protocol.sendPrivMsg(nick_from=dnickname, msg=f"[ {self.Config.COLORS.green}REPUTATION{self.Config.COLORS.black} ] : Activated by {fromuser}", channel=dchanlog)
+                            self.Protocol.send_priv_msg(nick_from=dnickname, msg=f"[ {self.Config.COLORS.green}REPUTATION{self.Config.COLORS.black} ] : Activated by {fromuser}", channel=dchanlog)
 
-                            self.Protocol.sendChanJoin(uidornickname=dnickname, channel=jail_chan)
+                            self.Protocol.send_join_chan(uidornickname=dnickname, channel=jail_chan)
                             self.Protocol.send2socket(f":{service_id} SAMODE {jail_chan} +{dumodes} {dnickname}")
                             self.Protocol.send2socket(f":{service_id} MODE {jail_chan} +{jail_chan_mode}")
 
@@ -1378,7 +1364,7 @@ class Defender():
                         if activation == 'off':
 
                             if self.ModConfig.reputation == 0:
-                                self.Protocol.sendPrivMsg(
+                                self.Protocol.send_priv_msg(
                                     nick_from=dnickname,
                                     msg=f"[ {self.Config.COLORS.green}REPUTATION{self.Config.COLORS.black} ] : Already deactivated",
                                     channel=dchanlog
@@ -1387,7 +1373,7 @@ class Defender():
 
                             self.__update_configuration(key, 0)
 
-                            self.Protocol.sendPrivMsg(
+                            self.Protocol.send_priv_msg(
                                     nick_from=dnickname,
                                     msg=f"[ {self.Config.COLORS.red}REPUTATION{self.Config.COLORS.black} ] : Deactivated by {fromuser}",
                                     channel=dchanlog
@@ -1419,7 +1405,7 @@ class Defender():
                                 if get_value == 'on':
 
                                     if self.ModConfig.reputation_ban_all_chan == 1:
-                                        self.Protocol.sendPrivMsg(
+                                        self.Protocol.send_priv_msg(
                                                 nick_from=dnickname,
                                                 msg=f"[ {self.Config.COLORS.red}BAN ON ALL CHANS{self.Config.COLORS.black} ] : Already activated",
                                                 channel=dchanlog
@@ -1429,7 +1415,7 @@ class Defender():
                                     # self.update_db_configuration(key, 1)
                                     self.__update_configuration(key, 1)
 
-                                    self.Protocol.sendPrivMsg(
+                                    self.Protocol.send_priv_msg(
                                                 nick_from=dnickname,
                                                 msg=f"[ {self.Config.COLORS.green}BAN ON ALL CHANS{self.Config.COLORS.black} ] : Activated by {fromuser}",
                                                 channel=dchanlog
@@ -1437,7 +1423,7 @@ class Defender():
 
                                 elif get_value == 'off':
                                     if self.ModConfig.reputation_ban_all_chan == 0:
-                                        self.Protocol.sendPrivMsg(
+                                        self.Protocol.send_priv_msg(
                                                 nick_from=dnickname,
                                                 msg=f"[ {self.Config.COLORS.red}BAN ON ALL CHANS{self.Config.COLORS.black} ] : Already deactivated",
                                                 channel=dchanlog
@@ -1447,7 +1433,7 @@ class Defender():
                                     # self.update_db_configuration(key, 0)
                                     self.__update_configuration(key, 0)
 
-                                    self.Protocol.sendPrivMsg(
+                                    self.Protocol.send_priv_msg(
                                                 nick_from=dnickname,
                                                 msg=f"[ {self.Config.COLORS.green}BAN ON ALL CHANS{self.Config.COLORS.black} ] : Deactivated by {fromuser}",
                                                 channel=dchanlog
@@ -1460,69 +1446,69 @@ class Defender():
                                 # self.update_db_configuration(key, reputation_seuil)
                                 self.__update_configuration(key, reputation_seuil)
 
-                                self.Protocol.sendPrivMsg(
+                                self.Protocol.send_priv_msg(
                                                 nick_from=dnickname,
                                                 msg=f"[ {self.Config.COLORS.green}REPUTATION SEUIL{self.Config.COLORS.black} ] : Limit set to {str(reputation_seuil)} by {fromuser}",
                                                 channel=dchanlog
                                             )
-                                self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" Reputation set to {reputation_seuil}")
+                                self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" Reputation set to {reputation_seuil}")
 
                             case 'timer':
                                 reputation_timer = int(cmd[3])
                                 key = 'reputation_timer'
                                 self.__update_configuration(key, reputation_timer)
 
-                                self.Protocol.sendPrivMsg(
+                                self.Protocol.send_priv_msg(
                                                 nick_from=dnickname,
                                                 msg=f"[ {self.Config.COLORS.green}REPUTATION TIMER{self.Config.COLORS.black} ] : Timer set to {str(reputation_timer)} minute(s) by {fromuser}",
                                                 channel=dchanlog
                                             )
-                                self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" Reputation set to {reputation_timer}")
+                                self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" Reputation set to {reputation_timer}")
 
                             case 'score_after_release':
                                 reputation_score_after_release = int(cmd[3])
                                 key = 'reputation_score_after_release'
                                 self.__update_configuration(key, reputation_score_after_release)
 
-                                self.Protocol.sendPrivMsg(
+                                self.Protocol.send_priv_msg(
                                                 nick_from=dnickname,
                                                 msg=f"[ {self.Config.COLORS.green}REPUTATION SCORE AFTER RELEASE{self.Config.COLORS.black} ] : Reputation score after release set to {str(reputation_score_after_release)} by {fromuser}",
                                                 channel=dchanlog
                                             )
-                                self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" Reputation score after release set to {reputation_score_after_release}")
+                                self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" Reputation score after release set to {reputation_score_after_release}")
 
                             case 'security_group':
                                 reputation_sg = int(cmd[3])
                                 key = 'reputation_sg'
                                 self.__update_configuration(key, reputation_sg)
 
-                                self.Protocol.sendPrivMsg(
+                                self.Protocol.send_priv_msg(
                                                 nick_from=dnickname,
                                                 msg=f"[ {self.Config.COLORS.green}REPUTATION SECURITY-GROUP{self.Config.COLORS.black} ] : Reputation Security-group set to {str(reputation_sg)} by {fromuser}",
                                                 channel=dchanlog
                                             )
-                                self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" Reputation score after release set to {reputation_sg}")
+                                self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" Reputation score after release set to {reputation_sg}")
 
                             case _:
-                                self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} reputation [ON/OFF]")
-                                self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} reputation set banallchan [ON/OFF]")
-                                self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} reputation set limit [1234]")
-                                self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} reputation set score_after_release [1234]")
-                                self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} reputation set timer [1234]")
-                                self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} reputation set action [kill|None]")
+                                self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} reputation [ON/OFF]")
+                                self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} reputation set banallchan [ON/OFF]")
+                                self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} reputation set limit [1234]")
+                                self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} reputation set score_after_release [1234]")
+                                self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} reputation set timer [1234]")
+                                self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} reputation set action [kill|None]")
 
                 except IndexError as ie:
                     self.Logs.warning(f'{ie}')
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} reputation [ON/OFF]")
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} reputation set banallchan [ON/OFF]")
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} reputation set limit [1234]")
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} reputation set score_after_release [1234]")
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} reputation set timer [1234]")
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} reputation set action [kill|None]")
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} reputation [ON/OFF]")
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} reputation set banallchan [ON/OFF]")
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} reputation set limit [1234]")
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} reputation set score_after_release [1234]")
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} reputation set timer [1234]")
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" Right command : /msg {dnickname} reputation set action [kill|None]")
 
                 except ValueError as ve:
                     self.Logs.warning(f'{ve}')
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" La valeur devrait etre un entier >= 0")
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=" La valeur devrait etre un entier >= 0")
 
             case 'proxy_scan':
 
@@ -1538,11 +1524,11 @@ class Defender():
                     set_key = str(cmd[1]).lower()
 
                     if set_key != 'set':
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f' Right command : /msg {dnickname} proxy_scan set local_scan [ON/OFF]')
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f' Right command : /msg {dnickname} proxy_scan set psutil_scan [ON/OFF]')
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f' Right command : /msg {dnickname} proxy_scan set abuseipdb_scan [ON/OFF]')
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f' Right command : /msg {dnickname} proxy_scan set freeipapi_scan [ON/OFF]')
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f' Right command : /msg {dnickname} proxy_scan set cloudfilt_scan [ON/OFF]')
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f' Right command : /msg {dnickname} proxy_scan set local_scan [ON/OFF]')
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f' Right command : /msg {dnickname} proxy_scan set psutil_scan [ON/OFF]')
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f' Right command : /msg {dnickname} proxy_scan set abuseipdb_scan [ON/OFF]')
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f' Right command : /msg {dnickname} proxy_scan set freeipapi_scan [ON/OFF]')
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f' Right command : /msg {dnickname} proxy_scan set cloudfilt_scan [ON/OFF]')
 
                     option = str(cmd[2]).lower() # => local_scan, psutil_scan, abuseipdb_scan
                     action = str(cmd[3]).lower() # => on / off
@@ -1551,105 +1537,105 @@ class Defender():
                         case 'local_scan':
                             if action == 'on':
                                 if self.ModConfig.local_scan == 1:
-                                    self.Protocol.sendPrivMsg(nick_from=dnickname, msg=f"[ {color_green}PROXY_SCAN {option.upper()}{color_black} ] : Already activated", channel=dchanlog)
+                                    self.Protocol.send_priv_msg(nick_from=dnickname, msg=f"[ {color_green}PROXY_SCAN {option.upper()}{color_black} ] : Already activated", channel=dchanlog)
                                     return None
 
                                 self.__update_configuration(option, 1)
 
-                                self.Protocol.sendPrivMsg(nick_from=dnickname, msg=f"[ {color_green}PROXY_SCAN {option.upper()}{color_black} ] : Activated by {fromuser}", channel=dchanlog)
+                                self.Protocol.send_priv_msg(nick_from=dnickname, msg=f"[ {color_green}PROXY_SCAN {option.upper()}{color_black} ] : Activated by {fromuser}", channel=dchanlog)
                             elif action == 'off':
                                 if self.ModConfig.local_scan == 0:
-                                    self.Protocol.sendPrivMsg(nick_from=dnickname, msg=f"[ {color_red}PROXY_SCAN {option.upper()}{color_black} ] : Already Deactivated", channel=dchanlog)
+                                    self.Protocol.send_priv_msg(nick_from=dnickname, msg=f"[ {color_red}PROXY_SCAN {option.upper()}{color_black} ] : Already Deactivated", channel=dchanlog)
                                     return None
 
                                 self.__update_configuration(option, 0)
 
-                                self.Protocol.sendPrivMsg(nick_from=dnickname, msg=f"[ {color_red}PROXY_SCAN {option.upper()}{color_black} ] : Deactivated by {fromuser}", channel=dchanlog)
+                                self.Protocol.send_priv_msg(nick_from=dnickname, msg=f"[ {color_red}PROXY_SCAN {option.upper()}{color_black} ] : Deactivated by {fromuser}", channel=dchanlog)
 
                         case 'psutil_scan':
                             if action == 'on':
                                 if self.ModConfig.psutil_scan == 1:
-                                    self.Protocol.sendPrivMsg(nick_from=dnickname, msg=f"[ {color_green}PROXY_SCAN {option.upper()}{color_black} ] : Already activated", channel=dchanlog)
+                                    self.Protocol.send_priv_msg(nick_from=dnickname, msg=f"[ {color_green}PROXY_SCAN {option.upper()}{color_black} ] : Already activated", channel=dchanlog)
                                     return None
 
                                 self.__update_configuration(option, 1)
 
-                                self.Protocol.sendPrivMsg(nick_from=dnickname, msg=f"[ {color_green}PROXY_SCAN {option.upper()}{color_black} ] : Activated by {fromuser}", channel=dchanlog)
+                                self.Protocol.send_priv_msg(nick_from=dnickname, msg=f"[ {color_green}PROXY_SCAN {option.upper()}{color_black} ] : Activated by {fromuser}", channel=dchanlog)
                             elif action == 'off':
                                 if self.ModConfig.psutil_scan == 0:
-                                    self.Protocol.sendPrivMsg(nick_from=dnickname, msg=f"[ {color_red}PROXY_SCAN {option.upper()}{color_black} ] : Already Deactivated", channel=dchanlog)
+                                    self.Protocol.send_priv_msg(nick_from=dnickname, msg=f"[ {color_red}PROXY_SCAN {option.upper()}{color_black} ] : Already Deactivated", channel=dchanlog)
                                     return None
 
                                 self.__update_configuration(option, 0)
 
-                                self.Protocol.sendPrivMsg(nick_from=dnickname, msg=f"[ {color_red}PROXY_SCAN {option.upper()}{color_black} ] : Deactivated by {fromuser}", channel=dchanlog)
+                                self.Protocol.send_priv_msg(nick_from=dnickname, msg=f"[ {color_red}PROXY_SCAN {option.upper()}{color_black} ] : Deactivated by {fromuser}", channel=dchanlog)
 
                         case 'abuseipdb_scan':
                             if action == 'on':
                                 if self.ModConfig.abuseipdb_scan == 1:
-                                    self.Protocol.sendPrivMsg(nick_from=dnickname, msg=f"[ {color_green}PROXY_SCAN {option.upper()}{color_black} ] : Already activated", channel=dchanlog)
+                                    self.Protocol.send_priv_msg(nick_from=dnickname, msg=f"[ {color_green}PROXY_SCAN {option.upper()}{color_black} ] : Already activated", channel=dchanlog)
                                     return None
 
                                 self.__update_configuration(option, 1)
 
-                                self.Protocol.sendPrivMsg(nick_from=dnickname, msg=f"[ {color_green}PROXY_SCAN {option.upper()}{color_black} ] : Activated by {fromuser}", channel=dchanlog)
+                                self.Protocol.send_priv_msg(nick_from=dnickname, msg=f"[ {color_green}PROXY_SCAN {option.upper()}{color_black} ] : Activated by {fromuser}", channel=dchanlog)
                             elif action == 'off':
                                 if self.ModConfig.abuseipdb_scan == 0:
-                                    self.Protocol.sendPrivMsg(nick_from=dnickname, msg=f"[ {color_red}PROXY_SCAN {option.upper()}{color_black} ] : Already Deactivated", channel=dchanlog)
+                                    self.Protocol.send_priv_msg(nick_from=dnickname, msg=f"[ {color_red}PROXY_SCAN {option.upper()}{color_black} ] : Already Deactivated", channel=dchanlog)
                                     return None
 
                                 self.__update_configuration(option, 0)
 
-                                self.Protocol.sendPrivMsg(nick_from=dnickname, msg=f"[ {color_red}PROXY_SCAN {option.upper()}{color_black} ] : Deactivated by {fromuser}", channel=dchanlog)
+                                self.Protocol.send_priv_msg(nick_from=dnickname, msg=f"[ {color_red}PROXY_SCAN {option.upper()}{color_black} ] : Deactivated by {fromuser}", channel=dchanlog)
 
                         case 'freeipapi_scan':
                             if action == 'on':
                                 if self.ModConfig.freeipapi_scan == 1:
-                                    self.Protocol.sendPrivMsg(nick_from=dnickname, msg=f"[ {color_green}PROXY_SCAN {option.upper()}{color_black} ] : Already activated", channel=dchanlog)
+                                    self.Protocol.send_priv_msg(nick_from=dnickname, msg=f"[ {color_green}PROXY_SCAN {option.upper()}{color_black} ] : Already activated", channel=dchanlog)
                                     return None
 
                                 self.__update_configuration(option, 1)
 
-                                self.Protocol.sendPrivMsg(nick_from=dnickname, msg=f"[ {color_green}PROXY_SCAN {option.upper()}{color_black} ] : Activated by {fromuser}", channel=dchanlog)
+                                self.Protocol.send_priv_msg(nick_from=dnickname, msg=f"[ {color_green}PROXY_SCAN {option.upper()}{color_black} ] : Activated by {fromuser}", channel=dchanlog)
                             elif action == 'off':
                                 if self.ModConfig.freeipapi_scan == 0:
-                                    self.Protocol.sendPrivMsg(nick_from=dnickname, msg=f"[ {color_red}PROXY_SCAN {option.upper()}{color_black} ] : Already Deactivated", channel=dchanlog)
+                                    self.Protocol.send_priv_msg(nick_from=dnickname, msg=f"[ {color_red}PROXY_SCAN {option.upper()}{color_black} ] : Already Deactivated", channel=dchanlog)
                                     return None
 
                                 self.__update_configuration(option, 0)
 
-                                self.Protocol.sendPrivMsg(nick_from=dnickname, msg=f"[ {color_red}PROXY_SCAN {option.upper()}{color_black} ] : Deactivated by {fromuser}", channel=dchanlog)
+                                self.Protocol.send_priv_msg(nick_from=dnickname, msg=f"[ {color_red}PROXY_SCAN {option.upper()}{color_black} ] : Deactivated by {fromuser}", channel=dchanlog)
 
                         case 'cloudfilt_scan':
                             if action == 'on':
                                 if self.ModConfig.cloudfilt_scan == 1:
-                                    self.Protocol.sendPrivMsg(nick_from=dnickname, msg=f"[ {color_green}PROXY_SCAN {option.upper()}{color_black} ] : Already activated", channel=dchanlog)
+                                    self.Protocol.send_priv_msg(nick_from=dnickname, msg=f"[ {color_green}PROXY_SCAN {option.upper()}{color_black} ] : Already activated", channel=dchanlog)
                                     return None
 
                                 self.__update_configuration(option, 1)
 
-                                self.Protocol.sendPrivMsg(nick_from=dnickname, msg=f"[ {color_green}PROXY_SCAN {option.upper()}{color_black} ] : Activated by {fromuser}", channel=dchanlog)
+                                self.Protocol.send_priv_msg(nick_from=dnickname, msg=f"[ {color_green}PROXY_SCAN {option.upper()}{color_black} ] : Activated by {fromuser}", channel=dchanlog)
                             elif action == 'off':
                                 if self.ModConfig.cloudfilt_scan == 0:
-                                    self.Protocol.sendPrivMsg(nick_from=dnickname, msg=f"[ {color_red}PROXY_SCAN {option.upper()}{color_black} ] : Already Deactivated", channel=dchanlog)
+                                    self.Protocol.send_priv_msg(nick_from=dnickname, msg=f"[ {color_red}PROXY_SCAN {option.upper()}{color_black} ] : Already Deactivated", channel=dchanlog)
                                     return None
 
                                 self.__update_configuration(option, 0)
 
-                                self.Protocol.sendPrivMsg(nick_from=dnickname, msg=f"[ {color_red}PROXY_SCAN {option.upper()}{color_black} ] : Deactivated by {fromuser}", channel=dchanlog)
+                                self.Protocol.send_priv_msg(nick_from=dnickname, msg=f"[ {color_red}PROXY_SCAN {option.upper()}{color_black} ] : Deactivated by {fromuser}", channel=dchanlog)
 
                         case _:
-                            self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f' Right command : /msg {dnickname} proxy_scan set local_scan [ON/OFF]')
-                            self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f' Right command : /msg {dnickname} proxy_scan set psutil_scan [ON/OFF]')
-                            self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f' Right command : /msg {dnickname} proxy_scan set abuseipdb_scan [ON/OFF]')
-                            self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f' Right command : /msg {dnickname} proxy_scan set freeipapi_scan [ON/OFF]')
-                            self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f' Right command : /msg {dnickname} proxy_scan set cloudfilt_scan [ON/OFF]')
+                            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f' Right command : /msg {dnickname} proxy_scan set local_scan [ON/OFF]')
+                            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f' Right command : /msg {dnickname} proxy_scan set psutil_scan [ON/OFF]')
+                            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f' Right command : /msg {dnickname} proxy_scan set abuseipdb_scan [ON/OFF]')
+                            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f' Right command : /msg {dnickname} proxy_scan set freeipapi_scan [ON/OFF]')
+                            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f' Right command : /msg {dnickname} proxy_scan set cloudfilt_scan [ON/OFF]')
                 else:
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f' Right command : /msg {dnickname} proxy_scan set local_scan [ON/OFF]')
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f' Right command : /msg {dnickname} proxy_scan set psutil_scan [ON/OFF]')
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f' Right command : /msg {dnickname} proxy_scan set abuseipdb_scan [ON/OFF]')
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f' Right command : /msg {dnickname} proxy_scan set freeipapi_scan [ON/OFF]')
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f' Right command : /msg {dnickname} proxy_scan set cloudfilt_scan [ON/OFF]')
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f' Right command : /msg {dnickname} proxy_scan set local_scan [ON/OFF]')
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f' Right command : /msg {dnickname} proxy_scan set psutil_scan [ON/OFF]')
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f' Right command : /msg {dnickname} proxy_scan set abuseipdb_scan [ON/OFF]')
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f' Right command : /msg {dnickname} proxy_scan set freeipapi_scan [ON/OFF]')
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f' Right command : /msg {dnickname} proxy_scan set cloudfilt_scan [ON/OFF]')
 
             case 'flood':
                 # .flood on/off
@@ -1664,21 +1650,21 @@ class Defender():
                         key = 'flood'
                         if activation == 'on':
                             if self.ModConfig.flood == 1:
-                                self.Protocol.sendPrivMsg(nick_from=dnickname, msg=f"[ {self.Config.COLORS.green}FLOOD{self.Config.COLORS.black} ] : Already activated", channel=dchanlog)
+                                self.Protocol.send_priv_msg(nick_from=dnickname, msg=f"[ {self.Config.COLORS.green}FLOOD{self.Config.COLORS.black} ] : Already activated", channel=dchanlog)
                                 return False
 
                             self.__update_configuration(key, 1)
 
-                            self.Protocol.sendPrivMsg(nick_from=dnickname, msg=f"[ {self.Config.COLORS.green}FLOOD{self.Config.COLORS.black} ] : Activated by {fromuser}", channel=dchanlog)
+                            self.Protocol.send_priv_msg(nick_from=dnickname, msg=f"[ {self.Config.COLORS.green}FLOOD{self.Config.COLORS.black} ] : Activated by {fromuser}", channel=dchanlog)
 
                         if activation == 'off':
                             if self.ModConfig.flood == 0:
-                                self.Protocol.sendPrivMsg(nick_from=dnickname, msg=f"[ {self.Config.COLORS.red}FLOOD{self.Config.COLORS.black} ] : Already Deactivated", channel=dchanlog)
+                                self.Protocol.send_priv_msg(nick_from=dnickname, msg=f"[ {self.Config.COLORS.red}FLOOD{self.Config.COLORS.black} ] : Already Deactivated", channel=dchanlog)
                                 return False
 
                             self.__update_configuration(key, 0)
 
-                            self.Protocol.sendPrivMsg(nick_from=dnickname, msg=f"[ {self.Config.COLORS.green}FLOOD{self.Config.COLORS.black} ] : Deactivated by {fromuser}", channel=dchanlog)
+                            self.Protocol.send_priv_msg(nick_from=dnickname, msg=f"[ {self.Config.COLORS.green}FLOOD{self.Config.COLORS.black} ] : Deactivated by {fromuser}", channel=dchanlog)
 
                     if len_cmd == 4:
                         set_key = str(cmd[2]).lower()
@@ -1690,7 +1676,7 @@ class Defender():
                                     set_value = int(cmd[3])
                                     self.__update_configuration(key, set_value)
 
-                                    self.Protocol.sendPrivMsg(nick_from=dnickname, 
+                                    self.Protocol.send_priv_msg(nick_from=dnickname, 
                                                               msg=f"[ {self.Config.COLORS.green}FLOOD{self.Config.COLORS.black} ] : Flood message set to {set_value} by {fromuser}", 
                                                               channel=dchanlog)
 
@@ -1699,7 +1685,7 @@ class Defender():
                                     set_value = int(cmd[3])
                                     self.__update_configuration(key, set_value)
 
-                                    self.Protocol.sendPrivMsg(nick_from=dnickname, 
+                                    self.Protocol.send_priv_msg(nick_from=dnickname, 
                                                               msg=f"[ {self.Config.COLORS.green}FLOOD{self.Config.COLORS.black} ] : Flood time set to {set_value} by {fromuser}", 
                                                               channel=dchanlog)
 
@@ -1708,7 +1694,7 @@ class Defender():
                                     set_value = int(cmd[3])
                                     self.__update_configuration(key, set_value)
 
-                                    self.Protocol.sendPrivMsg(nick_from=dnickname, 
+                                    self.Protocol.send_priv_msg(nick_from=dnickname, 
                                                               msg=f"[ {self.Config.COLORS.green}FLOOD{self.Config.COLORS.black} ] : Flood timer set to {set_value} by {fromuser}", 
                                                               channel=dchanlog)
 
@@ -1724,22 +1710,22 @@ class Defender():
                 color_black = self.Config.COLORS.black
                 nogc = self.Config.COLORS.nogc
                 try:
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f' [{color_green if self.ModConfig.reputation == 1 else color_red}Reputation{nogc}]                           ==> {self.ModConfig.reputation}')
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f'           reputation_seuil             ==> {self.ModConfig.reputation_seuil}')
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f'           reputation_after_release     ==> {self.ModConfig.reputation_score_after_release}')
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f'           reputation_ban_all_chan      ==> {self.ModConfig.reputation_ban_all_chan}')
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f'           reputation_timer             ==> {self.ModConfig.reputation_timer}')
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f' [Proxy_scan]')
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f'             {color_green if self.ModConfig.local_scan == 1 else color_red}local_scan{nogc}                 ==> {self.ModConfig.local_scan}')
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f'             {color_green if self.ModConfig.psutil_scan == 1 else color_red}psutil_scan{nogc}                ==> {self.ModConfig.psutil_scan}')
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f'             {color_green if self.ModConfig.abuseipdb_scan == 1 else color_red}abuseipdb_scan{nogc}             ==> {self.ModConfig.abuseipdb_scan}')
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f'             {color_green if self.ModConfig.freeipapi_scan == 1 else color_red}freeipapi_scan{nogc}             ==> {self.ModConfig.freeipapi_scan}')
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f'             {color_green if self.ModConfig.cloudfilt_scan == 1 else color_red}cloudfilt_scan{nogc}             ==> {self.ModConfig.cloudfilt_scan}')
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f' [{color_green if self.ModConfig.flood == 1 else color_red}Flood{nogc}]                                ==> {self.ModConfig.flood}')
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f'      flood_action                      ==> Coming soon')
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f'      flood_message                     ==> {self.ModConfig.flood_message}')
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f'      flood_time                        ==> {self.ModConfig.flood_time}')
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f'      flood_timer                       ==> {self.ModConfig.flood_timer}')
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f' [{color_green if self.ModConfig.reputation == 1 else color_red}Reputation{nogc}]                           ==> {self.ModConfig.reputation}')
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f'           reputation_seuil             ==> {self.ModConfig.reputation_seuil}')
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f'           reputation_after_release     ==> {self.ModConfig.reputation_score_after_release}')
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f'           reputation_ban_all_chan      ==> {self.ModConfig.reputation_ban_all_chan}')
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f'           reputation_timer             ==> {self.ModConfig.reputation_timer}')
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=' [Proxy_scan]')
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f'             {color_green if self.ModConfig.local_scan == 1 else color_red}local_scan{nogc}                 ==> {self.ModConfig.local_scan}')
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f'             {color_green if self.ModConfig.psutil_scan == 1 else color_red}psutil_scan{nogc}                ==> {self.ModConfig.psutil_scan}')
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f'             {color_green if self.ModConfig.abuseipdb_scan == 1 else color_red}abuseipdb_scan{nogc}             ==> {self.ModConfig.abuseipdb_scan}')
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f'             {color_green if self.ModConfig.freeipapi_scan == 1 else color_red}freeipapi_scan{nogc}             ==> {self.ModConfig.freeipapi_scan}')
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f'             {color_green if self.ModConfig.cloudfilt_scan == 1 else color_red}cloudfilt_scan{nogc}             ==> {self.ModConfig.cloudfilt_scan}')
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f' [{color_green if self.ModConfig.flood == 1 else color_red}Flood{nogc}]                                ==> {self.ModConfig.flood}')
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg='      flood_action                      ==> Coming soon')
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f'      flood_message                     ==> {self.ModConfig.flood_message}')
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f'      flood_time                        ==> {self.ModConfig.flood_time}')
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f'      flood_timer                       ==> {self.ModConfig.flood_timer}')
                 except KeyError as ke:
                     self.Logs.error(f"Key Error : {ke}")
 
@@ -1748,29 +1734,29 @@ class Defender():
                     nickoruid = cmd[1]
                     UserObject = self.User.get_User(nickoruid)
 
-                    if not UserObject is None:
+                    if UserObject is not None:
                         channels: list = []
                         for chan in self.Channel.UID_CHANNEL_DB:
                             for uid_in_chan in chan.uids:
                                 if self.Base.clean_uid(uid_in_chan) == UserObject.uid:
                                     channels.append(chan.name)
 
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f' UID              : {UserObject.uid}')
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f' NICKNAME         : {UserObject.nickname}')
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f' USERNAME         : {UserObject.username}')
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f' REALNAME         : {UserObject.realname}')
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f' HOSTNAME         : {UserObject.hostname}')
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f' VHOST            : {UserObject.vhost}')
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f' IP               : {UserObject.remote_ip}')
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f' Country          : {UserObject.geoip}')
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f' WebIrc           : {UserObject.isWebirc}')
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f' WebWebsocket     : {UserObject.isWebsocket}')
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f' REPUTATION       : {UserObject.score_connexion}')
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f' MODES            : {UserObject.umodes}')
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f' CHANNELS         : {channels}')
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f' CONNECTION TIME  : {UserObject.connexion_datetime}')
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f' UID              : {UserObject.uid}')
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f' NICKNAME         : {UserObject.nickname}')
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f' USERNAME         : {UserObject.username}')
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f' REALNAME         : {UserObject.realname}')
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f' HOSTNAME         : {UserObject.hostname}')
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f' VHOST            : {UserObject.vhost}')
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f' IP               : {UserObject.remote_ip}')
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f' Country          : {UserObject.geoip}')
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f' WebIrc           : {UserObject.isWebirc}')
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f' WebWebsocket     : {UserObject.isWebsocket}')
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f' REPUTATION       : {UserObject.score_connexion}')
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f' MODES            : {UserObject.umodes}')
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f' CHANNELS         : {channels}')
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f' CONNECTION TIME  : {UserObject.connexion_datetime}')
                     else:
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f":{dnickname} NOTICE {fromuser} : This user {nickoruid} doesn't exist")
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f":{dnickname} NOTICE {fromuser} : This user {nickoruid} doesn't exist")
 
                 except KeyError as ke:
                     self.Logs.warning(f"Key error info user : {ke}")
@@ -1784,10 +1770,10 @@ class Defender():
 
                 if activation == 'on':
                     for chan in self.Channel.UID_CHANNEL_DB:
-                        if not chan.name in channel_to_dont_quit:
-                            self.Protocol.sendChanJoin(uidornickname=dnickname, channel=chan.name)
+                        if chan.name not in channel_to_dont_quit:
+                            self.Protocol.send_join_chan(uidornickname=dnickname, channel=chan.name)
                 if activation == 'off':
                     for chan in self.Channel.UID_CHANNEL_DB:
-                        if not chan.name in channel_to_dont_quit:
+                        if chan.name not in channel_to_dont_quit:
                             self.Protocol.part(uidornickname=dnickname, channel=chan.name)
                     self.join_saved_channels()

mods/mod_jsonrpc.py

@@ -57,6 +57,7 @@ class Jsonrpc():
         # Insert module commands into the core one (Mandatory)
         self.__set_commands(self.commands_level)
         logging.getLogger('websockets').setLevel(logging.WARNING)
+        logging.getLogger('unrealircd-rpc-py').setLevel(logging.CRITICAL)
 
         # Create you own tables (Mandatory)
         # self.__create_tables()
@@ -65,13 +66,6 @@ class Jsonrpc():
         self.__load_module_configuration()
         # End of mandatory methods you can start your customization #
 
-        # self.UnrealIrcdRpcLive: Live = Live(
-        #                 req_method='unixsocket',
-        #                 path_to_socket_file=self.Config.JSONRPC_PATH_TO_SOCKET_FILE,
-        #                 callback_object_instance=self,
-        #                 callback_method_name='callback_sent_to_irc'
-        #                )
-
         self.UnrealIrcdRpcLive: Live = Live(
                     req_method='websocket',
                     url=self.Config.JSONRPC_URL,
@@ -91,14 +85,14 @@ class Jsonrpc():
         self.subscribed = False
 
         if self.Rpc.Error.code != 0:
-            self.Protocol.sendPrivMsg(
+            self.Protocol.send_priv_msg(
                 nick_from=self.Config.SERVICE_NICKNAME,
                 msg=f"[{self.Config.COLORS.red}ERROR{self.Config.COLORS.nogc}] {self.Rpc.Error.message}", 
                 channel=self.Config.SERVICE_CHANLOG
                 )
 
         if self.UnrealIrcdRpcLive.Error.code != 0:
-            self.Protocol.sendPrivMsg(
+            self.Protocol.send_priv_msg(
                     nick_from=self.Config.SERVICE_NICKNAME,
                     msg=f"[{self.Config.COLORS.red}ERROR{self.Config.COLORS.nogc}] {self.UnrealIrcdRpcLive.Error.message}", 
                     channel=self.Config.SERVICE_CHANLOG
@@ -153,7 +147,7 @@ class Jsonrpc():
         red = self.Config.COLORS.red
 
         if json_response.result == True:
-            self.Protocol.sendPrivMsg(
+            self.Protocol.send_priv_msg(
                 nick_from=self.Config.SERVICE_NICKNAME,
                 msg=f"[{bold}{green}JSONRPC{nogc}{bold}] Event activated", 
                 channel=dchanlog)
@@ -167,7 +161,7 @@ class Jsonrpc():
 
         build_msg = f"{green}{log_source}{nogc}: [{bold}{level}{bold}] {subsystem}.{event_id} - {msg}"
 
-        self.Protocol.sendPrivMsg(nick_from=dnickname, msg=build_msg, channel=dchanlog)
+        self.Protocol.send_priv_msg(nick_from=dnickname, msg=build_msg, channel=dchanlog)
 
     def thread_start_jsonrpc(self):
 
@@ -175,7 +169,7 @@ class Jsonrpc():
             self.UnrealIrcdRpcLive.subscribe(["all"])
             self.subscribed = True
         else:
-            self.Protocol.sendPrivMsg(
+            self.Protocol.send_priv_msg(
                     nick_from=self.Config.SERVICE_NICKNAME,
                     msg=f"[{self.Config.COLORS.red}ERROR{self.Config.COLORS.nogc}] {self.UnrealIrcdRpcLive.Error.message}", 
                     channel=self.Config.SERVICE_CHANLOG
@@ -214,7 +208,7 @@ class Jsonrpc():
 
         return None
 
-    def _hcmds(self, user:str, channel: any, cmd: list, fullcmd: list = []) -> None:
+    def hcmds(self, user:str, channel: any, cmd: list, fullcmd: list = []) -> None:
 
         command = str(cmd[0]).lower()
         dnickname = self.Config.SERVICE_NICKNAME
@@ -229,22 +223,27 @@ class Jsonrpc():
                     option = str(cmd[1]).lower()
 
                     if len(command) == 1:
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f'/msg {dnickname} jsonrpc on')
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f'/msg {dnickname} jsonrpc off')
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f'/msg {dnickname} jsonrpc on')
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f'/msg {dnickname} jsonrpc off')
 
                     match option:
 
                         case 'on':
+
+                            # for logger_name, logger in logging.root.manager.loggerDict.items():
+                            #     if isinstance(logger, logging.Logger):
+                            #         self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f"{logger_name} - {logger.level}")
+
                             for thread in self.Base.running_threads:
                                 if thread.getName() == 'thread_start_jsonrpc':
                                     if thread.is_alive():
-                                        self.Protocol.sendPrivMsg(
+                                        self.Protocol.send_priv_msg(
                                             nick_from=self.Config.SERVICE_NICKNAME,
                                             msg=f"Thread {thread.getName()} is running",
                                             channel=dchannel
                                             )
                                     else:
-                                        self.Protocol.sendPrivMsg(
+                                        self.Protocol.send_priv_msg(
                                             nick_from=self.Config.SERVICE_NICKNAME,
                                             msg=f"Thread {thread.getName()} is not running, wait untill the process will be cleaned up",
                                             channel=dchannel
@@ -265,7 +264,7 @@ class Jsonrpc():
                     option = str(cmd[1]).lower()
 
                     if len(command) == 1:
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f'/msg {dnickname} jruser get nickname')
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f'/msg {dnickname} jruser get nickname')
 
                     match option:
 
@@ -279,37 +278,37 @@ class Jsonrpc():
 
                             UserInfo = rpc.User.get(uid_to_get)
                             if rpc.Error.code != 0:
-                                self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f'{rpc.Error.message}')
+                                self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f'{rpc.Error.message}')
                                 return None
 
                             chan_list = []
                             for chan in UserInfo.user.channels:
                                 chan_list.append(chan.name)
 
-                            self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f'UID                  : {UserInfo.id}')
-                            self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f'NICKNAME             : {UserInfo.name}')
-                            self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f'USERNAME             : {UserInfo.user.username}')
-                            self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f'REALNAME             : {UserInfo.user.realname}')
-                            self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f'MODES                : {UserInfo.user.modes}')
-                            self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f'CHANNELS             : {chan_list}')
-                            self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f'SECURITY GROUP       : {UserInfo.user.security_groups}')
-                            self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f'REPUTATION           : {UserInfo.user.reputation}')
+                            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f'UID                  : {UserInfo.id}')
+                            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f'NICKNAME             : {UserInfo.name}')
+                            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f'USERNAME             : {UserInfo.user.username}')
+                            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f'REALNAME             : {UserInfo.user.realname}')
+                            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f'MODES                : {UserInfo.user.modes}')
+                            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f'CHANNELS             : {chan_list}')
+                            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f'SECURITY GROUP       : {UserInfo.user.security_groups}')
+                            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f'REPUTATION           : {UserInfo.user.reputation}')
 
-                            self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f'IP                   : {UserInfo.ip}')
-                            self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f'COUNTRY CODE         : {UserInfo.geoip.country_code}')
-                            self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f'ASN                  : {UserInfo.geoip.asn}')
-                            self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f'ASNAME               : {UserInfo.geoip.asname}')
-                            self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f'CLOAKED HOST         : {UserInfo.user.cloakedhost}')
-                            self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f'HOSTNAME             : {UserInfo.hostname}')
-                            self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f'VHOST                : {UserInfo.user.vhost}')
-                            self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f'CLIENT PORT          : {UserInfo.client_port}')
-                            self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f'SERVER PORT          : {UserInfo.server_port}')
+                            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f'IP                   : {UserInfo.ip}')
+                            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f'COUNTRY CODE         : {UserInfo.geoip.country_code}')
+                            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f'ASN                  : {UserInfo.geoip.asn}')
+                            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f'ASNAME               : {UserInfo.geoip.asname}')
+                            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f'CLOAKED HOST         : {UserInfo.user.cloakedhost}')
+                            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f'HOSTNAME             : {UserInfo.hostname}')
+                            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f'VHOST                : {UserInfo.user.vhost}')
+                            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f'CLIENT PORT          : {UserInfo.client_port}')
+                            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f'SERVER PORT          : {UserInfo.server_port}')
                             
-                            self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f'CERTFP               : {UserInfo.tls.certfp}')
-                            self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f'CIPHER               : {UserInfo.tls.cipher}')
+                            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f'CERTFP               : {UserInfo.tls.certfp}')
+                            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f'CIPHER               : {UserInfo.tls.cipher}')
 
-                            self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f'IDLE SINCE           : {UserInfo.idle_since}')
-                            self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f'CONNECTED SINCE      : {UserInfo.connected_since}')
+                            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f'IDLE SINCE           : {UserInfo.idle_since}')
+                            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f'CONNECTED SINCE      : {UserInfo.connected_since}')
 
                 except IndexError as ie:
                     self.Logs.error(ie)
@@ -319,11 +318,11 @@ class Jsonrpc():
 
                     self.Base.create_thread(self.thread_ask_ia, ('',))
 
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg=f" This is a notice to the sender ...")
-                    self.Protocol.sendPrivMsg(nick_from=dnickname, msg="This is private message to the sender ...", nick_to=fromuser)
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg=f" This is a notice to the sender ...")
+                    self.Protocol.send_priv_msg(nick_from=dnickname, msg="This is private message to the sender ...", nick_to=fromuser)
 
                     if not fromchannel is None:
-                        self.Protocol.sendPrivMsg(nick_from=dnickname, msg="This is channel message to the sender ...", channel=fromchannel)
+                        self.Protocol.send_priv_msg(nick_from=dnickname, msg="This is channel message to the sender ...", channel=fromchannel)
 
                     # How to update your module configuration
                     self.__update_configuration('param_exemple2', 7)

mods/mod_test.py

@@ -147,7 +147,7 @@ class Test():
         except Exception as err:
             self.Logs.error(f"General Error: {err}")
 
-    def _hcmds(self, user:str, channel: any, cmd: list, fullcmd: list = []) -> None:
+    def hcmds(self, user:str, channel: any, cmd: list, fullcmd: list = []) -> None:
 
         command = str(cmd[0]).lower()
         dnickname = self.Config.SERVICE_NICKNAME
@@ -159,11 +159,11 @@ class Test():
             case 'test-command':
                 try:
 
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser, msg="This is a notice to the sender ...")
-                    self.Protocol.sendPrivMsg(nick_from=dnickname, msg=f"This is private message to the sender ...", nick_to=fromuser)
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser, msg="This is a notice to the sender ...")
+                    self.Protocol.send_priv_msg(nick_from=dnickname, msg=f"This is private message to the sender ...", nick_to=fromuser)
 
                     if not fromchannel is None:
-                        self.Protocol.sendPrivMsg(nick_from=dnickname, msg=f"This is private message to the sender ...", channel=fromchannel)
+                        self.Protocol.send_priv_msg(nick_from=dnickname, msg=f"This is private message to the sender ...", channel=fromchannel)
 
                     # How to update your module configuration
                     self.__update_configuration('param_exemple2', 7)

mods/mod_votekick.py

@@ -122,7 +122,7 @@ class Votekick():
     def unload(self) -> None:
         try:
             for chan in self.VOTE_CHANNEL_DB:
-                self.Protocol.sendChanPart(uidornickname=self.Config.SERVICE_ID, channel=chan.channel_name)
+                self.Protocol.send_part_chan(uidornickname=self.Config.SERVICE_ID, channel=chan.channel_name)
 
             self.VOTE_CHANNEL_DB = []
             self.Logs.debug(f'Delete memory DB VOTE_CHANNEL_DB: {self.VOTE_CHANNEL_DB}')
@@ -238,7 +238,7 @@ class Votekick():
             if chan.channel_name == channel:
                 target_user = self.User.get_nickname(chan.target_user)
                 if chan.vote_for > chan.vote_against:
-                    self.Protocol.sendPrivMsg(
+                    self.Protocol.send_priv_msg(
                         nick_from=dnickname,
                         msg=f"User {self.Config.COLORS.bold}{target_user}{self.Config.COLORS.nogc} has {chan.vote_against} votes against and {chan.vote_for} votes for. For this reason, it'll be kicked from the channel",
                         channel=channel
@@ -246,7 +246,7 @@ class Votekick():
                     self.Protocol.send2socket(f":{dnickname} KICK {channel} {target_user} Following the vote, you are not welcome in {channel}")
                     self.Channel.delete_user_from_channel(channel, self.User.get_uid(target_user))
                 elif chan.vote_for <= chan.vote_against:
-                    self.Protocol.sendPrivMsg(
+                    self.Protocol.send_priv_msg(
                         nick_from=dnickname,
                         msg=f"User {self.Config.COLORS.bold}{target_user}{self.Config.COLORS.nogc} has {chan.vote_against} votes against and {chan.vote_for} votes for. For this reason, it\'ll remain in the channel",
                         channel=channel
@@ -254,7 +254,7 @@ class Votekick():
 
                 # Init the system
                 if self.init_vote_system(channel):
-                    self.Protocol.sendPrivMsg(
+                    self.Protocol.send_priv_msg(
                         nick_from=dnickname,
                         msg="System vote re initiated",
                         channel=channel
@@ -274,7 +274,7 @@ class Votekick():
         except Exception as err:
             self.Logs.error(f"General Error: {err}")
 
-    def _hcmds(self, user:str, channel: any, cmd: list, fullcmd: list = []) -> None:
+    def hcmds(self, user:str, channel: any, cmd: list, fullcmd: list = []) -> None:
         # cmd is the command starting from the user command
         # full cmd is sending the entire server response
 
@@ -288,14 +288,14 @@ class Votekick():
             case 'vote':
 
                 if len(cmd) == 1:
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser,msg=f' /msg {dnickname} vote activate #channel')
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser,msg=f' /msg {dnickname} vote deactivate #channel')
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser,msg=f' /msg {dnickname} vote +')
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser,msg=f' /msg {dnickname} vote -')
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser,msg=f' /msg {dnickname} vote cancel')
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser,msg=f' /msg {dnickname} vote status')
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser,msg=f' /msg {dnickname} vote submit nickname')
-                    self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser,msg=f' /msg {dnickname} vote verdict')
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser,msg=f' /msg {dnickname} vote activate #channel')
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser,msg=f' /msg {dnickname} vote deactivate #channel')
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser,msg=f' /msg {dnickname} vote +')
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser,msg=f' /msg {dnickname} vote -')
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser,msg=f' /msg {dnickname} vote cancel')
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser,msg=f' /msg {dnickname} vote status')
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser,msg=f' /msg {dnickname} vote submit nickname')
+                    self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser,msg=f' /msg {dnickname} vote verdict')
                     return None
 
                 option = str(cmd[1]).lower()
@@ -306,12 +306,12 @@ class Votekick():
                         try:
                             # vote activate #channel
                             if self.Admin.get_Admin(fromuser) is None:
-                                self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser,msg=f' :Your are not allowed to execute this command')
+                                self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser,msg=f' :Your are not allowed to execute this command')
                                 return None
 
                             sentchannel = str(cmd[2]).lower() if self.Channel.Is_Channel(str(cmd[2]).lower()) else None
                             if sentchannel is None:
-                                self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser,msg=f" The correct command is {self.Config.SERVICE_PREFIX}{command} {option} #CHANNEL")
+                                self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser,msg=f" The correct command is {self.Config.SERVICE_PREFIX}{command} {option} #CHANNEL")
 
                             self.insert_vote_channel(
                                 self.VoteChannelModel(
@@ -325,30 +325,30 @@ class Votekick():
 
                             self.Channel.db_query_channel('add', self.module_name, sentchannel)
 
-                            self.Protocol.sendChanJoin(uidornickname=dnickname, channel=sentchannel)
+                            self.Protocol.send_join_chan(uidornickname=dnickname, channel=sentchannel)
                             self.Protocol.send2socket(f":{dnickname} SAMODE {sentchannel} +o {dnickname}")
-                            self.Protocol.sendPrivMsg(nick_from=dnickname, 
+                            self.Protocol.send_priv_msg(nick_from=dnickname, 
                                                       msg="You can now use !submit <nickname> to decide if he will stay or not on this channel ",
                                                       channel=sentchannel
                                                       )
                         except Exception as err:
                             self.Logs.error(f'{err}')
-                            self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser,msg=f' /msg {dnickname} {command} {option} #channel')
-                            self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser,msg=f' Exemple /msg {dnickname} {command} {option} #welcome')
+                            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser,msg=f' /msg {dnickname} {command} {option} #channel')
+                            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser,msg=f' Exemple /msg {dnickname} {command} {option} #welcome')
 
                     case 'deactivate':
                         try:
                             # vote deactivate #channel
                             if self.Admin.get_Admin(fromuser) is None:
-                                self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser,msg=f" Your are not allowed to execute this command")
+                                self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser,msg=f" Your are not allowed to execute this command")
                                 return None
 
                             sentchannel = str(cmd[2]).lower() if self.Channel.Is_Channel(str(cmd[2]).lower()) else None
                             if sentchannel is None:
-                                self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser,msg=f" The correct command is {self.Config.SERVICE_PREFIX}{command} {option} #CHANNEL")
+                                self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser,msg=f" The correct command is {self.Config.SERVICE_PREFIX}{command} {option} #CHANNEL")
 
                             self.Protocol.send2socket(f":{dnickname} SAMODE {sentchannel} -o {dnickname}")
-                            self.Protocol.sendChanPart(uidornickname=dnickname, channel=sentchannel)
+                            self.Protocol.send_part_chan(uidornickname=dnickname, channel=sentchannel)
 
                             for chan in self.VOTE_CHANNEL_DB:
                                 if chan.channel_name == sentchannel:
@@ -358,8 +358,8 @@ class Votekick():
                             self.Logs.debug(f"The Channel {sentchannel} has been deactivated from the vote system")
                         except Exception as err:
                             self.Logs.error(f'{err}')
-                            self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser,msg=f" /msg {dnickname} {command} {option} #channel")
-                            self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser,msg=f" Exemple /msg {dnickname} {command} {option} #welcome")
+                            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser,msg=f" /msg {dnickname} {command} {option} #channel")
+                            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser,msg=f" Exemple /msg {dnickname} {command} {option} #welcome")
 
                     case '+':
                         try:
@@ -368,21 +368,21 @@ class Votekick():
                             for chan in self.VOTE_CHANNEL_DB:
                                 if chan.channel_name == channel:
                                     if fromuser in chan.voter_users:
-                                        self.Protocol.sendPrivMsg(nick_from=dnickname, 
+                                        self.Protocol.send_priv_msg(nick_from=dnickname, 
                                                       msg="You already submitted a vote",
                                                       channel=channel
                                                       )
                                     else:
                                         chan.vote_for += 1
                                         chan.voter_users.append(fromuser)
-                                        self.Protocol.sendPrivMsg(nick_from=dnickname, 
+                                        self.Protocol.send_priv_msg(nick_from=dnickname, 
                                                       msg="Vote recorded, thank you",
                                                       channel=channel
                                                       )
                         except Exception as err:
                             self.Logs.error(f'{err}')
-                            self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser,msg=f' /msg {dnickname} {command} {option}')
-                            self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser,msg=f' Exemple /msg {dnickname} {command} {option}')
+                            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser,msg=f' /msg {dnickname} {command} {option}')
+                            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser,msg=f' Exemple /msg {dnickname} {command} {option}')
 
                     case '-':
                         try:
@@ -391,65 +391,65 @@ class Votekick():
                             for chan in self.VOTE_CHANNEL_DB:
                                 if chan.channel_name == channel:
                                     if fromuser in chan.voter_users:
-                                        self.Protocol.sendPrivMsg(nick_from=dnickname, 
+                                        self.Protocol.send_priv_msg(nick_from=dnickname, 
                                                       msg="You already submitted a vote",
                                                       channel=channel
                                                       )
                                     else:
                                         chan.vote_against += 1
                                         chan.voter_users.append(fromuser)
-                                        self.Protocol.sendPrivMsg(nick_from=dnickname, 
+                                        self.Protocol.send_priv_msg(nick_from=dnickname, 
                                                       msg="Vote recorded, thank you",
                                                       channel=channel
                                                       )
                         except Exception as err:
                             self.Logs.error(f'{err}')
-                            self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser,msg=f' /msg {dnickname} {command} {option}')
-                            self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser,msg=f' Exemple /msg {dnickname} {command} {option}')
+                            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser,msg=f' /msg {dnickname} {command} {option}')
+                            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser,msg=f' Exemple /msg {dnickname} {command} {option}')
 
                     case 'cancel':
                         try:
                             # vote cancel
                             if self.Admin.get_Admin(fromuser) is None:
-                                self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser,msg=f' Your are not allowed to execute this command')
+                                self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser,msg=f' Your are not allowed to execute this command')
                                 return None
 
                             if channel is None:
                                 self.Logs.error(f"The channel is not known, defender can't cancel the vote")
-                                self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser,msg=f' You need to specify the channel => /msg {dnickname} vote_cancel #channel')
+                                self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser,msg=f' You need to specify the channel => /msg {dnickname} vote_cancel #channel')
 
                             for vote in self.VOTE_CHANNEL_DB:
                                 if vote.channel_name == channel:
                                     self.init_vote_system(channel)
-                                    self.Protocol.sendPrivMsg(nick_from=dnickname, 
+                                    self.Protocol.send_priv_msg(nick_from=dnickname, 
                                                       msg="Vote system re-initiated",
                                                       channel=channel
                                                       )
 
                         except Exception as err:
                             self.Logs.error(f'{err}')
-                            self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser,msg=f' /msg {dnickname} {command} {option}')
-                            self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser,msg=f' Exemple /msg {dnickname} {command} {option}')
+                            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser,msg=f' /msg {dnickname} {command} {option}')
+                            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser,msg=f' Exemple /msg {dnickname} {command} {option}')
 
                     case 'status':
                         try:
                             # vote status
                             for chan in self.VOTE_CHANNEL_DB:
                                 if chan.channel_name == channel:
-                                    self.Protocol.sendPrivMsg(nick_from=dnickname, 
+                                    self.Protocol.send_priv_msg(nick_from=dnickname, 
                                                       msg=f"Channel: {chan.channel_name} | Target: {self.User.get_nickname(chan.target_user)} | For: {chan.vote_for} | Against: {chan.vote_against} | Number of voters: {str(len(chan.voter_users))}",
                                                       channel=channel
                                                       )
                         except Exception as err:
                             self.Logs.error(f'{err}')
-                            self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser,msg=f' /msg {dnickname} {command} {option}')
-                            self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser,msg=f' Exemple /msg {dnickname} {command} {option}')
+                            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser,msg=f' /msg {dnickname} {command} {option}')
+                            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser,msg=f' Exemple /msg {dnickname} {command} {option}')
 
                     case 'submit':
                         try:
                             # vote submit nickname
                             if self.Admin.get_Admin(fromuser) is None:
-                                self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser,msg=f' Your are not allowed to execute this command')
+                                self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser,msg=f' Your are not allowed to execute this command')
                                 return None
 
                             nickname_submitted = cmd[2]
@@ -462,7 +462,7 @@ class Votekick():
                                     if vote.channel_name == channel:
                                         ongoing_user = self.User.get_nickname(vote.target_user)
 
-                                self.Protocol.sendPrivMsg(nick_from=dnickname, 
+                                self.Protocol.send_priv_msg(nick_from=dnickname, 
                                                       msg=f"There is an ongoing vote on {ongoing_user}",
                                                       channel=channel
                                                       )
@@ -470,7 +470,7 @@ class Votekick():
 
                             # check if the user exist
                             if user_submitted is None:
-                                self.Protocol.sendPrivMsg(nick_from=dnickname, 
+                                self.Protocol.send_priv_msg(nick_from=dnickname, 
                                                       msg=f"This nickname <{nickname_submitted}> do not exist",
                                                       channel=channel
                                                       )
@@ -479,7 +479,7 @@ class Votekick():
                             uid_cleaned = self.Base.clean_uid(uid_submitted)
                             ChannelInfo = self.Channel.get_Channel(channel)
                             if ChannelInfo is None:
-                                self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser,msg=f' This channel [{channel}] do not exist in the Channel Object')
+                                self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser,msg=f' This channel [{channel}] do not exist in the Channel Object')
                                 return False
 
                             clean_uids_in_channel: list = []
@@ -487,7 +487,7 @@ class Votekick():
                                 clean_uids_in_channel.append(self.Base.clean_uid(uid))
 
                             if not uid_cleaned in clean_uids_in_channel:
-                                self.Protocol.sendPrivMsg(nick_from=dnickname, 
+                                self.Protocol.send_priv_msg(nick_from=dnickname, 
                                                       msg=f"This nickname <{nickname_submitted}> is not available in this channel",
                                                       channel=channel
                                                       )
@@ -497,7 +497,7 @@ class Votekick():
                             pattern = fr'[o|B|S]'
                             operator_user = re.findall(pattern, user_submitted.umodes)
                             if operator_user:
-                                self.Protocol.sendPrivMsg(nick_from=dnickname, 
+                                self.Protocol.send_priv_msg(nick_from=dnickname, 
                                                       msg="You cant vote for this user ! he/she is protected",
                                                       channel=channel
                                                       )
@@ -507,40 +507,40 @@ class Votekick():
                                 if chan.channel_name == channel:
                                     chan.target_user = self.User.get_uid(nickname_submitted)
 
-                            self.Protocol.sendPrivMsg(nick_from=dnickname, 
+                            self.Protocol.send_priv_msg(nick_from=dnickname, 
                                                       msg=f"{nickname_submitted} has been targeted for a vote",
                                                       channel=channel
                                                       )
 
                             self.Base.create_timer(60, self.timer_vote_verdict, (channel, ))
-                            self.Protocol.sendPrivMsg(nick_from=dnickname, 
+                            self.Protocol.send_priv_msg(nick_from=dnickname, 
                                                       msg="This vote will end after 60 secondes",
                                                       channel=channel
                                                       )
 
                         except Exception as err:
                             self.Logs.error(f'{err}')
-                            self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser,msg=f' /msg {dnickname} {command} {option} nickname')
-                            self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser,msg=f' Exemple /msg {dnickname} {command} {option} adator')
+                            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser,msg=f' /msg {dnickname} {command} {option} nickname')
+                            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser,msg=f' Exemple /msg {dnickname} {command} {option} adator')
 
                     case 'verdict':
                         try:
                             # vote verdict
                             if self.Admin.get_Admin(fromuser) is None:
-                                self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser,msg=f'Your are not allowed to execute this command')
+                                self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser,msg=f'Your are not allowed to execute this command')
                                 return None
 
                             for chan in self.VOTE_CHANNEL_DB:
                                 if chan.channel_name == channel:
                                     target_user = self.User.get_nickname(chan.target_user)
                                     if chan.vote_for > chan.vote_against:
-                                        self.Protocol.sendPrivMsg(nick_from=dnickname, 
+                                        self.Protocol.send_priv_msg(nick_from=dnickname, 
                                                       msg=f"User {self.Config.COLORS.bold}{target_user}{self.Config.COLORS.nogc} has {chan.vote_against} votes against and {chan.vote_for} votes for. For this reason, it\'ll be kicked from the channel",
                                                       channel=channel
                                                       )
                                         self.Protocol.send2socket(f":{dnickname} KICK {channel} {target_user} Following the vote, you are not welcome in {channel}")
                                     elif chan.vote_for <= chan.vote_against:
-                                        self.Protocol.sendPrivMsg(
+                                        self.Protocol.send_priv_msg(
                                             nick_from=dnickname, 
                                             msg=f"User {self.Config.COLORS.bold}{target_user}{self.Config.COLORS.nogc} has {chan.vote_against} votes against and {chan.vote_for} votes for. For this reason, it\'ll remain in the channel",
                                             channel=channel
@@ -548,22 +548,22 @@ class Votekick():
 
                                     # Init the system
                                     if self.init_vote_system(channel):
-                                        self.Protocol.sendPrivMsg(
+                                        self.Protocol.send_priv_msg(
                                             nick_from=dnickname, 
                                             msg="System vote re initiated",
                                             channel=channel
                                             )
                         except Exception as err:
                             self.Logs.error(f'{err}')
-                            self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser,msg=f' /msg {dnickname} {command} {option}')
-                            self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser,msg=f' Exemple /msg {dnickname} {command} {option}')
+                            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser,msg=f' /msg {dnickname} {command} {option}')
+                            self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser,msg=f' Exemple /msg {dnickname} {command} {option}')
 
                     case _:
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser,msg=f' /msg {dnickname} vote activate #channel')
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser,msg=f' /msg {dnickname} vote deactivate #channel')
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser,msg=f' /msg {dnickname} vote +')
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser,msg=f' /msg {dnickname} vote -')
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser,msg=f' /msg {dnickname} vote cancel')
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser,msg=f' /msg {dnickname} vote status')
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser,msg=f' /msg {dnickname} vote submit nickname')
-                        self.Protocol.sendNotice(nick_from=dnickname, nick_to=fromuser,msg=f' /msg {dnickname} vote verdict')
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser,msg=f' /msg {dnickname} vote activate #channel')
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser,msg=f' /msg {dnickname} vote deactivate #channel')
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser,msg=f' /msg {dnickname} vote +')
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser,msg=f' /msg {dnickname} vote -')
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser,msg=f' /msg {dnickname} vote cancel')
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser,msg=f' /msg {dnickname} vote status')
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser,msg=f' /msg {dnickname} vote submit nickname')
+                        self.Protocol.send_notice(nick_from=dnickname, nick_to=fromuser,msg=f' /msg {dnickname} vote verdict')

version.json

@@ -1,9 +1,9 @@
 {
-    "version": "6.0.0",
+    "version": "6.0.5",
 
     "requests": "2.32.3",
     "psutil": "6.0.0",
-    "unrealircd_rpc_py": "1.0.6",
+    "unrealircd_rpc_py": "1.0.7",
     "sqlalchemy": "2.0.35",
     "faker": "30.1.0"
 }