Waiting on Reagon for a standard format for adding allowed function usage for each term in an ontology. Have the parser pick these out and add to the [Values] section of the BEL namespace

For Reagon's NPA variant, all of the upstream controllers of a given node are grabbed, then possibly recurring on their upstream controllers as well

Make a function that collapses nodes based on their orthology connections

def collapse_by_orthology(graph, priority_list=None):
   """Collapses a graph based on the orthology between nodes"""
   priority_list = ['HGNC', 'MGI', 'RGD'] if priority_list is none else priority_list
   ...

Give certain probability. Check the waltz-strogatz algorithm for small world network generation

Acquisition

1. Get all PubMed ID's in a graph
2. Look up the information for the given PMID. Store in a dictionary so multiple lookup isn't necessary
3. Stick in the network

Storage

• Export data to pybel.manager.models.Citation table for long term storage
• Provide inverse functions to relationalize/unrelationalize the citations in a BEL Graph

Summary

• Get all authors across all the citations in a given BEL Graph
• Get all authors, grouped by a given annotation (usually subgraph) in a given BEL Graph

See: pybel/pybel#60

Again, from aetionomy.pybel2 line 62:

def get_pubmedInfos_by_pmidList(self,pmids):
    """
    fetch from NCBI all publication information.
    @param pmids: PMID identifiers
    @type pmids: list
    @type pmids; tuple
    @return: dict with PMID as key and value => dict with keys: authors,title,pubdate,lastauthor,journal,volume,issue,pages,firstauthor,pmcId
    """
    pmids=list(set(list(pmids)))
    resultDict={}
    n = 200
    url = "http://eutils.ncbi.nlm.nih.gov/entrez/eutils/esummary.fcgi?db=pubmed&id=%s&retmode=json"
    for pmidList in [','.join(pmids[i:i+n]) for i in xrange(0, len(pmids), n)]:
        pmidsJson = json.loads(urllib2.urlopen(url % pmidList).read())
        for pmid in pmidsJson['result']['uids']:
            p=pmidsJson['result'][pmid]
            if 'error' not in p:
                authors = ', '.join([x['name'] for x in p['authors']]) if 'authors' in p else None 
                pubdate = None
                if re.search('^[12][0-9]{3} [a-zA-Z]{3} \d{1,2}$',p['pubdate']):
                    pubdate = datetime.datetime.strptime(p['pubdate'], '%Y %b %d').strftime('%Y-%m-%d')
                elif re.search('^[12][0-9]{3} [a-zA-Z]{3}$',p['pubdate']):
                    pubdate = datetime.datetime.strptime(p['pubdate'], '%Y %b').strftime('%Y-%m-01')
                elif re.search('^[12][0-9]{3}$',p['pubdate']):
                    pubdate = p['pubdate']+"-01-01"
                elif re.search('^[12][0-9]{3} [a-zA-Z]{3}-[a-zA-Z]{3}$',p['pubdate']):
                    pubdate = datetime.datetime.strptime(p['pubdate'][:-4], '%Y %b').strftime('%Y-%m-01')
                else:
                    print pubdate
                pmcIds = [x['value'] for x in p['articleids'] if x['idtype']=='pmc']
                pmcId = pmcIds[0] if pmcIds else None  
                resultDict[pmid]={
                    'authors':authors,
                    'title':p['title'],
                    'pubdate':pubdate,
                    'lastauthor':p['lastauthor'],
                    'journal':p['fulljournalname'],
                    'volume':p['volume'],
                    'issue':p['issue'],
                    'pages':p['pages'],
                    'firstauthor':p['sortfirstauthor'],
                    'pmcId':pmcId}
            else:
                print "probelms with following id:%s\nhttp://www.ncbi.nlm.nih.gov/pubmed/%s" % (pmid,pmid)
        time.sleep(1)
    return resultDict

see also: pybel_tools.boilerplate line 154 for grabbing information about abstracts

Allow list of definitions by file paths and urls

Since the functions in the database service are just simple wrappers around queries in the graph cache manager, would it make sense to just stick them in it? Or should we keep the cache manager just for functions of filling up and retrieving the cache, while query systems can wrap it and just use its connection?

Make a function that merge all node variants to its original protein/gene so we can infer all the neighborhood around that original node.

Validate if:

1. enzyme activity is described by the IUBMB EC classification system (http://www.chem.qmul.ac.uk/iubmb/)
2. a dbSNP RS identifier is correctly linked to a gene
3. substrates and products in a (bio-)chemical reaction are correct
   Please write comments if you have more suggestions

This issue has been migrated from pybel/pybel#65

From Reagon:

Find the statements that don't have a disease state (normal, AD, etc) to get flagged.

This could either be done on compile time, or the line number for each statement could be included in the graph.

This has been migrated from pybel/pybel#17.

Build a simple function that download all orthology data from HGNC's dump:

def download_orthology_dict():
   """Downloads orthology data from HGNC's data service

   :rtype: dict
   """
   pass

Chemicals shouldn't be counted, neither should pathologies, or pathologies

Maybe just pick genes after collapsing to genes?

Graphml, csv, graph not sure whether they are working. Check with @cthoyt

• encode color map in python and have it format it into the javascript
• new color map
• need legend

Make an asymmetric network merge merge(A, B) where the data from network A's nodes take preference over the data from network B

Use case:
Build network to represent Gene - SNP connections, but don't add any node dicts. I just want to add the edges, but not mess with the nodes in another graph.

We need to be able to give GET parameters to the /explorer/ endpoint and have those passed along to the ajax calls update the network. The ajax calls can conversely update the window's path to match any changes made without needing a hard reload.

Alternatively, the entire app could be model/view controller, like @cebel wanted in the first place.

With this all in place, it becomes trivial to implement the subgraph seeding

This needs a thorough testing suite with example graphs. Also test that node data gets updated properly (not overwritten?)

It would be great if the next step in the visualization system is to have a way to filter by annotations.

The obvious use case would be to filter by a specific subgraph, defined in the AD and PD assemblies.

Additionally, it might be nice to have a keyword argument to pre-specify which annotation to filter by, so the whole graph can be loaded in javascript, but only a specific slice would be shown initially

Get all edges from papers with either the given pubmed id's or authors, then expand on the first neighbors of these networks

For any two subgraphs and their parent graph, find the shortest path between the components. Do this with directed paths, and undirected path transformations.

Write information about the default host and port in the cli help message

This would be useful for the pybel-recuration interface.

It might also be possible to use/adapt the INDRA english assembler

Code skeleton:

def overlay_data(graph, data, label):
    """
    :type graph: :class:`pybel.BELGraph`
    :param data: a dictionary of {pybel node: data for that node}
    :type data: dict
    :param label:
    :type label: str
    """
    pass

Use Cases:

• I have differential gene expression data that I want to add as an attribute to all of my RNA nodes so I can do RCR or NPA later.
• I have a list of functional consequences for all of my SNPs and want to include this information in my network

Most miRNA can be written with g(HGNC:YFG) transcribedTo m(HGNC:YFG) so the inference of the central dogma should also make these edges.

I'm also curious about miRNA's themselves, since there's a differentiation between a "premature" and a "mature" sequence. Does the premature sequence count as an RNA and not an miRNA?

Thoughts @cebel, @dexterpratt?

Some endpoints have optional arguments, like offsets. Rather than having a more confusing API with many more routes, make these request parameters and switch on their existence using flask.request.args

Same as for kono in #43. Update web application to match.

Worth noting that we aren't going to do this because the way the API has grown organically... and not really in a planned way - lol

Some of them have non-filesystem safe characters, like slashes, which is a problem

Need external functions that allow for inference of translation and transcription

Need a stand-alone web app that can handle the nanopub posting endpoint: https://openbel.api-docs.io/1.1.0/api/cT63ahviFZ2ywLbMf

Resources

• Full swagger.json: https://api.stoplight.io/v1/versions/2PcWLTYmcRWXSZ8a7/export/oas.json
• Nanopub Schema: https://openbel.api-docs.io/1.1.0/models/nanopub
• Connexion: https://connexion.readthedocs.io/en/latest/routing.html

Grab DC terms out of the xpath ./Annotations

.Pathology {
fill: #FF7F0E;
}

.Abundance {
fill: #AEC7E8;
}

.Gene {
fill: #FFBB78;
}

.miRNA {
fill: #D62728;
}

.Protein {
fill: #1F77B4;
}

.RNA {
fill: #FF9896;
}

.BiologicalProcess {
fill: #2CA02C;
}

.Pathology {
fill: #FF7F0E;
}

.Complex {
fill: #98DF8A;
}

.Composite {
fill: #9467BD;
}

// ADD MORE HERE