X-Git-Url: https://git.notmuchmail.org/git?p=notmuch;a=blobdiff_plain;f=bindings%2Fpython%2Fnotmuch%2Fmessage.py;h=28723c10c246c871dcf7fb03d5f534c4d63d4ed8;hp=435a05db3400225fa143c60b9ab9919c9a0f30ac;hb=be851ad39de11f38e1cd4f7f15f1fa952232efe2;hpb=61f0184707db1bc50388ee635506fc5fa45cecc6 diff --git a/bindings/python/notmuch/message.py b/bindings/python/notmuch/message.py index 435a05db..28723c10 100644 --- a/bindings/python/notmuch/message.py +++ b/bindings/python/notmuch/message.py @@ -19,14 +19,15 @@ Copyright 2010 Sebastian Spaeth ' """ -from ctypes import c_char_p, c_void_p, c_long, c_uint, c_int +from ctypes import c_char_p, c_long, c_uint, c_int from datetime import date -from notmuch.globals import nmlib, STATUS, NotmuchError, Enum +from notmuch.globals import ( + nmlib, STATUS, NotmuchError, Enum, _str, Python3StringMixIn, + NotmuchTagsP, NotmuchMessagesP, NotmuchMessageP, NotmuchFilenamesP) from notmuch.tag import Tags from notmuch.filename import Filenames import sys import email -import types try: import simplejson as json except ImportError: @@ -92,10 +93,12 @@ class Messages(object): #notmuch_messages_get _get = nmlib.notmuch_messages_get - _get.restype = c_void_p + _get.argtypes = [NotmuchMessagesP] + _get.restype = NotmuchMessageP _collect_tags = nmlib.notmuch_messages_collect_tags - _collect_tags.restype = c_void_p + _collect_tags.argtypes = [NotmuchMessagesP] + _collect_tags.restype = NotmuchTagsP def __init__(self, msgs_p, parent=None): """ @@ -114,8 +117,8 @@ class Messages(object): :TODO: Make the iterator work more than once and cache the tags in the Python object.(?) """ - if msgs_p is None: - NotmuchError(STATUS.NULL_POINTER) + if not msgs_p: + raise NotmuchError(STATUS.NULL_POINTER) self._msgs = msgs_p #store parent, so we keep them alive as long as self is alive @@ -125,12 +128,14 @@ class Messages(object): """Return the unique :class:`Tags` in the contained messages :returns: :class:`Tags` - :exceptions: :exc:`NotmuchError` STATUS.NOT_INITIALIZED if not inited + :exceptions: :exc:`NotmuchError` STATUS.NOT_INITIALIZED if not init'ed + + .. note:: - .. note:: :meth:`collect_tags` will iterate over the messages and - therefore will not allow further iterations. + :meth:`collect_tags` will iterate over the messages and therefore + will not allow further iterations. """ - if self._msgs is None: + if not self._msgs: raise NotmuchError(STATUS.NOT_INITIALIZED) # collect all tags (returns NULL on error) @@ -146,38 +151,54 @@ class Messages(object): """ Make Messages an iterator """ return self - def next(self): - if self._msgs is None: + _valid = nmlib.notmuch_messages_valid + _valid.argtypes = [NotmuchMessagesP] + _valid.restype = bool + + _move_to_next = nmlib.notmuch_messages_move_to_next + _move_to_next.argtypes = [NotmuchMessagesP] + _move_to_next.restype = None + + def __next__(self): + if not self._msgs: raise NotmuchError(STATUS.NOT_INITIALIZED) - if not nmlib.notmuch_messages_valid(self._msgs): + if not self._valid(self._msgs): self._msgs = None raise StopIteration msg = Message(Messages._get(self._msgs), self) - nmlib.notmuch_messages_move_to_next(self._msgs) + self._move_to_next(self._msgs) return msg + next = __next__ # python2.x iterator protocol compatibility def __nonzero__(self): """ :return: True if there is at least one more thread in the Iterator, False if not.""" return self._msgs is not None and \ - nmlib.notmuch_messages_valid(self._msgs) > 0 + self._valid(self._msgs) > 0 + + _destroy = nmlib.notmuch_messages_destroy + _destroy.argtypes = [NotmuchMessagesP] + _destroy.restype = None def __del__(self): """Close and free the notmuch Messages""" if self._msgs is not None: - nmlib.notmuch_messages_destroy(self._msgs) + self._destroy(self._msgs) - def print_messages(self, format, indent=0, entire_thread=False): - """Outputs messages as needed for 'notmuch show' to sys.stdout + def format_messages(self, format, indent=0, entire_thread=False): + """Formats messages as needed for 'notmuch show'. :param format: A string of either 'text' or 'json'. :param indent: A number indicating the reply depth of these messages. :param entire_thread: A bool, indicating whether we want to output whole threads or only the matching messages. + :return: a list of lines """ + result = list() + if format.lower() == "text": set_start = "" set_end = "" @@ -187,44 +208,65 @@ class Messages(object): set_end = "]" set_sep = ", " else: - raise Exception + raise TypeError("format must be either 'text' or 'json'") first_set = True - sys.stdout.write(set_start) + result.append(set_start) # iterate through all toplevel messages in this thread for msg in self: # if not msg: # break if not first_set: - sys.stdout.write(set_sep) + result.append(set_sep) first_set = False - sys.stdout.write(set_start) + result.append(set_start) match = msg.is_match() next_indent = indent if (match or entire_thread): if format.lower() == "text": - sys.stdout.write(msg.format_message_as_text(indent)) - elif format.lower() == "json": - sys.stdout.write(msg.format_message_as_json(indent)) + result.append(msg.format_message_as_text(indent)) else: - raise NotmuchError + result.append(msg.format_message_as_json(indent)) next_indent = indent + 1 # get replies and print them also out (if there are any) - replies = msg.get_replies() - if not replies is None: - sys.stdout.write(set_sep) - replies.print_messages(format, next_indent, entire_thread) + replies = msg.get_replies().format_messages(format, next_indent, entire_thread) + if replies: + result.append(set_sep) + result.extend(replies) + + result.append(set_end) + result.append(set_end) + + return result - sys.stdout.write(set_end) - sys.stdout.write(set_end) + def print_messages(self, format, indent=0, entire_thread=False, handle=sys.stdout): + """Outputs messages as needed for 'notmuch show' to a file like object. + + :param format: A string of either 'text' or 'json'. + :param handle: A file like object to print to (default is sys.stdout). + :param indent: A number indicating the reply depth of these messages. + :param entire_thread: A bool, indicating whether we want to output + whole threads or only the matching messages. + """ + handle.write(''.join(self.format_messages(format, indent, entire_thread))) -class Message(object): +class EmptyMessagesResult(Messages): + def __init__(self, parent): + self._msgs = None + self._parent = parent + + def __next__(self): + raise StopIteration() + next = __next__ + + +class Message(Python3StringMixIn): """Represents a single Email message Technically, this wraps the underlying *notmuch_message_t* @@ -237,44 +279,60 @@ class Message(object): """notmuch_message_get_filename (notmuch_message_t *message)""" _get_filename = nmlib.notmuch_message_get_filename + _get_filename.argtypes = [NotmuchMessageP] _get_filename.restype = c_char_p """return all filenames for a message""" _get_filenames = nmlib.notmuch_message_get_filenames - _get_filenames.restype = c_void_p + _get_filenames.argtypes = [NotmuchMessageP] + _get_filenames.restype = NotmuchFilenamesP """notmuch_message_get_flag""" _get_flag = nmlib.notmuch_message_get_flag - _get_flag.restype = c_uint + _get_flag.argtypes = [NotmuchMessageP, c_uint] + _get_flag.restype = bool + + """notmuch_message_set_flag""" + _set_flag = nmlib.notmuch_message_set_flag + _set_flag.argtypes = [NotmuchMessageP, c_uint, c_int] + _set_flag.restype = None """notmuch_message_get_message_id (notmuch_message_t *message)""" _get_message_id = nmlib.notmuch_message_get_message_id + _get_message_id.argtypes = [NotmuchMessageP] _get_message_id.restype = c_char_p """notmuch_message_get_thread_id""" _get_thread_id = nmlib.notmuch_message_get_thread_id + _get_thread_id.argtypes = [NotmuchMessageP] _get_thread_id.restype = c_char_p """notmuch_message_get_replies""" _get_replies = nmlib.notmuch_message_get_replies - _get_replies.restype = c_void_p + _get_replies.argtypes = [NotmuchMessageP] + _get_replies.restype = NotmuchMessagesP """notmuch_message_get_tags (notmuch_message_t *message)""" _get_tags = nmlib.notmuch_message_get_tags - _get_tags.restype = c_void_p + _get_tags.argtypes = [NotmuchMessageP] + _get_tags.restype = NotmuchTagsP _get_date = nmlib.notmuch_message_get_date + _get_date.argtypes = [NotmuchMessageP] _get_date.restype = c_long _get_header = nmlib.notmuch_message_get_header + _get_header.argtypes = [NotmuchMessageP, c_char_p] _get_header.restype = c_char_p """notmuch_status_t ..._maildir_flags_to_tags (notmuch_message_t *)""" _tags_to_maildir_flags = nmlib.notmuch_message_tags_to_maildir_flags + _tags_to_maildir_flags.argtypes = [NotmuchMessageP] _tags_to_maildir_flags.restype = c_int """notmuch_status_t ..._tags_to_maildir_flags (notmuch_message_t *)""" _maildir_flags_to_tags = nmlib.notmuch_message_maildir_flags_to_tags + _maildir_flags_to_tags.argtypes = [NotmuchMessageP] _maildir_flags_to_tags.restype = c_int #Constants: Flags that can be set/get with set_flag @@ -291,8 +349,8 @@ class Message(object): automatically delete the parent object once all derived objects are dead. """ - if msg_p is None: - NotmuchError(STATUS.NULL_POINTER) + if not msg_p: + raise NotmuchError(STATUS.NULL_POINTER) self._msg = msg_p #keep reference to parent, so we keep it alive self._parent = parent @@ -304,9 +362,9 @@ class Message(object): :exception: :exc:`NotmuchError` STATUS.NOT_INITIALIZED if the message is not initialized. """ - if self._msg is None: + if not self._msg: raise NotmuchError(STATUS.NOT_INITIALIZED) - return Message._get_message_id(self._msg) + return Message._get_message_id(self._msg).decode('utf-8', 'ignore') def get_thread_id(self): """Returns the thread ID @@ -321,36 +379,36 @@ class Message(object): :exception: :exc:`NotmuchError` STATUS.NOT_INITIALIZED if the message is not initialized. """ - if self._msg is None: + if not self._msg: raise NotmuchError(STATUS.NOT_INITIALIZED) - return Message._get_thread_id(self._msg) + return Message._get_thread_id(self._msg).decode('utf-8', 'ignore') def get_replies(self): """Gets all direct replies to this message as :class:`Messages` iterator - .. note:: This call only makes sense if 'message' was - ultimately obtained from a :class:`Thread` object, (such as - by coming directly from the result of calling - :meth:`Thread.get_toplevel_messages` or by any number of - subsequent calls to :meth:`get_replies`). If this message was - obtained through some non-thread means, (such as by a call - to :meth:`Query.search_messages`), then this function will - return `None`. - - :returns: :class:`Messages` or `None` if there are no replies to - this message. + .. note:: + + This call only makes sense if 'message' was ultimately obtained from + a :class:`Thread` object, (such as by coming directly from the + result of calling :meth:`Thread.get_toplevel_messages` or by any + number of subsequent calls to :meth:`get_replies`). If this message + was obtained through some non-thread means, (such as by a call to + :meth:`Query.search_messages`), then this function will return + an empty Messages iterator. + + :returns: :class:`Messages`. :exception: :exc:`NotmuchError` STATUS.NOT_INITIALIZED if the message is not initialized. """ - if self._msg is None: + if not self._msg: raise NotmuchError(STATUS.NOT_INITIALIZED) msgs_p = Message._get_replies(self._msg) - if msgs_p is None: - return None + if not msgs_p: + return EmptyMessagesResult(self) return Messages(msgs_p, self) @@ -366,36 +424,37 @@ class Message(object): :exception: :exc:`NotmuchError` STATUS.NOT_INITIALIZED if the message is not initialized. """ - if self._msg is None: + if not self._msg: raise NotmuchError(STATUS.NOT_INITIALIZED) return Message._get_date(self._msg) def get_header(self, header): - """Returns a message header + """Get the value of the specified header. - This returns any message header that is stored in the notmuch database. - This is only a selected subset of headers, which is currently: + The value will be read from the actual message file, not from + the notmuch database. The header name is case insensitive. - TODO: add stored headers + Returns an empty string ("") if the message does not contain a + header line matching 'header'. :param header: The name of the header to be retrieved. - It is not case-sensitive (TODO: confirm). + It is not case-sensitive. :type header: str :returns: The header value as string :exception: :exc:`NotmuchError` * STATUS.NOT_INITIALIZED if the message is not initialized. - * STATUS.NULL_POINTER, if no header was found + * STATUS.NULL_POINTER if any error occured. """ - if self._msg is None: + if not self._msg: raise NotmuchError(STATUS.NOT_INITIALIZED) #Returns NULL if any error occurs. - header = Message._get_header(self._msg, header) + header = Message._get_header(self._msg, _str(header)) if header == None: raise NotmuchError(STATUS.NULL_POINTER) - return header + return header.decode('UTF-8', 'ignore') def get_filename(self): """Returns the file path of the message file @@ -404,9 +463,9 @@ class Message(object): :exception: :exc:`NotmuchError` STATUS.NOT_INITIALIZED if the message is not initialized. """ - if self._msg is None: + if not self._msg: raise NotmuchError(STATUS.NOT_INITIALIZED) - return Message._get_filename(self._msg) + return Message._get_filename(self._msg).decode('utf-8', 'ignore') def get_filenames(self): """Get all filenames for the email corresponding to 'message' @@ -414,7 +473,7 @@ class Message(object): Returns a Filenames() generator with all absolute filepaths for messages recorded to have the same Message-ID. These files must not necessarily have identical content.""" - if self._msg is None: + if not self._msg: raise NotmuchError(STATUS.NOT_INITIALIZED) files_p = Message._get_filenames(self._msg) @@ -434,7 +493,7 @@ class Message(object): :exception: :exc:`NotmuchError` STATUS.NOT_INITIALIZED if the message is not initialized. """ - if self._msg is None: + if not self._msg: raise NotmuchError(STATUS.NOT_INITIALIZED) return Message._get_flag(self._msg, flag) @@ -449,9 +508,9 @@ class Message(object): :exception: :exc:`NotmuchError` STATUS.NOT_INITIALIZED if the message is not initialized. """ - if self._msg is None: + if not self._msg: raise NotmuchError(STATUS.NOT_INITIALIZED) - nmlib.notmuch_message_set_flag(self._msg, flag, value) + self._set_flag(self._msg, flag, value) def get_tags(self): """Returns the message tags @@ -463,7 +522,7 @@ class Message(object): is not initialized. * STATUS.NULL_POINTER, on error """ - if self._msg is None: + if not self._msg: raise NotmuchError(STATUS.NOT_INITIALIZED) tags_p = Message._get_tags(self._msg) @@ -471,6 +530,10 @@ class Message(object): raise NotmuchError(STATUS.NULL_POINTER) return Tags(tags_p, self) + _add_tag = nmlib.notmuch_message_add_tag + _add_tag.argtypes = [NotmuchMessageP, c_char_p] + _add_tag.restype = c_uint + def add_tag(self, tag, sync_maildir_flags=False): """Adds a tag to the given message @@ -502,10 +565,10 @@ class Message(object): STATUS.NOT_INITIALIZED The message has not been initialized. """ - if self._msg is None: + if not self._msg: raise NotmuchError(STATUS.NOT_INITIALIZED) - status = nmlib.notmuch_message_add_tag(self._msg, tag) + status = self._add_tag(self._msg, _str(tag)) # bail out on failure if status != STATUS.SUCCESS: @@ -515,6 +578,10 @@ class Message(object): self.tags_to_maildir_flags() return STATUS.SUCCESS + _remove_tag = nmlib.notmuch_message_remove_tag + _remove_tag.argtypes = [NotmuchMessageP, c_char_p] + _remove_tag.restype = c_uint + def remove_tag(self, tag, sync_maildir_flags=False): """Removes a tag from the given message @@ -546,10 +613,10 @@ class Message(object): STATUS.NOT_INITIALIZED The message has not been initialized. """ - if self._msg is None: + if not self._msg: raise NotmuchError(STATUS.NOT_INITIALIZED) - status = nmlib.notmuch_message_remove_tag(self._msg, tag) + status = self._remove_tag(self._msg, _str(tag)) # bail out on error if status != STATUS.SUCCESS: raise NotmuchError(status) @@ -558,6 +625,10 @@ class Message(object): self.tags_to_maildir_flags() return STATUS.SUCCESS + _remove_all_tags = nmlib.notmuch_message_remove_all_tags + _remove_all_tags.argtypes = [NotmuchMessageP] + _remove_all_tags.restype = c_uint + def remove_all_tags(self, sync_maildir_flags=False): """Removes all tags from the given message. @@ -583,10 +654,10 @@ class Message(object): STATUS.NOT_INITIALIZED The message has not been initialized. """ - if self._msg is None: + if not self._msg: raise NotmuchError(STATUS.NOT_INITIALIZED) - status = nmlib.notmuch_message_remove_all_tags(self._msg) + status = self._remove_all_tags(self._msg) # bail out on error if status != STATUS.SUCCESS: @@ -596,12 +667,16 @@ class Message(object): self.tags_to_maildir_flags() return STATUS.SUCCESS + _freeze = nmlib.notmuch_message_freeze + _freeze.argtypes = [NotmuchMessageP] + _freeze.restype = c_uint + def freeze(self): """Freezes the current state of 'message' within the database This means that changes to the message state, (via :meth:`add_tag`, :meth:`remove_tag`, and :meth:`remove_all_tags`), will not be - committed to the database until the message is :meth:`thaw`ed. + committed to the database until the message is :meth:`thaw` ed. Multiple calls to freeze/thaw are valid and these calls will "stack". That is there must be as many calls to thaw as to freeze @@ -637,10 +712,10 @@ class Message(object): STATUS.NOT_INITIALIZED The message has not been initialized. """ - if self._msg is None: + if not self._msg: raise NotmuchError(STATUS.NOT_INITIALIZED) - status = nmlib.notmuch_message_freeze(self._msg) + status = self._freeze(self._msg) if STATUS.SUCCESS == status: # return on success @@ -648,6 +723,10 @@ class Message(object): raise NotmuchError(status) + _thaw = nmlib.notmuch_message_thaw + _thaw.argtypes = [NotmuchMessageP] + _thaw.restype = c_uint + def thaw(self): """Thaws the current 'message' @@ -672,10 +751,10 @@ class Message(object): STATUS.NOT_INITIALIZED The message has not been initialized. """ - if self._msg is None: + if not self._msg: raise NotmuchError(STATUS.NOT_INITIALIZED) - status = nmlib.notmuch_message_thaw(self._msg) + status = self._thaw(self._msg) if STATUS.SUCCESS == status: # return on success @@ -706,11 +785,11 @@ class Message(object): not work yet, as the modified tags have not been committed yet to the database. - :returns: a :class:`STATUS`. In short, you want to see + :returns: a :class:`STATUS` value. In short, you want to see notmuch.STATUS.SUCCESS here. See there for details.""" - if self._msg is None: + if not self._msg: raise NotmuchError(STATUS.NOT_INITIALIZED) - status = Message._tags_to_maildir_flags(self._msg) + return Message._tags_to_maildir_flags(self._msg) def maildir_flags_to_tags(self): """Synchronize file Maildir flags to notmuch tags @@ -735,21 +814,20 @@ class Message(object): :returns: a :class:`STATUS`. In short, you want to see notmuch.STATUS.SUCCESS here. See there for details.""" - if self._msg is None: + if not self._msg: raise NotmuchError(STATUS.NOT_INITIALIZED) - status = Message._tags_to_maildir_flags(self._msg) + return Message._tags_to_maildir_flags(self._msg) def __repr__(self): """Represent a Message() object by str()""" return self.__str__() - def __str__(self): - """A message() is represented by a 1-line summary""" - msg = {} - msg['from'] = self.get_header('from') - msg['tags'] = str(self.get_tags()) - msg['date'] = date.fromtimestamp(self.get_date()) - return "%(from)s (%(date)s) (%(tags)s)" % (msg) + def __unicode__(self): + format = "%s (%s) (%s)" + return format % (self.get_header('from'), + self.get_tags(), + date.fromtimestamp(self.get_date()), + ) def get_message_parts(self): """Output like notmuch show""" @@ -879,7 +957,7 @@ class Message(object): def __hash__(self): """Implement hash(), so we can use Message() sets""" file = self.get_filename() - if file is None: + if not file: return None return hash(file) @@ -897,7 +975,11 @@ class Message(object): res = cmp(list(self.get_filenames()), list(other.get_filenames())) return res + _destroy = nmlib.notmuch_message_destroy + _destroy.argtypes = [NotmuchMessageP] + _destroy.restype = None + def __del__(self): """Close and free the notmuch Message""" if self._msg is not None: - nmlib.notmuch_message_destroy(self._msg) + self._destroy(self._msg)