python: more error handling fixes

[notmuch] / bindings / python / notmuch / thread.py

diff --git a/bindings/python/notmuch/thread.py b/bindings/python/notmuch/thread.py
index 83b4202deb38d4e54371d31be8988e1f582d4625..c2347fe7d856e7cf9f35598c7ebb4439bfae0f74 100644 (file)
--- a/bindings/python/notmuch/thread.py
+++ b/bindings/python/notmuch/thread.py
@@ -17,14 +17,16 @@ along with notmuch.  If not, see <http://www.gnu.org/licenses/>.
 Copyright 2010 Sebastian Spaeth <Sebastian@SSpaeth.de>'
 """
 
 Copyright 2010 Sebastian Spaeth <Sebastian@SSpaeth.de>'
 """
 

-from ctypes import c_char_p, c_void_p, c_long
-from notmuch.globals import nmlib, STATUS, NotmuchError
+from ctypes import c_char_p, c_long, c_int
+from notmuch.globals import (nmlib, STATUS,
+    NotmuchError, NotmuchThreadP, NotmuchThreadsP, NotmuchMessagesP,
+    NotmuchTagsP, Python3StringMixIn)

 from notmuch.message import Messages
 from notmuch.tag import Tags
 from datetime import date
 
 
 from notmuch.message import Messages
 from notmuch.tag import Tags
 from datetime import date
 
 

-class Threads(object):
+class Threads(Python3StringMixIn):

     """Represents a list of notmuch threads
 
     This object provides an iterator over a list of notmuch threads
     """Represents a list of notmuch threads
 
     This object provides an iterator over a list of notmuch threads


@@ -75,7 +77,8 @@ class Threads(object):
 
     #notmuch_threads_get
     _get = nmlib.notmuch_threads_get
 
     #notmuch_threads_get
     _get = nmlib.notmuch_threads_get

-    _get.restype = c_void_p
+    _get.argtypes = [NotmuchThreadsP]
+    _get.restype = NotmuchThreadP

 
     def __init__(self, threads_p, parent=None):
         """
 
     def __init__(self, threads_p, parent=None):
         """


@@ -94,8 +97,8 @@ class Threads(object):
         :TODO: Make the iterator work more than once and cache the tags in
                the Python object.(?)
         """
         :TODO: Make the iterator work more than once and cache the tags in
                the Python object.(?)
         """

-        if threads_p is None:
-            NotmuchError(STATUS.NULL_POINTER)
+        if not threads_p:
+            raise NotmuchError(STATUS.NULL_POINTER)

 
         self._threads = threads_p
         #store parent, so we keep them alive as long as self  is alive
 
         self._threads = threads_p
         #store parent, so we keep them alive as long as self  is alive


@@ -105,17 +108,26 @@ class Threads(object):
         """ Make Threads an iterator """
         return self
 
         """ Make Threads an iterator """
         return self
 

-    def next(self):
-        if self._threads is None:
+    _valid = nmlib.notmuch_threads_valid
+    _valid.argtypes = [NotmuchThreadsP]
+    _valid.restype = bool
+
+    _move_to_next = nmlib.notmuch_threads_move_to_next
+    _move_to_next.argtypes = [NotmuchThreadsP]
+    _move_to_next.restype = None
+
+    def __next__(self):
+        if not self._threads:

             raise NotmuchError(STATUS.NOT_INITIALIZED)
 
             raise NotmuchError(STATUS.NOT_INITIALIZED)
 

-        if not nmlib.notmuch_threads_valid(self._threads):
+        if not self._valid(self._threads):

             self._threads = None
             raise StopIteration
 
         thread = Thread(Threads._get(self._threads), self)
             self._threads = None
             raise StopIteration
 
         thread = Thread(Threads._get(self._threads), self)

-        nmlib.notmuch_threads_move_to_next(self._threads)
+        self._move_to_next(self._threads)

         return thread
         return thread

+    next = __next__ # python2.x iterator protocol compatibility

 
     def __len__(self):
         """len(:class:`Threads`) returns the number of contained Threads
 
     def __len__(self):
         """len(:class:`Threads`) returns the number of contained Threads


@@ -129,13 +141,13 @@ class Threads(object):
                      # next line raises NotmuchError(STATUS.NOT_INITIALIZED)!!!
                      for thread in threads: print thread
         """
                      # next line raises NotmuchError(STATUS.NOT_INITIALIZED)!!!
                      for thread in threads: print thread
         """

-        if self._threads is None:
+        if not self._threads:

             raise NotmuchError(STATUS.NOT_INITIALIZED)
 
         i = 0
         # returns 'bool'. On out-of-memory it returns None
             raise NotmuchError(STATUS.NOT_INITIALIZED)
 
         i = 0
         # returns 'bool'. On out-of-memory it returns None

-        while nmlib.notmuch_threads_valid(self._threads):
-            nmlib.notmuch_threads_move_to_next(self._threads)
+        while self._valid(self._threads):
+            self._move_to_next(self._threads)

             i += 1
         # reset self._threads to mark as "exhausted"
         self._threads = None
             i += 1
         # reset self._threads to mark as "exhausted"
         self._threads = None


@@ -153,12 +165,16 @@ class Threads(object):
            Iterator, False if not. None on a "Out-of-memory" error.
         """
         return self._threads is not None and \
            Iterator, False if not. None on a "Out-of-memory" error.
         """
         return self._threads is not None and \

-            nmlib.notmuch_threads_valid(self._threads) > 0
+            self._valid(self._threads) > 0
+
+    _destroy = nmlib.notmuch_threads_destroy
+    _destroy.argtypes = [NotmuchThreadsP]
+    _destroy.argtypes = None

 
     def __del__(self):
         """Close and free the notmuch Threads"""
         if self._threads is not None:
 
     def __del__(self):
         """Close and free the notmuch Threads"""
         if self._threads is not None:

-            nmlib.notmuch_messages_destroy(self._threads)
+            self._destroy(self._threads)

 
 
 class Thread(object):
 
 
 class Thread(object):


@@ -166,29 +182,36 @@ class Thread(object):
 
     """notmuch_thread_get_thread_id"""
     _get_thread_id = nmlib.notmuch_thread_get_thread_id
 
     """notmuch_thread_get_thread_id"""
     _get_thread_id = nmlib.notmuch_thread_get_thread_id

+    _get_thread_id.argtypes = [NotmuchThreadP]

     _get_thread_id.restype = c_char_p
 
     """notmuch_thread_get_authors"""
     _get_authors = nmlib.notmuch_thread_get_authors
     _get_thread_id.restype = c_char_p
 
     """notmuch_thread_get_authors"""
     _get_authors = nmlib.notmuch_thread_get_authors

+    _get_authors.argtypes = [NotmuchThreadP]

     _get_authors.restype = c_char_p
 
     """notmuch_thread_get_subject"""
     _get_subject = nmlib.notmuch_thread_get_subject
     _get_authors.restype = c_char_p
 
     """notmuch_thread_get_subject"""
     _get_subject = nmlib.notmuch_thread_get_subject

+    _get_subject.argtypes = [NotmuchThreadP]

     _get_subject.restype = c_char_p
 
     """notmuch_thread_get_toplevel_messages"""
     _get_toplevel_messages = nmlib.notmuch_thread_get_toplevel_messages
     _get_subject.restype = c_char_p
 
     """notmuch_thread_get_toplevel_messages"""
     _get_toplevel_messages = nmlib.notmuch_thread_get_toplevel_messages

-    _get_toplevel_messages.restype = c_void_p
+    _get_toplevel_messages.argtypes = [NotmuchThreadP]
+    _get_toplevel_messages.restype = NotmuchMessagesP

 
     _get_newest_date = nmlib.notmuch_thread_get_newest_date
 
     _get_newest_date = nmlib.notmuch_thread_get_newest_date

+    _get_newest_date.argtypes = [NotmuchThreadP]

     _get_newest_date.restype = c_long
 
     _get_oldest_date = nmlib.notmuch_thread_get_oldest_date
     _get_newest_date.restype = c_long
 
     _get_oldest_date = nmlib.notmuch_thread_get_oldest_date

+    _get_oldest_date.argtypes = [NotmuchThreadP]

     _get_oldest_date.restype = c_long
 
     """notmuch_thread_get_tags"""
     _get_tags = nmlib.notmuch_thread_get_tags
     _get_oldest_date.restype = c_long
 
     """notmuch_thread_get_tags"""
     _get_tags = nmlib.notmuch_thread_get_tags

-    _get_tags.restype = c_void_p
+    _get_tags.argtypes = [NotmuchThreadP]
+    _get_tags.restype = NotmuchTagsP

 
     def __init__(self, thread_p, parent=None):
         """
 
     def __init__(self, thread_p, parent=None):
         """


@@ -205,8 +228,8 @@ class Thread(object):
               automatically delete the parent object once all derived
               objects are dead.
         """
               automatically delete the parent object once all derived
               objects are dead.
         """

-        if thread_p is None:
-            NotmuchError(STATUS.NULL_POINTER)
+        if not thread_p:
+            raise NotmuchError(STATUS.NULL_POINTER)

         self._thread = thread_p
         #keep reference to parent, so we keep it alive
         self._parent = parent
         self._thread = thread_p
         #keep reference to parent, so we keep it alive
         self._parent = parent


@@ -221,9 +244,13 @@ class Thread(object):
         :exception: :exc:`NotmuchError` STATUS.NOT_INITIALIZED if the thread
                     is not initialized.
         """
         :exception: :exc:`NotmuchError` STATUS.NOT_INITIALIZED if the thread
                     is not initialized.
         """

-        if self._thread is None:
+        if not self._thread:

             raise NotmuchError(STATUS.NOT_INITIALIZED)
             raise NotmuchError(STATUS.NOT_INITIALIZED)

-        return Thread._get_thread_id(self._thread)
+        return Thread._get_thread_id(self._thread).decode('utf-8', 'ignore')
+
+    _get_total_messages = nmlib.notmuch_thread_get_total_messages
+    _get_total_messages.argtypes = [NotmuchThreadP]
+    _get_total_messages.restype = c_int

 
     def get_total_messages(self):
         """Get the total number of messages in 'thread'
 
     def get_total_messages(self):
         """Get the total number of messages in 'thread'


@@ -234,9 +261,9 @@ class Thread(object):
         :exception: :exc:`NotmuchError` STATUS.NOT_INITIALIZED if the thread
                     is not initialized.
         """
         :exception: :exc:`NotmuchError` STATUS.NOT_INITIALIZED if the thread
                     is not initialized.
         """

-        if self._thread is None:
+        if not self._thread:

             raise NotmuchError(STATUS.NOT_INITIALIZED)
             raise NotmuchError(STATUS.NOT_INITIALIZED)

-        return nmlib.notmuch_thread_get_total_messages(self._thread)
+        return self._get_total_messages(self._thread)

 
     def get_toplevel_messages(self):
         """Returns a :class:`Messages` iterator for the top-level messages in
 
     def get_toplevel_messages(self):
         """Returns a :class:`Messages` iterator for the top-level messages in


@@ -257,16 +284,20 @@ class Thread(object):
                       * STATUS.NOT_INITIALIZED if query is not inited
                       * STATUS.NULL_POINTER if search_messages failed
         """
                       * STATUS.NOT_INITIALIZED if query is not inited
                       * STATUS.NULL_POINTER if search_messages failed
         """

-        if self._thread is None:
+        if not self._thread:

             raise NotmuchError(STATUS.NOT_INITIALIZED)
 
         msgs_p = Thread._get_toplevel_messages(self._thread)
 
             raise NotmuchError(STATUS.NOT_INITIALIZED)
 
         msgs_p = Thread._get_toplevel_messages(self._thread)
 

-        if msgs_p is None:
-            NotmuchError(STATUS.NULL_POINTER)
+        if not msgs_p:
+            raise NotmuchError(STATUS.NULL_POINTER)

 
         return Messages(msgs_p, self)
 
 
         return Messages(msgs_p, self)
 

+    _get_matched_messages = nmlib.notmuch_thread_get_matched_messages
+    _get_matched_messages.argtypes = [NotmuchThreadP]
+    _get_matched_messages.restype = c_int
+

     def get_matched_messages(self):
         """Returns the number of messages in 'thread' that matched the query
 
     def get_matched_messages(self):
         """Returns the number of messages in 'thread' that matched the query
 


@@ -276,9 +307,9 @@ class Thread(object):
         :exception: :exc:`NotmuchError` STATUS.NOT_INITIALIZED if the thread
                     is not initialized.
         """
         :exception: :exc:`NotmuchError` STATUS.NOT_INITIALIZED if the thread
                     is not initialized.
         """

-        if self._thread is None:
+        if not self._thread:

             raise NotmuchError(STATUS.NOT_INITIALIZED)
             raise NotmuchError(STATUS.NOT_INITIALIZED)

-        return nmlib.notmuch_thread_get_matched_messages(self._thread)
+        return self._get_matched_messages(self._thread)

 
     def get_authors(self):
         """Returns the authors of 'thread'
 
     def get_authors(self):
         """Returns the authors of 'thread'


@@ -290,12 +321,12 @@ class Thread(object):
         The returned string belongs to 'thread' and will only be valid for
         as long as this Thread() is not deleted.
         """
         The returned string belongs to 'thread' and will only be valid for
         as long as this Thread() is not deleted.
         """

-        if self._thread is None:
+        if not self._thread:

             raise NotmuchError(STATUS.NOT_INITIALIZED)
         authors = Thread._get_authors(self._thread)
             raise NotmuchError(STATUS.NOT_INITIALIZED)
         authors = Thread._get_authors(self._thread)

-        if authors is None:
+        if not authors:

             return None
             return None

-        return authors.decode('UTF-8')
+        return authors.decode('UTF-8', 'ignore')

 
     def get_subject(self):
         """Returns the Subject of 'thread'
 
     def get_subject(self):
         """Returns the Subject of 'thread'


@@ -303,12 +334,12 @@ class Thread(object):
         The returned string belongs to 'thread' and will only be valid for
         as long as this Thread() is not deleted.
         """
         The returned string belongs to 'thread' and will only be valid for
         as long as this Thread() is not deleted.
         """

-        if self._thread is None:
+        if not self._thread:

             raise NotmuchError(STATUS.NOT_INITIALIZED)
         subject = Thread._get_subject(self._thread)
             raise NotmuchError(STATUS.NOT_INITIALIZED)
         subject = Thread._get_subject(self._thread)

-        if subject is None:
+        if not subject:

             return None
             return None

-        return subject.decode('UTF-8')
+        return subject.decode('UTF-8', 'ignore')

 
     def get_newest_date(self):
         """Returns time_t of the newest message date
 
     def get_newest_date(self):
         """Returns time_t of the newest message date


@@ -318,7 +349,7 @@ class Thread(object):
         :exception: :exc:`NotmuchError` STATUS.NOT_INITIALIZED if the message
                     is not initialized.
         """
         :exception: :exc:`NotmuchError` STATUS.NOT_INITIALIZED if the message
                     is not initialized.
         """

-        if self._thread is None:
+        if not self._thread:

             raise NotmuchError(STATUS.NOT_INITIALIZED)
         return Thread._get_newest_date(self._thread)
 
             raise NotmuchError(STATUS.NOT_INITIALIZED)
         return Thread._get_newest_date(self._thread)
 


@@ -330,7 +361,7 @@ class Thread(object):
         :exception: :exc:`NotmuchError` STATUS.NOT_INITIALIZED if the message
                     is not initialized.
         """
         :exception: :exc:`NotmuchError` STATUS.NOT_INITIALIZED if the message
                     is not initialized.
         """

-        if self._thread is None:
+        if not self._thread:

             raise NotmuchError(STATUS.NOT_INITIALIZED)
         return Thread._get_oldest_date(self._thread)
 
             raise NotmuchError(STATUS.NOT_INITIALIZED)
         return Thread._get_oldest_date(self._thread)
 


@@ -353,7 +384,7 @@ class Thread(object):
                         is not initialized.
                       * STATUS.NULL_POINTER, on error
         """
                         is not initialized.
                       * STATUS.NULL_POINTER, on error
         """

-        if self._thread is None:
+        if not self._thread:

             raise NotmuchError(STATUS.NOT_INITIALIZED)
 
         tags_p = Thread._get_tags(self._thread)
             raise NotmuchError(STATUS.NOT_INITIALIZED)
 
         tags_p = Thread._get_tags(self._thread)


@@ -361,33 +392,23 @@ class Thread(object):
             raise NotmuchError(STATUS.NULL_POINTER)
         return Tags(tags_p, self)
 
             raise NotmuchError(STATUS.NULL_POINTER)
         return Tags(tags_p, self)
 

-    def __str__(self):
-        """A str(Thread()) is represented by a 1-line summary"""
-        thread = {}
-        thread['id'] = self.get_thread_id()
-
-        ###TODO: How do we find out the current sort order of Threads?
-        ###Add a "sort" attribute to the Threads() object?
-        #if (sort == NOTMUCH_SORT_OLDEST_FIRST)
-        #         date = notmuch_thread_get_oldest_date (thread);
-        #else
-        #         date = notmuch_thread_get_newest_date (thread);
-        thread['date'] = date.fromtimestamp(self.get_newest_date())
-        thread['matched'] = self.get_matched_messages()
-        thread['total'] = self.get_total_messages()
-        thread['authors'] = self.get_authors()
-        thread['subject'] = self.get_subject()
-        thread['tags'] = self.get_tags()
-
-        return "thread:%s %12s [%d/%d] %s; %s (%s)" % (thread['id'],
-                                                       thread['date'],
-                                                       thread['matched'],
-                                                       thread['total'],
-                                                       thread['authors'],
-                                                       thread['subject'],
-                                                       thread['tags'])
+    def __unicode__(self):
+        frm = "thread:%s %12s [%d/%d] %s; %s (%s)"
+
+        return frm % (self.get_thread_id(),
+                      date.fromtimestamp(self.get_newest_date()),
+                      self.get_matched_messages(),
+                      self.get_total_messages(),
+                      self.get_authors(),
+                      self.get_subject(),
+                      self.get_tags(),
+                     )
+
+    _destroy = nmlib.notmuch_thread_destroy
+    _destroy.argtypes = [NotmuchThreadP]
+    _destroy.restype = None

 
     def __del__(self):
         """Close and free the notmuch Thread"""
         if self._thread is not None:
 
     def __del__(self):
         """Close and free the notmuch Thread"""
         if self._thread is not None:

-            nmlib.notmuch_thread_destroy(self._thread)
+            self._destroy(self._thread)