package from Python's standard library. You could e.g. create
this as such::
- notmuch_msg = db.get_message(msgid) # or from a query
+ notmuch_msg = db.find(msgid) # or from a query
parser = email.parser.BytesParser(policy=email.policy.default)
with notmuch_msg.path.open('rb) as fp:
email_msg = parser.parse(fp)
def messageid(self):
"""The message ID as a string.
- The message ID is decoded with the ignore error handler. This
- is fine as long as the message ID is well formed. If it is
- not valid ASCII then this will be lossy. So if you need to be
- able to write the exact same message ID back you should use
- :attr:`messageidb`.
-
Note that notmuch will decode the message ID value and thus
strip off the surrounding ``<`` and ``>`` characters. This is
different from Python's :mod:`email` package behaviour which
self._msg_p, capi.lib.NOTMUCH_MESSAGE_FLAG_EXCLUDED)
return bool(ret)
+ @property
+ def matched(self):
+ """Indicates whether this message was matched by the query.
+
+ When a thread is created from a search, some of the
+ messages may not match the original query. This property
+ is set to *True* for those that do match.
+
+ :raises ObjectDestroyedError: if used after destroyed.
+ """
+ ret = capi.lib.notmuch_message_get_flag(
+ self._msg_p, capi.lib.NOTMUCH_MESSAGE_FLAG_MATCH)
+ return bool(ret)
+
@property
def date(self):
"""The message date as an integer.
:param header: Case-insensitive header name to retrieve.
:type header: str or bytes
- :returns: The header value, an empty string if the header is
- not present.
+ :returns: The header value.
:rtype: str
:raises LookupError: if the header is not present.
and thus are only recommended if you know there to be only one
value.
- Instead the map has an additional :meth:`PropertiesMap.all`
+ Instead the map has an additional :meth:`PropertiesMap.getall`
method which can be used to retrieve all properties of a given
- key. This method also allows iterating of a a subset of the
+ key. This method also allows iterating of a subset of the
keys starting with a given prefix.
"""
try:
This method will only work if the message was created from a
thread. Otherwise it will yield no results.
- :returns: An iterator yielding :class:`Message` instances.
+ :returns: An iterator yielding :class:`OwnedMessage` instances.
:rtype: MessageIter
"""
# The notmuch_messages_valid call accepts NULL and this will
# become an empty iterator, raising StopIteration immediately.
# Hence no return value checking here.
msgs_p = capi.lib.notmuch_message_get_replies(self._msg_p)
- return MessageIter(self, msgs_p, db=self._db)
+ return MessageIter(self, msgs_p, db=self._db, msg_cls=OwnedMessage)
def __hash__(self):
return hash(self.messageid)
"""A mutable mapping to manage properties.
Both keys and values of properties are supposed to be UTF-8
- strings in libnotmuch. However since the uderlying API uses
+ strings in libnotmuch. However since the underlying API uses
bytestrings you can use either str or bytes to represent keys and
all returned keys and values use :class:`BinString`.
return len(list(it))
def __getitem__(self, key):
- """Return **the first** peroperty associated with a key."""
+ """Return **the first** property associated with a key."""
if isinstance(key, str):
key = key.encode('utf-8')
value_pp = capi.ffi.new('char**')
"""Return a :class:`collections.abc.ItemsView` for this map.
The ItemsView treats a ``(key, value)`` pair as unique, so
- dupcliate ``(key, value)`` pairs will be merged together.
+ duplicate ``(key, value)`` pairs will be merged together.
However duplicate keys with different values will be returned.
"""
items = set()
return PropertiesItemsView(items)
def values(self):
- """Return a :class:`collecions.abc.ValuesView` for this map.
+ """Return a :class:`collections.abc.ValuesView` for this map.
All unique property values are included in the view.
"""
def getall(self, prefix='', *, exact=False):
"""Return an iterator yielding all properties for a given key prefix.
- The returned iterator yields all peroperties which start with
+ The returned iterator yields all properties which start with
a given key prefix as ``(key, value)`` namedtuples. If called
with ``exact=True`` then only properties which exactly match
the prefix are returned, those a key longer than the prefix
def __next__(self):
if not self._fn_valid(self._iter_p):
- self._destroy()
raise StopIteration
key = capi.lib.notmuch_message_properties_key(self._iter_p)
value = capi.lib.notmuch_message_properties_value(self._iter_p)
projects / notmuch / blobdiff