class Conversation(JSONSerializable, SimpleObservable):
_json_attrs = ["id", "name", "topic", "messages", "users", "index"]
def __init__(self, name, connection, users=None):
SimpleObservable.__init__(self)
self.id = str(uuid4())
self.name = name
self.connection = connection
self.users = users or []
self.users = ObservableList(*users)
self.topic = ""
self.messages = ObservableList()
self.index = None
#self.messages.subscribe("add", self.new_message)
#self.messages.subscribe("remove", self.delete_message)
def recv_message(self, message):
message.id = len(self.messages)
self.messages.append(message)
def send_message(self, message):
message.id = len(self.messages)
self.messages.append(message)
self.connection.send_message(message)
def delete_message(self, index, message):
raise Exception("Message deletion not allowed!")
def test_change(self):
# Create an observable dict
observable_list = ObservableList("something", "might", "change")
# Subscribe to change events
subscription = observable_list.subscribe("change", self.callback)
# Change an item in it
observable_list[1] = "will"
# Ensure this triggered the callback
self.assertEqual((1, "will"), self.callback_result)
def test_remove(self):
# Create an observable dict
observable_list = ObservableList("one", "of", "these", "things")
# Subscribe to remove events
subscription = observable_list.subscribe("remove", self.callback)
# Remove an item from it
del observable_list[2]
# Ensure this triggered the callback
self.assertEqual((2, "these"), self.callback_result)
def test_add(self):
# Create an observable list
observable_list = ObservableList()
# Subscribe to add events
subscription = observable_list.subscribe("add", self.callback)
# Add an item to it
observable_list.append("nom")
# Ensure this triggered the callback
self.assertEqual((0, "nom"), self.callback_result)
def test_propagation(self):
class Alerter(SimpleObservable):
def alert(self):
self._notify(None, "alert", "Alert!")
# Create an observable list that contains other observables
observable_list = ObservableList(Alerter(), Alerter())
# Subscribe to all events
subscription = observable_list.subscribe("__all__", self.callback)
# Trigger an alert on something in the list
observable_list[1].alert()
# Ensure this triggered the callback
self.assertEqual(((1, None), "alert", "Alert!"), self.callback_result)
def test_double_propagation(self):
class MiddleMan(SimpleObservable):
def __init__(self):
self.children = ObservableList()
# Create an observable list in an observable in an onbservable list
parent = ObservableList()
# Subscribe to the to-level list
parent.subscribe("__all__", self.callback)
# Add something to it
middle_man = MiddleMan()
parent.append(middle_man)
# Ensure this tells us the item was added at index 0 of the top-level
self.assertEqual((0, "add", middle_man), self.callback_result)
# Add a few things to the inner list
middle_man.children.append("hi!")
middle_man.children.append("hello!")
# Ensure we get told the string was added at parent[0].children[0]
self.assertEqual(((0, "children", 1), "add", "hello!"), self.callback_result)
def __init__(self, name, connection, users=None):
SimpleObservable.__init__(self)
self.id = str(uuid4())
self.name = name
self.connection = connection
self.users = users or []
self.users = ObservableList(*users)
self.topic = ""
self.messages = ObservableList()
self.index = None
def __init__(self):
self.connections = {} #ObservableDict()
self.users = ObservableList()
self.conversations = ObservableList()
self.conversation_lookup = {}
class Session(SimpleObservable, JSONSerializable):
_json_attrs = ["conversations", "users"]
def __init__(self):
self.connections = {} #ObservableDict()
self.users = ObservableList()
self.conversations = ObservableList()
self.conversation_lookup = {}
def conversation_key(self, connection, name):
return "%s@%s" % (name, connection)
def get_conversation(self, connection, name):
return self.conversation_lookup.get(self.conversation_key(connection, name))
def new_conversation(self, connection, name):
conv = Conversation(name, connection, {})
conv.index = len(self.conversations)
self.conversations.append(conv)
self.conversation_lookup[self.conversation_key(connection, name)] = conv
self.last_key = self.conversation_key(connection, name)
return conv
def join_conversation(self, connection, name):
connection.join(name)
def remove_conversation(self, connection, name):
for i in range(len(self.conversations)):
c = self.conversations[i]
print c
if c.name == name and c.connection == connection:
print "DELETED"
del self.conversation_lookup[self.conversation_key(connection, name)]
del self.conversations[i]
break
def leave_conversation(self, connection, name):
print "PART %s" % name
return connection.part([name])
def user_joined_conversation(self, connection, username, chatroom):
self.get_conversation(connection, chatroom).users.append(username)
def user_left_conversation(self, connection, username, chatroom):
try:
self.get_conversation(connection, chatroom).users.remove(username)
except:
print "Failed to remove %s from %s" % (username, self.get_conversation(connection, chatroom))
def recv_message(self, connection, username, message, chatroom=None):
if chatroom:
conv_name = chatroom
else:
conv_name = username
conv = self.get_conversation(connection, conv_name)
if not conv:
conv = self.create_conversation(connection, conv_name)
conv.recv_message(Message(None, username, message, conv))
def conversation_by_id(self, conv_id):
matches = [c for c in self.conversations if c.id == conv_id]
if matches:
return matches[0]
else:
return None
def send_message(self, conversation_id, message):
conv = self.conversation_by_id(conversation_id)
conv.send_message(Message(None, "me", message, conv))
# TODO: Support IRC ['ACTION', 'looks around']
def start(self):
irc = IRCConnection(self, [("irc.freenode.org", 6667)], "python_phone", "python_phone")
self.connections["irc"] = irc
print "Connecting..."
irc.start()
