for more details.
You should have received a copy of the GNU General Public License
-along with notmuch. If not, see <http://www.gnu.org/licenses/>.
+along with notmuch. If not, see <https://www.gnu.org/licenses/>.
-Copyright 2010 Sebastian Spaeth <Sebastian@SSpaeth.de>'
+Copyright 2010 Sebastian Spaeth <Sebastian@SSpaeth.de>
"""
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, NotInitializedError,
- OutOfMemoryError, XapianError, Enum, _str)
-from notmuch.thread import Threads
-from notmuch.message import Messages, Message
-from notmuch.tag import Tags
+import codecs
+import warnings
+from ctypes import c_char_p, c_void_p, c_uint, byref, POINTER
+from .compat import SafeConfigParser
+from .globals import (
+ nmlib,
+ Enum,
+ _str,
+ NotmuchConfigListP,
+ NotmuchDatabaseP,
+ NotmuchDirectoryP,
+ NotmuchIndexoptsP,
+ NotmuchMessageP,
+ NotmuchTagsP,
+)
+from .errors import (
+ STATUS,
+ FileError,
+ NotmuchError,
+ NullPointerError,
+ NotInitializedError,
+)
+from .message import Message
+from .tag import Tags
+from .query import Query
+from .directory import Directory
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. See :meth:`close` for more
+ information.
+
+ .. note::
+
+ Any function in this class can and will throw an
+ :exc:`NotInitializedError` if the database was not intitialized
+ properly.
"""
_std_db_path = None
"""Class attribute to cache user's default database"""
MODE = Enum(['READ_ONLY', 'READ_WRITE'])
"""Constants: Mode in which to open the database"""
+ DECRYPTION_POLICY = Enum(['FALSE', 'TRUE', 'AUTO', 'NOSTASH'])
+ """Constants: policies for decrypting messages during indexing"""
+
"""notmuch_database_get_directory"""
_get_directory = nmlib.notmuch_database_get_directory
- _get_directory.restype = c_void_p
+ _get_directory.argtypes = [NotmuchDatabaseP, c_char_p, POINTER(NotmuchDirectoryP)]
+ _get_directory.restype = c_uint
"""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_get_revision"""
+ _get_revision = nmlib.notmuch_database_get_revision
+ _get_revision.argtypes = [NotmuchDatabaseP, POINTER(c_char_p)]
+ _get_revision.restype = c_uint
+
"""notmuch_database_open"""
_open = nmlib.notmuch_database_open
- _open.restype = c_void_p
+ _open.argtypes = [c_char_p, c_uint, POINTER(NotmuchDatabaseP)]
+ _open.restype = c_uint
"""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.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.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, POINTER(NotmuchDatabaseP)]
+ _create.restype = c_uint
- def __init__(self, path=None, create=False, mode=0):
+ def __init__(self, path = None, create = False,
+ mode = MODE.READ_ONLY):
"""If *path* is `None`, we will try to read a users notmuch
configuration and use his configured database. The location of the
configuration file can be specified through the environment variable
:param mode: Mode to open a database in. Is always
:attr:`MODE`.READ_WRITE when creating a new one.
:type mode: :attr:`MODE`
- :exception: :exc:`NotmuchError` or derived exception in case of
+ :raises: :exc:`NotmuchError` or derived exception in case of
failure.
"""
self._db = None
+ self.mode = mode
if path is None:
# no path specified. use a user's default database
if Database._std_db_path is None:
else:
self.create(path)
+ _destroy = nmlib.notmuch_database_destroy
+ _destroy.argtypes = [NotmuchDatabaseP]
+ _destroy.restype = c_uint
+
+ def __del__(self):
+ if self._db:
+ status = self._destroy(self._db)
+ if status != STATUS.SUCCESS:
+ raise NotmuchError(status)
+
def _assert_db_is_initialized(self):
"""Raises :exc:`NotInitializedError` if self._db is `None`"""
- if self._db is None:
+ if not self._db:
raise NotInitializedError()
def create(self, path):
:param path: A directory in which we should create the database.
:type path: str
- :returns: Nothing
- :exception: :exc:`NotmuchError` in case of any failure
+ :raises: :exc:`NotmuchError` in case of any failure
(possibly after printing an error message on stderr).
"""
- if self._db is not None:
+ if self._db:
raise NotmuchError(message="Cannot create db, this Database() "
"already has an open one.")
- res = Database._create(_str(path), Database.MODE.READ_WRITE)
+ db = NotmuchDatabaseP()
+ status = Database._create(_str(path), byref(db))
- if res is None:
- raise NotmuchError(
- message="Could not create the specified database")
- self._db = res
+ if status != STATUS.SUCCESS:
+ raise NotmuchError(status)
+ self._db = db
+ return status
def open(self, path, mode=0):
"""Opens an existing database
: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).
+ :raises: Raises :exc:`NotmuchError` in case of any failure
+ (possibly after printing an error message on stderr).
"""
- res = Database._open(_str(path), mode)
+ db = NotmuchDatabaseP()
+ status = Database._open(_str(path), mode, byref(db))
- if res is None:
- raise NotmuchError(message="Could not open the specified database")
- self._db = res
+ if status != STATUS.SUCCESS:
+ raise NotmuchError(status)
+ self._db = db
+ return status
- def get_path(self):
- """Returns the file path of an open database
+ _close = nmlib.notmuch_database_close
+ _close.argtypes = [NotmuchDatabaseP]
+ _close.restype = c_uint
+
+ def close(self):
+ '''
+ Closes the notmuch database.
+
+ .. warning::
+
+ This function closes the notmuch database. From that point
+ on every method invoked on any object ever derived from
+ the closed database may cease to function and raise a
+ NotmuchError.
+ '''
+ if self._db:
+ status = self._close(self._db)
+ if status != STATUS.SUCCESS:
+ raise NotmuchError(status)
+
+ 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')
"""Returns the database format version
:returns: The database version as positive integer
- :exception: :exc:`NotInitializedError` if
- the database was not intitialized.
"""
self._assert_db_is_initialized()
return Database._get_version(self._db)
+ def get_revision (self):
+ """Returns the committed database revison and UUID
+
+ :returns: (revison, uuid) The database revision as a positive integer
+ and the UUID of the database.
+ """
+ self._assert_db_is_initialized()
+ uuid = c_char_p ()
+ revision = Database._get_revision(self._db, byref (uuid))
+ return (revision, uuid.value.decode ('utf-8'))
+
+ _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?
If this function returns `True` then no functions that modify the
- database (:meth:`add_message`,
+ database (:meth:`index_file`,
:meth:`Message.add_tag`, :meth:`Directory.set_mtime`,
etc.) will work unless :meth:`upgrade` is called successfully first.
:returns: `True` or `False`
- :exception: :exc:`NotInitializedError` 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
indicating the progress made so far in the upgrade process.
:TODO: catch exceptions, document return values and etc...
-
- :exception: :exc:`NotInitializedError` if
- the database was not intitialized.
"""
self._assert_db_is_initialized()
status = Database._upgrade(self._db, None, None)
- #TODO: catch exceptions, document return values and etc
+ # 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
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.
-
- :exc:`NotInitializedError` if
- the database was not intitialized.
+ :raises: :exc:`NotmuchError`: :attr:`STATUS`.XAPIAN_EXCEPTION
+ 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
:returns: :attr:`STATUS`.SUCCESS or raises
- :exception:
+ :raises:
:exc:`NotmuchError`:
:attr:`STATUS`.XAPIAN_EXCEPTION
A Xapian exception occurred; atomic section not
:attr:`STATUS`.UNBALANCED_ATOMIC:
end_atomic has been called more times than begin_atomic.
- :exc:`NotInitializedError` if
- the database was not intitialized.
-
*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
def get_directory(self, path):
"""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!
: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` with :attr:`STATUS`.FILE_ERROR
- If path is not relative database or absolute with initial
- components same as database.
-
- :exc:`NotInitializedError` if
- the database was not intitialized.
+ :raises: :exc:`FileError` 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
- if path[0] == os.sep:
+ if path and path[0] == os.sep:
# we got an absolute path
if not path.startswith(self.get_path()):
# but its initial components are not equal to the db path
- raise NotmuchError(STATUS.FILE_ERROR,
- message="Database().get_directory() called "
- "with a wrong absolute path.")
+ raise FileError('Database().get_directory() called '
+ 'with a wrong absolute path')
abs_dirpath = path
else:
#we got a relative path, make it absolute
abs_dirpath = os.path.abspath(os.path.join(self.get_path(), path))
- dir_p = Database._get_directory(self._db, _str(path))
+ dir_p = NotmuchDirectoryP()
+ status = Database._get_directory(self._db, _str(path), byref(dir_p))
+
+ if status != STATUS.SUCCESS:
+ raise NotmuchError(status)
+ if not dir_p:
+ return None
# return the Directory, init it with the absolute path
- return Directory(_str(abs_dirpath), dir_p, self)
+ return Directory(abs_dirpath, dir_p, self)
- def add_message(self, filename, sync_maildir_flags=False):
+ _get_default_indexopts = nmlib.notmuch_database_get_default_indexopts
+ _get_default_indexopts.argtypes = [NotmuchDatabaseP]
+ _get_default_indexopts.restype = NotmuchIndexoptsP
+
+ _indexopts_set_decrypt_policy = nmlib.notmuch_indexopts_set_decrypt_policy
+ _indexopts_set_decrypt_policy.argtypes = [NotmuchIndexoptsP, c_uint]
+ _indexopts_set_decrypt_policy.restype = None
+
+ _indexopts_destroy = nmlib.notmuch_indexopts_destroy
+ _indexopts_destroy.argtypes = [NotmuchIndexoptsP]
+ _indexopts_destroy.restype = None
+
+ _index_file = nmlib.notmuch_database_index_file
+ _index_file.argtypes = [NotmuchDatabaseP, c_char_p,
+ c_void_p,
+ POINTER(NotmuchMessageP)]
+ _index_file.restype = c_uint
+
+ def index_file(self, filename, sync_maildir_flags=False, decrypt_policy=None):
"""Adds a new message to the database
:param filename: should be a path relative to the path of the
API. You might want to look into the underlying method
:meth:`Message.maildir_flags_to_tags`.
+ :param decrypt_policy: If the message contains any encrypted
+ parts, and decrypt_policy is set to
+ :attr:`DECRYPTION_POLICY`.TRUE, notmuch will try to
+ decrypt the message and index the cleartext, stashing any
+ discovered session keys. If it is set to
+ :attr:`DECRYPTION_POLICY`.FALSE, it will never try to
+ decrypt during indexing. If it is set to
+ :attr:`DECRYPTION_POLICY`.AUTO, then it will try to use
+ any stashed session keys it knows about, but will not try
+ to access the user's secret keys.
+ :attr:`DECRYPTION_POLICY`.NOSTASH behaves the same as
+ :attr:`DECRYPTION_POLICY`.TRUE except that no session keys
+ are stashed in the database. If decrypt_policy is set to
+ None (the default), then the database itself will decide
+ whether to decrypt, based on the `index.decrypt`
+ configuration setting (see notmuch-config(1)).
+
:returns: On success, we return
1) a :class:`Message` object that can be used for things
:rtype: 2-tuple(:class:`Message`, :attr:`STATUS`)
- :exception: Raises a :exc:`NotmuchError` with the following meaning.
+ :raises: Raises a :exc:`NotmuchError` with the following meaning.
If such an exception occurs, nothing was added to the database.
:attr:`STATUS`.FILE_ERROR
:attr:`STATUS`.READ_ONLY_DATABASE
Database was opened in read-only mode so no message can
be added.
-
- :exc:`NotInitializedError` if
- the database was not intitialized.
"""
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()
+ indexopts = c_void_p(None)
+ if decrypt_policy is not None:
+ indexopts = self._get_default_indexopts(self._db)
+ self._indexopts_set_decrypt_policy(indexopts, decrypt_policy)
+
+ status = self._index_file(self._db, _str(filename), indexopts, byref(msg_p))
+
+ if indexopts:
+ self._indexopts_destroy(indexopts)
if not status in [STATUS.SUCCESS, STATUS.DUPLICATE_MESSAGE_ID]:
raise NotmuchError(status)
msg.maildir_flags_to_tags()
return (msg, status)
+ def add_message(self, filename, sync_maildir_flags=False):
+ """Deprecated alias for :meth:`index_file`
+ """
+ warnings.warn(
+ "This function is deprecated and will be removed in the future, use index_file.", DeprecationWarning)
+
+ return self.index_file(filename, sync_maildir_flags=sync_maildir_flags)
+
+ _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
This filename was removed but the message persists in the
database with at least one other filename.
- :exception: Raises a :exc:`NotmuchError` with the following meaning.
+ :raises: Raises a :exc:`NotmuchError` with the following meaning.
If such an exception occurs, nothing was removed from the
database.
:attr:`STATUS`.READ_ONLY_DATABASE
Database was opened in read-only mode so no message can be
removed.
-
- :exc:`NotInitializedError` if
- the database was not intitialized.
"""
self._assert_db_is_initialized()
- return nmlib.notmuch_database_remove_message(self._db,
- filename)
+ status = self._remove_message(self._db, _str(filename))
+ if status not in [STATUS.SUCCESS, STATUS.DUPLICATE_MESSAGE_ID]:
+ raise NotmuchError(status)
+ return status
def find_message(self, msgid):
"""Returns a :class:`Message` as identified by its message ID
:param msgid: The message ID
:type msgid: unicode or str
:returns: :class:`Message` or `None` if no message is found.
- :exception:
+ :raises:
:exc:`OutOfMemoryError`
- If an Out-of-memory occured while constructing the message.
+ If an Out-of-memory occurred 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
+ :exc:`NotInitializedError` if
the database was not intitialized.
"""
self._assert_db_is_initialized()
- msg_p = c_void_p()
+ msg_p = NotmuchMessageP()
status = Database._find_message(self._db, _str(msgid), byref(msg_p))
if status != STATUS.SUCCESS:
raise NotmuchError(status)
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!
-
:returns: If the database contains a message with the given
filename, then a class:`Message:` is returned. This
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.
+ :raises: :exc:`OutOfMemoryError` if an Out-of-memory occurred while
+ constructing the message.
+ :raises: :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.
+ :raises: :exc:`NotInitializedError` if the database was not
+ intitialized.
*Added in notmuch 0.9*"""
self._assert_db_is_initialized()
- msg_p = c_void_p()
+
+ msg_p = NotmuchMessageP()
status = Database._find_message_by_filename(self._db, _str(filename),
byref(msg_p))
if status != STATUS.SUCCESS:
"""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)
- if tags_p == None:
- raise NotmuchError(STATUS.NULL_POINTER)
+ if not tags_p:
+ raise NullPointerError()
return Tags(tags_p, self)
def create_query(self, querystring):
This function is a python extension and not in the underlying C API.
"""
- self._assert_db_is_initialized()
return Query(self, querystring)
+ """notmuch_database_status_string"""
+ _status_string = nmlib.notmuch_database_status_string
+ _status_string.argtypes = [NotmuchDatabaseP]
+ _status_string.restype = c_char_p
+
+ def status_string(self):
+ """Returns the status string of the database
+
+ This is sometimes used for additional error reporting
+ """
+ self._assert_db_is_initialized()
+ s = Database._status_string(self._db)
+ if s:
+ return s.decode('utf-8', 'ignore')
+ return s
+
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
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')
-
- @property
- def db_p(self):
- """Property returning a pointer to `notmuch_database_t` or `None`
+ db_path = config.get('database', 'path')
+ if not os.path.isabs(db_path):
+ db_path = os.path.expanduser(os.path.join("~", db_path))
+ return db_path
+
+ """notmuch_database_get_config"""
+ _get_config = nmlib.notmuch_database_get_config
+ _get_config.argtypes = [NotmuchDatabaseP, c_char_p, POINTER(c_char_p)]
+ _get_config.restype = c_uint
+
+ def get_config(self, key):
+ """Return the value of the given config key.
+
+ Note that only config values that are stored in the database are
+ searched and returned. The config file is not read.
+
+ :param key: the config key under which a value should be looked up, it
+ should probably be in the form "section.key"
+ :type key: str
+ :returns: the config value or the empty string if no value is present
+ for that key
+ :rtype: str
+ :raises: :exc:`NotmuchError` in case of failure.
- This should normally not be needed by a user (and is not yet
- guaranteed to remain stable in future versions).
"""
- 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
-
- Modifying attributes of this object will modify the
- database, not the real directory attributes.
-
- The Directory object is usually derived from another object
- e.g. via :meth:`Database.get_directory`, and will automatically be
- become invalid whenever that parent is deleted. You should
- therefore initialized this object handing it a reference to the
- parent, preventing the parent from automatically being garbage
- collected.
- """
-
- """notmuch_directory_get_mtime"""
- _get_mtime = nmlib.notmuch_directory_get_mtime
- _get_mtime.restype = c_long
-
- """notmuch_directory_set_mtime"""
- _set_mtime = nmlib.notmuch_directory_set_mtime
- _set_mtime.argtypes = [c_char_p, c_long]
-
- """notmuch_directory_get_child_files"""
- _get_child_files = nmlib.notmuch_directory_get_child_files
- _get_child_files.restype = c_void_p
-
- """notmuch_directory_get_child_directories"""
- _get_child_directories = nmlib.notmuch_directory_get_child_directories
- _get_child_directories.restype = c_void_p
-
- def _assert_dir_is_initialized(self):
- """Raises a NotmuchError(:attr:`STATUS`.NOT_INITIALIZED) if dir_p is None"""
- if self._dir_p is None:
- raise NotmuchError(STATUS.NOT_INITIALIZED)
-
- def __init__(self, path, dir_p, parent):
- """
- :param path: The absolute path of the directory object as unicode.
- :param dir_p: The pointer to an internal notmuch_directory_t object.
- :param parent: The object this Directory is derived from
- (usually a :class:`Database`). We do not directly use
- this, but store a reference to it as long as
- this Directory object lives. This keeps the
- parent object alive.
- """
- assert isinstance(path, unicode), "Path needs to be an UNICODE object"
- self._path = path
- self._dir_p = dir_p
- self._parent = parent
-
- def set_mtime(self, mtime):
- """Sets the mtime value of this directory in the database
-
- The intention is for the caller to use the mtime to allow efficient
- identification of new messages to be added to the database. The
- recommended usage is as follows:
-
- * Read the mtime of a directory from the filesystem
-
- * Call :meth:`Database.add_message` for all mail files in
- the directory
-
- * Call notmuch_directory_set_mtime with the mtime read from the
- filesystem. Then, when wanting to check for updates to the
- directory in the future, the client can call :meth:`get_mtime`
- 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.
-
- :param mtime: A (time_t) timestamp
- :returns: Nothing on success, raising an exception on failure.
- :exception: :exc:`NotmuchError`:
-
- :attr:`STATUS`.XAPIAN_EXCEPTION
- A Xapian exception occurred, mtime not stored.
- :attr:`STATUS`.READ_ONLY_DATABASE
- Database was opened in read-only mode so directory
- mtime cannot be modified.
- :attr:`STATUS`.NOT_INITIALIZED
- The directory has not been initialized
- """
- self._assert_dir_is_initialized()
- #TODO: make sure, we convert the mtime parameter to a 'c_long'
- status = Directory._set_mtime(self._dir_p, mtime)
-
- #return on success
- if status == STATUS.SUCCESS:
- return
- #fail with Exception otherwise
- raise NotmuchError(status)
-
- def get_mtime(self):
- """Gets the mtime value of this directory in the database
-
- Retrieves a previously stored mtime for this directory.
-
- :param mtime: A (time_t) timestamp
- :returns: Nothing on success, raising an exception on failure.
- :exception: :exc:`NotmuchError`:
-
- :attr:`STATUS`.NOT_INITIALIZED
- The directory has not been initialized
- """
- self._assert_dir_is_initialized()
- return Directory._get_mtime(self._dir_p)
+ self._assert_db_is_initialized()
+ return_string = c_char_p()
+ status = self._get_config(self._db, _str(key), byref(return_string))
+ if status != STATUS.SUCCESS:
+ raise NotmuchError(status)
+ return return_string.value.decode('utf-8')
- # Make mtime attribute a property of Directory()
- mtime = property(get_mtime, set_mtime, doc="""Property that allows getting
- and setting of the Directory *mtime* (read-write)
+ """notmuch_database_get_config_list"""
+ _get_config_list = nmlib.notmuch_database_get_config_list
+ _get_config_list.argtypes = [NotmuchDatabaseP, c_char_p,
+ POINTER(NotmuchConfigListP)]
+ _get_config_list.restype = c_uint
- See :meth:`get_mtime` and :meth:`set_mtime` for usage and
- possible exceptions.""")
+ _config_list_valid = nmlib.notmuch_config_list_valid
+ _config_list_valid.argtypes = [NotmuchConfigListP]
+ _config_list_valid.restype = bool
- def get_child_files(self):
- """Gets a Filenames iterator listing all the filenames of
- messages in the database within the given directory.
+ _config_list_key = nmlib.notmuch_config_list_key
+ _config_list_key.argtypes = [NotmuchConfigListP]
+ _config_list_key.restype = c_char_p
- The returned filenames will be the basename-entries only (not
- complete paths.
- """
- self._assert_dir_is_initialized()
- files_p = Directory._get_child_files(self._dir_p)
- return Filenames(files_p, self)
+ _config_list_value = nmlib.notmuch_config_list_value
+ _config_list_value.argtypes = [NotmuchConfigListP]
+ _config_list_value.restype = c_char_p
- def get_child_directories(self):
- """Gets a :class:`Filenames` iterator listing all the filenames of
- sub-directories in the database within the given directory
+ _config_list_move_to_next = nmlib.notmuch_config_list_move_to_next
+ _config_list_move_to_next.argtypes = [NotmuchConfigListP]
+ _config_list_move_to_next.restype = None
- The returned filenames will be the basename-entries only (not
- complete paths.
- """
- self._assert_dir_is_initialized()
- files_p = Directory._get_child_directories(self._dir_p)
- return Filenames(files_p, self)
+ _config_list_destroy = nmlib.notmuch_config_list_destroy
+ _config_list_destroy.argtypes = [NotmuchConfigListP]
+ _config_list_destroy.restype = None
- @property
- def path(self):
- """Returns the absolute path of this Directory (read-only)"""
- return self._path
+ def get_configs(self, prefix=''):
+ """Return a generator of key, value pairs where the start of key
+ matches the given prefix
- def __repr__(self):
- """Object representation"""
- return "<notmuch Directory object '%s'>" % self._path
-
- def __del__(self):
- """Close and free the Directory"""
- if self._dir_p is not None:
- nmlib.notmuch_directory_destroy(self._dir_p)
+ Note that only config values that are stored in the database are
+ searched and returned. The config file is not read. If no `prefix` is
+ given all config values are returned.
+ This could be used to get all named queries into a dict for example::
-class Filenames(object):
- """An iterator over File- or Directory names stored in the database"""
+ queries = {k[6:]: v for k, v in db.get_configs('query.')}
- #notmuch_filenames_get
- _get = nmlib.notmuch_filenames_get
- _get.restype = c_char_p
+ :param prefix: a string by which the keys should be selected
+ :type prefix: str
+ :yields: all key-value pairs where `prefix` matches the beginning
+ of the key
+ :ytype: pairs of str
+ :raises: :exc:`NotmuchError` in case of failure.
- def __init__(self, files_p, parent):
- """
- :param files_p: The pointer to an internal notmuch_filenames_t object.
- :param parent: The object this Directory is derived from
- (usually a Directory()). We do not directly use
- this, but store a reference to it as long as
- this Directory object lives. This keeps the
- parent object alive.
"""
- self._files_p = files_p
- self._parent = parent
-
- def __iter__(self):
- """ Make Filenames an iterator """
- return self
-
- def next(self):
- if self._files_p is None:
- raise NotmuchError(STATUS.NOT_INITIALIZED)
+ self._assert_db_is_initialized()
+ config_list_p = NotmuchConfigListP()
+ status = self._get_config_list(self._db, _str(prefix),
+ byref(config_list_p))
+ if status != STATUS.SUCCESS:
+ raise NotmuchError(status)
+ while self._config_list_valid(config_list_p):
+ key = self._config_list_key(config_list_p).decode('utf-8')
+ value = self._config_list_value(config_list_p).decode('utf-8')
+ yield key, value
+ self._config_list_move_to_next(config_list_p)
- if not nmlib.notmuch_filenames_valid(self._files_p):
- self._files_p = None
- raise StopIteration
+ """notmuch_database_set_config"""
+ _set_config = nmlib.notmuch_database_set_config
+ _set_config.argtypes = [NotmuchDatabaseP, c_char_p, c_char_p]
+ _set_config.restype = c_uint
- file = Filenames._get(self._files_p)
- nmlib.notmuch_filenames_move_to_next(self._files_p)
- return file
+ def set_config(self, key, value):
+ """Set a config value in the notmuch database.
- def __len__(self):
- """len(:class:`Filenames`) returns the number of contained files
+ If an empty string is provided as `value` the `key` is unset!
- .. note:: As this iterates over the files, we will not be able to
- iterate over them again! So this will fail::
+ :param key: the key to set
+ :type key: str
+ :param value: the value to store under `key`
+ :type value: str
+ :returns: None
+ :raises: :exc:`NotmuchError` in case of failure.
- #THIS FAILS
- files = Database().get_directory('').get_child_files()
- 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:
- raise NotmuchError(STATUS.NOT_INITIALIZED)
-
- i = 0
- while nmlib.notmuch_filenames_valid(self._files_p):
- nmlib.notmuch_filenames_move_to_next(self._files_p)
- i += 1
- self._files_p = None
- return i
-
- def __del__(self):
- """Close and free Filenames"""
- if self._files_p is not None:
- nmlib.notmuch_filenames_destroy(self._files_p)
+ self._assert_db_is_initialized()
+ status = self._set_config(self._db, _str(key), _str(value))
+ if status != STATUS.SUCCESS:
+ raise NotmuchError(status)
projects / notmuch / blobdiff