X-Git-Url: https://git.notmuchmail.org/git?p=notmuch;a=blobdiff_plain;f=bindings%2Fpython%2Fnotmuch%2Fdatabase.py;h=0958ce0ad8499f8f699391c356819b2fe14a65a7;hp=c29ca6ee6e99e5b8772b017514c1ec56376294b2;hb=bf6039e34eca52ccf7fe1db51e1b5c843a9828f3;hpb=eb4cd33e6b5406bf69273be52f88a57dad6e8126 diff --git a/bindings/python/notmuch/database.py b/bindings/python/notmuch/database.py index c29ca6ee..0958ce0a 100644 --- a/bindings/python/notmuch/database.py +++ b/bindings/python/notmuch/database.py @@ -18,20 +18,54 @@ Copyright 2010 Sebastian Spaeth ' """ import os -from ctypes import c_int, c_char_p, c_void_p, c_uint, c_long, byref -from notmuch.globals import nmlib, STATUS, NotmuchError, Enum, _str -from notmuch.thread import Threads -from notmuch.message import Messages, Message +import codecs +from ctypes import c_char_p, c_void_p, c_uint, c_long, byref, POINTER +from notmuch.globals import ( + nmlib, + STATUS, + NotmuchError, + NotInitializedError, + Enum, + _str, + NotmuchDatabaseP, + NotmuchDirectoryP, + NotmuchMessageP, + NotmuchTagsP, + NotmuchFilenamesP +) +from notmuch.message import Message from notmuch.tag import Tags +from .query import Query class Database(object): - """Represents a notmuch database (wraps notmuch_database_t) - - .. note:: Do remember that as soon as we tear down this object, - all underlying derived objects such as queries, threads, - messages, tags etc will be freed by the underlying library - as well. Accessing these objects will lead to segfaults and - other unexpected behavior. See above for more details. + """The :class:`Database` is the highest-level object that notmuch + provides. It references a notmuch database, and can be opened in + read-only or read-write mode. A :class:`Query` can be derived from + or be applied to a specific database to find messages. Also adding + and removing messages to the database happens via this + object. Modifications to the database are not atmic by default (see + :meth:`begin_atomic`) and once a database has been modified, all + other database objects pointing to the same data-base will throw an + :exc:`XapianError` as the underlying database has been + modified. Close and reopen the database to continue working with it. + + :class:`Database` objects implement the context manager protocol + so you can use the :keyword:`with` statement to ensure that the + database is properly closed. + + .. note:: + + Any function in this class can and will throw an + :exc:`NotInitializedError` if the database was not intitialized + properly. + + .. note:: + + Do remember that as soon as we tear down (e.g. via `del db`) this + object, all underlying derived objects such as queries, threads, + messages, tags etc will be freed by the underlying library as well. + Accessing these objects will lead to segfaults and other unexpected + behavior. See above for more details. """ _std_db_path = None """Class attribute to cache user's default database""" @@ -41,39 +75,50 @@ class Database(object): """notmuch_database_get_directory""" _get_directory = nmlib.notmuch_database_get_directory - _get_directory.restype = c_void_p + _get_directory.argtypes = [NotmuchDatabaseP, c_char_p] + _get_directory.restype = NotmuchDirectoryP """notmuch_database_get_path""" _get_path = nmlib.notmuch_database_get_path + _get_path.argtypes = [NotmuchDatabaseP] _get_path.restype = c_char_p """notmuch_database_get_version""" _get_version = nmlib.notmuch_database_get_version + _get_version.argtypes = [NotmuchDatabaseP] _get_version.restype = c_uint """notmuch_database_open""" _open = nmlib.notmuch_database_open - _open.restype = c_void_p + _open.argtypes = [c_char_p, c_uint] + _open.restype = NotmuchDatabaseP """notmuch_database_upgrade""" _upgrade = nmlib.notmuch_database_upgrade - _upgrade.argtypes = [c_void_p, c_void_p, c_void_p] + _upgrade.argtypes = [NotmuchDatabaseP, c_void_p, c_void_p] + _upgrade.restype = c_uint """ notmuch_database_find_message""" _find_message = nmlib.notmuch_database_find_message - _find_message.restype = c_void_p + _find_message.argtypes = [NotmuchDatabaseP, c_char_p, + POINTER(NotmuchMessageP)] + _find_message.restype = c_uint """notmuch_database_find_message_by_filename""" _find_message_by_filename = nmlib.notmuch_database_find_message_by_filename - _find_message_by_filename.restype = c_void_p + _find_message_by_filename.argtypes = [NotmuchDatabaseP, c_char_p, + POINTER(NotmuchMessageP)] + _find_message_by_filename.restype = c_uint """notmuch_database_get_all_tags""" _get_all_tags = nmlib.notmuch_database_get_all_tags - _get_all_tags.restype = c_void_p + _get_all_tags.argtypes = [NotmuchDatabaseP] + _get_all_tags.restype = NotmuchTagsP """notmuch_database_create""" _create = nmlib.notmuch_database_create - _create.restype = c_void_p + _create.argtypes = [c_char_p] + _create.restype = NotmuchDatabaseP def __init__(self, path=None, create=False, mode=0): """If *path* is `None`, we will try to read a users notmuch @@ -93,8 +138,8 @@ class Database(object): :param mode: Mode to open a database in. Is always :attr:`MODE`.READ_WRITE when creating a new one. :type mode: :attr:`MODE` - :returns: Nothing - :exception: :exc:`NotmuchError` in case of failure. + :exception: :exc:`NotmuchError` or derived exception in case of + failure. """ self._db = None if path is None: @@ -109,10 +154,13 @@ class Database(object): else: self.create(path) + def __del__(self): + self.close() + def _assert_db_is_initialized(self): - """Raises a NotmuchError in case self._db is still None""" + """Raises :exc:`NotInitializedError` if self._db is `None`""" if self._db is None: - raise NotmuchError(STATUS.NOT_INITIALIZED) + raise NotInitializedError() def create(self, path): """Creates a new notmuch database @@ -128,7 +176,7 @@ class Database(object): :type path: str :returns: Nothing :exception: :exc:`NotmuchError` in case of any failure - (after printing an error message on stderr). + (possibly after printing an error message on stderr). """ if self._db is not None: raise NotmuchError(message="Cannot create db, this Database() " @@ -136,7 +184,7 @@ class Database(object): res = Database._create(_str(path), Database.MODE.READ_WRITE) - if res is None: + if not res: raise NotmuchError( message="Could not create the specified database") self._db = res @@ -151,20 +199,39 @@ class Database(object): :param status: Open the database in read-only or read-write mode :type status: :attr:`MODE` :returns: Nothing - :exception: Raises :exc:`NotmuchError` in case - of any failure (after printing an error message on stderr). + :exception: Raises :exc:`NotmuchError` in case of any failure + (possibly after printing an error message on stderr). """ res = Database._open(_str(path), mode) - if res is None: - raise NotmuchError( - message="Could not open the specified database") + if not res: + raise NotmuchError(message="Could not open the specified database") self._db = res - def get_path(self): - """Returns the file path of an open database + _close = nmlib.notmuch_database_close + _close.argtypes = [NotmuchDatabaseP] + _close.restype = None + + def close(self): + """Close and free the notmuch database if needed""" + if self._db is not None: + self._close(self._db) + self._db = None + + def __enter__(self): + ''' + Implements the context manager protocol. + ''' + return self - .. ..:: Wraps underlying `notmuch_database_get_path`""" + def __exit__(self, exc_type, exc_value, traceback): + ''' + Implements the context manager protocol. + ''' + self.close() + + def get_path(self): + """Returns the file path of an open database""" self._assert_db_is_initialized() return Database._get_path(self._db).decode('utf-8') @@ -172,12 +239,14 @@ class Database(object): """Returns the database format version :returns: The database version as positive integer - :exception: :exc:`NotmuchError` with :attr:`STATUS`.NOT_INITIALIZED if - the database was not intitialized. """ self._assert_db_is_initialized() return Database._get_version(self._db) + _needs_upgrade = nmlib.notmuch_database_needs_upgrade + _needs_upgrade.argtypes = [NotmuchDatabaseP] + _needs_upgrade.restype = bool + def needs_upgrade(self): """Does this database need to be upgraded before writing to it? @@ -187,11 +256,9 @@ class Database(object): etc.) will work unless :meth:`upgrade` is called successfully first. :returns: `True` or `False` - :exception: :exc:`NotmuchError` with :attr:`STATUS`.NOT_INITIALIZED if - the database was not intitialized. """ self._assert_db_is_initialized() - return nmlib.notmuch_database_needs_upgrade(self._db) + return self._needs_upgrade(self._db) def upgrade(self): """Upgrades the current database @@ -213,6 +280,10 @@ class Database(object): #TODO: catch exceptions, document return values and etc return status + _begin_atomic = nmlib.notmuch_database_begin_atomic + _begin_atomic.argtypes = [NotmuchDatabaseP] + _begin_atomic.restype = c_uint + def begin_atomic(self): """Begin an atomic database operation @@ -223,17 +294,20 @@ class Database(object): neither begin nor end necessarily flush modifications to disk. :returns: :attr:`STATUS`.SUCCESS or raises + :exception: :exc:`NotmuchError`: :attr:`STATUS`.XAPIAN_EXCEPTION + Xapian exception occurred; atomic section not entered. - :exception: :exc:`NotmuchError` :attr:`STATUS`.XAPIAN_EXCEPTION:: - - A Xapian exception occurred; atomic section not - entered.""" + *Added in notmuch 0.9*""" self._assert_db_is_initialized() - status = nmlib.notmuch_database_begin_atomic(self._db) + status = self._begin_atomic(self._db) if status != STATUS.SUCCESS: raise NotmuchError(status) return status + _end_atomic = nmlib.notmuch_database_end_atomic + _end_atomic.argtypes = [NotmuchDatabaseP] + _end_atomic.restype = c_uint + def end_atomic(self): """Indicate the end of an atomic database operation @@ -247,9 +321,11 @@ class Database(object): A Xapian exception occurred; atomic section not ended. :attr:`STATUS`.UNBALANCED_ATOMIC: - end_atomic has been called more times than begin_atomic.""" + end_atomic has been called more times than begin_atomic. + + *Added in notmuch 0.9*""" self._assert_db_is_initialized() - status = nmlib.notmuch_database_end_atomic(self._db) + status = self._end_atomic(self._db) if status != STATUS.SUCCESS: raise NotmuchError(status) return status @@ -258,23 +334,20 @@ class Database(object): """Returns a :class:`Directory` of path, (creating it if it does not exist(?)) - .. warning:: This call needs a writeable database in - :attr:`Database.MODE`.READ_WRITE mode. The underlying library will exit the - program if this method is used on a read-only database! + .. warning:: + + This call needs a writeable database in + :attr:`Database.MODE`.READ_WRITE mode. The underlying library will + exit the program if this method is used on a read-only database! :param path: An unicode string containing the path relative to the path - of database (see :meth:`get_path`), or else should be an absolute path - with initial components that match the path of 'database'. + of database (see :meth:`get_path`), or else should be an absolute + path with initial components that match the path of 'database'. :returns: :class:`Directory` or raises an exception. - :exception: :exc:`NotmuchError` - - :attr:`STATUS`.NOT_INITIALIZED - If the database was not intitialized. - - :attr:`STATUS`.FILE_ERROR + :exception: + :exc:`NotmuchError` with :attr:`STATUS`.FILE_ERROR If path is not relative database or absolute with initial components same as database. - """ self._assert_db_is_initialized() # sanity checking if path is valid, and make path absolute @@ -295,6 +368,11 @@ class Database(object): # return the Directory, init it with the absolute path return Directory(_str(abs_dirpath), dir_p, self) + _add_message = nmlib.notmuch_database_add_message + _add_message.argtypes = [NotmuchDatabaseP, c_char_p, + POINTER(NotmuchMessageP)] + _add_message.restype = c_uint + def add_message(self, filename, sync_maildir_flags=False): """Adds a new message to the database @@ -343,14 +421,10 @@ class Database(object): :attr:`STATUS`.READ_ONLY_DATABASE Database was opened in read-only mode so no message can be added. - :attr:`STATUS`.NOT_INITIALIZED - The database has not been initialized. """ self._assert_db_is_initialized() - msg_p = c_void_p() - status = nmlib.notmuch_database_add_message(self._db, - _str(filename), - byref(msg_p)) + msg_p = NotmuchMessageP() + status = self._add_message(self._db, _str(filename), byref(msg_p)) if not status in [STATUS.SUCCESS, STATUS.DUPLICATE_MESSAGE_ID]: raise NotmuchError(status) @@ -362,6 +436,10 @@ class Database(object): msg.maildir_flags_to_tags() return (msg, status) + _remove_message = nmlib.notmuch_database_remove_message + _remove_message.argtypes = [NotmuchDatabaseP, c_char_p] + _remove_message.restype = c_uint + def remove_message(self, filename): """Removes a message (filename) from the given notmuch database @@ -388,12 +466,9 @@ class Database(object): :attr:`STATUS`.READ_ONLY_DATABASE Database was opened in read-only mode so no message can be removed. - :attr:`STATUS`.NOT_INITIALIZED - The database has not been initialized. """ self._assert_db_is_initialized() - return nmlib.notmuch_database_remove_message(self._db, - filename) + return self._remove_message(self._db, _str(filename)) def find_message(self, msgid): """Returns a :class:`Message` as identified by its message ID @@ -401,46 +476,68 @@ class Database(object): Wraps the underlying *notmuch_database_find_message* function. :param msgid: The message ID - :type msgid: string - :returns: :class:`Message` or `None` if no message is found or - if any xapian exception or out-of-memory situation - occurs. Do note that Xapian Exceptions include - "Database modified" situations, e.g. when the - notmuch database has been modified by - another program in the meantime. A return value of - `None` is therefore no guarantee that the message - does not exist. - :exception: :exc:`NotmuchError` with :attr:`STATUS`.NOT_INITIALIZED if - the database was not intitialized. + :type msgid: unicode or str + :returns: :class:`Message` or `None` if no message is found. + :exception: + :exc:`OutOfMemoryError` + If an Out-of-memory occured while constructing the message. + :exc:`XapianError` + In case of a Xapian Exception. These exceptions + include "Database modified" situations, e.g. when the + notmuch database has been modified by another program + in the meantime. In this case, you should close and + reopen the database and retry. + :exc:`NotInitializedError` if + the database was not intitialized. """ self._assert_db_is_initialized() - msg_p = Database._find_message(self._db, _str(msgid)) + msg_p = NotmuchMessageP() + status = Database._find_message(self._db, _str(msgid), byref(msg_p)) + if status != STATUS.SUCCESS: + raise NotmuchError(status) return msg_p and Message(msg_p, self) or None def find_message_by_filename(self, filename): """Find a message with the given filename - .. warning:: This call needs a writeable database in - :attr:`Database.MODE`.READ_WRITE mode. The underlying library will - exit the program if this method is used on a read-only - database! + .. warning:: + + This call needs a writeable database in + :attr:`Database.MODE`.READ_WRITE mode. The underlying library will + exit the program if this method is used on a read-only database! :returns: If the database contains a message with the given filename, then a class:`Message:` is returned. This - function returns None in the following situations: + function returns None if no message is found with the given + filename. + + :exception: + :exc:`OutOfMemoryError` + If an Out-of-memory occured while constructing the message. + :exc:`XapianError` + In case of a Xapian Exception. These exceptions + include "Database modified" situations, e.g. when the + notmuch database has been modified by another program + in the meantime. In this case, you should close and + reopen the database and retry. + :exc:`NotInitializedError` if + the database was not intitialized. - * No message is found with the given filename - * An out-of-memory situation occurs - * A Xapian exception occurs""" + *Added in notmuch 0.9*""" self._assert_db_is_initialized() - msg_p = Database._find_message_by_filename(self._db, _str(filename)) + msg_p = NotmuchMessageP() + status = Database._find_message_by_filename(self._db, _str(filename), + byref(msg_p)) + if status != STATUS.SUCCESS: + raise NotmuchError(status) return msg_p and Message(msg_p, self) or None def get_all_tags(self): """Returns :class:`Tags` with a list of all tags found in the database :returns: :class:`Tags` - :execption: :exc:`NotmuchError` with :attr:`STATUS`.NULL_POINTER on error + :execption: :exc:`NotmuchError` with :attr:`STATUS`.NULL_POINTER + on error """ self._assert_db_is_initialized() tags_p = Database._get_all_tags(self._db) @@ -466,30 +563,30 @@ class Database(object): This function is a python extension and not in the underlying C API. """ - self._assert_db_is_initialized() return Query(self, querystring) def __repr__(self): return "'Notmuch DB " + self.get_path() + "'" - def __del__(self): - """Close and free the notmuch database if needed""" - if self._db is not None: - nmlib.notmuch_database_close(self._db) - def _get_user_default_db(self): """ Reads a user's notmuch config and returns his db location Throws a NotmuchError if it cannot find it""" - from ConfigParser import SafeConfigParser + try: + # python3.x + from configparser import SafeConfigParser + except ImportError: + # python2.x + from ConfigParser import SafeConfigParser + config = SafeConfigParser() conf_f = os.getenv('NOTMUCH_CONFIG', os.path.expanduser('~/.notmuch-config')) - config.read(conf_f) + config.readfp(codecs.open(conf_f, 'r', 'utf-8')) if not config.has_option('database', 'path'): raise NotmuchError(message="No DB path specified" " and no user default found") - return config.get('database', 'path').decode('utf-8') + return config.get('database', 'path') @property def db_p(self): @@ -501,178 +598,6 @@ class Database(object): return self._db -class Query(object): - """Represents a search query on an opened :class:`Database`. - - A query selects and filters a subset of messages from the notmuch - database we derive from. - - Query() provides an instance attribute :attr:`sort`, which - contains the sort order (if specified via :meth:`set_sort`) or - `None`. - - Technically, it wraps the underlying *notmuch_query_t* struct. - - .. note:: Do remember that as soon as we tear down this object, - all underlying derived objects such as threads, - messages, tags etc will be freed by the underlying library - as well. Accessing these objects will lead to segfaults and - other unexpected behavior. See above for more details. - """ - # constants - SORT = Enum(['OLDEST_FIRST', 'NEWEST_FIRST', 'MESSAGE_ID', 'UNSORTED']) - """Constants: Sort order in which to return results""" - - """notmuch_query_create""" - _create = nmlib.notmuch_query_create - _create.restype = c_void_p - - """notmuch_query_search_threads""" - _search_threads = nmlib.notmuch_query_search_threads - _search_threads.restype = c_void_p - - """notmuch_query_search_messages""" - _search_messages = nmlib.notmuch_query_search_messages - _search_messages.restype = c_void_p - - """notmuch_query_count_messages""" - _count_messages = nmlib.notmuch_query_count_messages - _count_messages.restype = c_uint - - def __init__(self, db, querystr): - """ - :param db: An open database which we derive the Query from. - :type db: :class:`Database` - :param querystr: The query string for the message. - :type querystr: utf-8 encoded str or unicode - """ - self._db = None - self._query = None - self.sort = None - self.create(db, querystr) - - def create(self, db, querystr): - """Creates a new query derived from a Database - - This function is utilized by __init__() and usually does not need to - be called directly. - - :param db: Database to create the query from. - :type db: :class:`Database` - :param querystr: The query string - :type querystr: utf-8 encoded str or unicode - :returns: Nothing - :exception: :exc:`NotmuchError` - - * :attr:`STATUS`.NOT_INITIALIZED if db is not inited - * :attr:`STATUS`.NULL_POINTER if the query creation failed - (too little memory) - """ - if db.db_p is None: - raise NotmuchError(STATUS.NOT_INITIALIZED) - # create reference to parent db to keep it alive - self._db = db - # create query, return None if too little mem available - query_p = Query._create(db.db_p, _str(querystr)) - if query_p is None: - raise NotmuchError(STATUS.NULL_POINTER) - self._query = query_p - - def set_sort(self, sort): - """Set the sort order future results will be delivered in - - Wraps the underlying *notmuch_query_set_sort* function. - - :param sort: Sort order (see :attr:`Query.SORT`) - :returns: Nothing - :exception: :exc:`NotmuchError` :attr:`STATUS`.NOT_INITIALIZED if query has not - been initialized. - """ - if self._query is None: - raise NotmuchError(STATUS.NOT_INITIALIZED) - - self.sort = sort - nmlib.notmuch_query_set_sort(self._query, sort) - - def search_threads(self): - """Execute a query for threads - - Execute a query for threads, returning a :class:`Threads` iterator. - The returned threads are owned by the query and as such, will only be - valid until the Query is deleted. - - The method sets :attr:`Message.FLAG`\.MATCH for those messages that - match the query. The method :meth:`Message.get_flag` allows us - to get the value of this flag. - - Technically, it wraps the underlying - *notmuch_query_search_threads* function. - - :returns: :class:`Threads` - :exception: :exc:`NotmuchError` - - * :attr:`STATUS`.NOT_INITIALIZED if query is not inited - * :attr:`STATUS`.NULL_POINTER if search_threads failed - """ - if self._query is None: - raise NotmuchError(STATUS.NOT_INITIALIZED) - - threads_p = Query._search_threads(self._query) - - if threads_p is None: - raise NotmuchError(STATUS.NULL_POINTER) - - return Threads(threads_p, self) - - def search_messages(self): - """Filter messages according to the query and return - :class:`Messages` in the defined sort order - - Technically, it wraps the underlying - *notmuch_query_search_messages* function. - - :returns: :class:`Messages` - :exception: :exc:`NotmuchError` - - * :attr:`STATUS`.NOT_INITIALIZED if query is not inited - * :attr:`STATUS`.NULL_POINTER if search_messages failed - """ - if self._query is None: - raise NotmuchError(STATUS.NOT_INITIALIZED) - - msgs_p = Query._search_messages(self._query) - - if msgs_p is None: - raise NotmuchError(STATUS.NULL_POINTER) - - return Messages(msgs_p, self) - - def count_messages(self): - """Estimate the number of messages matching the query - - This function performs a search and returns Xapian's best - guess as to the number of matching messages. It is much faster - than performing :meth:`search_messages` and counting the - result with `len()` (although it always returned the same - result in my tests). Technically, it wraps the underlying - *notmuch_query_count_messages* function. - - :returns: :class:`Messages` - :exception: :exc:`NotmuchError` - - * :attr:`STATUS`.NOT_INITIALIZED if query is not inited - """ - if self._query is None: - raise NotmuchError(STATUS.NOT_INITIALIZED) - - return Query._count_messages(self._query) - - def __del__(self): - """Close and free the Query""" - if self._query is not None: - nmlib.notmuch_query_destroy(self._query) - - class Directory(object): """Represents a directory entry in the notmuch directory @@ -689,23 +614,28 @@ class Directory(object): """notmuch_directory_get_mtime""" _get_mtime = nmlib.notmuch_directory_get_mtime + _get_mtime.argtypes = [NotmuchDirectoryP] _get_mtime.restype = c_long """notmuch_directory_set_mtime""" _set_mtime = nmlib.notmuch_directory_set_mtime - _set_mtime.argtypes = [c_char_p, c_long] + _set_mtime.argtypes = [NotmuchDirectoryP, c_long] + _set_mtime.restype = c_uint """notmuch_directory_get_child_files""" _get_child_files = nmlib.notmuch_directory_get_child_files - _get_child_files.restype = c_void_p + _get_child_files.argtypes = [NotmuchDirectoryP] + _get_child_files.restype = NotmuchFilenamesP """notmuch_directory_get_child_directories""" _get_child_directories = nmlib.notmuch_directory_get_child_directories - _get_child_directories.restype = c_void_p + _get_child_directories.argtypes = [NotmuchDirectoryP] + _get_child_directories.restype = NotmuchFilenamesP def _assert_dir_is_initialized(self): - """Raises a NotmuchError(:attr:`STATUS`.NOT_INITIALIZED) if dir_p is None""" - if self._dir_p is None: + """Raises a NotmuchError(:attr:`STATUS`.NOT_INITIALIZED) + if dir_p is None""" + if not self._dir_p: raise NotmuchError(STATUS.NOT_INITIALIZED) def __init__(self, path, dir_p, parent): @@ -741,10 +671,12 @@ class Directory(object): and know that it only needs to add files if the mtime of the directory and files are newer than the stored timestamp. - .. note:: :meth:`get_mtime` function does not allow the caller - to distinguish a timestamp of 0 from a non-existent - timestamp. So don't store a timestamp of 0 unless you are - comfortable with that. + .. note:: + + :meth:`get_mtime` function does not allow the caller to + distinguish a timestamp of 0 from a non-existent timestamp. So + don't store a timestamp of 0 unless you are comfortable with + that. :param mtime: A (time_t) timestamp :returns: Nothing on success, raising an exception on failure. @@ -821,10 +753,14 @@ class Directory(object): """Object representation""" return "" % self._path + _destroy = nmlib.notmuch_directory_destroy + _destroy.argtypes = [NotmuchDirectoryP] + _destroy.argtypes = None + def __del__(self): """Close and free the Directory""" if self._dir_p is not None: - nmlib.notmuch_directory_destroy(self._dir_p) + self._destroy(self._dir_p) class Filenames(object): @@ -832,6 +768,7 @@ class Filenames(object): #notmuch_filenames_get _get = nmlib.notmuch_filenames_get + _get.argtypes = [NotmuchFilenamesP] _get.restype = c_char_p def __init__(self, files_p, parent): @@ -850,41 +787,57 @@ class Filenames(object): """ Make Filenames an iterator """ return self - def next(self): - if self._files_p is None: + _valid = nmlib.notmuch_filenames_valid + _valid.argtypes = [NotmuchFilenamesP] + _valid.restype = bool + + _move_to_next = nmlib.notmuch_filenames_move_to_next + _move_to_next.argtypes = [NotmuchFilenamesP] + _move_to_next.restype = None + + def __next__(self): + if not self._files_p: raise NotmuchError(STATUS.NOT_INITIALIZED) - if not nmlib.notmuch_filenames_valid(self._files_p): + if not self._valid(self._files_p): self._files_p = None raise StopIteration - file = Filenames._get(self._files_p) - nmlib.notmuch_filenames_move_to_next(self._files_p) - return file + file_ = Filenames._get(self._files_p) + self._move_to_next(self._files_p) + return file_.decode('utf-8', 'ignore') + next = __next__ # python2.x iterator protocol compatibility def __len__(self): """len(:class:`Filenames`) returns the number of contained files - .. note:: As this iterates over the files, we will not be able to - iterate over them again! So this will fail:: + .. note:: + + As this iterates over the files, we will not be able to + iterate over them again! So this will fail:: #THIS FAILS files = Database().get_directory('').get_child_files() - if len(files) > 0: #this 'exhausts' msgs - # next line raises NotmuchError(:attr:`STATUS`.NOT_INITIALIZED)!!! + if len(files) > 0: # this 'exhausts' msgs + # next line raises + # NotmuchError(:attr:`STATUS`.NOT_INITIALIZED) for file in files: print file """ - if self._files_p is None: + if not self._files_p: raise NotmuchError(STATUS.NOT_INITIALIZED) i = 0 - while nmlib.notmuch_filenames_valid(self._files_p): - nmlib.notmuch_filenames_move_to_next(self._files_p) + while self._valid(self._files_p): + self._move_to_next(self._files_p) i += 1 self._files_p = None return i + _destroy = nmlib.notmuch_filenames_destroy + _destroy.argtypes = [NotmuchFilenamesP] + _destroy.restype = None + def __del__(self): """Close and free Filenames""" if self._files_p is not None: - nmlib.notmuch_filenames_destroy(self._files_p) + self._destroy(self._files_p)