def get_galaxy_connection(args, file=None, log=None, login_required=True): """ Return a Galaxy connection, given a user or an API key. If not given gets the arguments from the file. If either is missing raise ValueError. """ if file: file_content = load_yaml_file(file) else: file_content = dict() url = args.galaxy or file_content.get('galaxy_instance') galaxy_url = check_url(url, log) api_key = args.api_key or file_content.get('api_key') if args.user and args.password: return galaxy.GalaxyInstance(url=galaxy_url, email=args.user, password=args.password) elif api_key: return galaxy.GalaxyInstance(url=galaxy_url, key=api_key) elif not login_required: return galaxy.GalaxyInstance(url=galaxy_url) else: raise ValueError( "Missing api key or user & password combination, in order to make a galaxy connection." )
def test_dataset_permissions(self): admin_user_id = self.gi.users.get_current_user()['id'] user_id = self.gi.users.create_local_user('newuser3', '*****@*****.**', 'secret')['id'] user_api_key = self.gi.users.create_user_apikey(user_id) anonymous_gi = galaxy.GalaxyInstance(url=self.gi.base_url, key=None) user_gi = galaxy.GalaxyInstance(url=self.gi.base_url, key=user_api_key) sharing_role = self.gi.roles.create_role( 'sharing_role', 'sharing_role', [user_id, admin_user_id])['id'] self.gi.datasets.publish_dataset(self.dataset_id, published=False) with self.assertRaises(ConnectionError): anonymous_gi.datasets.show_dataset(self.dataset_id) self.gi.datasets.publish_dataset(self.dataset_id, published=True) # now dataset is public, i.e. accessible to anonymous users self.assertEqual( anonymous_gi.datasets.show_dataset(self.dataset_id)['id'], self.dataset_id) self.gi.datasets.publish_dataset(self.dataset_id, published=False) with self.assertRaises(ConnectionError): user_gi.datasets.show_dataset(self.dataset_id) self.gi.datasets.update_permissions(self.dataset_id, access_ids=[sharing_role], manage_ids=[sharing_role]) self.assertEqual( user_gi.datasets.show_dataset(self.dataset_id)['id'], self.dataset_id) # anonymous access now fails because sharing is only with the shared user role with self.assertRaises(ConnectionError): anonymous_gi.datasets.show_dataset(self.dataset_id)
def main(): parent = get_common_args() parser = argparse.ArgumentParser( parents=[parent], description='Populate the Galaxy data library with test data.') parser.add_argument('-i', '--infile', required=True, type=argparse.FileType('r')) args = parser.parse_args() if args.user and args.password: gi = galaxy.GalaxyInstance(url=args.galaxy, email=args.user, password=args.password) elif args.api_key: gi = galaxy.GalaxyInstance(url=args.galaxy, key=args.api_key) else: sys.exit( 'Please specify either a valid Galaxy username/password or an API key.' ) if args.verbose: log.basicConfig(level=log.DEBUG) setup_data_libraries(gi, args.infile)
def get_galaxy_connection(): """ Given access to the configuration dict that galaxy passed us, we try and connect to galaxy's API. First we try connecting to galaxy directly, using an IP address given us by docker (since the galaxy host is the default gateway for docker). Using additional information collected by galaxy like the port it is running on and the application path, we build a galaxy URL and test our connection by attempting to get a history listing. This is done to avoid any nasty network configuration that a SysAdmin has placed between galaxy and us inside docker, like disabling API queries. If that fails, we failover to using the URL the user is accessing through. This will succeed where the previous connection fails under the conditions of REMOTE_USER and galaxy running under uWSGI. """ conf = _get_conf() try: # Remove trailing slashes app_path = conf['galaxy_url'].rstrip('/') # Remove protocol+host:port if included app_path = ''.join(app_path.split('/')[3:]) # Now obtain IP address from a netstat command. cmd_netstat = ['netstat', '-nr'] p1 = subprocess.Popen(cmd_netstat, stdout=subprocess.PIPE) cmd_grep = ['grep', '^0\.0\.0\.0'] p2 = subprocess.Popen(cmd_grep, stdin=p1.stdout, stdout=subprocess.PIPE) cmd_awk = ['awk', '{ print $2 }'] p3 = subprocess.Popen(cmd_awk, stdin=p2.stdout, stdout=subprocess.PIPE) # Now we have an ip address to connect to galaxy on. galaxy_ip = p3.stdout.read() # We should be able to find a port to connect to galaxy on via this # conf var: galaxy_paster_port galaxy_port = conf['galaxy_paster_port'] if not galaxy_port: # We've failed to detect a port in the config we were given by # galaxy, so we won't be able to construct a valid URL raise Exception("No port") built_galaxy_url = 'http://%s:%s/%s' % (galaxy_ip.strip(), galaxy_port, app_path.strip()) gi = galaxy.GalaxyInstance(url=built_galaxy_url.rstrip('/'), key=conf['api_key']) gi.histories.get_histories() except: try: gi = galaxy.GalaxyInstance(url=conf['galaxy_url'], key=conf['api_key']) gi.histories.get_histories() except: raise Exception( "Could not connect to a galaxy instance. Please contact your SysAdmin for help with this error" ) return gi
def _gi(args): gi = galaxy.GalaxyInstance(args.host, key=args.api_key) name = "wftest-user-%d" % random.randint(0, 1000000) user = gi.users.create_local_user(name, "*****@*****.**" % name, "pass123") user_id = user["id"] api_key = gi.users.create_user_apikey(user_id) user_gi = galaxy.GalaxyInstance(args.host, api_key) return user_gi
def get_galaxy_connection(args): """ Return a Galaxy connection, given a user or an API key. """ if args.user and args.password: gi = galaxy.GalaxyInstance(url=args.galaxy, email=args.user, password=args.password) elif args.api_key: gi = galaxy.GalaxyInstance(url=args.galaxy, key=args.api_key) return gi or False
def main(): """ load histories, workflows and trigger tool dependency installation. Well, try. Keep this idiom handy: #x=gi.make_get_request(f"http://nginx/api/tools/{tfid}/dependencies", params={'api_key':'fakekey'}) """ args = _parser().parse_args() if args.key: connected = False started = time.time() while not connected: try: gi = galaxy.GalaxyInstance(url=args.galaxy, key=args.key) connected = True except Exception: print('install-history: No gi yet...%d seconds' % int(time.time() - started)) time.sleep(5) else: print('Need a key passed to install-history - no default found') sys.exit(1) job_check(gi) wfpaths = args.wfpaths for wfpath in wfpaths: x = gi.workflows.import_workflow_from_local_path(wfpath, publish=True) job_check(gi) print('Installed %s, res= %s' % (wfpath, x)) hists = args.history_path for hf in hists: if os.path.isdir(hf): for fp in os.listdir(hf): hp = os.path.join(hf, fp) if os.path.isfile(hp): x = gi.histories.import_history(file_path=hp, url=None) print('installed ', hp, 'res=', x) job_check(gi) else: x = gi.histories.import_history(file_path=hf, url=None) print('installed', hf, 'res=', x) job_check(gi) x = '' gi = galaxy.GalaxyInstance(url=args.galaxy, key=args.key) for tfid in args.toolid: try: x = gi.tools.install_dependencies(tfid, resolver_type="singularity") except Exception: print('Attempt to install %s failed' % tfid) job_check(gi) print('tried installing dependencies for', tfid, 'dependencies, res=', x)
def get_galaxy_client(args): if args.create_user: master_client = galaxy.GalaxyInstance(args.url, key=args.master_api_key) user_info = master_client.users.create_local_user(args.user, '*****@*****.**' % args.user, args.user) api_key = master_client.users.create_user_apikey(user_info.get('id')) sys.stderr.write('Created user %s with api key %s\n' % (args.user, api_key)) else: api_key = args.api_key return galaxy.GalaxyInstance(args.url, key=api_key)
def main(): args = _parser().parse_args() if args.user and args.password: gi = galaxy.GalaxyInstance(url=args.galaxy, email=args.user, password=args.password) elif args.api_key: gi = galaxy.GalaxyInstance(url=args.galaxy, key=args.api_key) else: sys.exit('Please specify either a valid Galaxy username/password or an API key.') if args.verbose: log.basicConfig(level=log.DEBUG) setup_data_libraries(gi, args.infile, training=args.training, legacy=args.legacy)
def install_deps(self, tool_id): gi = galaxy.GalaxyInstance(url='http://galaxy-server', key='fakekey') try: res = gi.tools.install_dependencies(tool_id) logging.info('Tried installing dependencies for %s. Got %s' % (tool_id,res)) except Exception: logging.warning('Attempt to install %s failed' % tool_id)
def configure_galaxy_api_key(self, driver): """Make a new Galaxy admin API key and configure the tool to use it""" gal = galaxy.GalaxyInstance(self.GALAXY_URL, email=self.EMAIL, password=self.GALAXY_PASSWORD) self.configure_tool('Galaxy', 'admin_key', gal.key) print 'key:' + gal.key
def send_result_to_galaxy(self): """Send a result file to Galaxy""" filename = "AskOmics_result_{}.tsv".format(self.id) galaxy_instance = galaxy.GalaxyInstance(self.session["user"]["galaxy"]["url"], self.session["user"]["galaxy"]["apikey"]) last_history = galaxy_instance.histories.get_most_recently_used_history() galaxy_instance.tools.upload_file(self.file_path, last_history['id'], file_name=filename, file_type='tabular')
def _login(): login_dict = _read_configfile() cnfg = login_dict['logins'][login_dict['active_login']] aliases = login_dict['aliases'] gi = galaxy.GalaxyInstance(cnfg['url'], cnfg['api_key']) gi.histories.get_histories() # just to check the connection return gi, cnfg, aliases
def __main__(): parser = argparse.ArgumentParser(description="""Script to run all workflows mentioned in workflows_to_test. It will import the shared workflows are create histories for each workflow run, prefixed with ``TEST_RUN_<date>:`` Make sure the yaml has file names identical to those in the data library.""") parser.add_argument('-k', '--api-key', '--key', dest='key', metavar='your_api_key', help='The account linked to this key needs to have admin right to upload by server path', required=True) parser.add_argument('-u', '--url', dest='url', metavar="http://galaxy_url:port", help="Be sure to specify the port on which galaxy is running", default="http://usegalaxy.org") parser.add_argument('-x', '--xunit-output', dest="xunit_output", type=argparse.FileType('w'), default='report.xml', help="""Location to store xunit report in""") args = parser.parse_args() gi = galaxy.GalaxyInstance(args.url, args.key) hist = gi.histories.create_history('Load All Student Genomes') org_names = ('Soft', '2ww-3119', 'ISA', 'Inf_Still_Creek', 'J76', 'K6', 'K7', 'K8', 'MIS1-LT2', 'MIS3-3117', 'MP16', 'Pin', 'SCI', 'SCS', 'SL-Ken', 'ScaAbd', 'ScaApp', 'Sw1_3003', 'Sw2-Ken', 'UDP') test_suites = [] for name in org_names: ts = retrieve_and_rename(gi, hist, name) test_suites.append(ts) args.xunit_output.write(xunit_dump(test_suites))
def main(): """ This script uses bioblend to import .ga workflow files into a running instance of Galaxy """ parser = argparse.ArgumentParser() parser.add_argument("-w", "--workflow_path", help='Path to workflow file') parser.add_argument( "-g", "--galaxy", dest="galaxy_url", help="Target Galaxy instance URL/IP address (required " "if not defined in the tools list file)", ) parser.add_argument( "-a", "--apikey", dest="api_key", help="Galaxy admin user API key (required if not " "defined in the tools list file)", ) args = parser.parse_args() gi = galaxy.GalaxyInstance(url=args.galaxy_url, key=args.api_key) with open(args.workflow_path, 'r') as wf_file: import_uuid = json.load(wf_file).get('uuid') existing_uuids = [ d.get('latest_workflow_uuid') for d in gi.workflows.get_workflows() ] if import_uuid not in existing_uuids: gi.workflows.import_workflow_from_local_path(args.workflow_path)
def check_instance(galaxy_url, tutorial_path): """ Check if a given tutorial can be run on a given Galaxy instance """ # TODO: support specific revision checking # TODO: discussion: for suites, encourage to list all tools actually needed in yaml, not just the suite? gi = galaxy.GalaxyInstance(url=galaxy_url) # find tools needed for the tutorial with open(os.path.join(tutorial_path, 'tools.yaml')) as f: tool_yaml = yaml.safe_load(f) tools_required = [] for tool in tool_yaml['tools']: tools_required.append(tool['name']) # check if all tools are installed tools_list = gi.tools.get_tools() tools_available = [] for t in tools_list: try: tools_available.append(t['tool_shed_repository']['name']) except KeyError: pass tool_requirements_satisfied = set(tools_required) < set(tools_available) # output what is installed and what is missing print "This Galaxy instance (" + galaxy_url + ") can run my tutorial: " + str( tool_requirements_satisfied) for tool in tools_required: print " - " + tool + ": " + ("present" if tool in tools_available else "not present") return tool_requirements_satisfied
def cli(ctx, url=None, api_key=None, admin=False, **kwds): """Help initialize global configuration (in home directory) """ # TODO: prompt for values someday. click.echo(""" Welcome to ____ ____ _ _____ _____ ___ _____ / __ \ / __ `/ / ___/ / ___/ / _ \ / ___/ / /_/ // /_/ / / / (__ ) / __// /__ / .___/ \__,_/ /_/ /____/ \___/ \___/ /_/ Galaxy at the Speed of Light """) config_path = config.global_config_path() if os.path.exists(config_path): info("Your parsec configuration already exists. Please edit it instead: %s" % config_path) return 0 while True: galaxy_url = url if url is None or len(url) == 0 : galaxy_url = click.prompt("Please entry your Galaxy's URL") galaxy_key = api_key if api_key is None or len(api_key) == 0 : galaxy_key = click.prompt("Please entry your Galaxy API Key") info("Testing connection...") gi = galaxy.GalaxyInstance(galaxy_url, galaxy_key) try: conf = gi.config.get_config() if 'version_major' in conf: # Ok, success info("Ok! Everything looks good.") break else: warn("Error, we could not access the configuration data for your instance.") should_break = click.prompt("Continue despite inability to contact this Galaxy Instance? [y/n]") if should_break in ('Y', 'y'): break except Exception as e: warn_msg = ("Error, we could not access the configuration data for your instance. " "The server responded with error code %s. If your galaxy uses remote_user " "authentication (i.e. as username + password is requested if you try to curl " "or wget %s.) If this is the case, you may need to add an exception for the " "Galaxy API. Please see https://galaxyproject.org/admin/config/apache-external-user-auth/ " "or https://galaxyproject.org/admin/config/nginx-external-user-auth/ for more information.)") warn(warn_msg, e.status_code, galaxy_url) should_break = click.prompt("Continue despite inability to contact this Galaxy Instance? [y/n]") if should_break in ('Y', 'y'): break if os.path.exists(config_path): warn("File %s already exists, refusing to overwrite." % config_path) return -1 with open(config_path, "w") as f: f.write( CONFIG_TEMPLATE % { 'key': galaxy_key, 'url': galaxy_url, }) info(SUCCESS_MESSAGE)
def main(): if len(sys.argv) < 2: print "USAGE:\n\tpython {} api_key.txt <history name (optional) >\n\n\tNOTE: if not history name is given" \ " all histories will be downloaded".format(sys.argv[0]) sys.exit(1) logger.info("############") apiFile = open(sys.argv[1]) url, key = apiFile.read().strip().split(',') gi = galaxy.GalaxyInstance(url=url, key=key) logger.info("Getting history IDs") hist_name = None if len(sys.argv) < 3 else sys.argv[2] histories = get_history(gi, hist_name) logger.info("Creating the Download dir (if necessary)") down_dir = os.getcwd() + "/download" mkpath(os.getcwd() + "/download") jehas = prepare_download(gi, histories) for item in jehas: dfile = open(down_dir + "/" + item.name + ".tar.gz", "wb") dhist = downlad_history(gi, item.id, item.jeha, dfile) logger.info("The Download of {} is {}".format(item.name, dhist)) dfile.close()
def export_user_histories(api_key, GalaxyURL): gui = galaxy.GalaxyInstance(url=GalaxyURL, key=api_key) histories = gui.histories.get_histories() for history in histories: print("exporting history %s" % history[u'id']) print(gui.histories.export_history(history[u'id'], include_hidden=True))
def send_query_to_galaxy(self): """Send the json query to a galaxy dataset""" galaxy_instance = galaxy.GalaxyInstance(self.session["user"]["galaxy"]["url"], self.session["user"]["galaxy"]["apikey"]) last_history_id = galaxy_instance.histories.get_most_recently_used_history()['id'] # Name of the json file name = "AskOmics_query_{}.json".format(self.id) # Load the file into Galaxy galaxy_instance.tools.paste_content(json.dumps(self.get_graph_state(formated=True)), last_history_id, file_type='json', file_name=name)
def send_to_history(self, path, name, filetype): """Send a file into the most recent Galaxy history :param path: path of file to load into Galaxy :type path: string """ galaxy_instance = galaxy.GalaxyInstance(self.url, self.apikey) last_history = galaxy_instance.histories.get_most_recently_used_history() galaxy_instance.tools.upload_file(path, last_history['id'], file_name=name, file_type=filetype)
def __init__(self, url, api, library_id, folder_id, should_link, non_local): self.gi = galaxy.GalaxyInstance(url=url, key=api) self.library_id = library_id self.folder_id = folder_id self.should_link = should_link self.non_local = non_local self.memo_path = {} self.prepopulate_memo()
def __main__(): args = _parse_cli_options() ADMIN_KEY = args.api_key GalaxyURL = args.admin_galaxy_url gi = galaxy.GalaxyInstance(url=GalaxyURL, key=ADMIN_KEY) all_users = gi.users.get_users() selected_users = extract_users(args.emails, all_users) user_api_keys = get_user_apikeys(gi, selected_users) for api_key in user_api_keys: export_user_histories(api_key, GalaxyURL)
def __init__(self, settings, request): """constructor""" self.settings = settings self.request = request # Start a connection with galaxy self.galaxy_instance = galaxy.GalaxyInstance( self.settings['askomics.testing_galaxy_url'], self.settings['askomics.testing_galaxy_key']) self.history_id = ''
def main(data): """ Load files into a Galaxy data library. By default all test-data tools from all installed tools will be linked into a data library. """ log.info("Importing data libraries.") url = "http://*****:*****@galaxy.org') admin_pass = os.environ.get('GALAXY_DEFAULT_ADMIN_PASSWORD', 'admin') # Establish connection to galaxy instance gi = galaxy.GalaxyInstance(url=url, email=admin_email, password=admin_pass) jc = galaxy.jobs.JobsClient(gi) folders = dict() libraries = yaml.load(data) for lib in libraries['libraries']: folders[lib['name']] = lib['files'] if folders: log.info("Create 'Test Data' library.") lib = gi.libraries.create_library('Training Data', 'Data pulled from online archives.') lib_id = lib['id'] for fname, urls in folders.items(): log.info("Creating folder: %s" % fname) folder = gi.libraries.create_folder(lib_id, fname) for url in urls: gi.libraries.upload_file_from_url( lib_id, url, folder_id=folder[0]['id'], ) no_break = True while True: no_break = False for job in jc.get_jobs(): if job['state'] != 'ok': no_break = True if not no_break: break time.sleep(3) time.sleep(20) log.info("Finished importing test data.")
def get_installed_tool_version(args): gi = galaxy.GalaxyInstance(url=args.gi_url, key=args.api_key) ts_repositories = gi.toolShed.get_repositories() for repo in ts_repositories: test = (str(repo['name']) == args.tool_name) test &= (not repo['deleted']) test &= (str(repo['tool_shed']) == args.tool_shed) if test: print repo['installed_changeset_revision'] print repo['owner']
def __main__(): parser = argparse.ArgumentParser( description= """Script to run all workflows mentioned in workflows_to_test. It will import the shared workflows are create histories for each workflow run, prefixed with ``TEST_RUN_<date>:`` Make sure the yaml has file names identical to those in the data library.""" ) parser.add_argument( '-k', '--api-key', '--key', dest='key', metavar='your_api_key', help= 'The account linked to this key needs to have admin right to upload by server path', required=True) parser.add_argument( '-u', '--url', dest='url', metavar="http://galaxy_url:port", help="Be sure to specify the port on which galaxy is running", default="http://usegalaxy.org") parser.add_argument('-w', '--workflow-output', dest="workflow_output", type=str, default='out.ga', help="""Location to store Galaxy workflow in""") parser.add_argument('-i', '--workflow-id', dest="workflow_id", type=str) args = parser.parse_args() gi = galaxy.GalaxyInstance(args.url, args.key) wf = gi.workflows.get_workflows(workflow_id=args.workflow_id)[0] gi.workflows.export_workflow_to_local_path(args.workflow_id, args.workflow_output, use_default_filename=False) # Get the current invocations invocations = gi.workflows.get_invocations(args.workflow_id) workflow_states = {} for invocation in tqdm(invocations): invoke = gi.workflows.show_invocation(wf['id'], invocation['id']) workflow_states[invocation['id']] = {} for step in invoke['steps']: sid = step['workflow_step_uuid'] if sid == 'None': sid = step['order_index'] workflow_states[invocation['id']][sid] = step['state'] print(json.dumps(workflow_states, sort_keys=True, indent=2))
def get_datasets_and_histories(self, allowed_files, history_id=None): """Get Galaxy datasets of current history and all histories of a user :returns: a list of datasets :rtype: dict """ galaxy_instance = galaxy.GalaxyInstance(self.url, self.apikey) results = {} # get current history if not history_id: history_id = galaxy_instance.histories.get_most_recently_used_history( )['id'] # Get all available history id and name histories = galaxy_instance.histories.get_histories() histories_list = [] for history in histories: if history['id'] == history_id: history_dict = { "name": history['name'], "id": history['id'], "selected": True } else: history_dict = { "name": history['name'], "id": history['id'], "selected": False } histories_list.append(history_dict) # Get datasets of selected history dataset_list = [] history_content = galaxy_instance.histories.show_history(history_id, contents=True) for dataset in history_content: if 'extension' not in dataset: continue if dataset['extension'] not in allowed_files: continue if 'deleted' in dataset: # Don't show deleted datasets if dataset['deleted']: continue dataset_list.append(dataset) results['datasets'] = dataset_list results['histories'] = histories_list return results
def main(master_api_key, api_url, galaxy_admin_user, galaxy_admin_pass, workflows_dir): gi = galaxy.GalaxyInstance(url=api_url, key=master_api_key) #adding new user admin_key = create_user(gi, galaxy_admin_user.split('@')[0], galaxy_admin_user, galaxy_admin_pass) print "Galaxy API key [%s] created for user [%s]." % (admin_key,galaxy_admin_user) print "Signing in as admin user." gi = galaxy.GalaxyInstance(url=api_url, key=admin_key) for (dir_name, sub_dir, file_names) in os.walk(workflows_dir): for xml_file in filter(lambda f: f == 'repository_dependencies.xml', file_names): xml_path = os.path.join(dir_name, xml_file) print "Going to parse " + xml_path xml_doc = ET.parse(xml_path) xml_root = xml_doc.getroot() for repository in xml_root.findall('.//repository'): name = repository.get('name') owner = repository.get('owner') url = repository.get('toolshed') revision = repository.get('changeset_revision') tool_info = ", ".join([name, owner, url, revision]) print "Going to install %s" % tool_info try: gi.toolShed.install_repository_revision(url, name, owner, revision, install_tool_dependencies = True, install_repository_dependencies = True) except galaxy.client.ConnectionError as e: error_body = json.loads(e.body) if (error_body['err_code'] == 400008): print "%s is already installed, skipping." % tool_info else: print "%s failed to install, check the galaxy logs." % tool_info raise for workflow_file in filter(lambda f: f.endswith('.ga'), file_names): workflow_path = os.path.join(dir_name, workflow_file) print "Going to load " + workflow_path gi.workflows.import_workflow_from_local_path(workflow_path) return
def main(): parser = argparse.ArgumentParser( description='Populate the Galaxy data library with test data.') parser.add_argument("-v", "--verbose", help="Increase output verbosity.", action="store_true") parser.add_argument('-i', '--infile', type=argparse.FileType('r')) parser.add_argument("-g", "--galaxy", help="Target Galaxy instance URL/IP address.") parser.add_argument("-u", "--user", help="Galaxy user name") parser.add_argument("-p", "--password", help="Password for the Galaxy user") parser.add_argument( "-a", "--api_key", dest="api_key", help= "Galaxy admin user API key (required if not defined in the tools list file)" ) args = parser.parse_args() if args.user and args.password: gi = galaxy.GalaxyInstance(url=args.galaxy, email=args.user, password=args.password) elif args.api_key: gi = galaxy.GalaxyInstance(url=args.galaxy, key=args.api_key) else: sys.exit( 'Please specify either a valid Galaxy username/password or an API key.' ) if args.verbose: log.basicConfig(level=log.DEBUG) setup_data_libraries(gi, args.infile)