def conn():
"""Initialize a memory DB with test data and return a connexion on this DB"""
conn = sql.get_sql_connection(":memory:")
sql.create_project(conn, "test", "hg19")
assert table_exists(conn, "projects"), "cannot create table projects"
sql.create_table_fields(conn)
assert table_exists(conn, "fields"), "cannot create table fields"
sql.insert_many_fields(conn, FIELDS)
assert table_count(conn,
"fields") == len(FIELDS), "cannot insert many fields"
sql.create_table_selections(conn)
assert table_exists(conn, "selections"), "cannot create table selections"
sql.create_table_annotations(
conn, sql.get_field_by_category(conn, "annotations"))
assert table_exists(conn, "annotations"), "cannot create table annotations"
sql.create_table_samples(conn, sql.get_field_by_category(conn, "samples"))
assert table_exists(conn, "samples"), "cannot create table samples"
sql.insert_many_samples(conn, SAMPLES)
sql.create_table_variants(conn,
sql.get_field_by_category(conn, "variants"))
assert table_exists(conn, "variants"), "cannot create table variants"
sql.insert_many_variants(conn, VARIANTS)
sql.create_table_wordsets(conn)
assert table_exists(conn, "wordsets"), "cannot create table sets"
return conn
def conn():
# Do not use ":memory:" ! SqlThread open the file
tempdb = tempfile.mkstemp(suffix=".db")[1]
conn = sql.get_sql_connection(tempdb)
importer.import_reader(
conn, VcfReader(open("examples/test.snpeff.vcf"), "snpeff"))
return conn
def run(self):
"""Execute the function in a new thread
Note:
All the context of this function is executed into a separated thread.
"""
self.last_error = None
if self.function is None:
LOGGER.exception("no function defined")
return
self._async_conn = get_sql_connection(self.db_file)
assert self.async_conn
try:
LOGGER.debug("thread start ")
self.results = self.function(self.async_conn)
LOGGER.debug("Thread finished")
except Exception as e:
# LOGGER.exception(e)
self.last_error = "%s: %s" % (e.__class__.__name__, str(e))
self.async_conn.close()
self.error.emit(self.last_error)
else:
self.async_conn.close()
self.result_ready.emit()
return
def conn():
# Required a real file to make it work !
tempdb = tempfile.mkstemp(suffix=".db")[1]
conn = sql.get_sql_connection(tempdb)
importer.import_reader(
conn, VcfReader(open("examples/test.snpeff.vcf"), "snpeff"))
return conn
def run(self):
"""Execute the function in a new thread
Note:
All the context of this function is executed into a separated thread.
Signals:
- started: When the threaded function is started
- finished: When the function has finished its execution.
"""
# Copy the current query number so it is attached to this run only
query_number = int(self.query_number)
# Use a new connection to be thread safe
thread_id = QThread.currentThread()
if thread_id not in self.sql_connections_pool:
# Current thread hasn't its connection => create a new one
# LOGGER.debug("NEW CONN for %s", thread_id)
self.async_conn = get_sql_connection(self.db_file)
self.sql_connections_pool[thread_id] = self.async_conn
else:
# Reuse sql connection
# LOGGER.debug("REUSE CONN for %s", thread_id)
self.async_conn = self.sql_connections_pool[thread_id]
# Connection must be established
assert self.async_conn
self.started.emit()
try:
self.results = self.function(self.async_conn)
except Exception as e:
LOGGER.exception(e)
self.error.emit("%s: %s" % (e.__class__.__name__, str(e)))
return
self.finished.emit(query_number)
def conn():
conn = sql.get_sql_connection(":memory:")
import_reader(conn, VcfReader(open("examples/test.snpeff.vcf"), "snpeff"))
return conn
if sql.table_exists(conn, "annotations"):
genes_data = get_gene_counts(conn)
else:
gene_data = {}
return meta_data, stats_data, genes_data
self.status_bar.showMessage("Loading ...")
self.metric_thread = SqlThread(self.conn, compute_metrics)
self.metric_thread.result_ready.connect(self.loaded)
self.metric_thread.start()
def loaded(self):
"""Called at the end of the thread and populate data"""
meta_data, stats_data, genes_data = self.metric_thread.results
self.stat_view.set_dict(stats_data)
self.meta_view.set_dict(meta_data)
self.ann_view.set_dict(genes_data)
self.status_bar.showMessage("")
if __name__ == "__main__":
from PySide2.QtWidgets import QApplication
import sys
app = QApplication(sys.argv)
conn = sql.get_sql_connection("test.db")
dialog = MetricsDialog(conn=conn)
app.exec_()
def mousePressEvent(self, event):
# HACK for testing...
self.changed.emit()
if __name__ == "__main__":
from cutevariant.core import sql
from PySide2.QtWidgets import *
import sys
app = QApplication(sys.argv)
conn = sql.get_sql_connection("C:/sacha/Dev/cutevariant/exome.db")
all_w = FiltersEditor()
elements = {
"tabs": [{
"name":
"tab1",
"sections": [{
"name":
"section1",
"widgets": [
{
"name": "chr",
"description": "editeur de truc",
"widget": StringFilterWidget("chr"),
from prompt_toolkit.history import InMemoryHistory
from prompt_toolkit.auto_suggest import AutoSuggestFromHistory
from cutevariant.core import command as cmd
from cutevariant.core import sql
from cutevariant.core.importer import import_file
from cutevariant.core.vql import VQLSyntaxError
from prompt_toolkit.lexers import PygmentsLexer
from pygments.lexers.sql import SqlLexer
import types
session = PromptSession(lexer=PygmentsLexer(SqlLexer))
conn = sql.get_sql_connection(":memory:")
import_file(conn, "examples/test.snpeff.vcf")
while True:
text = session.prompt('vql> ', auto_suggest=AutoSuggestFromHistory())
if text == "exit":
break
try:
fct = cmd.execute(conn, text)
if isinstance(fct, types.GeneratorType):
for variant in fct:
print(variant)
if self.conn:
self.populate()
def populate(self):
"""Actualize the list of word sets"""
self.view.clear()
self.set_names = list()
for data in get_wordsets(self.conn):
set_name = data["name"]
item = QListWidgetItem()
item.setText(set_name)
item.setIcon(FIcon(0xF0A38))
self.view.addItem(item)
self.set_names.append(set_name)
if __name__ == "__main__":
import sys
from PySide2.QtWidgets import QApplication
app = QApplication(sys.argv)
conn = get_sql_connection("C:/sacha/Dev/cutevariant/test.db")
# import_cmd(conn, "sets", "boby", "examples/gene.txt")
w = WordSetWidget()
w.conn = conn
w.populate()
w.show()
app.exec_()
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)
},
]
},
]
}
elif filter_type == self.X_LINKED_RECESSIVE:
filters = {
"AND": [
{"field": "chr", "operator": "=", "value": "X"},
{"field": ("sample", father, "gt"), "operator": "=", "value": 0},
{"field": ("sample", mother, "gt"), "operator": "=", "value": 1},
{"field": ("sample", child, "gt"), "operator": ">", "value": 0},
]
}
self.mainwindow.state.filters = filters
self.mainwindow.refresh_plugins()
self.close()
if __name__ == "__main__":
from PySide2.QtWidgets import QApplication
import sys
app = QApplication(sys.argv)
conn = sql.get_sql_connection("/home/sacha/Dev/corpasome.db")
dialog = TrioAnalysisDialog(conn=conn)
dialog.show()
app.exec_()
