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