def test_function():
print("EXPECTED:", ", ".join(sorted(tuple(expected.keys()))))
found = parse_one_vql(vql_expr)
print("FOUND:", ", ".join(sorted(tuple(found.keys()))))
pprint(expected)
print()
pprint(found)
assert found == expected
def execute(conn: sqlite3.Connection, vql_source: str):
"""Execute a vql query
Examples:
>>> for variant in execute(conn,"SELECT chr from variants"):
>>> print(variant)
Args:
conn (sqlite3.Connection): sqlite3 connection
vql_source (str): a VQL query
Returns:
dict: Return command output as a dict
"""
# Convert VQL string into VQL object
vql_obj = vql.parse_one_vql(vql_source)
# Convert VQL object into wrapped SQL query
cmd = create_command_from_obj(conn, vql_obj)
return cmd()
def test_create_command_from_obj(conn):
"""Test create_command_from_obj
- Test from VQL Query
- Test from VQL Object
"""
## From VQL Query ##########################################################
cmd = command.create_command_from_obj(
conn, vql.parse_one_vql("CREATE denovo FROM variants"))
expected_kwargs = {
"cmd": "create_cmd",
"source": "variants",
"filters": {},
"target": "denovo",
}
print(cmd.keywords)
assert cmd.keywords == expected_kwargs
cmd = command.create_command_from_obj(
conn, vql.parse_one_vql("CREATE denovo = a | b "))
print(cmd.keywords)
expected_kwargs = {
"cmd": "set_cmd",
"target": "denovo",
"first": "a",
"operator": "|",
"second": "b",
}
assert cmd.keywords == expected_kwargs
cmd = command.create_command_from_obj(
conn,
vql.parse_one_vql("CREATE denovo FROM variants INTERSECT 'test.bed' "))
print(cmd.keywords)
# Keywords of partial function
expected_kwargs = {
"cmd": "bed_cmd",
"target": "denovo",
"source": "variants",
"path": "test.bed",
}
assert cmd.keywords == expected_kwargs
## From VQL objects ########################################################
expected_kwargs = {
"cmd": "create_cmd",
"fields": ["chr", "pos"],
"target": "test",
"source": "variants",
"filters": {},
}
partial_fct = command.create_command_from_obj(conn, expected_kwargs)
print(partial_fct.keywords)
assert partial_fct.keywords == expected_kwargs
expected_kwargs = {
"cmd": "select_cmd",
"fields": ["chr", "pos"],
"source": "variants",
"filters": {},
}
partial_fct = command.create_command_from_obj(conn, expected_kwargs)
print(partial_fct.keywords)
assert partial_fct.keywords == expected_kwargs
def main():
# noinspection PyTypeChecker
parser = argparse.ArgumentParser(
formatter_class=lambda prog: argparse.RawDescriptionHelpFormatter(prog),
description="""
Cutevariant cli mode helps to run actions directly from command-line.\n
The env variable $CUTEVARIANT_DB can be used to define a database instead of
the arguments.""",
epilog="""Examples:
$ cutevariant-cli show --db my_database.db samples
or
$ export CUTEVARIANT_DB=my_database.db
$ cutevariant-cli show samples""",
)
# Default log level: critical
parser.add_argument(
"-vv",
"--verbose",
nargs="?",
default="error",
choices=["debug", "info", "critical", "error", "warning"],
)
sub_parser = parser.add_subparsers(dest="subparser")
# Common parser: Database file requirement #################################
parent_parser = argparse.ArgumentParser(add_help=False)
parent_parser.add_argument(
"--db", help="SQLite database. By default, $CUTEVARIANT_DB is used."
)
# Create DB parser #########################################################
createdb_parser = sub_parser.add_parser(
"createdb",
help="Build a SQLite database from a vcf file",
parents=[parent_parser],
epilog="""Examples:
$ cutevariant-cli createdb -i "examples/test.snpeff.vcf"
""",
)
createdb_parser.add_argument("-i", "--input", help="VCF file path", required=True)
# Show parser ##############################################################
show_parser = sub_parser.add_parser(
"show", help="Display table content", parents=[parent_parser]
)
show_parser.add_argument(
"table",
choices=["fields", "selections", "samples", "wordsets"],
help="Possible names of tables.",
)
# Remove parser ############################################################
remove_parser = sub_parser.add_parser(
"remove", help="remove selection", parents=[parent_parser]
)
remove_parser.add_argument("names", nargs="+", help="Name(s) of selection(s).")
# VQL parser ###############################################################
select_parser = sub_parser.add_parser(
"exec",
help="Execute a VQL statement.",
parents=[parent_parser],
formatter_class=argparse.RawDescriptionHelpFormatter,
epilog="""Examples:
$ cutevariant-cli exec "SELECT favorite,chr,pos,ref,alt FROM variants"
or
$ cutevariant-cli exec "SELECT chr,ref,alt FROM variants" -s myselection
or
$ cutevariant-cli exec "IMPORT WORDSETs 'examples/gene.txt' AS mygenes"
or
$ cutevariant-cli exec "DROP WORDSETS mygenes"
or
$ cutevariant-cli exec "CREATE myselection1 FROM variants WHERE gene = 'CHID1'"
$ cutevariant-cli exec "CREATE myselection2 FROM variants WHERE gene = 'CICP23'"
$ cutevariant-cli exec "CREATE myselection3 = myselection2 | myselection2"
or
$ cutevariant-cli exec "CREATE boby FROM variants INTERSECT 'examples/test.bed'"
""",
)
select_parser.add_argument("vql", help="A VQL statement.")
select_parser.add_argument(
"-l",
"--limit",
help="Limit the number of lines in output.",
type=int,
default=100,
)
# select_parser.add_argument(
# "-g",
# "--group",
# action="store_true",
# help="Group SELECT query by...(chr,pos,ref,alt).",
# )
select_parser.add_argument(
"-s", "--to-selection", help="Save SELECT query into a selection name."
)
# Set parser ###############################################################
# set_parser = sub_parser.add_parser("set", help="Set variable", parents=[parent_parser])
# Workaround for sphinx-argparse module that require the object parser
# before the call of parse_args()
if "html" in sys.argv:
return parser
args = parser.parse_args()
if len(sys.argv) == 1:
parser.print_help(sys.stderr)
sys.exit(1)
# Set log level
# _logger.setLevel(logging.DEBUG)
log_level(args.verbose)
# Create DB parser #########################################################
if args.subparser == "createdb":
if not args.db:
# Database file is not set:
# The output file will be based on the name of the VCF one
args.db = args.input + ".db"
if os.path.exists(args.db):
# Remove existing file
os.remove(args.db)
conn = sql.get_sql_connection(args.db)
if conn:
# TODO: bug ... max is not 100...
for i, message in progressbar.progressbar(
async_import_file(conn, args.input), redirect_stdout=True
):
print(message)
print("The database is successfully created!")
exit()
# Prepare SQL connection on DB file
if "CUTEVARIANT_DB" in os.environ and args.subparser != "createdb":
args.db = os.environ["CUTEVARIANT_DB"]
elif not args.db:
print("You must specify a database file via $CUTEVARIANT_DB or --db argument")
exit()
# Init SQL connection
conn = sql.get_sql_connection(args.db)
# Show parser ##############################################################
if args.subparser == "show":
if args.table == "fields":
display_sql_results(
(i.values() for i in sql.get_fields(conn)),
["id", "name", "table", "type", "description"],
)
if args.table == "samples":
display_sql_results(
(i.values() for i in sql.get_samples(conn)), ["id", "name"]
)
if args.table == "selections":
display_sql_results(
(i.values() for i in sql.get_selections(conn)),
["id", "name", "variant_count"],
)
if args.table == "wordsets":
display_sql_results(
(i.values() for i in sql.get_wordsets(conn)), ["id", "word_count"]
)
# Remove parser ############################################################
if args.subparser == "remove":
for name in args.names:
sql.delete_selection_by_name(conn, name)
# VQL parser ###############################################################
if args.subparser == "exec":
query = "".join(args.vql)
vql_command = None
# Test the VQL query
try:
cmd = vql.parse_one_vql(query)
except (vql.textx.TextXSyntaxError, vql.VQLSyntaxError) as e:
# Available attributes: e.message, e.line, e.col
print("%s: %s, col: %d" % (e.__class__.__name__, e.message, e.col))
print("For query:", query)
exit(0)
# Select command with redirection to selection
if cmd["cmd"] == "select_cmd" and args.to_selection:
vql_command = partial(
command.create_cmd,
conn,
args.to_selection,
source=cmd["source"],
filters=cmd["filters"],
)
try:
# Is it redundant with check_vql ?
# No because we also execute SQL statement here
if vql_command:
ret = vql_command()
else:
ret = command.create_command_from_obj(conn, cmd)()
if not isinstance(ret, dict):
# For drop_cmd, import_cmd,
ret = list(ret)
except (sqlite3.DatabaseError, vql.VQLSyntaxError) as e:
LOGGER.exception(e)
exit(0)
LOGGER.debug("SQL result: %s", ret)
LOGGER.debug("VQL command: %s", cmd["cmd"])
# Note: show_cmd is supported in a separated command option
# Select command
if cmd["cmd"] in ("select_cmd",) and not args.to_selection:
display_sql_results((i.values() for i in ret), ["id"] + cmd["fields"])
exit(1)
if (
cmd["cmd"] in ("drop_cmd", "import_cmd", "create_cmd", "set_cmd", "bed_cmd")
or args.to_selection
):
# PS: to_selection is used to detect select_cmd with selection creation
display_query_status(ret)