# EW6: Finding nodes in Rattus norvegicus pathways with IUPAC names

Hypothesis: Rattus norvegicus pathways in WikiPathways have DataNode’s with labels containing IUPAC names which can be tagged as type Metabolite.

Start date: 2014-09-05 End date: 2014-09-05

Description:

WikiPathways entries in GPML have DataNode objects and Label objects. It was found before [here, here] that metabolites can be encoded in pathways is Label objects and therefore not machine-readable as Metabolite-type DataNode and unable to have a database identifier. As such, these metabolites are unusable for pathway analysis of metabolomics data.

By processing these GPML files (they are XML-based) and iterating over all Label’s we can attempt to convert this label into chemical structure with OPSIN. This goes under the assumption that if OPSIN can parse the label into a structure, it is one. This label will be recorded along with the pathway identifier for manual inspection. For each structure it will also look up a ChemSpider identifier.

Methods

Unchanged protocol.

• Get a working Bioclipse development version (hard) with the OPSIN, InChI, and ChemSpider extensions
• A Groovy script to iterate over the GPML, find <Label> elementsEach <Label> is parsed with OPSIN and if successful, generate an InChI
• Use the InChIs to find ChemSpider identifiers
• Output all as a text file and open metabolites in a Structure table

Report

Similar to the experiment for Anopheles gambiae and Homo sapiens only curated pathways were analyzed, 143 in total, downloaded from WikiPathways.org on August 24. The Groovy script is used detailed in this experiment.

The script found 47 Labels that are possibly metabolites in 8 different rat pathways. The full list was uploaded to Gist.

Conclusion: Rat pathways also include metabolites encoded in GPML <Label> elements.

# EW5: Finding nodes in Homo sapiens pathways with IUPAC names

Hypothesis: Homo sapiens pathways in WikiPathways have DataNode’s with labels containing IUPAC names which can be tagged as type Metabolite.

Start date: 2014-09-01 End date: 2014-09-01

Description: WikiPathways entries in GPML have DataNode objects and Label objects. It was found before [here] that metabolites can be encoded in pathways is Label objects and therefore not machine-readable as Metabolite-type DataNode and unable to have a database identifier. As such, these metabolites are unusable for pathway analysis of metabolomics data.

By processing these GPML files (they are XML-based) and iterating over all Label’s we can attempt to convert this label into chemical structure with OPSIN. This goes under the assumption that if OPSIN can parse the label into a structure, it is one. This label will be recorded along with the pathway identifier for manual inspection. For each structure it will also look up a ChemSpider identifier.

Methods

• Get a working Bioclipse development version (hard) with the OPSIN, InChI, and ChemSpider extensions
• A Groovy script to iterate over the GPML, find <Label> elements
• Each <Label> is parsed with OPSIN and if successful, generate an InChI
• Use the InChIs to find ChemSpider identifiers
• Output all as a text file and open metabolites in a Structure table

Report

Similar to the experiment for Anopheles gambiae only curated pathways were analyzed, some 266 in total, downloaded from WikiPathways.org on August 24. The previous Groovy script was updated to point to the human pathways, but also to output the results in a file, rather than STDOUT. The new script was uploaded to myExperiment.org.

The script found 42 Labels that are possibly metabolites. The full list was uploaded to Gist. Again, labels were found which could not be linked to a single ChemSpider ID. For example, “5b-Pregnane-3,20-dione” which will results in these ChemSpider search hits: 21427590, 389575, 21232692, 21239075, 21237402. The result file also shows a few labels with new lines.

One metabolite was manually confirmed in WP1449Imidazoquinolin. Interestingly, the Label was visually “connected” with “(anti-viral compounds)” which have a ChEBI identifier and could be converted to a DataNode of type Metabolite too:

Most work, however, needs to be done in the Tryptophan metabolism pathway (WP465); many metabolites are not properly made machine readable.

Conclusion:

Human pathways also include metabolites encoded in GPML <Label> elements, even in the curated subset.

# EW4: Finding nodes in Anopheles gambiae pathways with IUPAC names

Hypothesis: Anopheles gambiae pathways in WikiPathways have DataNode’s with labels containing IUPAC names which can be tagged as type Metabolite.

Start date: 2014-08-24 End date: 2014-08-24

Description: WikiPathways entries in GPML have DataNode objects and Label objects. It was found before [no published] that metabolites can be encoded in pathways is Label objects and therefore not machine-readable as Metabolite-type DataNode and unable to have a database identifier. As such, these metabolites are unusable for pathway analysis of metabolomics data.

By processing these GPML files (they are XML-based) and iterating over all Label’s we can attempt to convert this label into chemical structure with OPSIN. This goes under the assumption that if OPSIN can parse the label into a structure, it is one. This label will be recorded along with the pathway identifier for manual inspection. For each structure it will also look up a ChemSpider identifier.

Methods

• Get a working Bioclipse development version (hard) with the OPSIN, InChI, and ChemSpider extensions
• A Groovy script to iterate over the GPML, find <Label> elements
• Each <Label> is parsed with OPSIN and if successful, generate an InChI
• Use the InChIs to find ChemSpider identifiers
• Output all as a text file and open metabolites in a Structure table

Report

Twelve WikiPathways for Anopheles gambiae were downloaded part of the analysis collection. In the future, uncurated pathways can also be included, anticipating to have more metabolites not annotated as Metabolite type. A custom Groovy script for Bioclipse was used, based on a previous similar script available from myExperiment.org. The updated script has been made available on myExperiment.org too. The results of running this script are visible in the above screenshot.

Key calls to Bioclipse managers used in this script, in addition to using the Groovy XMLParser, are:

• cdk.createMoleculeList()
• opsin.parseIUPACName(name)
• inchi.generate(molecule)
• chemspider.resolve(inchiKey)

Four metabolites were found, in one pathway (WP1230):

Ag_One_Carbon_Metabolism_WP1230_68447.gpml: node b93 -> Serine -> MTCFGRXMJLQNBG-UHFFFAOYSA-N -> CSID: [597]
Ag_One_Carbon_Metabolism_WP1230_68447.gpml: node ff7 -> Glycine -> DHMQDGOQFOQNFH-UHFFFAOYSA-N -> CSID: [730]
Ag_One_Carbon_Metabolism_WP1230_68447.gpml: node c8c -> Deoxythymidine monophosphate -> WVNRRNJFRREKAR-UHFFFAOYSA-N -> CSID: [315142]
Ag_One_Carbon_Metabolism_WP1230_68447.gpml: node a47 -> Deoxyuridine monophosphate -> JSRLJPSBLDHEIO-UHFFFAOYSA-N -> CSID: [21537275, 668, 21230588]

Three metabolites have a single ChemSpider identifier, whereas one has three ChemSpider identifiers.

Visual inspection of WP1230 (revision 68447) confirms our hypothesis:

Conclusion: Anopheles gambiae pathways indeed also include metabolites encoded in GPML <Label> elements.

# EW3: Exposing more Jena functionality in Bioclipse

Hypothesis: Jena functionality for triple set comparison can be exposed via Bioclipse script

Start date: 2014-08-20 End date: 2014-08-20

Description: Bioclipse in the development branch mostly uses Jena for handling RDF data. The “rdf” manager already exposes various features of Jena. We here wish to expose the functionality of Jena to make unions, intersections, and differences of two triple stores (“Model”s in Jena terms) and to use the experimental shortest path method from the OntTool class.

Methods

• define additional methods in the IRDFManager interface with the proper code
• write implementations of these methods in the RDFManager class
• publish the patches

Report While I still had a development environment from this step, Bioclipse no longer properly booted. Between that experiment and this one various things happened:

1. Bioclipse had a new target platform
2. I moved to a 64bit operating system
3. I only reinstalled Java8

For resetting the target platform the normal protocol was used, though I had to repeat it a few times to get fully working. As usual, I first had to ask Arvid in Uppsala before it really started working (#overlyhonestmethods). There may have been a confounding issue with not having the proper javax.xml.soap version in my installation, and Arvid’s suggestion to manually remove the java.xml plugin from the target platform, via the Content tab.

A further issue was found in using Java8 which has a different provider for the JavaScript extension. As a result, the Bioclipse JavaScript console did not start. Apparently, my Java 8_11 installation in Eclipse does not provide any scripting environment (tested by asking the ScriptEngineManager for all engines; none were reported). Because the nashorn.jar that contains the implementation was provided by Oracle as a separate jar, containing an open source JavaScript engine originally by Mozilla, now provided via OpenJDK, I could include this jar in the Bioclipse plugin, solving these issues. Along with a few other patches, these tweaks are available in this branch on GitHub. These patches are not pushed for inclusion in the Bioclipse development branch.

The test suite was not extended and not run as “JUnit Plug-in Test” using Eclipse, because my development environment is not able to properly run these at this moment. Instead, the functionality was tested using the rdf manager from the JavaScript console with this script:

store = rdf.createInMemoryStore()

rdf.addObjectProperty(store,
  "http://example.com/#subject",
  "http://example.com/#predicate",
  "http://example.com/#object"
);
rdf.addObjectProperty(store,
  "http://example.com/#subject",
  "http://example.com/#predicate",
  "http://example.com/#object2"
);
secondStore = rdf.createInMemoryStore();
rdf.addObjectProperty(secondStore,
  "http://example.com/#subject",
  "http://example.com/#predicate",
  "http://example.com/#object"
);
rdf.addDataProperty(secondStore,
  "http://example.com/#subject",
  "http://example.com/#predicate",
  "someDataObject"
);

unionStore = rdf.union(store, secondStore);
diffStore = rdf.difference(store, secondStore);
intersectStore = rdf.intersection(store, secondStore);
rdf.asTurtle(diffStore)

This showed expected results, with the exception that the Jena code makes default triples more visible. That is, converting the store to Turtle shows two triples, even though it has an additional 39~ish additional triples from the RDF and RDF Schema specifications. Weirdly, making a union of the store and secondStore, the number of triples increases to about 150 and converting this to Turtle does serialize all those RDF and RDF Schema triples. I have been unable to work around this feature.

The above three methods are easily wrapped, but the shortest path functionality requires an additional step: the OntTool return value is a toolkit specific type (Path) and the rdf manager was designed to convert this to a java.util.List of Strings. This functionality too was tested via the JavaScriptConsole:

store = rdf.createInMemoryStore()

rdf.addObjectProperty(store,
  "http://example.com/#subject",
  "http://example.com/#predicate",
  "http://example.com/#subject2"
);
rdf.addObjectProperty(store,
  "http://example.com/#subject2",
  "http://example.com/#predicate",
  "http://example.com/#subject3"
);

rdf.shortestPath(store,
  "http://example.com/#subject",
  "http://example.com/#subject3"
);

The manager provides two variants at this moment of this shortestPath() method: the above exemplified version and one that takes a fourth parameter, being a String representation of an URI matching the only predicate that can be part of the path. Both methods were found to work as expected based on the above code. No application to larger data sets have been tried.

Resulting patches have been provided as a pull request.

Conclusion: Exposing the additional functionality yielded an more functional rdf manager with interesting new features.

# EW1: Updating Bioclipse with OPSIN 1.6.0

Hypothesis: Bioclipse works just as well with OPSIN 1.6.0 as it does with 1.5.0.

Start date: 2014-07-20 End date: 2014-07-21

Description: Bioclipse in the development branch has OPSIN 1.5.0 exposed with the opsin manager. The intention of this experiment is to update Bioclipse with OPSIN 1.6.0, keeping the opsin manager methods working.

Methods

• update the OPSIN version
• test with the test suite
• publish the patches

Report

I still had a working development environment around. As I installed Eclipse 4.4 a few days earlier, I opened the Eclipse workspace with this version, which triggered an irreversible upgrade of the workspace so that I cannot return to Eclipse 4.3. The test suite was run as “JUnit Plug-in Test” using Eclipse, defined by the AllOpsinManagerPluginTests class. This shows two fails in the APITest test class, related to @TestClass and @TestMethod annotation. Annotation was added and committed as a patch to ensure no fails were reported.

Then the opsin-1.6.0-excludingInChI-jar-with-dependencies.jar was downloaded from the OPSIN download page. This version was selected because the 1.5.0 version excluded the InChI bits too and these is already available from other Bioclipse plugins. The new jar was copied into the net.bioclipse.opsin’s jar/ folder and .classpatch, MANIFEST.MF, and build.properties were updated accordingly.

The result was successfully testing using the aforementioned AllOpsinManagerPluginTests class and by running Bioclipse itself and using the opsin manager from the JavaScript console with the command ui.open(opsin.parseIUPACName(“benzene”)).

The two patches were made available as pull request 46.

Conclusion:

No special updated were needed and Bioclipse works with OPSIN 1.6.0 just as it did with OPSIN 1.5.0.