Changeset 41

Timestamp:

10/22/07 01:55:26 (1 year ago)

Author:

amcgregor

Message:

Rewrite of the AddressList? class and its integration into the Message class.

Location:

branches/3.0/turbomail

Files:

• message.py (modified) (6 diffs)
• util.py (modified) (1 diff)

branches/3.0/turbomail/message.py

@@ -37 +37 @@
         
         def __str__(self):
-                assert self.sender
-                assert self.recipients
-                assert self.message
-                
                 return self.message
 
 
 class Message(object):
-        """Simple e-mail message class.
-        
-        Message provides a means to easily create e-mail messages to be
-        sent through the Dispatch mechanism or MailPool.  Message provides
-        various helper functions to correctly format plain text, dual plain
-        text and rich text MIME encoded messages, as well as handle
-        embedded and external attachments.
-        
-        All properties can be set from the constructor.
-        """
+        """Simple e-mail message class."""
         
         def __init__(self, **kw):
@@ -70 +57 @@
                 self._dirty = False
                 
-                self.date = formatdate(localtime=True)
-                
-                self._sender = AddressList(turbomail.config.get("mail.message.sender", None))
-                self._envelope = AddressList(turbomail.config.get("mail.message.envelope", None))
-                self._reply = AddressList(turbomail.config.get("mail.message.reply", None))
-                self._to = AddressList()
-                self._cc = AddressList(turbomail.config.get("mail.message.cc", None))
-                self._bcc = AddressList(turbomail.config.get("mail.message.bcc", None))
-                self._disposition = AddressList(turbomail.config.get("mail.message.disposition", None))
-                
-                self.organization = turbomail.config.get("mail.message.organization", None)
-                self.encoding = turbomail.config.get("mail.encoding", 'us-ascii')
-                self.priority = turbomail.config.get("mail.message.priority", None)
-                self.subject = None
-                self.plain = None
-                self.rich = None
-                self.attachments = []
-                self.embedded = []
-                self.headers = turbomail.config.get("mail.message.headers", [])
-                self.tries = turbomail.config.get("mail.tries", 3)
-                
-                self._id = None
-                
-                for i, j in kw.iteritems():
-                        assert hasattr(self, i), "Unknown attribute: '%s'" % i
-                        setattr(self, i, j)
+                def configget(name, key, default=None):
+                        pass
+                
+                self.date = kw.get("date", formatdate(localtime=True))
+                
+                self._senders = AddressList(kw.get("sender", turbomail.config.get("mail.message.sender", None)))
+                self._senders = AddressList(kw.get("senders", turbomail.config.get("mail.message.senders", self._senders)))
+                self._envelope = AddressList(kw.get("envelope", turbomail.config.get("mail.message.envelope", None)))
+                self._reply = AddressList(kw.get("reply", turbomail.config.get("mail.message.reply", None)))
+                self._to = AddressList(kw.get("to", None))
+                self._cc = AddressList(kw.get("cc", turbomail.config.get("mail.message.cc", None)))
+                self._bcc = AddressList(kw.get("bcc", turbomail.config.get("mail.message.bcc", None)))
+                self._disposition = AddressList(kw.get("disposition", turbomail.config.get("mail.message.disposition", None)))
+                
+                self.organization = kw.get("organization", turbomail.config.get("mail.message.organization", None))
+                self.encoding = kw.get("encoding", turbomail.config.get("mail.encoding", 'us-ascii'))
+                self.priority = kw.get("priority", turbomail.config.get("mail.message.priority", None))
+                self.subject = kw.get("subject", None)
+                self.plain = kw.get("plain", None)
+                self.rich = kw.get("rich", None)
+                self.attachments = kw.get("attachments", [])
+                self.embedded = kw.get("embedded", [])
+                self.headers = kw.get("headers", turbomail.config.get("mail.message.headers", []))
+                self.tries = kw.get("tries", turbomail.config.get("mail.tries", 3))
+                
+                self._id = kw.get("id", None)
         
         def __setattr__(self, name, value):
@@ -102 +89 @@
                 super(Message, self).__setattr__(name, value)
                 
-                if name not in ('bcc', '_dirty'): self.__dict__['_dirty'] = True
+                if name not in ('bcc', '_dirty', '_processed'): self.__dict__['_dirty'] = True
         
         def __str__(self):
                 return self.mime.as_string()
         
-        sender = property(lambda self: self._sender, lambda self, value: self._sender.replace(value), lambda self: self._sender.replace())
-        envelope = property(lambda self: self._envelope, lambda self, value: self._envelope.replace(value), lambda self: self._envelope.replace())
-        reply = property(lambda self: self._reply, lambda self, value: self._reply.replace(value), lambda self: self._reply.replace())
-        to = property(lambda self: self._to, lambda self, value: self._to.replace(value), lambda self: self._to.replace())
-        cc = property(lambda self: self._cc, lambda self, value: self._cc.replace(value), lambda self: self._cc.replace())
-        bcc = property(lambda self: self._bcc, lambda self, value: self._bcc.replace(value), lambda self: self._bcc.replace())
-        disposition = property(lambda self: self._disposition, lambda self, value: self._disposition.replace(value), lambda self: self._disposition.replace())
-        
-        @property
+        def _get_sender(self):
+                if self._envelope:
+                        return self._envelope.addresses[0]
+                return self._senders.addresses[0]
+        
+        sender = AddressList.protected('_senders')
+        senders = AddressList.protected('_senders')
+        envelope = AddressList.protected('_envelope')
+        reply = AddressList.protected('_reply')
+        to = AddressList.protected('_to')
+        cc = AddressList.protected('_cc')
+        bcc = AddressList.protected('_bcc')
+        disposition = AddressList.protected('_disposition')
+        
         def id(self):
                 if not self._id or (self._processed and self._dirty):
@@ -122 +114 @@
                 
                 return self._id
-        
-        @property
+        id = property(id)
+        
         def recipients(self):
                 return [isinstance(i, tuple) and i[1] or i for i in self.to + self.cc + self.bcc]
-        
-        @property
+        recipients = property(recipients)
+        
         def mime(self):
                 """Produce the final MIME message."""
 
-                assert self.sender, "You must specify a sender."
+                assert self.senders, "You must specify a sender."
                 assert self.subject, "You must specify a subject."
                 assert self.to or self.cc or self.bcc, "You must specify at least one recipient."
@@ -170 +162 @@
 
                 headers = [
-                                ('Sender', self.envelope and self.envelope[0] or AddressList(self.sender[0])), # AddressList
-                                ('From', self.sender), # AddressList
+                                ('Sender', self.sender), # AddressList
+                                ('From', self.senders), # AddressList
                                 ('Reply-To', self.reply), # AddressList
                                 ('Subject', self.subject),
@@ -202 +194 @@
                 
                 return message
+        mime = property(mime)
         
         def attach(self, file, name=None):

branches/3.0/turbomail/util.py

@@ -3 +3 @@
 """MIME-encoded electronic mail message classes."""
 
+import re, turbomail
+from turbomail.exceptions import MailNotEnabledError
 from email.Header import Header
-from email.utils import formataddr
+from email.utils import parseaddr, formataddr
 
-__all__ = ['AddressList']
+__all__ = ['Address', 'AddressList', 'protected', 'send']
+
+
+class Address(object):
+        validator = re.compile(r'^([0-9a-zA-Z]([-.\w]*[0-9a-zA-Z])*(\+([0-9a-zA-Z])+)?@([0-9a-zA-Z][-\w]*[0-9a-zA-Z]\.)+[a-zA-Z]{2,9})$')
+        
+        def __init__(self, *args):
+                assert len(args) < 3 and len(args) > 0, "You must specify an address or a name and address."
+                
+                if len(args) == 1 and isinstance(args[0], basestring):
+                        self.name, self.address = parseaddr(args[0])
+                        
+                elif not isinstance(args[0], basestring):
+                        self.name, self.address = args[0]
+                        
+                else:
+                        self.name, self.address = args
+                
+                if not self.validator.match(self.address):
+                        raise ValueError, 'Invalid e-mail address.'
+                
+                super(Address, self).__init__()
+        
+        def __cmp__(self, other):
+                if isinstance(other, (Address, basestring)):
+                        return cmp(str(self), str(other))
+                elif isinstance(other, tuple):
+                        return cmp((self.name, self.address), other)
+                return cmp(self, other)
+        
+        def __repr__(self):
+                return "Address(\"%s\")" % str(self)
+        
+        def __str__(self):
+                assert self.address, "You must specify an address."
+                
+                return formataddr((self.name, self.address)).replace("\n", "")
+        
 
 
 class AddressList(list):
-        """docstring for AddressList"""
-        
         def __init__(self, addresses=[]):
                 super(AddressList, self).__init__()
-                self.replace(addresses)
+                
+                if isinstance(addresses, (basestring, tuple)):
+                        addresses = [addresses]
+                
+                if addresses is not None:
+                        self.extend(addresses)
         
-        def replace(self, addresses=[]):
-                del self[:]
-                if not addresses: return
-                self.extend(isinstance(addresses, list) and addresses or [addresses])
+        def __repr__(self):
+                if not self: return "AddressList()"
+                return "AddressList(\"" + "\", \"".join([str(i) for i in self]) + "\")"
         
         def __str__(self):
-                addresses = []
+                return ",\n ".join([str(i) for i in self])
+        
+        def __setitem__(self, k, value):
+                if not isinstance(value, Address):
+                        value = Address(value)
                 
-                for address in self:
-                        if type(address) == type(()):
-                                addresses.append(formataddr(address)) # Header(address[0]) was to encode names.  Still nessicary?
-                        else: addresses.append(address)
+                super(AddressList, self).__setitem__(k, value)
+        
+        def extend(self, value):
+                values = []
                 
-                return ",\n ".join(addresses)
+                for i in value:
+                        if not isinstance(i, Address):
+                                i = Address(i)
+                        values.append(i)
+                
+                super(AddressList, self).extend(values)
+        
+        def append(self, value):
+                self.extend([value])
+        
+        def addresses(self):
+                return AddressList([i.address for i in self])
+        
+        addresses = property(addresses)
+        
+        def protected(cls, field):
+                def fget(self):
+                        return getattr(self, field)
+
+                def fset(self, value):
+                        if not isinstance(value, AddressList):
+                                value = AddressList(value)
+
+                        setattr(self, field, AddressList(value))
+
+                def fdel(self):
+                        setattr(self, field, AddressList())
+
+                return property(fget, fset, fdel)
+        
+        protected = classmethod(protected)
+
+
+def send(message):
+        if not turbomail.manager:
+                raise MailNotEnabledError
+        
+        return turbomail.manager.deliver(message)