X-Git-Url: https://git.notmuchmail.org/git?a=blobdiff_plain;f=bindings%2Fpython%2Fnotmuch%2Fdatabase.py;h=2866b86087838cedf29f6e4ec1d0aae8f3315389;hb=6c6b0f13ffc3988b0f31774b33b8215be02abaa9;hp=67fb1c41142428ed6c06e36a985de8f1f784a1db;hpb=92d8eae8f182e4eebc87d76f8d4f37e6c018883a;p=notmuch diff --git a/bindings/python/notmuch/database.py b/bindings/python/notmuch/database.py index 67fb1c41..2866b860 100644 --- a/bindings/python/notmuch/database.py +++ b/bindings/python/notmuch/database.py @@ -19,12 +19,14 @@ Copyright 2010 Sebastian Spaeth import os 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, NotmuchMessageP, @@ -86,6 +88,11 @@ class Database(object): _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.argtypes = [c_char_p, c_uint, POINTER(NotmuchDatabaseP)] @@ -261,6 +268,17 @@ class Database(object): 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 @@ -269,7 +287,7 @@ class Database(object): """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. @@ -383,12 +401,13 @@ class Database(object): # return the Directory, init it with the absolute path return Directory(abs_dirpath, dir_p, self) - _add_message = nmlib.notmuch_database_add_message - _add_message.argtypes = [NotmuchDatabaseP, c_char_p, + _index_file = nmlib.notmuch_database_index_file + _index_file.argtypes = [NotmuchDatabaseP, c_char_p, + c_void_p, POINTER(NotmuchMessageP)] - _add_message.restype = c_uint + _index_file.restype = c_uint - def add_message(self, filename, sync_maildir_flags=False): + def index_file(self, filename, sync_maildir_flags=False): """Adds a new message to the database :param filename: should be a path relative to the path of the @@ -439,7 +458,7 @@ class Database(object): """ self._assert_db_is_initialized() msg_p = NotmuchMessageP() - status = self._add_message(self._db, _str(filename), byref(msg_p)) + status = self._index_file(self._db, _str(filename), c_void_p(None), byref(msg_p)) if not status in [STATUS.SUCCESS, STATUS.DUPLICATE_MESSAGE_ID]: raise NotmuchError(status) @@ -451,6 +470,14 @@ class Database(object): 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 @@ -608,3 +635,108 @@ class Database(object): raise NotmuchError(message="No DB path specified" " and no user default found") return config.get('database', '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. + + """ + 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') + + """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 + + _config_list_valid = nmlib.notmuch_config_list_valid + _config_list_valid.argtypes = [NotmuchConfigListP] + _config_list_valid.restype = bool + + _config_list_key = nmlib.notmuch_config_list_key + _config_list_key.argtypes = [NotmuchConfigListP] + _config_list_key.restype = c_char_p + + _config_list_value = nmlib.notmuch_config_list_value + _config_list_value.argtypes = [NotmuchConfigListP] + _config_list_value.restype = c_char_p + + _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 + + _config_list_destroy = nmlib.notmuch_config_list_destroy + _config_list_destroy.argtypes = [NotmuchConfigListP] + _config_list_destroy.restype = None + + def get_config_list(self, prefix): + """Return a list of key, value pairs where the start of key matches the + given prefix + + Note that only config values that are stored in the database are + searched and returned. The config file is not read. + + :param prefix: a string by which the keys should be selected + :type prefix: str + :returns: all key-value pairs where `prefix` matches the beginning + of the key + :rtype: a list of pairs of str + :raises: :exc:`NotmuchError` in case of failure. + + """ + 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) + config_list = [] + 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') + config_list.append((key, value)) + self._config_list_move_to_next(config_list_p) + return config_list + + """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 + + def set_config(self, key, value): + """Set a config value in the notmuch database. + + If an empty string is provided as `value` the `key` is unset! + + :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. + + """ + self._assert_db_is_initialized() + status = self._set_config(self._db, _str(key), _str(value)) + if status != STATUS.SUCCESS: + raise NotmuchError(status)