import argparse
import configparser
import os
import sys
from timeit import default_timer as timer
from sqlalchemy import create_engine, exc
from sqlalchemy.orm import sessionmaker
import quarg.actions as actions
import quarg.database.filters as filters
import quarg.quassel.formatter as formatter
from quarg.database.tables import Backlog, Buffer, Network, QuasselUser, Sender
from quarg.utils import errx
# pylint: disable=line-too-long
cli = argparse.ArgumentParser()
cli.add_argument('keyword', nargs='*', help='match messages containing this keyword')
cli.add_argument('-d', action='store_true', dest='debug', help='print debug and SQL query information')
cli.add_argument('-e', action='store_true', dest='expr', help='interpret keywords as LIKE expression')
cli.add_argument('-l', dest='limit', metavar='NUM', type=int, help='limit the number of matches')
cli.add_argument('-o', action=actions.ParseOrder, dest='order', metavar='asc|desc', help='sort matches in this order')
matchers = cli.add_argument_group('matching message context')
matchers.add_argument('-b', action='append', dest='buffer', help='match this buffer')
matchers.add_argument('-B', action=actions.ParseBufferType, dest='buftype', help='match buffers of this type')
matchers.add_argument('-n', action='append', dest='nick', help='match this nickname')
matchers.add_argument('-m', action='append', dest='prefix', help='match nicknames with this channel membership prefix')
matchers.add_argument('-N', action='append', dest='network', help='match this network')
matchers.add_argument('-Q', action='append', dest='user', help='match this quassel user')
matchers.add_argument('-t', action=actions.ParseMessageType, dest='msgtype', help='match this message type')
matchers.add_argument('-f', action=actions.ParseMessageFlag, dest='msgflag', help='match this message flag')
date_matchers = cli.add_argument_group('matching message timestamps')
date_matchers.add_argument('--after', action=actions.ParseDate, metavar='DATE', help='sent after this date')
date_matchers.add_argument('--before', action=actions.ParseDate, metavar='DATE', help='sent before this date')
date_matchers.add_argument('--around', action=actions.ParseAround, metavar='DATE[/RANGE]', help='sent RANGE hours/minutes before or after this date')
joined_group = matchers.add_mutually_exclusive_group()
joined_group.add_argument('--joined', default=None, action='store_true', dest='joined', help='match buffers which are currently joined')
joined_group.add_argument('--no-joined', default=None, action='store_false', dest='joined', help='match buffers which are not currently joined')
# pylint: enable=line-too-long
Session = sessionmaker()
def get_config():
xdg_config_home = os.path.expanduser('~/.config/')
if 'XDG_CONFIG_HOME' in os.environ:
xdg_config_home = os.environ['XDG_CONFIG_HOME']
path = os.path.join(xdg_config_home, 'quarg', 'config')
config = configparser.ConfigParser()
config.read(path)
return config
def check_args(args):
if args.around is not None:
if args.before is not None or args.after is not None:
errx('--around cannot be used with --after or --before')
def collect_predicates(args):
funs = {
'keyword': filters.msg_like if args.expr else filters.msg_contains,
'buffer': filters.buffer,
'nick': filters.nick,
'after': filters.time_after,
'before': filters.time_before,
'around': filters.time_around,
'user': filters.user,
'network': filters.network,
'msgflag': filters.msgflag,
'msgtype': filters.msgtype,
'buftype': filters.buftype,
'prefix': filters.prefix,
'joined': filters.joined,
}
for key, value in vars(args).items():
# ignore unset or empty arguments
# Note: 'if not value' does not work here because 'joined' can be falsy
# but still needs to be passed to filters.joined
if value is None or value == []:
continue
# ignore arguments that do not map to predicates
if key not in funs:
continue
if args.debug:
print(f'{key}: {value}', file=sys.stderr)
fun = funs[key]
if isinstance(value, list):
yield filters.any_filter(fun, value)
else:
yield fun(value)
def prepare_query(session, predicates, args):
query = session.query(Backlog).join(Sender).join(Buffer).join(Network).join(QuasselUser)
for predicate in predicates:
query = query.filter(predicate)
order = Backlog.time.asc()
if args.order == 'desc':
order = Backlog.time.desc()
query = query.order_by(order)
if args.limit:
query = query.limit(args.limit)
return query
def time_query(query):
start = timer()
rows = query.all()
end = timer()
return rows, end - start
def main():
args = cli.parse_intermixed_args()
check_args(args)
config = get_config()
if not config.has_option('Database', 'url'):
errx('No database URL set in config file.')
engine = create_engine(config.get('Database', 'url'), echo=args.debug)
session = Session(bind=engine)
predicates = list(collect_predicates(args))
if not predicates:
errx('Nothing to match.')
try:
query = prepare_query(session, predicates, args)
rows, time = time_query(query)
for row in rows:
print(formatter.format_from(row))
except exc.SQLAlchemyError as err:
errx(err)
except (KeyboardInterrupt, BrokenPipeError):
session.rollback()
session.close()
sys.exit(1)
print(f'Query returned {len(rows)} lines in {time:.4f} seconds.', file=sys.stderr)
if __name__ == "__main__":
main()
