Changeset 130:c866b6ef9447

Timestamp:

27/01/10 08:18:56 (2 years ago)

Author:

Menno Smits <menno@…>

Branch:

default

Parents:

126:4319998fc9b5 (diff), 129:b627e75c7088 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merged COPY command implementation (#36)

Files:

• imapclient/imapclient.py (modified) (1 diff)
• imapclient/imapclient.py (modified) (8 diffs)
• imapclient/test/test_FetchParser.py (deleted)
• livetest.py (modified) (6 diffs)
• livetest.py (modified) (3 diffs)

imapclient/imapclient.py

@@ -500 +500 @@
 
 
+    def copy(self, messages, folder):
+        """Copy one or more messages from the current folder to another folder
+
+        @param messages: Message IDs to fetch.
+        @param folder: Folder name to append to.
+        @return: The COPY command response message returned by the
+          server.
+        """
+        msg_list = messages_to_str(messages)
+        folder = self._encode_folder_name(folder)
+
+        if self.use_uid:
+            typ, data = self._imap.uid('COPY', msg_list, folder)
+        else:
+            typ, data = self._imap.copy(msg_list, folder)
+        self._checkok('copy', typ, data)
+        return data[0]
+
+
     def expunge(self):
         typ, data = self._imap.expunge()

imapclient/imapclient.py

@@ -6 +6 @@
 import imaplib
 import shlex
-import datetime
 #imaplib.Debug = 5
 
@@ -15 +14 @@
 __all__ = ['IMAPClient', 'DELETED', 'SEEN', 'ANSWERED', 'FLAGGED', 'DRAFT',
     'RECENT']
+
+from response_parser import parse_response, parse_fetch_response
+
 
 # System flags
@@ -204 +206 @@
 
         @param folder: The folder name.
-        @return: Number of messages in the folder.
-        @rtype: long int
+        @return: A dictionary containing the SELECT response
+          values. At least the EXISTS, FLAGS and RECENT keys are
+          guaranteed to exist. Example:
+            {'EXISTS': 3,
+             'FLAGS': ('\\Answered', '\\Flagged', '\\Deleted', ... ),
+             'RECENT': 0,
+             'PERMANENTFLAGS': ('\\Answered', '\\Flagged', '\\Deleted', ... ),
+             'READ-WRITE': True,
+             'UIDNEXT': 11,
+             'UIDVALIDITY': 1239278212}
         """
         typ, data = self._imap.select(self._encode_folder_name(folder))
         self._checkok('select', typ, data)
-        return long(data[0])
+        return self._process_select_response(self._imap.untagged_responses)
+
+
+    def _process_select_response(self, resp):
+        out = {}
+        for key, value in resp.iteritems():
+            key = key.upper()
+            if key == 'OK':
+                continue
+            elif key in ('EXISTS', 'RECENT', 'UIDNEXT', 'UIDVALIDITY'):
+                value = int(value[0])
+            elif key in ('FLAGS', 'PERMANENTFLAGS'):
+                value = parse_response(value)[0]
+            elif key == 'READ-WRITE':
+                value = True
+                                 
+            out[key] = value
+        return out
 
 
@@ -327 +354 @@
 
         self._checkok('search', typ, data)
+        if data == [None]: # no untagged responses...
+            return []
 
         return [ long(i) for i in data[0].split() ]
@@ -428 +457 @@
 
         if self.use_uid:
-            typ, data = self._imap.uid('FETCH', msg_list, parts_list)
-        else:
-            typ, data = self._imap.fetch(msg_list, parts_list)
+            tag = self._imap._command('UID', 'FETCH', msg_list, parts_list)
+        else:
+            tag = self._imap._command('FETCH', msg_list, parts_list)
+        typ, data = self._imap._command_complete('FETCH', tag)
         self._checkok('fetch', typ, data)
-
-        parser = FetchParser()
-        return parser(data)
+        typ, data = self._imap._untagged_response(typ, data, 'FETCH')
+        # appears to be a special case - no 'untagged' responses (ie, no
+        # folders) results in [None]
+        if data == [None]:
+          return {}
+
+        return parse_fetch_response(data)
 
 
@@ -560 +594 @@
         self._checkok('store', typ, data)
 
-        return self._flatten_dict(FetchParser()(data))
+        return self._flatten_dict(parse_fetch_response((data)))
 
 
@@ -579 +613 @@
             return imap_utf7.encode(name)
         return name
-
-
-class FetchParser(object):
-    """
-    Parse an IMAP FETCH response and convert the return values to useful Python
-    values.
-    """
-
-    def parse(self, response):
-        out = {}
-        for response_item in response:
-            msgid, data = self.parse_data(response_item)
-
-            if msgid != None:
-                # Response for a new message
-                current_msg_data = {}
-                out[msgid] = current_msg_data
-
-            current_msg_data.update(data)
-
-        return out
-
-    __call__ = parse
-
-    def parse_data(self, data):
-        out = {}
-
-        if isinstance(data, str):
-            if data == ')':
-                # End of response for current message
-                return None, {}
-
-        elif isinstance(data, tuple):
-            data, literal_data = data
-
-        else:
-            raise ValueError("don't know how to handle %r" % data)
-
-        data = data.lstrip()
-        msgid = None
-        if data[0].isdigit():
-            # Get message ID
-            msgid, data = data.split(None, 1)
-            msgid = long(msgid)
-
-            assert data.startswith('('), data
-            data = data[1:]
-
-        if data.endswith(')'):
-            data = data[:-1]
-
-        for name, item in FetchTokeniser().process_pairs(data):
-            name = name.upper()
-
-            if name == 'UID':
-                # Using UID's, override the message ID
-                msgid = long(item)
-
-            else:
-                if isinstance(item, Literal):
-                    #assert len(data) == item.length
-                    arg = literal_data
-                else:
-                    arg = item
-
-                # Call handler function based on the response type
-                methname = 'do_'+name.upper().replace('.', '_')
-                meth = getattr(self, methname, self.do_default)
-                out[name] = meth(arg)
-
-        return msgid, out
-
-    def do_INTERNALDATE(self, arg):
-        """Process an INTERNALDATE response
-
-        @param arg: A quoted IMAP INTERNALDATE string
-            (eg. " 9-Feb-2007 17:08:08 +0000")
-        @return: datetime.datetime instance for the given time (in UTC)
-        """
-        arg = 'INTERNALDATE "%s"' % arg
-        mo = imaplib.InternalDate.match(arg)
-        if not mo:
-            raise ValueError("couldn't parse date %r" % arg)
-
-        zoneh = int(mo.group('zoneh'))
-        zonem = (zoneh * 60) + int(mo.group('zonem'))
-        if mo.group('zonen') == '-':
-            zonem = -zonem
-        tz = FixedOffset(zonem)
-
-        year = int(mo.group('year'))
-        mon = imaplib.Mon2num[mo.group('mon')]
-        day = int(mo.group('day'))
-        hour = int(mo.group('hour'))
-        min = int(mo.group('min'))
-        sec = int(mo.group('sec'))
-
-        dt = datetime.datetime(year, mon, day, hour, min, sec, 0, tz)
-
-        # Normalise to host system's timezone
-        return dt.astimezone(FixedOffset.for_system()).replace(tzinfo=None)
-
-
-    def do_default(self, arg):
-        return arg
-
-
-class FetchTokeniser(object):
-    """
-    General response tokenizer and converter
-    """
-
-    QUOTED_STRING = '(?:".*?")'
-    PAREN_LIST = '(?:\(.*?\))'
-
-    PAIR_RE = re.compile((
-        '([\w\.]+(?:\[[^\]]+\]+)?)\s+' +    # name (matches "FOO", "FOO.BAR" & "BODY[SECTION STUFF]")
-        '((?:\d+)' +                        # bare integer
-        '|(?:{\d+?})' +                     # IMAP literal
-        '|' + QUOTED_STRING +
-        '|' + PAREN_LIST +
-        ')\s*'))
-
-    DATA_RE = re.compile((
-        '(' + QUOTED_STRING +
-        '|' + PAREN_LIST +
-        '|(?:\S+)' +            # word
-        ')\s*'))
-
-    def process_pairs(self, s):
-        """Break up and convert a string of FETCH response pairs
-
-        @param s: FETCH response string eg. "FOO 12 BAH (1 abc def "foo bar")"
-        @return: Tokenised and converted input return as (name, data) pairs.
-        """
-        out = []
-        for m in strict_finditer(self.PAIR_RE, s):
-            name, data = m.groups()
-            out.append((name, self.nativefy(data)))
-        return out
-
-    def process_list(self, s):
-        """Break up and convert a string of data items
-
-        @param s: FETCH response string eg. "(1 abc def "foo bar")"
-        @return: A list of converted items.
-        """
-        if s == '':
-            return []
-        out = []
-        for m in strict_finditer(self.DATA_RE, s):
-            out.append(self.nativefy(m.group(1)))
-        return out
-
-    def nativefy(self, s):
-        if s.startswith('"'):
-            return s[1:-1]      # Debracket
-        elif s.startswith('{'):
-            return Literal(long(s[1:-1]))
-        elif s.startswith('('):
-            return self.process_list(s[1:-1])
-        elif s.isdigit():
-            return long(s)
-        elif s.upper() == 'NIL':
-            return None
-        else:
-            return s
-
-
-class Literal(object):
-    """
-    Simple class to represent a literal token in the fetch response
-    (eg. "{21}")
-    """
-
-    def __init__(self, length):
-        self.length = length
-
-    def __eq__(self, other):
-        return self.length == other.length
-
-    def __str__(self):
-        return '{%d}' % self.length
-
-
-def strict_finditer(regex, s):
-    """Like re.finditer except the regex must match from exactly where the
-    previous match ended and all the entire input must be matched.
-    """
-    i = 0
-    matched = False
-    while 1:
-        match = regex.match(s[i:])
-        if match:
-            matched = True
-            i += match.end()
-            yield match
-        else:
-            if (len(s) > 0 and not matched) or i < len(s):
-                raise ValueError("failed to match all of input. "
-                        "%r remains" % s[i:])
-            else:
-                return
 
 
@@ -819 +650 @@
     if not dt.tzinfo:
         dt = dt.replace(tzinfo=FixedOffset.for_system())
-
     return dt.strftime("%d-%b-%Y %H:%M:%S %z")
-    
-
+
+

livetest.py

@@ -12 +12 @@
 
 #TODO: more fetch() testing
+
+SIMPLE_MESSAGE = 'Subject: something\r\n\r\nFoo\r\n'
 
 def test_capabilities(client):
@@ -118 +120 @@
 
         # Add a message to the folder, it should show up now.
-        body = 'Subject: something\r\n\r\nFoo'
-        client.append(new_folder, body)
+        client.append(new_folder, SIMPLE_MESSAGE)
 
         status = client.folder_status(new_folder)
@@ -139 +140 @@
 
     # Append message
-    body = 'Subject: something\r\n\r\nFoo\r\n'
-    resp = client.append('INBOX', body, ('abc', 'def'), msg_time)
+    resp = client.append('INBOX', SIMPLE_MESSAGE, ('abc', 'def'), msg_time)
     assert isinstance(resp, str)
 
@@ -164 +164 @@
 
     # Message body should match
-    assert msginfo['RFC822'] == body
+    assert msginfo['RFC822'] == SIMPLE_MESSAGE
 
 
@@ -220 +220 @@
     assert len(client.search(['NOT DELETED', 'SUBJECT "a"'])) == 1
     assert len(client.search(['NOT DELETED', 'SUBJECT "c"'])) == 0
+
+
+def test_copy(client):
+    clear_folders(client)
+    clear_folder(client, 'INBOX')
+
+    client.select_folder('INBOX')
+    client.append('INBOX', SIMPLE_MESSAGE)
+    client.create_folder('target')
+    msg_id = client.search()[0]
+    
+    client.copy(msg_id, 'target')
+
+    client.select_folder('target')
+    msgs = client.search()
+    assert len(msgs) == 1
+    msg_id = msgs[0]
+    assert 'something' in client.fetch(msg_id, ['RFC822'])[msg_id]['RFC822']
 
 
@@ -245 +263 @@
     test_flags(client)
     test_search(client)
+    test_copy(client)
+
 
 def clear_folder(client, folder):

livetest.py

@@ -39 +39 @@
 
 def test_select_and_close(client):
-    num_msgs = client.select_folder('INBOX')
-    assert isinstance(num_msgs, long)
-    assert num_msgs >= 0
+    resp = client.select_folder('INBOX')
+    assert isinstance(resp['EXISTS'], int)
+    assert resp['EXISTS'] > 1
+    assert isinstance(resp['RECENT'], int)
+    assert isinstance(resp['FLAGS'], tuple)
+    assert len(resp['FLAGS']) > 1
     client.close_folder()
 
@@ -141 +144 @@
 
     # Retrieve the just added message and check that all looks well
-    num_msgs = client.select_folder('INBOX')
-    assert num_msgs == 1
+    assert client.select_folder('INBOX')['EXISTS'] == 1
 
     resp = client.fetch(
@@ -175 +177 @@
 
         assert answer.has_key(msgid)
-        answer_flags = answer[msgid]
+        answer_flags = list(answer[msgid])
 
         # This is required because the order of the returned flags isn't