Changeset 137

Timestamp:

04/26/08 16:07:44 (2 years ago)

Author:

xbright

Message:

Quelques petites choses sur le code

Files:

• randomchat/randomchat.py (modified) (12 diffs)

randomchat/randomchat.py

@@ -1 @@
-#!/usr/bin/python
-# -*- coding: UTF-8 -*-
-
-import xmpp
-import random
-import sha
-import time
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+#import xmpp
+from xmpp import (NS_DISCO_ITEMS, NS_DISCO_INFO, NS_REGISTER, NS_MUC, JID, \
+                  Error, Message, Presence, Node, Component, browser)
+
+from random import choice as random_choice
+from sha import sha
+from time import time
 
 import config
 
-NS_MUC_USER = xmpp.NS_MUC+'#user'
+NS_MUC_USER = NS_MUC + '#user'
 
 def db_connect(config):
     if config.DB_MODULE == 'sqlite':
-      from pysqlite2 import dbapi2 as sqlite
-      return sqlite.connect(config.SQLITE_DB)
-    else:
-        raise Exception("Incorrect DB module")
+        try:
+            import sqlite3 as sqlite
+        except ImportError:
+            try:
+                from pysqlite2 import dbapi2 as sqlite
+            except ImportError:
+                raise ImportError('Incorrect DB module')
+
+        return sqlite.connect(config.SQLITE_DB)
+
+
 
 class Users:
@@ -26 +36 @@
     def read_users(self):
         cursor = self.db.cursor()
-        cursor.execute("SELECT jid FROM randomchat WHERE 1")
-        user = cursor.fetchone()
-        while user:
+        cursor.execute('SELECT jid FROM randomchat')
+        users = cursor.fetchall()
+
+        for user in users:
             self.users_list[user[0]] = False
-            user = cursor.fetchone()
+
         cursor.close()
 
@@ -37 +48 @@
 
     def add_user(self, jid):
-        self.db.execute("INSERT INTO randomchat (jid) VALUES (?)", (jid,))
+        self.db.execute('INSERT INTO randomchat (jid) VALUES (?)', (jid,))
         self.db.commit()
         self.users_list[jid] = False
 
     def remove_user(self, jid):
-        self.db.execute("DELETE FROM randomchat WHERE jid=?", (jid,))
+        self.db.execute('DELETE FROM randomchat WHERE jid=?', (jid,))
         self.db.commit()
         del self.users_list[jid]
@@ -49 +60 @@
         user = jid.getStripped()
         users = [jid for jid in self.users_list.keys() if self.users_list[jid]]
-        #if we have only one participant don't start a chat, except when the user is not in this list (so in fact we have two participants)
+
+        # If we have only one participant don't start a chat, except when the
+        # user is not in this list (so in fact we have two participants).
+
         if (len(users) < 2 and user in users) or len(users) < 1:
             return None
         else:
-            other = random.choice(users)
+            other = random_choice(users)
             while other == user:
-                other = random.choice(users)
+                other = random_choice(users)
+
             return other
 
@@ -61 +76 @@
         if not self.has_user(jid):
             return
+
         self.users_list[jid] = availability
 
@@ -72 +88 @@
         self.jid = selfjid
         self.con = con
-        self.users = {} # contains the users list as keys
-        self.rooms = {} # contains the rooms name as keys and the full JID of the participants as values
+
+        # Contains the users list as keys.
+        self.users = {}
+
+        # Contains the rooms name as keys and the full JID of the participants
+        # as values.
+        self.rooms = {}
 
     def message_handler(self, con, msg):
@@ -79 +100 @@
         frm_str = frm.getStripped()
         room = msg.getTo().getNode()
-        room_jid = room+'@'+self.jid
-        if not frm_str in self.users or not self.users[frm_str].has_key(room) or self.users[frm_str][room]['nick'] is None:
-            con.send(xmpp.Error(msg, 'item-not-found'))
+        room_jid = room + '@' + self.jid
+
+        if not frm_str in self.users or not self.users[frm_str].has_key(room) \
+           or not self.users[frm_str][room]['nick']:
+            con.send(Error(msg, 'item-not-found'))
             return
         if msg.getType() != 'groupchat':
-            con.send(xmpp.Error(msg, 'bad-format'))
-
-        message = xmpp.Message(body = msg.getBody(), typ='groupchat')
+            con.send(Error(msg, 'bad-format'))
+
+        message = Message(body = msg.getBody(), typ='groupchat')
         for jid in self.rooms[room]:
             message.setTo(jid)
             if jid == frm:
-                message.setFrom(room_jid+'/'+self.users[frm_str][room]['nick'])
+                message.setFrom(room_jid + '/' + 
+                                           self.users[frm_str][room]['nick'])
             else:
-                message.setFrom(room_jid+'/'+config.NICK_GUEST)
+                message.setFrom(room_jid + '/' + config.NICK_GUEST)
+
             con.send(message)
 
@@ -99 +124 @@
             if not self.users.has_key(jid.getStripped()):
                 continue
+
             user = self.users[jid.getStripped()][room]
-            destroy = xmpp.Presence(to = jid, frm = room+'@'+self.jid+'/'+user['nick'], typ = 'unavailable', payload = [ 
-                xmpp.Node('x', attrs={'xmlns': xmpp.NS_MUC+'#user'}, payload = [ 
-                    xmpp.Node('item', attrs={'affiliation': 'none', 'role': 'none'}),
-                    xmpp.Node('destroy',payload = [ 
-                        xmpp.Node('reason', payload = ['Votre interlocuteur a quitté le salon'] ) 
+            destroy = Presence(to=jid, frm=room +
+                                           '@' + 
+                                           self.jid +'/' + 
+                                           user['nick'], typ='unavailable', 
+                                           payload =
+            [
+                Node('x', attrs={'xmlns': NS_MUC+'#user'}, payload =
+                [
+                    Node('item', attrs={'affiliation': 'none', 'role': 'none'}),
+                    Node('destroy',payload =
+                    [
+                        Node('reason',
+                           payload = ['Votre interlocuteur a quitté le salon'] ) 
                     ])
                 ])
             ])
+
             self.con.send(destroy)
             del self.users[jid.getStripped()]
+
         del self.rooms[room]
-
 
     def presence_handler(self, con, prs):
@@ -117 +152 @@
         frm_str = frm.getStripped()
         room = prs.getTo().getNode()
-        room_jid = room+'@'+self.jid
+        room_jid = room + '@' + self.jid
         nick = prs.getTo().getResource()
+
         if nick == '':
-            con.send(xmpp.Error(prs, 'bad-format'))
-            return
-        if not self.users.has_key(frm_str) or not self.users[frm_str].has_key(room):
-            con.send(xmpp.Error(prs, 'item-not-found'))
+            con.send(Error(prs, 'bad-format'))
+            return
+
+        if not self.users.has_key(frm_str) \
+           or not self.users[frm_str].has_key(room):
+            con.send(Error(prs, 'item-not-found'))
             return
 
         user = self.users[frm_str][room]
-
         print user['nick']
-        if user['nick'] is not None and prs.getType() == 'available': # discard presence if the user is already in the chat
+
+        # Discard presence if the user is already in the chat.
+        if user['nick'] is not None and prs.getType() == 'available':
             return
 
         if user['nick'] is None:
-            presence = xmpp.Presence(show = 'chat', payload = [xmpp.Node('x',  attrs = {'xmlns': NS_MUC_USER})])
+            presence = Presence(show='chat', payload=[
+                                    Node('x', attrs = {'xmlns': NS_MUC_USER})])
+
             x = presence.getTag('x')
-            x.addChild('item', attrs = {'affiliation': 'member', 'role': 'participant'})
+            x.addChild('item', attrs = {'affiliation': 'member',
+                                        'role': 'participant'})
+
             if len(self.rooms[room]) == 1:
                 presence.setTo(frm)
-                presence.setFrom(room_jid+'/'+config.NICK_GUEST)
-                con.send(presence) # sends the presence of the other participant to the current participant
+                presence.setFrom(room_jid + '/' + config.NICK_GUEST)
+
+                # Sends the presence of the other participant to
+                # the current participant.
+                con.send(presence) 
                 presence.setTo(self.rooms[room][0])
-                con.send(presence) # does the opposite
+
+                # Does the opposite.
+                con.send(presence)
+
             presence.setTo(frm)
-            presence.setFrom(room_jid+'/'+nick)
+            presence.setFrom(room_jid + '/' + nick)
             x.addChild('status', attrs = {'code': '110'})
-            con.send(presence) # send the user self presence
-            # add the user in the room
+
+            # Send the user self presence.
+            con.send(presence)
+
+            # Add the user in the room.
             user['nick'] = nick
             self.rooms[room].append(frm)
-        else: # if the user is already in, and we are this far, that means that we got a presence type!= available, we assume that he has left the chat
+
+        # If the user is already in, and we are this far, that means that we
+        # got a presence type != available, we assume that he has left the chat.
+        else: 
             self.destroy_room(room)
-        
 
     def invite(self, room, jid):
-        invite = xmpp.Message(to = jid, frm = room+'@'+self.jid, body = 'Vous avez été invité dans le salon '+room+'@'+self.jid, payload = [ 
-            xmpp.Node('x', attrs={'xmlns': xmpp.NS_MUC+'#user'}, payload = [ 
-                xmpp.Node('invite', attrs={'from': room+'@'+self.jid}, payload = [ 
-                    xmpp.Node('reason', payload = ['Random chat !'] ) 
-                ])
-            ])
-        ])
+        invite = Message(to=jid, frm=room + '@' + self.jid, 
+          body = 'Vous avez été invité dans le salon ' + room + '@' + self.jid,
+          payload = 
+          [ 
+              Node('x', attrs={'xmlns': NS_MUC+'#user'}, payload =
+              [
+                  Node('invite', attrs={'from': room+'@'+self.jid}, payload =
+                  [
+                      Node('reason', payload=['Random chat !'] ) 
+                  ])
+              ])
+          ])
+
         self.con.send(invite)
 
     def invite_users(self, jid1, jid2):
-        room = sha.sha(str(jid1)+str(jid2)+str(time.time())).hexdigest()
+        room = sha(str(jid1) + str(jid2) + str(time())).hexdigest()
+
         self.rooms[room] = []
         jid1_str = jid1.getStripped()
         jid2_str = jid2.getStripped()
+
         if not self.users.has_key(jid1_str):
             self.users[jid1_str]={}
         self.users[jid1_str][room] = {'other': jid2_str, 'nick': None}
+
         if not self.users.has_key(jid2_str):
             self.users[jid2_str]={}
+ 
         self.users[jid2_str][room] = {'other': jid1_str, 'nick': None}
         self.invite(room,jid1)
         self.invite(room,jid2)
-        #TODO add a timeout and destroy the room if neither of them has joined the room
+        # TODO: add a timeout and destroy the room if neither
+        # of them has joined the room
 
 
@@ -183 +248 @@
     def __init__(self, users, jid, pwd, server, port=5347):
         self.users = users
-        self.con = xmpp.Component(server, port)
+        self.con = Component(server, port)
         self.jid = jid
         self.muc = MUC(jid, self.con)
+
         if not self.con.connect():
             raise Exception('Unable to connect to %s:%s' % (server, port))
@@ -191 +257 @@
             raise Exception('Unable to authenticate as %s' % (jid))
 
-        #register the handlers 
+        # Register XMPP handlers.
         self.con.RegisterHandler('presence', self.presence_handler)
-        self.con.RegisterHandler('presence', self.subscribe_handler, 'subscribe')
-        self.con.RegisterHandler('presence', self.subscribed_handler, 'subscribed')
-        self.con.RegisterHandler('presence', self.unsubscribe_handler, 'unsubscribe')
-        self.con.RegisterHandler('presence', self.unsubscribed_handler, 'unsubscribed')
+        self.con.RegisterHandler('presence', self.subscribe_handler,
+                                                                    'subscribe')
+        self.con.RegisterHandler('presence', self.subscribed_handler,
+                                                                   'subscribed')
+        self.con.RegisterHandler('presence', self.unsubscribe_handler,
+                                                                  'unsubscribe')
+        self.con.RegisterHandler('presence', self.unsubscribed_handler,
+                                                                 'unsubscribed')
         self.con.RegisterHandler('message', self.message_handler)
 
-        b=xmpp.browser.Browser()
+        b = browser.Browser()
         b.PlugIn(self.con)
-        items=[]
-        info={'ids':[{'category': 'conference', 'type': 'text', 'name': 'Random Chat'}], 'features':[xmpp.NS_REGISTER, xmpp.NS_DISCO_INFO, xmpp.NS_DISCO_ITEMS]}
-        b.setDiscoHandler({'items':items,'info':info})
-
+        items = []
+        info = {'ids': [{'category': 'conference',
+                         'type': 'text',
+                         'name': 'Random Chat'}],
+                'features': [NS_REGISTER, NS_DISCO_INFO, NS_DISCO_ITEMS]}
+
+        b.setDiscoHandler({'items': items,'info': info})
 
         self.send_probes()
-
 
         while 1:
             self.con.Process(10)
 
-
     def subscribe_handler(self, con, prs):
         user = prs.getFrom().getStripped()
+
         if not self.users.has_user(user):
-            self.con.send(xmpp.Presence(to = prs.getFrom(), frm = self.jid, typ = 'subscribe'))
-        self.con.send(xmpp.Presence(to = prs.getFrom(), frm = self.jid, typ = 'subscribed'))
+            self.con.send(Presence(to=prs.getFrom(), frm=self.jid,
+                                                               typ='subscribe'))
+        self.con.send(Presence(to=prs.getFrom(), frm=self.jid,
+                                                              typ='subscribed'))
 
     def subscribed_handler(self, con, prs):
@@ -225 +299 @@
 
     def unsubscribe_handler(self, con, prs):
-        self.con.send(xmpp.Presence(to = prs.getFrom(), frm = self.jid, typ = 'unsubscribe'))
+        self.con.send(Presence(to=prs.getFrom(), frm=self.jid,
+                                                             typ='unsubscribe'))
 
     def unsubscribed_handler(self, con, prs):
         user = prs.getFrom().getStripped()
         self.users.remove_user(user)
-        self.con.send(xmpp.Presence(to = prs.getFrom(), frm = self.jid, typ = 'unsubscribed'))
+        self.con.send(Presence(to=prs.getFrom(), frm=self.jid,
+                                                            typ='unsubscribed'))
 
     def presence_handler(self, con, prs):
         if prs.getType() == 'error':
             return
+
         if prs.getTo().getNode() != '':
             self.muc.presence_handler(con, prs)
             return
+
         if prs.getType() is None and prs.getShow() == 'chat':
-            #available to chat
+
+            # Available to chat.
             self.users.update_availability(prs.getFrom().getStripped(), True)
-            con.send(xmpp.Presence(frm = self.jid, to = prs.getFrom(), show = 'chat'))
+            con.send(Presence(frm=self.jid, to=prs.getFrom(), show='chat'))
         else:
             self.users.update_availability(prs.getFrom().getStripped(), False)
             if prs.getType() is None:
-                con.send(xmpp.Presence(frm = self.jid, to = prs.getFrom()))
+                con.send(Presence(frm=self.jid, to=prs.getFrom()))
             else:
-                con.send(xmpp.Presence(frm = self.jid, to = prs.getFrom(), typ = 'unavailable'))
-
+                con.send(Presence(frm=self.jid, to=prs.getFrom(),
+                                                             typ='unavailable'))
 
     def message_handler(self, con, msg):
-        if msg.getTo().getNode() != '':
+        if msg.getTo().getNode():
             self.muc.message_handler(con, msg)
             return
+
         if not self.init_chat(msg.getFrom()):
-            con.send(xmpp.Message(to = msg.getFrom(), frm = msg.getTo(), body = 'Pas de participant trouvé', typ = msg.getType()))
+            con.send(Message(to=msg.getFrom(), frm=msg.getTo(),
+                             body='Pas de participant trouvé',
+                             typ=msg.getType()))
 
     def init_chat(self, jid):
         other_jid = self.users.get_chat_partner(jid)
-        if other_jid is None:
+
+        if not other_jid:
             return False
-        self.muc.invite_users(jid, xmpp.JID(other_jid))
+
+        self.muc.invite_users(jid, JID(other_jid))
         return True
 
     def send_probes(self):
         for jid in self.users.jid_list():
-            self.con.send(xmpp.Presence(to = jid, frm = self.jid, typ='probe'))
+            self.con.send(Presence(to=jid, frm=self.jid, typ='probe'))