initial commit

canaux_reddit.txt

+
+#nardco|
+jokes,#gynecoloc|hearthstone,dirtyjokes,
+meanjokes,#leagueoflegends|leagueoflegends,
+#reddit|askreddit,
+#Titch|jokes,
+#2a|surreal,
\ No newline at end of file

ircbot.py

+# Copyright (C) 1999--2002  Joel Rosdahl
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
+#
+# Joel Rosdahl <joel@rosdahl.net>
+#
+# $Id: ircbot.py,v 1.23 2008/09/11 07:38:30 keltus Exp $
+
+"""ircbot -- Simple IRC bot library.
+
+This module contains a single-server IRC bot class that can be used to
+write simpler bots.
+"""
+
+import sys
+from UserDict import UserDict
+
+from irclib import SimpleIRCClient
+from irclib import nm_to_n, irc_lower, all_events
+from irclib import parse_channel_modes, is_channel
+from irclib import ServerConnectionError
+
+class SingleServerIRCBot(SimpleIRCClient):
+    """A single-server IRC bot class.
+
+    The bot tries to reconnect if it is disconnected.
+
+    The bot keeps track of the channels it has joined, the other
+    clients that are present in the channels and which of those that
+    have operator or voice modes.  The "database" is kept in the
+    self.channels attribute, which is an IRCDict of Channels.
+    """
+    def __init__(self, server_list, nickname, realname, reconnection_interval=60):
+        """Constructor for SingleServerIRCBot objects.
+
+        Arguments:
+
+            server_list -- A list of tuples (server, port) that
+                           defines which servers the bot should try to
+                           connect to.
+
+            nickname -- The bot's nickname.
+
+            realname -- The bot's realname.
+
+            reconnection_interval -- How long the bot should wait
+                                     before trying to reconnect.
+
+            dcc_connections -- A list of initiated/accepted DCC
+            connections.
+        """
+
+        SimpleIRCClient.__init__(self)
+        self.channels = IRCDict()
+        self.server_list = server_list
+        if not reconnection_interval or reconnection_interval < 0:
+            reconnection_interval = 2**31
+        self.reconnection_interval = reconnection_interval
+
+        self._nickname = nickname
+        self._realname = realname
+        for i in ["disconnect", "join", "kick", "mode",
+                  "namreply", "nick", "part", "quit"]:
+            self.connection.add_global_handler(i,
+                                               getattr(self, "_on_" + i),
+                                               -10)
+    def _connected_checker(self):
+        """[Internal]"""
+        if not self.connection.is_connected():
+            self.connection.execute_delayed(self.reconnection_interval,
+                                            self._connected_checker)
+            self.jump_server()
+
+    def _connect(self):
+        """[Internal]"""
+        password = None
+        if len(self.server_list[0]) > 2:
+            password = self.server_list[0][2]
+        try:
+            self.connect(self.server_list[0][0],
+                         self.server_list[0][1],
+                         self._nickname,
+                         password,
+                         ircname=self._realname)
+        except ServerConnectionError:
+            pass
+
+    def _on_disconnect(self, c, e):
+        """[Internal]"""
+        self.channels = IRCDict()
+        self.connection.execute_delayed(self.reconnection_interval,
+                                        self._connected_checker)
+
+    def _on_join(self, c, e):
+        """[Internal]"""
+        ch = e.target()
+        nick = nm_to_n(e.source())
+        if nick == c.get_nickname():
+            self.channels[ch] = Channel()
+        self.channels[ch].add_user(nick)
+
+    def _on_kick(self, c, e):
+        """[Internal]"""
+        nick = e.arguments()[0]
+        channel = e.target()
+
+        if nick == c.get_nickname():
+            del self.channels[channel]
+        else:
+            self.channels[channel].remove_user(nick)
+
+    def _on_mode(self, c, e):
+        """[Internal]"""
+        modes = parse_channel_modes(" ".join(e.arguments()))
+        t = e.target()
+        if is_channel(t):
+            ch = self.channels[t]
+            for mode in modes:
+                if mode[0] == "+":
+                    f = ch.set_mode
+                else:
+                    f = ch.clear_mode
+                f(mode[1], mode[2])
+        else:
+            # Mode on self... XXX
+            pass
+
+    def _on_namreply(self, c, e):
+        """[Internal]"""
+
+        # e.arguments()[0] == "@" for secret channels,
+        #                     "*" for private channels,
+        #                     "=" for others (public channels)
+        # e.arguments()[1] == channel
+        # e.arguments()[2] == nick list
+
+        ch = e.arguments()[1]
+        for nick in e.arguments()[2].split():
+            if nick[0] == "@":
+                nick = nick[1:]
+                self.channels[ch].set_mode("o", nick)
+            elif nick[0] == "+":
+                nick = nick[1:]
+                self.channels[ch].set_mode("v", nick)
+            self.channels[ch].add_user(nick)
+
+    def _on_nick(self, c, e):
+        """[Internal]"""
+        before = nm_to_n(e.source())
+        after = e.target()
+        for ch in self.channels.values():
+            if ch.has_user(before):
+                ch.change_nick(before, after)
+
+    def _on_part(self, c, e):
+        """[Internal]"""
+        nick = nm_to_n(e.source())
+        channel = e.target()
+
+        if nick == c.get_nickname():
+            del self.channels[channel]
+        else:
+            self.channels[channel].remove_user(nick)
+
+    def _on_quit(self, c, e):
+        """[Internal]"""
+        nick = nm_to_n(e.source())
+        for ch in self.channels.values():
+            if ch.has_user(nick):
+                ch.remove_user(nick)
+
+    def die(self, msg="Bye, cruel world!"):
+        """Let the bot die.
+
+        Arguments:
+
+            msg -- Quit message.
+        """
+
+        self.connection.disconnect(msg)
+        sys.exit(0)
+
+    def disconnect(self, msg="I'll be back!"):
+        """Disconnect the bot.
+
+        The bot will try to reconnect after a while.
+
+        Arguments:
+
+            msg -- Quit message.
+        """
+        self.connection.disconnect(msg)
+
+    def get_version(self):
+        """Returns the bot version.
+
+        Used when answering a CTCP VERSION request.
+        """
+        return "ircbot.py by Joel Rosdahl <joel@rosdahl.net>"
+
+    def jump_server(self, msg="Changing servers"):
+        """Connect to a new server, possibly disconnecting from the current.
+
+        The bot will skip to next server in the server_list each time
+        jump_server is called.
+        """
+        if self.connection.is_connected():
+            self.connection.disconnect(msg)
+
+        self.server_list.append(self.server_list.pop(0))
+        self._connect()
+
+    def on_ctcp(self, c, e):
+        """Default handler for ctcp events.
+
+        Replies to VERSION and PING requests and relays DCC requests
+        to the on_dccchat method.
+        """
+        if e.arguments()[0] == "VERSION":
+            c.ctcp_reply(nm_to_n(e.source()),
+                         "VERSION " + self.get_version())
+        elif e.arguments()[0] == "PING":
+            if len(e.arguments()) > 1:
+                c.ctcp_reply(nm_to_n(e.source()),
+                             "PING " + e.arguments()[1])
+        elif e.arguments()[0] == "DCC" and e.arguments()[1].split(" ", 1)[0] == "CHAT":
+            self.on_dccchat(c, e)
+
+    def on_dccchat(self, c, e):
+        pass
+
+    def start(self):
+        """Start the bot."""
+        self._connect()
+        SimpleIRCClient.start(self)
+
+
+class IRCDict:
+    """A dictionary suitable for storing IRC-related things.
+
+    Dictionary keys a and b are considered equal if and only if
+    irc_lower(a) == irc_lower(b)
+
+    Otherwise, it should behave exactly as a normal dictionary.
+    """
+
+    def __init__(self, dict=None):
+        self.data = {}
+        self.canon_keys = {}  # Canonical keys
+        if dict is not None:
+            self.update(dict)
+    def __repr__(self):
+        return repr(self.data)
+    def __cmp__(self, dict):
+        if isinstance(dict, IRCDict):
+            return cmp(self.data, dict.data)
+        else:
+            return cmp(self.data, dict)
+    def __len__(self):
+        return len(self.data)
+    def __getitem__(self, key):
+        return self.data[self.canon_keys[irc_lower(key)]]
+    def __setitem__(self, key, item):
+        if key in self:
+            del self[key]
+        self.data[key] = item
+        self.canon_keys[irc_lower(key)] = key
+    def __delitem__(self, key):
+        ck = irc_lower(key)
+        del self.data[self.canon_keys[ck]]
+        del self.canon_keys[ck]
+    def __iter__(self):
+        return iter(self.data)
+    def __contains__(self, key):
+        return self.has_key(key)
+    def clear(self):
+        self.data.clear()
+        self.canon_keys.clear()
+    def copy(self):
+        if self.__class__ is UserDict:
+            return UserDict(self.data)
+        import copy
+        return copy.copy(self)
+    def keys(self):
+        return self.data.keys()
+    def items(self):
+        return self.data.items()
+    def values(self):
+        return self.data.values()
+    def has_key(self, key):
+        return irc_lower(key) in self.canon_keys
+    def update(self, dict):
+        for k, v in dict.items():
+            self.data[k] = v
+    def get(self, key, failobj=None):
+        return self.data.get(key, failobj)
+
+
+class Channel:
+    """A class for keeping information about an IRC channel.
+
+    This class can be improved a lot.
+    """
+
+    def __init__(self):
+        self.userdict = IRCDict()
+        self.operdict = IRCDict()
+        self.voiceddict = IRCDict()
+        self.modes = {}
+
+    def users(self):
+        """Returns an unsorted list of the channel's users."""
+        return self.userdict.keys()
+
+    def opers(self):
+        """Returns an unsorted list of the channel's operators."""
+        return self.operdict.keys()
+
+    def voiced(self):
+        """Returns an unsorted list of the persons that have voice
+        mode set in the channel."""
+        return self.voiceddict.keys()
+
+    def has_user(self, nick):
+        """Check whether the channel has a user."""
+        return nick in self.userdict
+
+    def is_oper(self, nick):
+        """Check whether a user has operator status in the channel."""
+        return nick in self.operdict
+
+    def is_voiced(self, nick):
+        """Check whether a user has voice mode set in the channel."""
+        return nick in self.voiceddict
+
+    def add_user(self, nick):
+        self.userdict[nick] = 1
+
+    def remove_user(self, nick):
+        for d in self.userdict, self.operdict, self.voiceddict:
+            if nick in d:
+                del d[nick]
+
+    def change_nick(self, before, after):
+        self.userdict[after] = 1
+        del self.userdict[before]
+        if before in self.operdict:
+            self.operdict[after] = 1
+            del self.operdict[before]
+        if before in self.voiceddict:
+            self.voiceddict[after] = 1
+            del self.voiceddict[before]
+
+    def set_mode(self, mode, value=None):
+        """Set mode on the channel.
+
+        Arguments:
+
+            mode -- The mode (a single-character string).
+
+            value -- Value
+        """
+        if mode == "o":
+            self.operdict[value] = 1
+        elif mode == "v":
+            self.voiceddict[value] = 1
+        else:
+            self.modes[mode] = value
+
+    def clear_mode(self, mode, value=None):
+        """Clear mode on the channel.
+
+        Arguments:
+
+            mode -- The mode (a single-character string).
+
+            value -- Value
+        """
+        try:
+            if mode == "o":
+                del self.operdict[value]
+            elif mode == "v":
+                del self.voiceddict[value]
+            else:
+                del self.modes[mode]
+        except KeyError:
+            pass
+
+    def has_mode(self, mode):
+        return mode in self.modes
+
+    def is_moderated(self):
+        return self.has_mode("m")
+
+    def is_secret(self):
+        return self.has_mode("s")
+
+    def is_protected(self):
+        return self.has_mode("p")
+
+    def has_topic_lock(self):
+        return self.has_mode("t")
+
+    def is_invite_only(self):
+        return self.has_mode("i")
+
+    def has_allow_external_messages(self):
+        return self.has_mode("n")
+
+    def has_limit(self):
+        return self.has_mode("l")
+
+    def limit(self):
+        if self.has_limit():
+            return self.modes[l]
+        else:
+            return None
+
+    def has_key(self):
+        return self.has_mode("k")
+
+    def key(self):
+        if self.has_key():
+            return self.modes["k"]
+        else:
+            return None

module_red.py

+# -*- coding: utf-8 -*-
+import random
+import praw
+
+def Decoup(chaine) :
+	chaine = chaine.replace('\n',' ')
+	tmp = chaine.split(" ")
+	res = []
+	a = 0
+	tmp2 = ""
+	for f in tmp :
+		if a < 10 :
+			tmp2 = tmp2+" "+f
+			a = a+1
+		if a == 10 :
+			res.append(tmp2)
+			tmp2 = ""
+			a = 0
+	res.append(tmp2)
+	return res
+
+
+# https://www.reddit.com/r/jokes/.json?sort=new
+
+
+def get_new(fichier_origine, canal) :
+	try :
+		UA = "Nardco fait des blagues"
+		r = praw.Reddit(user_agent = UA)
+		res = []
+		bd = open(fichier_origine, "r")
+		for f in bd :
+			if canal == f.split("|")[0] :
+				subs = f.split("|")[1].split(",")
+		bd.close()
+		subs.pop(-1)
+		for f in subs :
+			#recuperer les sub, titres, urls
+			sub = r.get_subreddit(f).get_hot(limit = 5)
+			sub = list(sub)
+			tmp = ""
+			res.append("sub = "+f)
+			for g in sub :
+				tmp = tmp + g.title+" , url : "+g.short_link+" || "
+			res.append(tmp)
+		
+
+		return res
+	except :
+		print "erreur"
+		return ["oups, c'est cassé"]
+	
+
+#Sort le titre, le texte et l'url d'un subreddit = arg
+def joke(arg = "", link = 0 ) :
+	try :
+		UA = "Nardco fait des blagues"
+		r = praw.Reddit(user_agent = UA)
+		a = random.randint(0,99)
+		if arg != "" :
+			subreddit = r.get_subreddit(arg)
+		else :
+			subreddit = r.get_subreddit('random')
+		subs = subreddit.get_hot(limit = 100)
+		subs = list(subs)
+
+
+		titre = (subs[a]).title
+		texte = (subs[a]).selftext
+		if  len(texte) > 100 :
+			texte = texte[:100] + "[...]"
+		url = (subs[a]).short_link
+		texte = texte+ " | url : "+url
+
+		if titre in texte :
+			return Decoup(texte.encode('utf8'))
+
+		else :
+			return Decoup( (titre+" : "+ texte).encode('utf8'))
+		
+		return Decoup("Houston, on a un probleme...")
+	except :
+		return Decoup("Erreur :(")

nardco.py

+# -*- coding: utf8 -*-
+
+
+import irclib
+import ircbot
+import random
+import time
+import module_red as red
+from fuzzywuzzy import fuzz
+
+# import rateau
+def couper(pseudo):
+    return pseudo.split("!")[0]
+
+
+def aram():
+    Champ = [" Aatrox ", " Ahri ", " Akali ", " Alistar ", " Amumu ", " Anivia ", " Annie ", " Ashe ", " Azir ",
+             " Bard ", " Blitzcrank ", " Brand ", " Braum ", " Caitlyn ", " Cassiopeia ", " Cho'Gath ", " Corki ",
+             " Darius ", " Diana ", " Dr.Mundo ", " Draven ", " Ekko ", " Elise ", " Evelynn ", " Ezreal ",
+             " Fiddlesticks ", " Fiora ", " Fizz ", " Galio ", " Gangplank ", " Garen ", " Gnar ", " Gragas ",
+             " Graves ", " Hecarim ", " Heimerdinger ", " Irelia ", " Janna ", " Jarvan IV ", " Jayce ", " Jax ",
+             " Jinx ", " Kalista ", " Karma ", " Karthus ", " Kassadin ", " Katarina ", " Kayle ", " Kennen ",
+             " Kha'Zix", " Kog'Maw ", " LeBlanc ", " Lee Sin ", " Leona ", " Lissandra ", " Lucian ", " Lulu ", " Lux ",
+             " Maître Yi ", " Malphite ", " Malzahar ", " Maokai ", " Miss Fortune ", " Mordekaiser ", " Morgana ",
+             " Nami ", " Nasus ", " Nautilus ", " Nidalee ", " Nocturne ", " Nunu ", " Olaf ", " Orianna ",
+             " Pantheon ", " Poppy ", " Quinn ", " Rammus ", " Rek'Sai ", " Renekton ", " Rengar ", " Riven ",
+             " Rumble ", " Ryze ", " Sejuani ", " Shaco ", " Shen ", " Shyvana ", " Singed ", " Sion ", " Sivir ",
+             " Skarner ", " Sona ", " Soraka ", " Swain ", " Syndra ", " Tahm Kench ", " Talon ", " Taric ", " Teemo ",
+             " Thresh ", " Tristana ", " Trundle ", " Tryndamere ", " Twisted Fate ", " Twitch ", " Udyr ", " Urgot ",
+             " Varus ", " Vayne ", " Veigar ", " Vel'Koz ", " Vi ", " Viktor ", " Vladimir ", " Volibear ", " Warwick ",
+             " Wukong ", " Xerath ", " Xin Zhao ", " Yasuo ", " Yorick ", " Zac ", " Zed ", " Ziggs ", " Zilean ",
+             " Zyra"]
+    return Champ[random.randint(0, len(Champ) - 1)]
+
+
+global pour
+pour = []
+global suple
+suple = -1
+
+global cmdCarac
+cmdCarac = "$"
+
+def isCommande(string):
+    global cmdCarac
+    return string[0] == cmdCarac
+
+
+class Boooob(ircbot.SingleServerIRCBot):
+    def __init__(self):
+        ircbot.SingleServerIRCBot.__init__(self, [("irc.iiens.net", 6667)], "nardco", "Je suis un bot")
+        self.temps = 0
+        self.reddit_temps = 0
+        self.fichier_reddit = "canaux_reddit.txt"
+        self.clever = -1
+
+    #
+    def on_welcome(self, serv, ev):
+        serv.join("#nardco")
+        serv.join("#fokontest")
+        serv.join("#Titch")
+        # serv.join("#gynecoloc")
+        serv.privmsg("NickServ", "IDENTIFY MotDePasse")  # rejoint #nardco à sa connexion
+
+    #
+    def on_join(self, serv, ev):  # Quand qq entre dans le chann, le bot inclus
+        auteur = str(irclib.nm_to_n(ev.source()))
+        canal = ev.target()
+
+    def on_privmsg(self, serv, ev):  # msg privé
+        personne = ev.source()
+        canal = ""
+
+        if "tichadou" in personne:
+            msg = ev.arguments()[0]
+            msg = msg.split(" ")
+            a = 0
+            for f in msg:
+                a = a + 1
+                if f[0] == "#":
+                    canal = f
+                    msg.pop(a - 1)
+                    break
+            msg = " ".join(msg)
+            try:
+                serv.privmsg(canal, msg)
+            except:
+                serv.privmsg("#nardco", "probleeeeme")
+
+    def on_invite(self, serv, ev):
+        personne = ev.source()
+        canal = ev.arguments()[0]
+        serv.privmsg("Titch", couper(personne) + " m'a invité sur " + canal)
+        serv.join(canal)
+
+    def on_kick(self, serv, ev):
+        serv.join("#nardco")
+        print("kick")
+        personne = ev.source()
+        personne = couper(personne)
+        canal = ev.target()
+        if canal == "#Titch" and personne != "Titch" :
+            serv.mode(canal, "-o " + personne)
+
+
+    def on_pubmsg(self, serv, ev):  # quand qq ecrit dans le chat
+        global suple
+        global cmdCarac
+        canal = ev.target()
+
+        personne = ev.source()
+        personne = couper(personne)
+        message = ev.arguments()[0]
+        message = message.lower()  # Passe le message en minuscules
+	split = message.split(" ")
+        if "op pls" in message or "op plz" in message :
+            serv.mode(canal, "+o "+personne)
+	if 'nardco' in split[0] and ' ou ' in message :
+	    splt = split[1:]
+	    idx = splt.index("ou")
+	    choice = random.randint(0,1)
+	    if choice == 0 :
+                res = splt[:idx]
+	    else :
+		if '?' in splt[-1] :
+		    res = splt[idx+1:-1]	
+	        else :
+		    res = splt[idx+1:]
+	    serv.privmsg(canal, ' '.join(res)+ "!")
+
+        # lol of legends
+        if " aram " in message:
+            people = ["Jara", "Nami"]
+            if personne in people:
+                if "Jara" in personne:
+                    serv.privmsg(canal, "TOURBILOL DEBILE MOUHAHAHA")
+                if "Nami" in personne:
+                    serv.privmsg(canal, "Non Nami, ton main n'est pas op ! <3")
+            else:
+                serv.privmsg(canal, "A l'evidence," + aram() + "est totalement op.")
+
+            # les lignes suivantes sont pour le lol
+        if "Titch" in personne and "tg" in message:
+            serv.privmsg(canal, "Oui maitre...")
+            suple = -1
+
+        if "Titch" in personne and "openbar" in message:
+            serv.privmsg(canal, "OPEN BAAAAAAR")
+            suple = 1
+        if "souple" in message and suple == 1:
+            serv.privmsg(canal, "et fruité")
+        if "fruité" in message and suple == 1:
+            serv.privmsg(canal, "et gouleyant")
+        if "gouleyant" in message and suple == 1:
+            serv.privmsg(canal, "et souple")
+
+        if suple == 1 and ("dur" in message or "long" in message or "court" in message or "molle" in message):
+            serv.privmsg(canal, "Comme ta bite " + personne + "! ")
+        if suple == 1:
+            if "aucun lien" in message:
+                serv.privmsg(canal, "Je suis fils unique...")
+
+
+
+
+                # fonctions de deplacement dans les chann
+
+        if "Titch" in personne and "goto" in message and "nardco" in message:
+            f = 0
+            for f in range(len(message) - 4):
+                if message[f:f + 4] == "goto":
+                    serv.join("#" + message[f + 5:])
+                    break
+        if "Titch" in personne and "leave" in message and "nardco" in message:
+            serv.part(canal)
+
+
+            # REDDIT // A COMPLETER
+        if isCommande(message):
+            args = message[1:].split(" ")
+            cmd = args[0]
+
+            if cmd == "help":
+                if len(message.split(" ")) > 1:
+                    if "reddit" in message.split(" ")[1]:
+                        serv.privmsg(
+                            canal,
+                            "Commandes : {0}reddit <sub> ; {0}addsub <sub> ; {0}delsub <sub> ; {0}getsub . (getsub renvoie des infos sur tous les subs enregistrés pour le chann) ".format(cmdCarac))
+                else:
+                    serv.privmsg(canal,
+                                 "Commandes disponibles : {0}help reddit , sinon, tentez de dire 'op plz' ...".format(cmdCarac))
+
+            if cmd == "getsub":
+                res = red.get_new(self.fichier_reddit, canal)
+                for f in res:
+                    serv.privmsg(canal, f)
+
+            if cmd == "sub":
+                bd = open(self.fichier_reddit, "r")
+                for f in bd:
+                    try:
+                        if canal == f.split("|")[0]:
+                            serv.privmsg(canal, "Liste des subs pour " + canal + " : " + f.split("|")[1])
+                    except:
+                        pass
+
+            if cmd == "delsub":
+                sub = message.split(" ")[1]
+                bd = open(self.fichier_reddit, "r")
+                rem = 0
+                tmp = []
+                for f in bd:
+                    tmp.append(f)
+                    try:
+                        if sub in f.split("|")[1] and canal == f.split("|")[0]:
+                            rem = 1
+                    except:
+                        pass
+                bd.close()
+                if rem == 1:
+                    bd = open(self.fichier_reddit, "w")
+                    for f in tmp:
+                        if canal == f.split("|")[0]:
+                            h = f.split("|")[1]
+                            h = h.split(",")
+                            h.remove(sub)
+
+                            g = f.split("|")[0] + "|" + ",".join(h)
+                        else:
+                            g = f
+                        bd.write(g)
+                    serv.privmsg(canal, "sub : " + sub + " enlevé de la bd pour " + canal)
+                else:
+                    serv.privmsg(canal, "Erreur, le sub n'est pas dans la bd")
+
+            if cmd == "addsub":
+                sub = message.split(" ")[1]
+                bd = open(self.fichier_reddit, "r")
+                add = 1
+                tmp = []
+                for f in bd:
+                    tmp.append(f)  # On ajoute la ligne -> tmpt est une image de la bd
+                    try:
+
+                        if sub in f.split("|")[1] and canal == f.split("|")[0]:
+                            add = 0
+                    except:
+                        pass
+                bd.close()
+                if add == 1:
+                    canalok = 0
+                    bd = open(self.fichier_reddit, "w")
+                    for f in tmp:
+                        if canal == f.split("|")[0]:
+                            g = f + sub + ","
+                            canalok = 1
+                        else:
+                            g = f
+                        bd.write(g)
+                    if canalok == 0:
+                        bd.write("\n" + canal + "|" + sub + ",")
+                    bd.close()
+                    serv.privmsg(canal, "Subreddit : " + sub + " ajouté a la bd pour " + canal)
+                else:
+                    serv.privmsg(canal, "Subreddit deja dans la bd...")
+
+            if fuzz.ratio(cmd, "reddit") > 80 :
+                if time.time() - self.reddit_temps > 10:
+                    self.reddit_temps = time.time()
+
+                    try:
+                        tmp = red.joke(message.split(" ")[1])
+
+
+                    except:
+                        tmp = red.joke()
+
+                    try:
+
+                        for f in tmp:
+                            serv.privmsg(canal, f)
+                            time.sleep(0.5)
+                        time.sleep(1)
+
+                    except:
+                        serv.privmsg(canal, "oups, c'est cassé...")
+                else:
+                    serv.privmsg(canal, personne + ": Merci de patienter :)")
+
+
+if __name__ == "__main__":
+    Boooob().start()