A small assert because I'm annoyed with leaking states

[theonering] / src / handle.py

diff --git a/src/handle.py b/src/handle.py
index e2c7ae3..9c34ca5 100644 (file)
--- a/src/handle.py
+++ b/src/handle.py
@@ -3,21 +3,10 @@ import weakref
 
 import telepathy
 
+import util.misc as util_misc
 
-_moduleLogger = logging.getLogger("handle")
-
-
-class MetaMemoize(type):
-       """
-       Allows a class to cache off instances for reuse
-       """
 
-       def __call__(cls, connection, *args):
-               obj, newlyCreated = cls.__new__(cls, connection, *args)
-               if newlyCreated:
-                       obj.__init__(connection, connection.get_handle_id(), *args)
-                       _moduleLogger.info("New Handle %r" % obj)
-               return obj
+_moduleLogger = logging.getLogger("handle")
 
 
 class TheOneRingHandle(telepathy.server.Handle):
@@ -25,19 +14,6 @@ class TheOneRingHandle(telepathy.server.Handle):
        Instances are memoized
        """
 
-       __metaclass__ = MetaMemoize
-
-       _instances = weakref.WeakValueDictionary()
-
-       def __new__(cls, connection, *args):
-               key = cls, connection.username, args
-               if key in cls._instances.keys():
-                       return cls._instances[key], False
-               else:
-                       instance = object.__new__(cls, connection, *args)
-                       cls._instances[key] = instance # TRICKY: instances is a weakdict
-                       return instance, True
-
        def __init__(self, connection, id, handleType, name):
                telepathy.server.Handle.__init__(self, id, handleType, name)
                self._conn = weakref.proxy(connection)
@@ -54,8 +30,6 @@ class TheOneRingHandle(telepathy.server.Handle):
 
 class ConnectionHandle(TheOneRingHandle):
 
-       instance = None
-
        def __init__(self, connection, id):
                handleType = telepathy.HANDLE_TYPE_CONTACT
                handleName = connection.username
@@ -64,35 +38,45 @@ class ConnectionHandle(TheOneRingHandle):
                self.profile = connection.username
 
 
-def field_join(fields):
-       """
-       >>> field_join("1", "First Name")
-       '1#First Name'
-       """
-       return "#".join(fields)
+class ContactHandle(TheOneRingHandle):
 
+       def __init__(self, connection, id, contactId, phoneNumber):
+               handleType = telepathy.HANDLE_TYPE_CONTACT
+               handleName = self.to_handle_name(contactId, phoneNumber)
+               TheOneRingHandle.__init__(self, connection, id, handleType, handleName)
 
-def field_split(fields):
-       """
-       >>> field_split('1#First Name')
-       ['1', 'First Name']
-       """
-       return fields.split("#")
+               self._contactId = contactId
+               self._phoneNumber = util_misc.strip_number(phoneNumber)
 
+       @staticmethod
+       def from_handle_name(handleName):
+               parts = handleName.split("#", 1)
+               if len(parts) == 2:
+                       contactId, contactNumber = parts[0:2]
+               elif len(parts) == 1:
+                       contactId, contactNumber = "", handleName
+               else:
+                       raise RuntimeError("Invalid handle: %s" % handleName)
 
-class ContactHandle(TheOneRingHandle):
+               contactNumber = util_misc.strip_number(contactNumber)
+               return contactId, contactNumber
 
-       def __init__(self, connection, id, contactId, contactAccount):
-               handleType = telepathy.HANDLE_TYPE_CONTACT
-               handleName = field_join(contactId, contactAccount)
-               TheOneRingHandle.__init__(self, connection, id, handleType, handleName)
+       @staticmethod
+       def to_handle_name(contactId, contactNumber):
+               handleName = "#".join((contactId, util_misc.strip_number(contactNumber)))
+               return handleName
 
-               self.account = contactAccount
-               self._id = contactId
+       @property
+       def contactID(self):
+               return self._contactId
+
+       @property
+       def phoneNumber(self):
+               return self._phoneNumber
 
        @property
-       def contact(self):
-               return self._conn.gvoice_client.get_contact_details(self._id)
+       def contactDetails(self):
+               return self._conn.addressbook.get_contact_details(self._id)
 
 
 class ListHandle(TheOneRingHandle):
@@ -103,23 +87,35 @@ class ListHandle(TheOneRingHandle):
                TheOneRingHandle.__init__(self, connection, id, handleType, handleName)
 
 
-class GroupHandle(TheOneRingHandle):
-
-       def __init__(self, connection, id, groupName):
-               handleType = telepathy.HANDLE_TYPE_GROUP
-               handleName = groupName
-               TheOneRingHandle.__init__(self, connection, id, handleType, handleName)
-
-
 _HANDLE_TYPE_MAPPING = {
        'connection': ConnectionHandle,
        'contact': ContactHandle,
        'list': ListHandle,
-       'group': GroupHandle,
 }
 
 
-def create_handle(connection, type, *args):
-       handle = _HANDLE_TYPE_MAPPING[type](connection, *args)
-       connection._handles[handle.get_type(), handle.get_id()] = handle
-       return handle
+def create_handle_factory():
+
+       cache = weakref.WeakValueDictionary()
+
+       def create_handle(connection, type, *args):
+               Handle = _HANDLE_TYPE_MAPPING[type]
+               key = Handle, connection.username, args
+               try:
+                       handle = cache[key]
+                       isNewHandle = False
+               except KeyError:
+                       # The misnamed get_handle_id requests a new handle id
+                       handle = Handle(connection, connection.get_handle_id(), *args)
+                       cache[key] = handle
+                       isNewHandle = True
+               connection._handles[handle.get_type(), handle.get_id()] = handle
+               if False:
+                       handleStatus = "Is New!" if isNewHandle else "From Cache"
+                       _moduleLogger.info("Created Handle: %r (%s)" % (handle, handleStatus))
+               return handle
+
+       return create_handle
+
+
+create_handle = create_handle_factory()