debian/notmuch
1
0
Fork 0
mirror of https://git.notmuchmail.org/git/notmuch synced 2024-11-26 12:55:18 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

cleanup style, hopefully no functional changes.

Browse source
This commit is contained in:
acoolon 2010-04-07 16:26:42 +02:00
parent 6218951743
commit 702f88ea90
1 changed files with 575 additions and 610 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

707
notmuch
View file

@ -9,118 +9,178 @@ notmuch configuration (e.g. the database path).
Jesse Rosenthal <jrosenthal@jhu.edu> Jesse Rosenthal <jrosenthal@jhu.edu>
This code is licensed under the GNU GPL v3+. This code is licensed under the GNU GPL v3+.
""" """
from __future__ import with_statement # This isn't required in Python 2.6 import sys
import sys, os, re, stat import os
import re
import stat
import email
from cnotmuch.notmuch import Database, Query, NotmuchError, STATUS from cnotmuch.notmuch import Database, Query, NotmuchError, STATUS
PREFIX=re.compile('(\w+):(.*$)') from ConfigParser import SafeConfigParser
from cStringIO import StringIO
PREFIX = re.compile('(\w+):(.*$)')
HELPTEXT = """The notmuch mail system.
Usage: notmuch <command> [args...]
Where <command> and [args...] are as follows:
setup Interactively setup notmuch for first use.
new [--verbose]
Find and import new messages to the notmuch database.
search [options...] <search-terms> [...]
Search for messages matching the given search terms.
show <search-terms> [...]
Show all messages matching the search terms.
count <search-terms> [...]
Count messages matching the search terms.
reply [options...] <search-terms> [...]
Construct a reply template for a set of messages.
tag +<tag>|-<tag> [...] [--] <search-terms> [...]
Add/remove tags for all messages matching the search terms.
dump [<filename>]
Create a plain-text dump of the tags for each message.
restore <filename>
Restore the tags from the given dump file (see 'dump').
search-tags [<search-terms> [...] ]
List all tags found in the database or matching messages.
help [<command>]
This message, or more detailed help for the named command.
Use "notmuch help <command>" for more details on each command.
And "notmuch help search-terms" for the common search-terms syntax.
"""
USAGE = """Notmuch is configured and appears to have a database. Excellent!
At this point you can start exploring the functionality of notmuch by
using commands such as:
notmuch search tag:inbox
notmuch search to:"%(fullname)s"
notmuch search from:"%(mailaddress)s"
notmuch search subject:"my favorite things"
See "notmuch help search" for more details.
You can also use "notmuch show" with any of the thread IDs resulting
from a search. Finally, you may want to explore using a more sophisticated
interface to notmuch such as the emacs interface implemented in notmuch.el
or any other interface described at http://notmuchmail.org
And don't forget to run "notmuch new" whenever new mail arrives.
Have fun, and may your inbox never have much mail.
"""
#------------------------------------------------------------------------- #-------------------------------------------------------------------------
def quote_query_line(argv): def quote_query_line(argv):
#mangle arguments wrapping terms with spaces in quotes # mangle arguments wrapping terms with spaces in quotes
for i in xrange(0,len(argv)): for (num, item) in enumerate(argv):
if argv[i].find(' ') >= 0: if item.find(' ') >= 0:
#if we use prefix:termWithSpaces, put quotes around term # if we use prefix:termWithSpaces, put quotes around term
m = PREFIX.match(argv[i]) match = PREFIX.match(item)
if m: if match:
argv[i] = '%s:"%s"' % (m.group(1), m.group(2)) argv[num] = '%s:"%s"' %(match.group(1), match.group(2))
else: else:
argv[i] = '"'+argv[i]+'"' argv[num] = '"%s"' % item
return ' '.join(argv) return ' '.join(argv)
#------------------------------------------------------------------------- #-------------------------------------------------------------------------
class Notmuch:
def __init__(self):
class Notmuch(object):
def __init__(self, configpath="~/.notmuch-config)"):
self._config = None self._config = None
self._configpath = os.getenv('NOTMUCH_CONFIG',
os.path.expanduser(configpath))
def cmd_usage(self): def cmd_usage(self):
"""Print the usage text and exits""" """Print the usage text and exits"""
data={} data={}
names = self.get_user_email_addresses() names = self.get_user_email_addresses()
data['fullname'] =names[0] if names[0] else 'My Name' data['fullname'] = names[0] if names[0] else 'My Name'
data['mailaddress']=names[1] if names[1] else 'My@email.address' data['mailaddress'] = names[1] if names[1] else 'My@email.address'
print (Notmuch.USAGE % data) print USAGE % data
def cmd_new(self): def cmd_new(self):
"""Run 'notmuch new'""" """Run 'notmuch new'"""
#get the database directory #get the database directory
db = Database(mode=Database.MODE.READ_WRITE) db = Database(mode=Database.MODE.READ_WRITE)
path = db.get_path() path = db.get_path()
print self._add_new_files_recursively(path, db)
(added, moved, removed) = self._add_new_files_recursively(path, db)
print (added, moved, removed)
def cmd_help(self, subcmd=None): def cmd_help(self, subcmd=None):
"""Print help text for 'notmuch help'""" """Print help text for 'notmuch help'"""
if len(subcmd) > 1: if len(subcmd) > 1:
print "Help for specific commands not implemented" print "Help for specific commands not implemented"
return return
print HELPTEXT
print (Notmuch.HELPTEXT)
def _get_user_notmuch_config(self): def _get_user_notmuch_config(self):
"""Returns the ConfigParser of the user's notmuch-config""" """Returns the ConfigParser of the user's notmuch-config"""
# return the cached config parser if we read it already # return the cached config parser if we read it already
if self._config is not None: if self._config:
return self._config return self._config
from ConfigParser import SafeConfigParser
config = SafeConfigParser() config = SafeConfigParser()
conf_f = os.getenv('NOTMUCH_CONFIG', config.read(self._configpath)
os.path.expanduser('~/.notmuch-config'))
config.read(conf_f)
self._config = config self._config = config
return config return config
def _add_new_files_recursively(self, path, db): def _add_new_files_recursively(self, path, db):
""":returns: (added, moved, removed)""" """:returns: (added, moved, removed)"""
print "Enter add new files with path %s" % path print "Enter add new files with path %s" % path
(added, moved, removed) = (0,)*3
try: try:
#get the Directory() object for this path #get the Directory() object for this path
db_dir = db.get_directory(path) db_dir = db.get_directory(path)
added = moved = removed = 0
except NotmuchError: except NotmuchError:
#Occurs if we have wrong absolute paths in the db, for example # Occurs if we have wrong absolute paths in the db, for example
return (0,0,0) return (0,0,0)
#for folder in subdirs: # for folder in subdirs:
#TODO, retrieve dir mtime here and store it later # TODO, retrieve dir mtime here and store it later
#as long as Filenames() does not allow multiple iteration, we need to # as long as Filenames() does not allow multiple iteration, we need to
#use this kludgy way to get a sorted list of filenames # use this kludgy way to get a sorted list of filenames
#db_files is a list of subdirectories and filenames in this folder # db_files is a list of subdirectories and filenames in this folder
db_files = set() db_files = set()
db_folders = set() db_folders = set()
for subdir in db_dir.get_child_directories(): for subdir in db_dir.get_child_directories():
db_folders.add(subdir) db_folders.add(subdir)
for file in db_dir.get_child_files(): # file is a keyword (remove this ;))
db_files.add(file) for mail in db_dir.get_child_files():
db_files.add(mail)
fs_files = set(os.listdir(db_dir.path)) fs_files = set(os.listdir(db_dir.path))
#list of files (and folders) on the fs, but not the db # list of files (and folders) on the fs, but not the db
for fs_file in ((fs_files - db_files) - db_folders): for fs_file in ((fs_files - db_files) - db_folders):
absfile = os.path.normpath(os.path.join(db_dir.path, fs_file)) absfile = os.path.normpath(os.path.join(db_dir.path, fs_file))
statinfo = os.stat(absfile) statinfo = os.stat(absfile)
if stat.S_ISDIR(statinfo.st_mode): if stat.S_ISDIR(statinfo.st_mode):
#This is a directory # This is a directory
if fs_file in ['.notmuch','tmp','.']: if fs_file in ['.notmuch','tmp','.']:
continue continue
print "%s %s" % (fs_file, db_folders) print "%s %s" % (fs_file, db_folders)
print "Directory not in db yet. Descending into %s" % absfile print "Directory not in db yet. Descending into %s" % absfile
(new_added, new_moved, new_removed) = \ new = self._add_new_files_recursively(absfile, db)
self._add_new_files_recursively(absfile, db) added += new[0]
added += new_added moved += new[1]
moved += new_moved removed += new[2]
removed += new_removed
elif stat.S_ISLNK(statinfo.st_mode): elif stat.S_ISLNK(statinfo.st_mode):
print ("%s is a symbolic link (%d). FIXME!!!" % (absfile, statinfo.st_mode)) print ("%s is a symbolic link (%d). FIXME!!!" %
sys.exit() (absfile, statinfo.st_mode))
exit(1)
else: else:
#This is a regular file, not in the db yet. Add it. # This is a regular file, not in the db yet. Add it.
print "This file needs to be added %s" % (absfile) print "This file needs to be added %s" % (absfile)
(msg, status) = db.add_message(absfile) (msg, status) = db.add_message(absfile)
# We increases 'added', even on dupe messages. If it is a moved # We increases 'added', even on dupe messages. If it is a moved
@ -128,7 +188,6 @@ class Notmuch:
added += 1 added += 1
if status == STATUS.DUPLICATE_MESSAGE_ID: if status == STATUS.DUPLICATE_MESSAGE_ID:
#This message was already in the database
print "Added msg was in the db" print "Added msg was in the db"
else: else:
print "New message." print "New message."
@ -138,43 +197,46 @@ class Notmuch:
for db_file in (db_files - fs_files): for db_file in (db_files - fs_files):
absfile = os.path.normpath(os.path.join(db_dir.path, db_file)) absfile = os.path.normpath(os.path.join(db_dir.path, db_file))
#remove a mail message from the db # remove a mail message from the db
print ("%s is not on the fs anymore. Delete" % absfile) print ("%s is not on the fs anymore. Delete" % absfile)
status = db.remove_message(absfile) status = db.remove_message(absfile)
if status == STATUS.SUCCESS: if status == STATUS.SUCCESS:
# we just deleted the last reference, so this was a remove # we just deleted the last reference, so this was a remove
removed += 1 removed += 1
sys.stderr.write("SUCCESS %d %s %s.\n" % (status, STATUS.status2str(status), absfile)) sys.stderr.write("SUCCESS %d %s %s.\n" %
(status, STATUS.status2str(status), absfile))
elif status == STATUS.DUPLICATE_MESSAGE_ID: elif status == STATUS.DUPLICATE_MESSAGE_ID:
# The filename exists already somewhere else, so this is a move # The filename exists already somewhere else, so this is a move
moved += 1 moved += 1
added -= 1 added -= 1
sys.stderr.write("DUPE %d %s %s.\n" % (status, STATUS.status2str(status), absfile)) sys.stderr.write("DUPE %d %s %s.\n" %
(status, STATUS.status2str(status), absfile))
else: else:
#This should not occur # This should not occur
sys.stderr.write("This should not occur %d %s %s.\n" % (status, STATUS.status2str(status), absfile)) sys.stderr.write("This should not occur %d %s %s.\n" %
(status, STATUS.status2str(status), absfile))
#list of folders in the filesystem. Just descend into dirs # list of folders in the filesystem. Just descend into dirs
for fs_file in fs_files: for fs_file in fs_files:
absfile = os.path.normpath(os.path.join(db_dir.path, fs_file)) absfile = os.path.normpath(os.path.join(db_dir.path, fs_file))
if os.path.isdir(absfile): if os.path.isdir(absfile):
#This is a directory. # This is a directory. Remove it from the db_folder list.
# Remove it from the db_folder list. All remaining db_folders # All remaining db_folders at the end will be not present
# at the end will be not present on the file system. # on the file system.
db_folders.remove(fs_file) db_folders.remove(fs_file)
if fs_file in ['.notmuch','tmp','.']: if fs_file in ['.notmuch','tmp','.']:
continue continue
(new_added, new_moved, new_removed) = \ new = self._add_new_files_recursively(absfile, db)
self._add_new_files_recursively(absfile, db) added += new[0]
added += new_added moved += new[0]
moved += new_moved removed += new[0]
removed += new_removed
# we are not interested in anything but directories here # we are not interested in anything but directories here
#TODO: All remaining elements of db_folders are not in the filesystem #TODO: All remaining elements of db_folders are not in the filesystem
#delete those #delete those
return (added, moved, removed) return added, moved, removed
#Read the mtime of a directory from the filesystem #Read the mtime of a directory from the filesystem
# #
#* Call :meth:`Database.add_message` for all mail files in #* Call :meth:`Database.add_message` for all mail files in
@ -189,34 +251,32 @@ class Notmuch:
def get_user_email_addresses(self): def get_user_email_addresses(self):
""" Reads a user's notmuch config and returns his email addresses as """ Reads a user's notmuch config and returns his email addresses as
list (name, primary_address, other_address1,...)""" list (name, primary_address, other_address1,...)"""
import email.utils
#read the config file #read the config file
config = self._get_user_notmuch_config() config = self._get_user_notmuch_config()
if not config.has_option('user','name'): name = "" conf = {'name': '', 'primary_email': ''}
else:name = config.get('user','name') for entry in conf:
if config.has_option('user', entry):
conf[entry] = config.get('user', entry)
if not config.has_option('user','primary_email'): mail = "" if config.has_option('user','other_email'):
else:mail = config.get('user','primary_email') other = config.get('user','other_email')
other = [mail.strip() for mail in other.split(';') if mail]
if not config.has_option('user','other_email'): other = [] else:
else:other = config.get('user','other_email').rstrip(';').split(';') other = []
# for being compatible. It would be nicer to return a dict.
other.insert(0, mail) return conf.keys() + other
other.insert(0, name)
return other
def quote_msg_body(self, oldbody ,date, from_address): def quote_msg_body(self, oldbody ,date, from_address):
"""Transform a mail body into a quoted text, """Transform a mail body into a quoted text,
starting with On blah, x wrote: starting with On foo, bar wrote:
:param body: a str with a mail body :param body: a str with a mail body
:returns: The new payload of the email.message() :returns: The new payload of the email.message()
""" """
from cStringIO import StringIO
#we get handed a string, wrap it in a file-like object # we get handed a string, wrap it in a file-like object
oldbody = StringIO(oldbody) oldbody = StringIO(oldbody)
newbody = StringIO() newbody = StringIO()
@ -234,45 +294,44 @@ class Notmuch:
notmuch output as much as it can to pass the test suite. It notmuch output as much as it can to pass the test suite. It
could deserve a healthy bit of love. It is also buggy because could deserve a healthy bit of love. It is also buggy because
it returns after the first message it has handled.""" it returns after the first message it has handled."""
import email
for msg in msgs: for msg in msgs:
f = open(msg.get_filename(),"r") f = open(msg.get_filename(), "r")
reply = email.message_from_file(f) reply = email.message_from_file(f)
#handle the easy non-multipart case: # handle the easy non-multipart case:
if not reply.is_multipart(): if not reply.is_multipart():
reply.set_payload(self.quote_msg_body(reply.get_payload(), reply.set_payload(self.quote_msg_body(reply.get_payload(),
reply['date'],reply['from'])) reply['date'], reply['from']))
else: else:
#handle the tricky multipart case # handle the tricky multipart case
deleted = "" deleted = ""
"""A string describing which nontext attachements that """A string describing which nontext attachements
have been deleted""" that have been deleted"""
delpayloads = [] delpayloads = []
"""A list of payload indices to be deleted""" """A list of payload indices to be deleted"""
payloads = reply.get_payload() payloads = reply.get_payload()
for i, part in enumerate(payloads): for (num, part) in enumerate(payloads):
mime_main = part.get_content_maintype() mime_main = part.get_content_maintype()
if mime_main not in ['multipart', 'message', 'text']: if mime_main not in ['multipart', 'message', 'text']:
deleted += "Non-text part: %s\n" % (part.get_content_type()) deleted += "Non-text part: %s\n" % (part.get_content_type())
payloads[i].set_payload("Non-text part: %s" % (part.get_content_type())) payloads[num].set_payload("Non-text part: %s" %
payloads[i].set_type('text/plain') (part.get_content_type()))
delpayloads.append(i) payloads[num].set_type('text/plain')
delpayloads.append(num)
elif mime_main == 'text': elif mime_main == 'text':
payloads[i].set_payload(self.quote_msg_body(payloads[i].get_payload(),reply['date'],reply['from'])) payloads[num].set_payload(self.quote_msg_body(
payloads[num].get_payload(),
reply['date'], reply['from']))
else: else:
#TODO handle deeply nested multipart messages # TODO handle deeply nested multipart messages
sys.stderr.write ("FIXME: Ignoring multipart part. Handle me\n") sys.stderr.write ("FIXME: Ignoring multipart part. Handle me\n")
# Delete those payloads that we don't need anymore # Delete those payloads that we don't need anymore
for i in reversed(sorted(delpayloads)): for item in reversed(sorted(delpayloads)):
del payloads[i] del payloads[item]
#Back to single- and multipart handling # Back to single- and multipart handling
my_addresses = self.get_user_email_addresses() my_addresses = self.get_user_email_addresses()
used_address = None used_address = None
# filter our email addresses from all to: cc: and bcc: fields # filter our email addresses from all to: cc: and bcc: fields
@ -282,166 +341,79 @@ class Notmuch:
if not header in reply: if not header in reply:
#only handle fields that exist #only handle fields that exist
continue continue
addresses = email.utils.getaddresses(reply.get_all(header,[])) addresses = email.utils.getaddresses(reply.get_all(header, []))
purged_addr = [] purged_addr = []
for name, mail in addresses: for (name, mail) in addresses:
if mail in my_addresses[1:]: if mail in my_addresses[1:]:
used_address = email.utils.formataddr((my_addresses[0],mail)) used_address = email.utils.formataddr(
(my_addresses[0], mail))
else: else:
purged_addr.append(email.utils.formataddr((name,mail))) purged_addr.append(email.utils.formataddr((name, mail)))
if len(purged_addr): if purged_addr:
reply.replace_header(header, ", ".join(purged_addr)) reply.replace_header(header, ", ".join(purged_addr))
else: else:
#we deleted all addresses, delete the header # we deleted all addresses, delete the header
del reply[header] del reply[header]
# Use our primary email address to the From # Use our primary email address to the From
# (save original from line, we still need it) # (save original from line, we still need it)
orig_from = reply['From'] new_to = reply['From']
del reply['From'] if used_address:
reply['From'] = used_address if used_address \ reply['From'] = used_address
else email.utils.formataddr((my_addresses[0],my_addresses[1])) else:
email.utils.formataddr((my_addresses[0], my_addresses[1]))
#reinsert the Subject after the From reply['Subject'] = 'Re: ' + reply['Subject']
orig_subject = reply['Subject']
del reply['Subject']
reply['Subject'] = 'Re: ' + orig_subject
# Calculate our new To: field # Calculate our new To: field
new_to = orig_from
# add all remaining original 'To' addresses # add all remaining original 'To' addresses
if 'To' in reply: if 'To' in reply:
new_to += ", " + reply['To'] new_to += ", " + reply['To']
del reply['To']
reply.add_header('To', new_to) reply.add_header('To', new_to)
# Add our primary email address to the BCC # Add our primary email address to the BCC
new_bcc = my_addresses[1] new_bcc = my_addresses[1]
if reply.has_key('Bcc'): if 'Bcc' in reply:
new_bcc += ', ' + reply['Bcc'] new_bcc += ', ' + reply['Bcc']
del reply['Bcc']
reply['Bcc'] = new_bcc reply['Bcc'] = new_bcc
# Set replies 'In-Reply-To' header to original's Message-ID # Set replies 'In-Reply-To' header to original's Message-ID
if reply.has_key('Message-ID') : if 'Message-ID' in reply:
del reply['In-Reply-To']
reply['In-Reply-To'] = reply['Message-ID'] reply['In-Reply-To'] = reply['Message-ID']
#Add original's Message-ID to replies 'References' header. #Add original's Message-ID to replies 'References' header.
if reply.has_key('References'): if 'References' in reply:
ref = reply['References'] + ' ' +reply['Message-ID'] reply['References'] = ' '.join([reply['References'], reply['Message-ID']])
else: else:
ref = reply['Message-ID'] reply['References'] = reply['Message-ID']
del reply['References']
reply['References'] = ref
# Delete the original Message-ID. # Delete the original Message-ID.
del(reply['Message-ID']) del(reply['Message-ID'])
# filter all existing headers but a few and delete them from 'reply' # filter all existing headers but a few and delete them from 'reply'
delheaders = filter(lambda x: x not in ['From','To','Subject','CC', delheaders = filter(lambda x: x not in ['From', 'To', 'Subject', 'CC',
'Bcc','In-Reply-To', 'Bcc', 'In-Reply-To',
'References','Content-Type'], 'References', 'Content-Type'],
reply.keys()) reply.keys())
map(reply.__delitem__, delheaders) map(reply.__delitem__, delheaders)
# TODO: OUCH, we return after the first msg we have handled rather than # TODO: OUCH, we return after the first msg we have handled rather than
# handle all of them # handle all of them
#return resulting message without Unixfrom # return resulting message without Unixfrom
return reply.as_string(False) return reply.as_string(False)
HELPTEXT="""The notmuch mail system. def main():
Usage: notmuch <command> [args...]
Where <command> and [args...] are as follows:
setup Interactively setup notmuch for first use.
new [--verbose]
Find and import new messages to the notmuch database.
search [options...] <search-terms> [...]
Search for messages matching the given search terms.
show <search-terms> [...]
Show all messages matching the search terms.
count <search-terms> [...]
Count messages matching the search terms.
reply [options...] <search-terms> [...]
Construct a reply template for a set of messages.
tag +<tag>|-<tag> [...] [--] <search-terms> [...]
Add/remove tags for all messages matching the search terms.
dump [<filename>]
Create a plain-text dump of the tags for each message.
restore <filename>
Restore the tags from the given dump file (see 'dump').
search-tags [<search-terms> [...] ]
List all tags found in the database or matching messages.
help [<command>]
This message, or more detailed help for the named command.
Use "notmuch help <command>" for more details on each command.
And "notmuch help search-terms" for the common search-terms syntax.
"""
USAGE="""Notmuch is configured and appears to have a database. Excellent!
At this point you can start exploring the functionality of notmuch by
using commands such as:
notmuch search tag:inbox
notmuch search to:"%(fullname)s"
notmuch search from:"%(mailaddress)s"
notmuch search subject:"my favorite things"
See "notmuch help search" for more details.
You can also use "notmuch show" with any of the thread IDs resulting
from a search. Finally, you may want to explore using a more sophisticated
interface to notmuch such as the emacs interface implemented in notmuch.el
or any other interface described at http://notmuchmail.org
And don't forget to run "notmuch new" whenever new mail arrives.
Have fun, and may your inbox never have much mail.
"""
# MAIN
#-------------------------------------------------------------------------
if __name__ == '__main__':
# Handle command line options # Handle command line options
#------------------------------------- #------------------------------------
# No option given, print USAGE and exit # No option given, print USAGE and exit
if len(sys.argv) == 1: if len(sys.argv) == 1:
Notmuch().cmd_usage() Notmuch().cmd_usage()
#------------------------------------- #------------------------------------
elif sys.argv[1] == 'setup': elif sys.argv[1] == 'setup':
"""Interactively setup notmuch for first use.""" """Interactively setup notmuch for first use."""
print "Not implemented." exit("Not implemented.")
#------------------------------------- #-------------------------------------
elif sys.argv[1] == 'new': elif sys.argv[1] == 'new':
"""Check for new and removed messages.""" """Check for new and removed messages."""
@ -452,237 +424,230 @@ if __name__ == '__main__':
Notmuch().cmd_help(sys.argv[1:]) Notmuch().cmd_help(sys.argv[1:])
#------------------------------------- #-------------------------------------
elif sys.argv[1] == 'part': elif sys.argv[1] == 'part':
db = Database() part()
query_string = ''
part_num=0
first_search_term = None
for (i, arg) in enumerate(sys.argv[1:]):
if arg.startswith('--part='):
part_num_str=arg.split("=")[1]
try:
part_num = int(part_num_str)
except ValueError:
# just emulating behavior
sys.exit()
elif not arg.startswith('--'):
#save the position of the first sys.argv that is a search term
first_search_term = i+1
if first_search_term:
#mangle arguments wrapping terms with spaces in quotes
querystr = quote_query_line(sys.argv[first_search_term:])
qry = Query(db,querystr)
msgs = qry.search_messages()
msg_list = []
for m in msgs:
msg_list.append(m)
if len(msg_list) == 0:
sys.exit()
elif len(msg_list) > 1:
raise Exception("search term did not match precisely one message")
else:
msg = msg_list[0]
print(msg.get_part(part_num))
#------------------------------------- #-------------------------------------
elif sys.argv[1] == 'search': elif sys.argv[1] == 'search':
db = Database() search()
query_string = ''
sort_order="newest-first"
first_search_term = None
for (i, arg) in enumerate(sys.argv[1:]):
if arg.startswith('--sort='):
sort_order=arg.split("=")[1]
if not sort_order in ("oldest-first", "newest-first"):
raise Exception("unknown sort order")
elif not arg.startswith('--'):
#save the position of the first sys.argv that is a search term
first_search_term = i+1
if first_search_term:
#mangle arguments wrapping terms with spaces in quotes
querystr = quote_query_line(sys.argv[first_search_term:])
qry = Query(db,querystr)
if sort_order == "oldest-first":
qry.set_sort(Query.SORT.OLDEST_FIRST)
else:
qry.set_sort(Query.SORT.NEWEST_FIRST)
t = qry.search_threads()
for thread in t:
print(str(thread))
#------------------------------------- #-------------------------------------
elif sys.argv[1] == 'show': elif sys.argv[1] == 'show':
entire_thread = False show()
db = Database()
out_format="text"
querystr=''
first_search_term = None
#ugly homegrown option parsing
#TODO: use OptionParser
for (i, arg) in enumerate(sys.argv[1:]):
if arg == '--entire-thread':
entire_thread = True
elif arg.startswith("--format="):
out_format = arg.split("=")[1]
if out_format == 'json':
#for compatibility use --entire-thread for json
entire_thread = True
if not out_format in ("json", "text"):
raise Exception("unknown format")
elif not arg.startswith('--'):
#save the position of the first sys.argv that is a search term
first_search_term = i+1
if first_search_term:
#mangle arguments wrapping terms with spaces in quotes
querystr = quote_query_line(sys.argv[first_search_term:])
t = Query(db,querystr).search_threads()
first_toplevel=True
if out_format.lower()=="json":
sys.stdout.write("[")
for thrd in t:
msgs = thrd.get_toplevel_messages()
if not first_toplevel:
if out_format.lower()=="json":
sys.stdout.write(", ")
first_toplevel = False
msgs.print_messages(out_format, 0, entire_thread)
if out_format.lower() == "json":
sys.stdout.write("]")
sys.stdout.write("\n")
#------------------------------------- #-------------------------------------
elif sys.argv[1] == 'reply': elif sys.argv[1] == 'reply':
db = Database() db = Database()
if len(sys.argv) == 2: if len(sys.argv) == 2:
#no search term. abort # no search term. abort
print("Error: notmuch reply requires at least one search term.") exit("Error: notmuch reply requires at least one search term.")
sys.exit() # mangle arguments wrapping terms with spaces in quotes
#mangle arguments wrapping terms with spaces in quotes
querystr = quote_query_line(sys.argv[2:]) querystr = quote_query_line(sys.argv[2:])
msgs = Query(db,querystr).search_messages() msgs = Query(db, querystr).search_messages()
print (Notmuch().format_reply(msgs)) print Notmuch().format_reply(msgs)
#------------------------------------- #-------------------------------------
elif sys.argv[1] == 'count': elif sys.argv[1] == 'count':
if len(sys.argv) == 2: if len(sys.argv) == 2:
#no further search term, count all # no further search term, count all
querystr='' querystr = ''
else: else:
#mangle arguments wrapping terms with spaces in quotes # mangle arguments wrapping terms with spaces in quotes
querystr = quote_query_line(sys.argv[2:]) querystr = quote_query_line(sys.argv[2:])
print(Database().create_query(querystr).count_messages()) print Database().create_query(querystr).count_messages()
#------------------------------------- #-------------------------------------
elif sys.argv[1] == 'tag': elif sys.argv[1] == 'tag':
#build lists of tags to be added and removed # build lists of tags to be added and removed
add, remove = [], [] add = []
while not sys.argv[2]=='--' and \ remove = []
while not sys.argv[2] == '--' and \
(sys.argv[2].startswith('+') or sys.argv[2].startswith('-')): (sys.argv[2].startswith('+') or sys.argv[2].startswith('-')):
if sys.argv[2].startswith('+'): if sys.argv[2].startswith('+'):
#append to add list without initial + # append to add list without initial +
add.append(sys.argv.pop(2)[1:]) add.append(sys.argv.pop(2)[1:])
else: else:
#append to remove list without initial - # append to remove list without initial -
remove.append(sys.argv.pop(2)[1:]) remove.append(sys.argv.pop(2)[1:])
#skip eventual '--' # skip eventual '--'
if sys.argv[2]=='--': sys.argv.pop(2) if sys.argv[2] == '--': sys.argv.pop(2)
#the rest is search terms # the rest is search terms
querystr = quote_query_line(sys.argv[2:]) querystr = quote_query_line(sys.argv[2:])
db = Database(mode=Database.MODE.READ_WRITE) db = Database(mode=Database.MODE.READ_WRITE)
m = Query(db,querystr).search_messages() msgs = Query(db, querystr).search_messages()
for msg in m: for msg in msgs:
#actually add and remove all tags # actually add and remove all tags
map(msg.add_tag, add) map(msg.add_tag, add)
map(msg.remove_tag, remove) map(msg.remove_tag, remove)
#------------------------------------- #-------------------------------------
elif sys.argv[1] == 'search-tags': elif sys.argv[1] == 'search-tags':
if len(sys.argv) == 2: if len(sys.argv) == 2:
#no further search term # no further search term
print("\n".join(Database().get_all_tags())) print "\n".join(Database().get_all_tags())
else: else:
#mangle arguments wrapping terms with spaces in quotes # mangle arguments wrapping terms with spaces in quotes
querystr = quote_query_line(sys.argv[2:]) querystr = quote_query_line(sys.argv[2:])
db = Database() db = Database()
m = Query(db,querystr).search_messages() msgs = Query(db, querystr).search_messages()
print("\n".join([t for t in m.collect_tags()])) print "\n".join([t for t in msgs.collect_tags()])
#------------------------------------- #-------------------------------------
elif sys.argv[1] == 'dump': elif sys.argv[1] == 'dump':
#TODO: implement "dump <filename>" # TODO: implement "dump <filename>"
if len(sys.argv) == 2: if len(sys.argv) == 2:
f = sys.stdout f = sys.stdout
else: else:
f = open(sys.argv[2],"w") f = open(sys.argv[2], "w")
db = Database() db = Database()
q = Query(db,'') query = Query(db, '')
q.set_sort(Query.SORT.MESSAGE_ID) query.set_sort(Query.SORT.MESSAGE_ID)
m = q.search_messages() msgs = query.search_messages()
for msg in m: for msg in msgs:
f.write("%s (%s)\n" % (msg.get_message_id(), msg.get_tags())) f.write("%s (%s)\n" % (msg.get_message_id(), msg.get_tags()))
#------------------------------------- #-------------------------------------
elif sys.argv[1] == 'restore': elif sys.argv[1] == 'restore':
import re
if len(sys.argv) == 2: if len(sys.argv) == 2:
print("No filename given. Reading dump from stdin.") print("No filename given. Reading dump from stdin.")
f = sys.stdin f = sys.stdin
else: else:
f = open(sys.argv[2],"r") f = open(sys.argv[2], "r")
#split the msg id and the tags
# split the msg id and the tags
MSGID_TAGS = re.compile("(\S+)\s\((.*)\)$") MSGID_TAGS = re.compile("(\S+)\s\((.*)\)$")
db = Database(mode=Database.MODE.READ_WRITE) db = Database(mode=Database.MODE.READ_WRITE)
#read each line of the dump file #read each line of the dump file
for line in f: for line in f:
m = MSGID_TAGS.match(line) msgs = MSGID_TAGS.match(line)
if not m: if not msgs:
sys.stderr.write("Warning: Ignoring invalid input line: %s" % sys.stderr.write("Warning: Ignoring invalid input line: %s" %
line) line)
continue continue
# split line in components and fetch message # split line in components and fetch message
msg_id = m.group(1) msg_id = msgs.group(1)
new_tags= set(m.group(2).split()) new_tags = set(msgs.group(2).split())
msg = db.find_message(msg_id) msg = db.find_message(msg_id)
if msg == None: if msg == None:
sys.stderr.write( sys.stderr.write(
"Warning: Cannot apply tags to missing message: %s\n" % id) "Warning: Cannot apply tags to missing message: %s\n" % msg_id)
continue continue
#do nothing if the old set of tags is the same as the new one # do nothing if the old set of tags is the same as the new one
old_tags = set(msg.get_tags()) old_tags = set(msg.get_tags())
if old_tags == new_tags: continue if old_tags == new_tags: continue
#set the new tags # set the new tags
msg.freeze() msg.freeze()
#only remove tags if the new ones are not a superset anyway # only remove tags if the new ones are not a superset anyway
if not (new_tags > old_tags): msg.remove_all_tags() if not (new_tags > old_tags): msg.remove_all_tags()
for tag in new_tags: msg.add_tag(tag) for tag in new_tags: msg.add_tag(tag)
msg.thaw() msg.thaw()
#------------------------------------- #-------------------------------------
else: else:
# unknown command # unknown command
print "Error: Unknown command '%s' (see \"notmuch help\")" % sys.argv[1] exit("Error: Unknown command '%s' (see \"notmuch help\")" % sys.argv[1])
def part():
db = Database()
query_string = ''
part_num = 0
first_search_term = 0
for (num, arg) in enumerate(sys.argv[1:]):
if arg.startswith('--part='):
part_num_str = arg.split("=")[1]
try:
part_num = int(part_num_str)
except ValueError:
# just emulating behavior
exit(1)
elif not arg.startswith('--'):
# save the position of the first sys.argv
# that is a search term
first_search_term = num + 1
if first_search_term:
# mangle arguments wrapping terms with spaces in quotes
querystr = quote_query_line(sys.argv[first_search_term:])
qry = Query(db,querystr)
msgs = [msg for msg in qry.search_messages()]
#TODO: implement if not msgs:
""" sys.exit(1)
setup elif len(msgs) > 1:
new raise Exception("search term did not match precisely one message")
show <search-terms> [...] else:
reply [options...] <search-terms> [...] msg = msgs[0]
restore <filename> print msg.get_part(part_num)
"""
def search():
db = Database()
query_string = ''
sort_order = "newest-first"
first_search_term = 0
for (num, arg) in enumerate(sys.argv[1:]):
if arg.startswith('--sort='):
sort_order=arg.split("=")[1]
if not sort_order in ("oldest-first", "newest-first"):
raise Exception("unknown sort order")
elif not arg.startswith('--'):
# save the position of the first sys.argv that is a search term
first_search_term = num + 1
if first_search_term:
# mangle arguments wrapping terms with spaces in quotes
querystr = quote_query_line(sys.argv[first_search_term:])
qry = Query(db, querystr)
if sort_order == "oldest-first":
qry.set_sort(Query.SORT.OLDEST_FIRST)
else:
qry.set_sort(Query.SORT.NEWEST_FIRST)
threads = qry.search_threads()
for thread in threads:
print thread
def show():
entire_thread = False
db = Database()
out_format = "text"
querystr = ''
first_search_term = None
# ugly homegrown option parsing
# TODO: use OptionParser
for (num, arg) in enumerate(sys.argv[1:]):
if arg == '--entire-thread':
entire_thread = True
elif arg.startswith("--format="):
out_format = arg.split("=")[1]
if out_format == 'json':
# for compatibility use --entire-thread for json
entire_thread = True
if not out_format in ("json", "text"):
raise Exception("unknown format")
elif not arg.startswith('--'):
# save the position of the first sys.argv that is a search term
first_search_term = num + 1
if first_search_term:
# mangle arguments wrapping terms with spaces in quotes
querystr = quote_query_line(sys.argv[first_search_term:])
threads = Query(db, querystr).search_threads()
first_toplevel = True
if out_format == "json":
sys.stdout.write("[")
for thread in threads:
msgs = thread.get_toplevel_messages()
if not first_toplevel:
if out_format == "json":
sys.stdout.write(", ")
first_toplevel = False
msgs.print_messages(out_format, 0, entire_thread)
if out_format == "json":
sys.stdout.write("]")
sys.stdout.write("\n")
if __name__ == '__main__':
main()
# TODO: implement
"""
setup (not?)
new (halfway there)
"""