def insert_graph(
manager: Manager,
graph: BELGraph,
user: User,
public: bool = True,
use_tqdm: bool = False,
) -> Network:
"""Insert a graph and also make a report.
:param manager: A PyBEL manager
:param graph: A BEL graph
:param user: The identifier of the user to report. Defaults to 1. Can also give a user object.
:param public: Should the network be public? Defaults to False.
:param use_tqdm: Show a progress bar? Defaults to False.
:raises: TypeError
"""
if manager.has_name_version(graph.name, graph.version):
logger.info('database already has %s', graph)
return manager.get_network_by_name_version(graph.name, graph.version)
network = manager.insert_graph(graph, use_tqdm=use_tqdm)
report = Report(public=public, user=user)
fill_out_report(graph=graph, network=network, report=report)
manager.session.add(report)
manager.session.commit()
return network
def register_examples(manager: Manager, user_datastore: SQLAlchemyUserDatastore, butler: User) -> None:
"""Insert example graphs."""
for graph in (sialic_acid_graph, egf_graph, statin_graph, homology_graph):
if not manager.has_name_version(graph.name, graph.version):
logger.info('uploading public example graph: %s', graph)
insert_graph(manager, graph, user=butler, public=True)
test_user = user_datastore.find_user(email='*****@*****.**')
if test_user:
for graph in (braf_graph,):
if not manager.has_name_version(graph.name, graph.version):
logger.info('uploading internal example graph: %s', graph)
insert_graph(manager, graph, user=test_user, public=False)
def from_query(manager: Manager, query: pybel.struct.query.Query) -> Query:
"""Build an ORM query from a PyBEL query."""
networks = manager.get_networks_by_ids(query.network_ids)
result = Query.from_networks(networks)
result.set_seeding_from_query(query)
result.set_pipeline_from_query(query)
return result
def ci(directory: str, connection: str, required_annotations: List[str]):
"""Run in continuous integration setting."""
repo = Repo(directory)
file_names = get_changed(repo)
if not file_names:
click.secho(f'{EMOJI} no BEL files changed')
sys.exit(0)
manager = Manager(connection=connection)
failures = []
for file_name in file_names:
click.echo(f'{EMOJI} file changed: {file_name}')
t = time.time()
graph = from_bel_script(file_name,
manager=manager,
required_annotations=required_annotations)
fg_color = 'green'
if graph.warnings:
failures.append((file_name, graph))
fg_color = 'red'
click.secho(
f'{EMOJI} done checking: {file_name} ({time.time() - t:.2f} seconds)',
fg=fg_color)
click.echo(graph.summary_str())
if not failures:
sys.exit(0)
click.echo('')
for file_name, graph in failures:
click.secho(f'failed: {file_name} - {graph}', fg='red')
sys.exit(1)
def _help_check_hgnc(self, manager: Manager) -> None:
"""Help check the HGNC namespace was loaded properly."""
entry = manager.get_namespace_entry(HGNC_URL, 'MHS2')
self.assertIsNotNone(entry)
self.assertEqual('MHS2', entry.name)
self.assertIn('G', entry.encoding)
entry = manager.get_namespace_entry(HGNC_URL, 'MIATNB')
self.assertIsNotNone(entry)
self.assertEqual('MIATNB', entry.name)
self.assertIn('G', entry.encoding)
self.assertIn('R', entry.encoding)
entry = manager.get_namespace_entry(HGNC_URL, 'MIA')
self.assertIsNotNone(entry)
self.assertEqual('MIA', entry.name)
self.assertIn('G', entry.encoding)
self.assertIn('P', entry.encoding)
self.assertIn('R', entry.encoding)
def get_numbers(graph: pybel.BELGraph, manager: pybel.Manager)->float:
"""Insert and drop a graph to count how long it takes.
:param graph:
:param manager:
:return: The time it took to drop
"""
print('inserting')
parse_start_time = time.time()
network = manager.insert_graph(graph)
print(f'inserted in {time.time() - parse_start_time:.2f} seconds')
print('dropping')
drop_start_time = time.time()
manager.drop_network(network)
drop_time = time.time() - drop_start_time
print(f'dropped in {drop_time:.2f} seconds')
return drop_time
def create_app(manager: Optional[Manager] = None) -> Flask:
"""Create a Flask app.
:param manager: Either a connection string or PyBEL manager.
"""
app = Flask(__name__)
if manager is None:
manager = Manager()
build_admin_service(app, manager)
return app
def build_database(manager: pybel.Manager, annotation_url: Optional[str] = None) -> None:
"""Build a database of scores for NeuroMMSig annotated graphs.
1. Get all networks that use the Subgraph annotation
2. run on each
"""
annotation_url = annotation_url or NEUROMMSIG_DEFAULT_URL
annotation = manager.get_namespace_by_url(annotation_url)
if annotation is None:
raise RuntimeError('no graphs in database with given annotation')
networks = get_networks_using_annotation(manager, annotation)
dtis = ...
for network in networks:
graph = network.as_bel()
scores = get_drug_scores(graph, dtis)
for (drug_name, subgraph_name), score in scores.items():
drug_model = get_drug_model(manager, drug_name)
subgraph_model = manager.get_annotation_entry(annotation_url, subgraph_name)
score_model = Score(
network=network,
annotation=subgraph_model,
drug=drug_model,
score=score
)
manager.session.add(score_model)
t = time.time()
logger.info('committing scores')
manager.session.commit()
logger.info('committed scores in %.2f seconds', time.time() - t)
def load_paths(paths, connection=None):
"""Parses multiple BEL scripts with :func:`pybel.from_path` and returns the union of the resulting graphs.
:param iter[str] paths: An iterable over paths to BEL scripts
:param connection: A custom database connection string or manager
:type connection: Optional[str or pybel.manager.Manager]
:rtype: pybel.BELGraph
"""
manager = Manager.ensure(connection)
return union(
from_path(path, manager=manager)
for path in paths
)
def ci_gitlab(directory: str, connection: str, project_id: int, url: str,
token: str):
"""Run in a continuous integration setting with communication to GitLab."""
from pybel_git.gitlab import GitlabConfig, gitlab_feedback
gitlab_config = GitlabConfig.load(
project_id=project_id,
url=url,
token=token,
)
project = gitlab_config.get_project()
repo = Repo(directory)
manager = Manager(connection=connection)
gitlab_feedback(
project=project,
repo=repo,
manager=manager,
)
def test_convert(self, mock_get):
"""Test conversion via the CLI."""
with self.runner.isolated_filesystem():
test_csv = os.path.abspath('test.csv')
test_gpickle = os.path.abspath('test.gpickle')
test_canon = os.path.abspath('test.bel')
args = [
'convert',
# Input
'--path',
test_bel_thorough,
'--connection',
self.connection,
# Outputs
'--csv',
test_csv,
'--pickle',
test_gpickle,
'--bel',
test_canon,
'--store',
'--allow-nested'
]
result = self.runner.invoke(cli.main, args)
self.assertEqual(0,
result.exit_code,
msg='{}\n{}\n{}'.format(
result.exc_info[0], result.exc_info[1],
traceback.format_tb(result.exc_info[2])))
self.assertTrue(os.path.exists(test_csv))
self.bel_thorough_reconstituted(from_pickle(test_gpickle))
self.bel_thorough_reconstituted(from_path(test_canon))
manager = Manager(connection=self.connection)
self.bel_thorough_reconstituted(
from_database(expected_test_thorough_metadata[METADATA_NAME],
manager=manager))
metadata = load_metadata(directory)
omics = create_omics_models(directory, metadata)
upload_omics_models(omics, manager=manager)
write_manifest(directory, omics)
def main(manager: Manager, reload: bool = False):
"""Load *-omics* models to database.
:param bool reload: Should the experiments be reloaded?
"""
directories = [
os.path.join(OMICS_DATA_DIR, 'GSE28146'),
os.path.join(OMICS_DATA_DIR, 'GSE1297'),
os.path.join(OMICS_DATA_DIR, 'GSE63063'),
]
for directory in directories:
try:
work_omics(directory=directory, manager=manager, reload=reload)
except Exception:
logger.exception('failed for directory %s', directory)
continue
if __name__ == '__main__':
logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(name)s - %(message)s")
logger.setLevel(logging.INFO)
main(Manager())
def test_instantiate_manager_session_missing(self):
with self.assertRaises(ValueError):
Manager(engine='fake-engine', session=None)
def test_instantiate_manager_engine_fail_too_many_keywords(self):
with self.assertRaises(ValueError):
Manager(engine='something', session='something', echo=True)
def test_instantiate_manager_connection_fail_too_many_keyword(self):
with self.assertRaises(ValueError):
Manager(connection=self.connection,
engine='something',
session='something')
def test_instantiate_manager_keyword(self):
manager = Manager(connection=self.connection)
self.assertEqual(self.connection, str(manager.engine.url))
def test_instantiate_manager_fail_positional(self):
with self.assertRaises(ValueError):
Manager(self.connection, True)
def test_instantiate_manager_positional_with_keyword(self):
manager = Manager(self.connection, echo=True)
self.assertEqual(self.connection, str(manager.engine.url))
def test_instantiate_manager_positional(self):
manager = Manager(self.connection)
self.assertEqual(self.connection, str(manager.engine.url))
def test_instantiate_init(self):
"""Test what happens when no connection is specified for the normal constructor."""
with self.mock_connection:
manager = Manager()
self.assertEqual(self.connection, str(manager.engine.url))
def iter_recent_public_networks(manager: Manager) -> Iterable[Network]:
"""Iterate over the recent networks from that have been made public."""
for network in manager.list_recent_networks():
if network.report and network.report.public:
yield network