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_()