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")
