def test_build_where_clause_1(self, parse_filter_mock): """Verify parse_filter() is called with correct parameters. """ parse_filter_mock.return_value = ["phage", "Cluster", "!=", "A"] querying.build_where_clause(self.graph, "phage.Cluster != A") parse_filter_mock.assert_called_with("phage.Cluster != A")
def test_build_where_clause_3(self): """Verify build_where_clause() builds from specified value. """ where_clause = querying.build_where_clause(self.graph, "phage.PhageID=Trixie") self.assertEqual(where_clause.right.value, "Trixie")
def test_build_where_clause_2(self): """Verify build_where_clause() builds from specified Column. """ where_clause = querying.build_where_clause(self.graph, "phage.PhageID=Trixie") self.assertEqual(where_clause.left, self.PhageID)
def test_build_where_clause_1(self): """Verify build_where_clause() returns a BinaryExpression object. """ where_clause = querying.build_where_clause(self.graph, "phage.PhageID=Trixie") self.assertTrue(isinstance(where_clause, BinaryExpression))
def test_first_column_1(self): """Verify first_column() returns expected data type. """ where_clause = querying.build_where_clause(self.graph, "phage.Cluster=A") phageid = querying.get_column(self.metadata, "phage.PhageID") select = querying.build_select(self.graph, phageid, where=where_clause) results = querying.first_column(self.engine, select) self.assertTrue(isinstance(results, list)) self.assertTrue(isinstance(results[0], str))
def test_first_column_2(self): """Verify first_column() retrieves expected data. """ where_clause = querying.build_where_clause(self.graph, "phage.Cluster=A") phageid = querying.get_column(self.metadata, "phage.PhageID") select = querying.build_select(self.graph, phageid, where=where_clause) results = querying.first_column(self.engine, select) self.assertTrue("Trixie" in results) self.assertTrue("D29" in results) self.assertFalse("Myrna" in results)
def add(self, filter): where_clause = q.build_where_clause(self.graph, filter) parsed_filter = parsing.parse_filter(filter) filter_left = parsed_filter[0] + "." + parsed_filter[1]\ + parsed_filter[2] if filter_left not in self._filters.keys(): self._filters.update({filter_left: [where_clause]}) else: self._filters[filter_left].append(where_clause) self._updated = False
def test_execute_2(self): """Verify execute() retrieves expected data. """ where_clause = querying.build_where_clause(self.graph, "phage.Cluster=A") phage_table = querying.get_table(self.metadata, "phage") select = querying.build_select(self.graph, phage_table, where=where_clause) results = querying.execute(self.engine, select) for result in results: self.assertEqual(result["Cluster"], "A")
def test_execute_1(self): """Verify execute() correctly executes SQLAlchemy select objects. """ where_clause = querying.build_where_clause(self.graph, "phage.Cluster=A") phage_table = querying.get_table(self.metadata, "phage") select = querying.build_select(self.graph, phage_table, where=where_clause) results = querying.execute(self.engine, select) result_keys = results[0].keys() self.assertTrue("PhageID" in result_keys) self.assertTrue("Cluster" in result_keys) self.assertTrue("Subcluster" in result_keys)
def use_function_report_data(db_filter, data_dicts, columns, conditionals, verbose=False): """Reads in FunctionReport data and pairs it with existing data. :param db_filter: A connected and fully built Filter object. :type db_filter: Filter :param data_dicts: List of data dictionaries from a FunctionReport file. :type data_dicts: list[dict] :param columns: List of SQLAlchemy Columns to retrieve data for. :type columns: list[Column] :param conditionals: List of SQLAlchemy BinaryExpressions to filter with. :type conditionals: List[BinaryExpression] :param verbose: A boolean value to toggle progress print statements. :type verbose: bool """ if verbose: print("Retreiving feature data using pham function report...") export_dicts = [] for data_dict in data_dicts: final_call = data_dict["Final Call"] if final_call.lower() == "hypothetical protein": final_call = "" conditionals.append( querying.build_where_clause(db_filter.graph, f"gene.Notes!='{final_call}'")) query = querying.build_select(db_filter.graph, columns, where=conditionals) results = querying.execute(db_filter.engine, query, in_column=db_filter.key, values=[data_dict["Pham"]]) for result in results: if (not result["Accession"]) or (not result["LocusTag"]): continue result["Notes"] = data_dict["Final Call"] result["Start"] = result["Start"] + 1 export_dicts.append(result) return export_dicts
def and_(self, filter): """Add an and conditional to the Filter object class. :param_filter: Formatted MySQL WHERE clause. :type_filter: str """ if self._or_index < 0: self.new_or_() where_clause = q.build_where_clause(self.graph, filter) filter_key = parsing.create_filter_key(filter) or_block = self._filters[self._or_index] #Stores the BinaryExpression with a key of the Column/Operator pairing. or_block.update({filter_key: where_clause}) self._updated = False
def test_execute_value_subqueries(self): """Verify execute_value_subqueries() retrieves expected data. """ where_clause = querying.build_where_clause(self.graph, "phage.Cluster=A") phage_table = querying.get_table(self.metadata, "phage") phageid = querying.get_column(self.metadata, "phage.PhageID") select = querying.build_select(self.graph, phage_table, where=where_clause) results = querying.execute_value_subqueries( self.engine, select, phageid, ["Trixie", "D29", "Alice", "Myrna"], limit=2) for result in results: self.assertEqual(result["Cluster"], "A")
def execute_resubmit(alchemist, revisions_data_dicts, folder_path, folder_name, filters="", groups=[], verbose=False): """Executes the entirety of the genbank resubmit pipeline. :param alchemist: A connected and fully built AlchemyHandler object. :type alchemist: AlchemyHandler :param revisions_data_dicts: Data dictionaries containing pham/notes data. :type revisions_data_dicts: list[dict] :param folder_path: Path to a valid dir for new dir creation. :type folder_path: Path :param folder_name: A name for the export folder. :type folder_name: str :param verbose: A boolean value to toggle progress print statements. :type verbose: bool """ db_filter = Filter(alchemist=alchemist) db_filter.key = "gene.PhamID" db_filter.add(BASE_CONDITIONALS) if filters != "": try: db_filter.add(filters) except: print("Please check your syntax for the conditional string:\n" f"{filters}") resubmit_columns = db_filter.get_columns(RESUBMIT_COLUMNS) phams = [] for data_dict in revisions_data_dicts: phams.append(data_dict["Pham"]) db_filter.values = phams if verbose: print("Creating export folder...") export_path = folder_path.joinpath(folder_name) export_path = basic.make_new_dir(folder_path, export_path, attempt=50) conditionals_map = {} export_db.build_groups_map(db_filter, export_path, conditionals_map, groups=groups, verbose=verbose) if verbose: print("Prepared query and path structure, beginning review export...") for mapped_path in conditionals_map.keys(): if verbose: print("Retreiving phage data for pham revisions...") export_dicts = [] for data_dict in revisions_data_dicts: if verbose: print(f"...Retrieving data for pham {data_dict['Pham']}...") conditionals = conditionals_map[mapped_path] final_call = data_dict["Final Call"] if final_call == "Hypothetical Protein": final_call = "" conditionals.append( querying.build_where_clause(alchemist.graph, f"gene.Notes!={final_call}")) query = querying.build_select(alchemist.graph, resubmit_columns, where=conditionals) results = querying.execute(alchemist.engine, query, in_column=db_filter.key, values=[data_dict["Pham"]]) for result in results: format_resubmit_data(result, data_dict["Final Call"]) export_dicts.append(result) if not export_dicts: if verbose: print("'{mapped_path.name}' data selected for resubmision " "matches selected call; no resubmision exported...") mapped_path.rmdir() continue export_dicts = sorted(export_dicts, key=lambda export_dict: export_dict["Phage"]) if verbose: print(f"Writing {CSV_NAME} in {mapped_path.name}...") file_path = mapped_path.joinpath(CSV_NAME) basic.export_data_dict(export_dicts, file_path, RESUBMIT_HEADER, include_headers=True)
def test_build_where_clause_2(self, check_operator_mock): """Verify check_operator() is called with correct parameters. """ querying.build_where_clause(self.graph, "gene.PhamID = 2") check_operator_mock.assert_called_with("=", self.PhamID)
def test_build_where_clause_2(self, CheckOperator): querying.build_where_clause(self.graph, "gene.PhamID = 2") CheckOperator.assert_called_with("=", self.PhamID)
def test_build_where_clause_1(self, ParseFilter): ParseFilter.return_value = ["phage", "Cluster", "!=", "A"] querying.build_where_clause(self.graph, "phage.Cluster != A") ParseFilter.assert_called_with("phage.Cluster != A")