2 This file is part of notmuch.
4 Notmuch is free software: you can redistribute it and/or modify it
5 under the terms of the GNU General Public License as published by the
6 Free Software Foundation, either version 3 of the License, or (at your
7 option) any later version.
9 Notmuch is distributed in the hope that it will be useful, but WITHOUT
10 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 You should have received a copy of the GNU General Public License
15 along with notmuch. If not, see <http://www.gnu.org/licenses/>.
17 Copyright 2010 Sebastian Spaeth <Sebastian@SSpaeth.de>
22 from ctypes import c_char_p, c_void_p, c_uint, byref, POINTER
23 from notmuch.globals import (
38 ReadOnlyDatabaseError,
40 from notmuch.message import Message
41 from notmuch.tag import Tags
42 from .query import Query
43 from .directory import Directory
45 class Database(object):
46 """The :class:`Database` is the highest-level object that notmuch
47 provides. It references a notmuch database, and can be opened in
48 read-only or read-write mode. A :class:`Query` can be derived from
49 or be applied to a specific database to find messages. Also adding
50 and removing messages to the database happens via this
51 object. Modifications to the database are not atmic by default (see
52 :meth:`begin_atomic`) and once a database has been modified, all
53 other database objects pointing to the same data-base will throw an
54 :exc:`XapianError` as the underlying database has been
55 modified. Close and reopen the database to continue working with it.
57 :class:`Database` objects implement the context manager protocol
58 so you can use the :keyword:`with` statement to ensure that the
59 database is properly closed.
63 Any function in this class can and will throw an
64 :exc:`NotInitializedError` if the database was not intitialized
69 Do remember that as soon as we tear down (e.g. via `del db`) this
70 object, all underlying derived objects such as queries, threads,
71 messages, tags etc will be freed by the underlying library as well.
72 Accessing these objects will lead to segfaults and other unexpected
73 behavior. See above for more details.
76 """Class attribute to cache user's default database"""
78 MODE = Enum(['READ_ONLY', 'READ_WRITE'])
79 """Constants: Mode in which to open the database"""
81 """notmuch_database_get_directory"""
82 _get_directory = nmlib.notmuch_database_get_directory
83 _get_directory.argtypes = [NotmuchDatabaseP, c_char_p]
84 _get_directory.restype = NotmuchDirectoryP
86 """notmuch_database_get_path"""
87 _get_path = nmlib.notmuch_database_get_path
88 _get_path.argtypes = [NotmuchDatabaseP]
89 _get_path.restype = c_char_p
91 """notmuch_database_get_version"""
92 _get_version = nmlib.notmuch_database_get_version
93 _get_version.argtypes = [NotmuchDatabaseP]
94 _get_version.restype = c_uint
96 """notmuch_database_open"""
97 _open = nmlib.notmuch_database_open
98 _open.argtypes = [c_char_p, c_uint]
99 _open.restype = NotmuchDatabaseP
101 """notmuch_database_upgrade"""
102 _upgrade = nmlib.notmuch_database_upgrade
103 _upgrade.argtypes = [NotmuchDatabaseP, c_void_p, c_void_p]
104 _upgrade.restype = c_uint
106 """ notmuch_database_find_message"""
107 _find_message = nmlib.notmuch_database_find_message
108 _find_message.argtypes = [NotmuchDatabaseP, c_char_p,
109 POINTER(NotmuchMessageP)]
110 _find_message.restype = c_uint
112 """notmuch_database_find_message_by_filename"""
113 _find_message_by_filename = nmlib.notmuch_database_find_message_by_filename
114 _find_message_by_filename.argtypes = [NotmuchDatabaseP, c_char_p,
115 POINTER(NotmuchMessageP)]
116 _find_message_by_filename.restype = c_uint
118 """notmuch_database_get_all_tags"""
119 _get_all_tags = nmlib.notmuch_database_get_all_tags
120 _get_all_tags.argtypes = [NotmuchDatabaseP]
121 _get_all_tags.restype = NotmuchTagsP
123 """notmuch_database_create"""
124 _create = nmlib.notmuch_database_create
125 _create.argtypes = [c_char_p]
126 _create.restype = NotmuchDatabaseP
128 def __init__(self, path = None, create = False,
129 mode = MODE.READ_ONLY):
130 """If *path* is `None`, we will try to read a users notmuch
131 configuration and use his configured database. The location of the
132 configuration file can be specified through the environment variable
133 *NOTMUCH_CONFIG*, falling back to the default `~/.notmuch-config`.
135 If *create* is `True`, the database will always be created in
136 :attr:`MODE`.READ_WRITE mode. Default mode for opening is READ_ONLY.
138 :param path: Directory to open/create the database in (see
139 above for behavior if `None`)
140 :type path: `str` or `None`
141 :param create: Pass `False` to open an existing, `True` to create a new
144 :param mode: Mode to open a database in. Is always
145 :attr:`MODE`.READ_WRITE when creating a new one.
146 :type mode: :attr:`MODE`
147 :raises: :exc:`NotmuchError` or derived exception in case of
153 # no path specified. use a user's default database
154 if Database._std_db_path is None:
155 #the following line throws a NotmuchError if it fails
156 Database._std_db_path = self._get_user_default_db()
157 path = Database._std_db_path
160 self.open(path, mode)
164 _destroy = nmlib.notmuch_database_destroy
165 _destroy.argtypes = [NotmuchDatabaseP]
166 _destroy.restype = None
170 self._destroy(self._db)
172 def _assert_db_is_initialized(self):
173 """Raises :exc:`NotInitializedError` if self._db is `None`"""
175 raise NotInitializedError()
177 def create(self, path):
178 """Creates a new notmuch database
180 This function is used by __init__() and usually does not need
181 to be called directly. It wraps the underlying
182 *notmuch_database_create* function and creates a new notmuch
183 database at *path*. It will always return a database in :attr:`MODE`
184 .READ_WRITE mode as creating an empty database for
185 reading only does not make a great deal of sense.
187 :param path: A directory in which we should create the database.
189 :raises: :exc:`NotmuchError` in case of any failure
190 (possibly after printing an error message on stderr).
192 if self._db is not None:
193 raise NotmuchError(message="Cannot create db, this Database() "
194 "already has an open one.")
196 res = Database._create(_str(path), Database.MODE.READ_WRITE)
200 message="Could not create the specified database")
203 def open(self, path, mode=0):
204 """Opens an existing database
206 This function is used by __init__() and usually does not need
207 to be called directly. It wraps the underlying
208 *notmuch_database_open* function.
210 :param status: Open the database in read-only or read-write mode
211 :type status: :attr:`MODE`
212 :raises: Raises :exc:`NotmuchError` in case of any failure
213 (possibly after printing an error message on stderr).
215 res = Database._open(_str(path), mode)
218 raise NotmuchError(message="Could not open the specified database")
221 _close = nmlib.notmuch_database_close
222 _close.argtypes = [NotmuchDatabaseP]
223 _close.restype = None
227 Closes the notmuch database.
230 self._close(self._db)
234 Implements the context manager protocol.
238 def __exit__(self, exc_type, exc_value, traceback):
240 Implements the context manager protocol.
245 """Returns the file path of an open database"""
246 self._assert_db_is_initialized()
247 return Database._get_path(self._db).decode('utf-8')
249 def get_version(self):
250 """Returns the database format version
252 :returns: The database version as positive integer
254 self._assert_db_is_initialized()
255 return Database._get_version(self._db)
257 _needs_upgrade = nmlib.notmuch_database_needs_upgrade
258 _needs_upgrade.argtypes = [NotmuchDatabaseP]
259 _needs_upgrade.restype = bool
261 def needs_upgrade(self):
262 """Does this database need to be upgraded before writing to it?
264 If this function returns `True` then no functions that modify the
265 database (:meth:`add_message`,
266 :meth:`Message.add_tag`, :meth:`Directory.set_mtime`,
267 etc.) will work unless :meth:`upgrade` is called successfully first.
269 :returns: `True` or `False`
271 self._assert_db_is_initialized()
272 return self._needs_upgrade(self._db)
275 """Upgrades the current database
277 After opening a database in read-write mode, the client should
278 check if an upgrade is needed (notmuch_database_needs_upgrade) and
279 if so, upgrade with this function before making any modifications.
281 NOT IMPLEMENTED: The optional progress_notify callback can be
282 used by the caller to provide progress indication to the
283 user. If non-NULL it will be called periodically with
284 'progress' as a floating-point value in the range of [0.0..1.0]
285 indicating the progress made so far in the upgrade process.
287 :TODO: catch exceptions, document return values and etc...
289 self._assert_db_is_initialized()
290 status = Database._upgrade(self._db, None, None)
291 #TODO: catch exceptions, document return values and etc
294 _begin_atomic = nmlib.notmuch_database_begin_atomic
295 _begin_atomic.argtypes = [NotmuchDatabaseP]
296 _begin_atomic.restype = c_uint
298 def begin_atomic(self):
299 """Begin an atomic database operation
301 Any modifications performed between a successful
302 :meth:`begin_atomic` and a :meth:`end_atomic` will be applied to
303 the database atomically. Note that, unlike a typical database
304 transaction, this only ensures atomicity, not durability;
305 neither begin nor end necessarily flush modifications to disk.
307 :returns: :attr:`STATUS`.SUCCESS or raises
308 :raises: :exc:`NotmuchError`: :attr:`STATUS`.XAPIAN_EXCEPTION
309 Xapian exception occurred; atomic section not entered.
311 *Added in notmuch 0.9*"""
312 self._assert_db_is_initialized()
313 status = self._begin_atomic(self._db)
314 if status != STATUS.SUCCESS:
315 raise NotmuchError(status)
318 _end_atomic = nmlib.notmuch_database_end_atomic
319 _end_atomic.argtypes = [NotmuchDatabaseP]
320 _end_atomic.restype = c_uint
322 def end_atomic(self):
323 """Indicate the end of an atomic database operation
325 See :meth:`begin_atomic` for details.
327 :returns: :attr:`STATUS`.SUCCESS or raises
331 :attr:`STATUS`.XAPIAN_EXCEPTION
332 A Xapian exception occurred; atomic section not
334 :attr:`STATUS`.UNBALANCED_ATOMIC:
335 end_atomic has been called more times than begin_atomic.
337 *Added in notmuch 0.9*"""
338 self._assert_db_is_initialized()
339 status = self._end_atomic(self._db)
340 if status != STATUS.SUCCESS:
341 raise NotmuchError(status)
344 def get_directory(self, path):
345 """Returns a :class:`Directory` of path,
346 (creating it if it does not exist(?))
348 :param path: An unicode string containing the path relative to the path
349 of database (see :meth:`get_path`), or else should be an absolute
350 path with initial components that match the path of 'database'.
351 :returns: :class:`Directory` or raises an exception.
352 :raises: :exc:`FileError` if path is not relative database or absolute
353 with initial components same as database.
354 :raises: :exc:`ReadOnlyDatabaseError` if the database has not been
355 opened in read-write mode
357 self._assert_db_is_initialized()
359 # work around libnotmuch calling exit(3), see
360 # id:20120221002921.8534.57091@thinkbox.jade-hamburg.de
361 # TODO: remove once this issue is resolved
362 if self.mode != Database.MODE.READ_WRITE:
363 raise ReadOnlyDatabaseError('The database has to be opened in '
364 'read-write mode for get_directory')
366 # sanity checking if path is valid, and make path absolute
367 if path and path[0] == os.sep:
368 # we got an absolute path
369 if not path.startswith(self.get_path()):
370 # but its initial components are not equal to the db path
371 raise FileError('Database().get_directory() called '
372 'with a wrong absolute path')
375 #we got a relative path, make it absolute
376 abs_dirpath = os.path.abspath(os.path.join(self.get_path(), path))
378 dir_p = Database._get_directory(self._db, _str(path))
380 # return the Directory, init it with the absolute path
381 return Directory(abs_dirpath, dir_p, self)
383 _add_message = nmlib.notmuch_database_add_message
384 _add_message.argtypes = [NotmuchDatabaseP, c_char_p,
385 POINTER(NotmuchMessageP)]
386 _add_message.restype = c_uint
388 def add_message(self, filename, sync_maildir_flags=False):
389 """Adds a new message to the database
391 :param filename: should be a path relative to the path of the
392 open database (see :meth:`get_path`), or else should be an
393 absolute filename with initial components that match the
394 path of the database.
396 The file should be a single mail message (not a
397 multi-message mbox) that is expected to remain at its
398 current location, since the notmuch database will reference
399 the filename, and will not copy the entire contents of the
402 :param sync_maildir_flags: If the message contains Maildir
403 flags, we will -depending on the notmuch configuration- sync
404 those tags to initial notmuch tags, if set to `True`. It is
405 `False` by default to remain consistent with the libnotmuch
406 API. You might want to look into the underlying method
407 :meth:`Message.maildir_flags_to_tags`.
409 :returns: On success, we return
411 1) a :class:`Message` object that can be used for things
412 such as adding tags to the just-added message.
413 2) one of the following :attr:`STATUS` values:
415 :attr:`STATUS`.SUCCESS
416 Message successfully added to database.
417 :attr:`STATUS`.DUPLICATE_MESSAGE_ID
418 Message has the same message ID as another message already
419 in the database. The new filename was successfully added
420 to the list of the filenames for the existing message.
422 :rtype: 2-tuple(:class:`Message`, :attr:`STATUS`)
424 :raises: Raises a :exc:`NotmuchError` with the following meaning.
425 If such an exception occurs, nothing was added to the database.
427 :attr:`STATUS`.FILE_ERROR
428 An error occurred trying to open the file, (such as
429 permission denied, or file not found, etc.).
430 :attr:`STATUS`.FILE_NOT_EMAIL
431 The contents of filename don't look like an email
433 :attr:`STATUS`.READ_ONLY_DATABASE
434 Database was opened in read-only mode so no message can
437 self._assert_db_is_initialized()
438 msg_p = NotmuchMessageP()
439 status = self._add_message(self._db, _str(filename), byref(msg_p))
441 if not status in [STATUS.SUCCESS, STATUS.DUPLICATE_MESSAGE_ID]:
442 raise NotmuchError(status)
444 #construct Message() and return
445 msg = Message(msg_p, self)
446 #automatic sync initial tags from Maildir flags
447 if sync_maildir_flags:
448 msg.maildir_flags_to_tags()
451 _remove_message = nmlib.notmuch_database_remove_message
452 _remove_message.argtypes = [NotmuchDatabaseP, c_char_p]
453 _remove_message.restype = c_uint
455 def remove_message(self, filename):
456 """Removes a message (filename) from the given notmuch database
458 Note that only this particular filename association is removed from
459 the database. If the same message (as determined by the message ID)
460 is still available via other filenames, then the message will
461 persist in the database for those filenames. When the last filename
462 is removed for a particular message, the database content for that
463 message will be entirely removed.
465 :returns: A :attr:`STATUS` value with the following meaning:
467 :attr:`STATUS`.SUCCESS
468 The last filename was removed and the message was removed
470 :attr:`STATUS`.DUPLICATE_MESSAGE_ID
471 This filename was removed but the message persists in the
472 database with at least one other filename.
474 :raises: Raises a :exc:`NotmuchError` with the following meaning.
475 If such an exception occurs, nothing was removed from the
478 :attr:`STATUS`.READ_ONLY_DATABASE
479 Database was opened in read-only mode so no message can be
482 self._assert_db_is_initialized()
483 return self._remove_message(self._db, _str(filename))
485 def find_message(self, msgid):
486 """Returns a :class:`Message` as identified by its message ID
488 Wraps the underlying *notmuch_database_find_message* function.
490 :param msgid: The message ID
491 :type msgid: unicode or str
492 :returns: :class:`Message` or `None` if no message is found.
494 :exc:`OutOfMemoryError`
495 If an Out-of-memory occured while constructing the message.
497 In case of a Xapian Exception. These exceptions
498 include "Database modified" situations, e.g. when the
499 notmuch database has been modified by another program
500 in the meantime. In this case, you should close and
501 reopen the database and retry.
502 :exc:`NotInitializedError` if
503 the database was not intitialized.
505 self._assert_db_is_initialized()
506 msg_p = NotmuchMessageP()
507 status = Database._find_message(self._db, _str(msgid), byref(msg_p))
508 if status != STATUS.SUCCESS:
509 raise NotmuchError(status)
510 return msg_p and Message(msg_p, self) or None
512 def find_message_by_filename(self, filename):
513 """Find a message with the given filename
515 :returns: If the database contains a message with the given
516 filename, then a class:`Message:` is returned. This
517 function returns None if no message is found with the given
520 :raises: :exc:`OutOfMemoryError` if an Out-of-memory occured while
521 constructing the message.
522 :raises: :exc:`XapianError` in case of a Xapian Exception.
523 These exceptions include "Database modified"
524 situations, e.g. when the notmuch database has been
525 modified by another program in the meantime. In this
526 case, you should close and reopen the database and
528 :raises: :exc:`NotInitializedError` if the database was not
530 :raises: :exc:`ReadOnlyDatabaseError` if the database has not been
531 opened in read-write mode
533 *Added in notmuch 0.9*"""
534 self._assert_db_is_initialized()
536 # work around libnotmuch calling exit(3), see
537 # id:20120221002921.8534.57091@thinkbox.jade-hamburg.de
538 # TODO: remove once this issue is resolved
539 if self.mode != Database.MODE.READ_WRITE:
540 raise ReadOnlyDatabaseError('The database has to be opened in '
541 'read-write mode for get_directory')
543 msg_p = NotmuchMessageP()
544 status = Database._find_message_by_filename(self._db, _str(filename),
546 if status != STATUS.SUCCESS:
547 raise NotmuchError(status)
548 return msg_p and Message(msg_p, self) or None
550 def get_all_tags(self):
551 """Returns :class:`Tags` with a list of all tags found in the database
553 :returns: :class:`Tags`
554 :execption: :exc:`NotmuchError` with :attr:`STATUS`.NULL_POINTER
557 self._assert_db_is_initialized()
558 tags_p = Database._get_all_tags(self._db)
560 raise NullPointerError()
561 return Tags(tags_p, self)
563 def create_query(self, querystring):
564 """Returns a :class:`Query` derived from this database
566 This is a shorthand method for doing::
569 # Automatically frees the Database() when 'q' is deleted
571 q = Database(dbpath).create_query('from:"Biene Maja"')
573 # long version, which is functionally equivalent but will keep the
574 # Database in the 'db' variable around after we delete 'q':
576 db = Database(dbpath)
577 q = Query(db,'from:"Biene Maja"')
579 This function is a python extension and not in the underlying C API.
581 return Query(self, querystring)
584 return "'Notmuch DB " + self.get_path() + "'"
586 def _get_user_default_db(self):
587 """ Reads a user's notmuch config and returns his db location
589 Throws a NotmuchError if it cannot find it"""
592 from configparser import SafeConfigParser
595 from ConfigParser import SafeConfigParser
597 config = SafeConfigParser()
598 conf_f = os.getenv('NOTMUCH_CONFIG',
599 os.path.expanduser('~/.notmuch-config'))
600 config.readfp(codecs.open(conf_f, 'r', 'utf-8'))
601 if not config.has_option('database', 'path'):
602 raise NotmuchError(message="No DB path specified"
603 " and no user default found")
604 return config.get('database', 'path')
608 """Property returning a pointer to `notmuch_database_t` or `None`
610 This should normally not be needed by a user (and is not yet
611 guaranteed to remain stable in future versions).