def _check_reach_env():
"""Check that the environment supports runnig reach."""
# Get the path to the REACH JAR
path_to_reach = get_config('REACHPATH')
if path_to_reach is None:
path_to_reach = environ.get('REACHPATH', None)
if path_to_reach is None or not path.exists(path_to_reach):
raise ReachError(
'Reach path unset or invalid. Check REACHPATH environment var '
'and/or config file.'
)
logger.debug('Using REACH jar at: %s' % path_to_reach)
# Get the reach version.
reach_version = get_config('REACH_VERSION')
if reach_version is None:
reach_version = environ.get('REACH_VERSION', None)
if reach_version is None:
logger.debug('REACH version not set in REACH_VERSION')
m = re.match('reach-(.*?)\.jar', path.basename(path_to_reach))
reach_version = re.sub('-SNAP.*?$', '', m.groups()[0])
logger.debug('Using REACH version: %s' % reach_version)
return path_to_reach, reach_version
def __init__(self,
storage_mode='web',
dart_url=None,
dart_uname=None,
dart_pwd=None,
local_storage=None):
self.storage_mode = storage_mode
# We set the local storage in either mode, since even in web mode
# it is used as a cache
self.local_storage = local_storage if local_storage else \
get_config('INDRA_WM_CACHE')
# In web mode, we try to get a URL, a username and a password. In order
# of priority, we first take arguments provided directly, otherwise
# we take configuration values.
if self.storage_mode == 'web':
if dart_url:
self.dart_url = dart_url
else:
dart_config_url = get_config('DART_WM_URL')
self.dart_url = dart_config_url if dart_config_url else \
default_dart_url
if dart_uname:
self.dart_uname = dart_uname
else:
self.dart_uname = get_config('DART_WM_USERNAME')
if dart_pwd:
self.dart_pwd = dart_pwd
else:
self.dart_pwd = get_config('DART_WM_PASSWORD')
if not self.dart_uname or not self.dart_pwd:
logger.warning('DART is used in web mode but username or '
'password were not provided or set in the '
'DART_WM_USERNAME and DART_WM_PASSWORD '
'configurations.')
# In local mode, we need to have a local storage set
else:
self.dart_url = None
if not self.local_storage:
raise ValueError('DART client initialized in local mode '
'without a local storage path.')
# If the local storage doesn't exist, we try create the folder
if not os.path.exists(self.local_storage):
logger.info('The local storage path %s for the DART client '
'doesn\'t exist and will now be created' %
self.local_storage)
try:
os.makedirs(self.local_storage)
except Exception as e:
logger.error('Could not create DART client local storage: %s' %
e)
logger.info('Running DART client in %s mode with local storage at %s' %
(self.storage_mode, self.local_storage))
def test_curation_submission():
from indra.config import get_config
api_key = get_config('INDRA_DB_REST_API_KEY', failure_ok=True)
if not api_key:
raise SkipTest("No API Key, this test will not work.")
res = dbr.submit_curation(32760831642168299, 'TEST', 'This is a test.',
'tester', is_test=True)
assert res['result'] == 'test passed', res
def test_get_curations():
from indra.config import get_config
api_key = get_config('INDRA_DB_REST_API_KEY', failure_ok=True)
if not api_key:
raise SkipTest("No API Key, this test will not work.")
stmt_hash = -13159234982749425
src_hash = 3817298406742073624
res = dbr.get_curations(stmt_hash, src_hash)
assert isinstance(res, list)
assert len(res) > 0
assert all(c['pa_hash'] == stmt_hash and c['source_hash'] == src_hash
for c in res)
def get_config_extended(key):
"""Return config either from INDRA, environemnt, or AWS SSM."""
from indra.config import get_config
val = get_config(key)
if val:
logger.info('Got %s from environment' % key)
return val
import boto3
client = boto3.client('ssm')
response = client.get_parameter(Name=key, WithDecryption=True)
val = response['Parameter']['Value']
logger.info('Got %s from SSM' % key)
return val
def _run_drum(self, host, port):
drum_path = get_config('DRUMPATH')
cmd_path = os.path.join(drum_path, 'bin', 'trips-drum')
options = ['-nouser']
if host:
options += ['-host', host]
if port:
options += ['-port', str(port)]
cmd = [cmd_path] + options
# The os.setsid() is passed in the argument preexec_fn so
# it's run after the fork() and before exec() to run the shell.
# Uncomment the stdout line to supress printing to stdout
drum_proc = subprocess.Popen(cmd,
stdout=subprocess.PIPE,
preexec_fn=os.setsid)
# TODO: Here we could monitor the stdout and wait for the "Ready" line
time.sleep(20)
return drum_proc
ga.save_pdf(fname)
return fname
elif output_format == 'json':
msg = json.dumps(stmts_to_json(stmts), indent=1)
return msg
elif output_format == 'html':
ev_counts = {} if not ev_counts else ev_counts
ha = HtmlAssembler(stmts, ev_totals=ev_counts,
source_counts=source_counts)
fname = 'indrabot.html'
ha.save_model(fname)
return fname
return None
db_rest_url = get_config('INDRA_DB_REST_URL')
def dump_to_s3(stmts, ev_counts, source_counts):
s3 = boto3.client('s3')
bucket = 'indrabot-results'
fname = '%s.html' % uuid.uuid4()
ha = HtmlAssembler(stmts, db_rest_url=db_rest_url, ev_totals=ev_totals,
source_counts=source_counts)
html_str = ha.make_model()
url = 'https://s3.amazonaws.com/%s/%s' % (bucket, fname)
logger.info('Dumping to %s' % url)
s3.put_object(Key=fname, Body=html_str.encode('utf-8'),
Bucket=bucket, ContentType='text/html')
logger.info('Dumped to %s' % url)
return url
def get_version(cls):
jar_name = path.basename(get_config('EIDOSPATH'))
return re.match(r'eidos-assembly-(.+).jar', jar_name).groups()[0]
from indra.statements import *
from indra.util import read_unicode_csv
from indra.config import has_config, get_config
from indra.databases import uniprot_client, hgnc_client, phosphosite_client
# Python 2
try:
basestring
# Python 3
except:
basestring = str
logger = logging.getLogger('sitemapper')
if has_config('SITEMAPPER_CACHE_PATH'):
sitemapper_cache = get_config('SITEMAPPER_CACHE_PATH')
else:
sitemapper_cache = None
class MappedStatement(object):
"""Information about a Statement found to have invalid sites.
Parameters
----------
original_stmt : :py:class:`indra.statements.Statement`
The statement prior to mapping.
mapped_mods : list of tuples
A list of invalid sites, where each entry in the list has two
elements: ((gene_name, residue, position), mapped_site). If the
invalid position was not found in the site map, mapped_site is
"""This module implements a client to the Gilda grounding web service,
and contains functions to help apply it during the course of INDRA assembly."""
import logging
import requests
from copy import deepcopy
from urllib.parse import urljoin
from indra.ontology.standardize \
import standardize_agent_name
from indra.config import get_config, has_config
from indra.pipeline import register_pipeline
logger = logging.getLogger(__name__)
grounding_service_url = get_config('GILDA_URL', failure_ok=True) \
if has_config('GILDA_URL') else 'http://grounding.indra.bio/'
def get_grounding(txt, context=None, mode='web'):
"""Return the top Gilda grounding for a given text.
Parameters
----------
txt : str
The text to ground.
context : Optional[str]
Any context for the grounding.
mode : Optional[str]
If 'web', the web service given in the GILDA_URL config setting or
environmental variable is used. Otherwise, the gilda package is
attempted to be imported and used. Default: web
def get_api_key():
return get_config('CROSSREF_CLICKTHROUGH_KEY')
__all__ = ['process_annotations', 'get_annotations']
import requests
from indra.config import get_config
from .processor import HypothesisProcessor
base_url = 'https://api.hypothes.is/api/'
api_key = get_config('HYPOTHESIS_API_KEY')
headers = {
'Authorization': 'Bearer %s' % api_key,
'Accept': 'application/vnd.hypothesis.v1+json',
'content-type': 'application/json'
}
indra_group = get_config('HYPOTHESIS_GROUP')
def send_request(endpoint, **params):
"""Send a request to the hypothes.is web service and return JSON response.
Note that it is assumed that `HYPOTHESIS_API_KEY` is set either as a
configuration entry or as an environmental variable.
Parameters
----------
endpoint : str
The endpoint to call, e.g., `search`.
params : kwargs
A set of keyword arguments that are passed to the `requests.get` call
as `params.
"""
if api_key is None:
def _get_sofia_auth():
sofia_username = get_config('SOFIA_USERNAME')
sofia_password = get_config('SOFIA_PASSWORD')
return sofia_username, sofia_password
"""Module containing the implementation of an IndraOntology for the
general biology use case."""
__all__ = ['bio_ontology', 'BioOntology']
from indra.config import get_config
from .ontology import BioOntology
from ..virtual import VirtualOntology
indra_ontology_url = get_config('INDRA_ONTOLOGY_URL')
bio_ontology = BioOntology() if not indra_ontology_url else \
VirtualOntology(url=indra_ontology_url)
"""A client for accessing reader output from the DART system."""
import os
import tqdm
import json
import logging
import requests
import itertools
from datetime import datetime
from collections import defaultdict
from indra.config import get_config
logger = logging.getLogger(__name__)
dart_uname = get_config('DART_WM_USERNAME')
dart_pwd = get_config('DART_WM_PASSWORD')
# The URL is configurable since it is subject to change per use case
dart_base_url = get_config('DART_WM_URL')
if dart_base_url is None:
dart_base_url = ('https://wm-ingest-pipeline-rest-1.prod.dart'
'.worldmodelers.com/dart/api/v1/readers')
meta_endpoint = dart_base_url + '/query'
downl_endpoint = dart_base_url + '/download/'
def get_content_by_storage_key(storage_key):
"""Return content from DART based on its storage key.
Parameters
----------
from pathlib import Path
from indra.config import get_config
default_bucket = 'world-modelers'
default_key_base = 'indra_models'
default_profile = 'wm'
cache_config = get_config('INDRA_WM_CACHE')
if cache_config:
CACHE = Path(cache_config)
CACHE.mkdir(exist_ok=True)
else:
CACHE = None
import os
import logging
import argparse
from flask import jsonify, Flask, render_template, request
from flask_wtf import FlaskForm
from wtforms import SubmitField, validators, SelectMultipleField, \
StringField, TextAreaField, SelectField
from wtforms.fields.html5 import DateField
from flask_bootstrap import Bootstrap
from indra.config import get_config
from indra_world.sources.dart import DartClient, prioritize_records
from indra_world.service.corpus_manager import CorpusManager
DB_URL = get_config('INDRA_WM_SERVICE_DB', failure_ok=False)
dart_client = DartClient()
logger = logging.getLogger('indra_wm_service.assembly_dashboard')
app = Flask(__name__)
app.config['SECRET_KEY'] = 'dev_key'
Bootstrap(app)
reader_names = [('eidos', 'eidos'),
('hume', 'hume'),
('sofia', 'sofia')]
assembly_levels = [('grounding', 'grounding'),
('location', 'location'),
def get_api_key():
return get_config('CROSSREF_CLICKTHROUGH_KEY')
'type': 'xref',
'source': 'mirbase'
}))
self.add_edges_from(edges)
def add_activity_hierarchy(self):
rels = [('transcription', 'activity'), ('catalytic', 'activity'),
('gtpbound', 'activity'), ('kinase', 'catalytic'),
('phosphatase', 'catalytic'), ('gef', 'catalytic'),
('gap', 'catalytic')]
self.add_edges_from([(self.label('INDRA_ACTIVITIES', source),
self.label('INDRA_ACTIVITIES', target), {
'type': 'isa'
}) for source, target in rels])
def add_modification_hierarchy(self):
self.add_edges_from([(self.label('INDRA_MODS', source),
self.label('INDRA_MODS', 'modification'), {
'type': 'isa'
}) for source in modtype_conditions
if source != 'modification'])
HERE = os.path.dirname(os.path.abspath(__file__))
resources = os.path.join(HERE, os.pardir, os.pardir, 'resources')
CACHE_DIR = get_config('INDRA_RESOURCES') or \
os.path.join(os.path.expanduser('~'), '.indra',
'%s_ontology' % BioOntology.name,
BioOntology.version)
CACHE_FILE = os.path.join(CACHE_DIR, 'bio_ontology.pkl')
def test_api():
health_ep = dart_client.dart_base_url + '/health'
dart_uname = get_config('DART_WM_USERNAME', failure_ok=False)
dart_pwd = get_config('DART_WM_PASSWORD', failure_ok=False)
res = requests.get(health_ep, auth=(dart_uname, dart_pwd))
assert res.status_code == 200
import logging
import json
from indra.config import get_config
from indra.statements import stmts_to_json
from flask import Flask, request, abort
from flask_restx import Api, Resource, fields
from .controller import ServiceController
from ..sources.dart import DartClient
from ..sources import hume, cwms, sofia, eidos
logger = logging.getLogger('indra_world.service.app')
db_url = get_config('INDRA_WM_SERVICE_DB', failure_ok=False)
if not get_config('DART_WM_URL'):
dart_client = DartClient(storage_mode='local')
else:
dart_client = DartClient(storage_mode='web')
sc = ServiceController(db_url, dart_client=dart_client)
app = Flask(__name__)
app.config['RESTX_MASK_SWAGGER'] = False
api = Api(app, title='INDRA World Modelers API',
description='REST API for INDRA World Modelers')
# Namespaces
base_ns = api.namespace('Basic functions',
'Basic functions',
path='/')
dart_ns = api.namespace('DART endpoints',
'DART endpoints',
self.label('INDRA_MODS', 'modification'), {
'type': 'isa'
}) for source in modtype_conditions
if source != 'modification'])
def add_nodes_from(self, nodes_for_adding, **attr):
for label, _ in nodes_for_adding:
self.assert_valid_node(label)
super().add_nodes_from(nodes_for_adding, **attr)
def add_edges_from(self, ebunch_to_add, **attr):
for source, target, _ in ebunch_to_add:
for label in [source, target]:
self.assert_valid_node(label)
super().add_edges_from(ebunch_to_add, **attr)
def assert_valid_node(self, label):
db_ns, db_id = self.get_ns_id(label)
if db_ns in {'INDRA_ACTIVITIES', 'INDRA_MODS'}:
return
try:
assert_valid_db_refs({db_ns: db_id})
except Exception as e:
logger.warning(e)
CACHE_DIR = os.path.join((get_config('INDRA_RESOURCES')
or os.path.join(os.path.expanduser('~'), '.indra')),
'%s_ontology' % BioOntology.name, BioOntology.version)
CACHE_FILE = os.path.join(CACHE_DIR, 'bio_ontology.pkl')
def _get_sofia_auth():
sofia_username = get_config('SOFIA_USERNAME')
sofia_password = get_config('SOFIA_PASSWORD')
return sofia_username, sofia_password
