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>
"""
-from ctypes import c_char_p, c_uint
-from notmuch.globals import (
+from ctypes import c_char_p, c_uint, POINTER, byref
+from .globals import (
nmlib,
Enum,
_str,
NotmuchThreadsP,
NotmuchDatabaseP,
NotmuchMessagesP,
+)
+from .errors import (
+ NotmuchError,
NullPointerError,
NotInitializedError,
)
-from notmuch.thread import Threads
-from notmuch.message import Messages
+from .threads import Threads
+from .messages import Messages
class Query(object):
:type db: :class:`Database`
:param querystr: The query string
:type querystr: utf-8 encoded str or unicode
- :returns: Nothing
- :exception:
+ :raises:
:exc:`NullPointerError` if the query creation failed
(e.g. too little memory).
:exc:`NotInitializedError` if the underlying db was not
# 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))
+ query_p = Query._create(db._db, _str(querystr))
if not query_p:
raise NullPointerError
self._query = query_p
self.sort = sort
self._set_sort(self._query, sort)
+ _exclude_tag = nmlib.notmuch_query_add_tag_exclude
+ _exclude_tag.argtypes = [NotmuchQueryP, c_char_p]
+ _exclude_tag.resttype = None
+
+ def exclude_tag(self, tagname):
+ """Add a tag that will be excluded from the query results by default.
+
+ This exclusion will be overridden if this tag appears explicitly in the
+ query.
+
+ :param tagname: Name of the tag to be excluded
+ """
+ self._assert_query_is_initialized()
+ self._exclude_tag(self._query, _str(tagname))
+
"""notmuch_query_search_threads"""
_search_threads = nmlib.notmuch_query_search_threads
- _search_threads.argtypes = [NotmuchQueryP]
- _search_threads.restype = NotmuchThreadsP
+ _search_threads.argtypes = [NotmuchQueryP, POINTER(NotmuchThreadsP)]
+ _search_threads.restype = c_uint
def search_threads(self):
"""Execute a query for threads
to get the value of this flag.
:returns: :class:`Threads`
- :exception: :exc:`NullPointerError` if search_threads failed
+ :raises: :exc:`NullPointerError` if search_threads failed
"""
self._assert_query_is_initialized()
- threads_p = Query._search_threads(self._query)
+ threads_p = NotmuchThreadsP() # == NULL
+ status = Query._search_threads(self._query, byref(threads_p))
+ if status != 0:
+ raise NotmuchError(status)
if not threads_p:
raise NullPointerError
return Threads(threads_p, self)
- """notmuch_query_search_messages"""
- _search_messages = nmlib.notmuch_query_search_messages
- _search_messages.argtypes = [NotmuchQueryP]
- _search_messages.restype = NotmuchMessagesP
+ """notmuch_query_search_messages_st"""
+ _search_messages_st = nmlib.notmuch_query_search_messages_st
+ _search_messages_st.argtypes = [NotmuchQueryP, POINTER(NotmuchMessagesP)]
+ _search_messages_st.restype = c_uint
def search_messages(self):
"""Filter messages according to the query and return
:class:`Messages` in the defined sort order
:returns: :class:`Messages`
- :exception: :exc:`NullPointerError` if search_messages failed
+ :raises: :exc:`NullPointerError` if search_messages failed
"""
self._assert_query_is_initialized()
- msgs_p = Query._search_messages(self._query)
+ msgs_p = NotmuchMessagesP() # == NULL
+ status = Query._search_messages_st(self._query, byref(msgs_p))
+ if status != 0:
+ raise NotmuchError(status)
if not msgs_p:
raise NullPointerError
return Messages(msgs_p, self)
- _count_messages = nmlib.notmuch_query_count_messages
- _count_messages.argtypes = [NotmuchQueryP]
+ _count_messages = nmlib.notmuch_query_count_messages_st
+ _count_messages.argtypes = [NotmuchQueryP, POINTER(c_uint)]
_count_messages.restype = c_uint
def count_messages(self):
:rtype: int
'''
self._assert_query_is_initialized()
- return Query._count_messages(self._query)
-
- _count_threads = nmlib.notmuch_query_count_threads
- _count_threads.argtypes = [NotmuchQueryP]
+ count = c_uint(0)
+ status = Query._count_messages(self._query, byref(count))
+ if status != 0:
+ raise NotmuchError(status)
+ return count.value
+
+ _count_threads = nmlib.notmuch_query_count_threads_st
+ _count_threads.argtypes = [NotmuchQueryP, POINTER(c_uint)]
_count_threads.restype = c_uint
def count_threads(self):
:rtype: int
'''
self._assert_query_is_initialized()
- return Query._count_threads(self._query)
+ count = c_uint(0)
+ status = Query._count_threads(self._query, byref(count))
+ if status != 0:
+ raise NotmuchError(status)
+ return count.value
_destroy = nmlib.notmuch_query_destroy
_destroy.argtypes = [NotmuchQueryP]
def __del__(self):
"""Close and free the Query"""
- if self._query is not None:
+ if self._query:
self._destroy(self._query)
projects / notmuch / blobdiff