1470

pending completion

Build # 1470

Build Type

push

travis-ci

Committed by

web-flow

Commit Message

Merge pull request #173 from eweitz/ortholog-expansion

Compare whole genomes for many more organisms

Run Details

888 of 1074 branches covered (82.68%)

Branch coverage included in aggregate %.

46 of 46 new or added lines in 4 files covered. (100.0%)

2540 of 2700 relevant lines covered (94.07%)

57512.95 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

88.21

/src/js/services/organisms.js

import {d3} from '../lib';

/**
 *  Returns NCBI Taxonomy identifier (taxid) for organism name
 */
function getTaxidFromEutils(orgName, ideo) {
  var taxonomySearch, taxid;

  taxonomySearch = ideo.esearch + '&db=taxonomy&term=' + orgName;

  return d3.json(taxonomySearch).then(function(data) {
    taxid = data.esearchresult.idlist[0];
    return taxid;
  });
}

/**
 * Returns organism common name given an NCBI Taxonomy ID
 *
 * @param taxid NCBI Taxonomy ID
 * @param callback Function to call upon completing ESearch request
 */
function getOrganismFromEutils(taxid, callback) {
  var organism, taxonomySearch,
    ideo = this;

  taxid = ideo.config.organism;

  taxonomySearch = ideo.esummary + '&db=taxonomy&id=' + taxid;

  d3.json(taxonomySearch).then(function(data) {
    organism = data.result[String(taxid)].commonname;
    ideo.config.organism = organism;
    return callback(organism);
  });
}

function setTaxidData(taxid, ideo) {

  var dataDir, organism, urlOrg, taxids;

  if (ideo.assemblyIsAccession()) {
    return new Promise(function(resolve) {
      ideo.coordinateSystem = 'bp';
      ideo.getAssemblyAndChromosomesFromEutils(taxid, resolve);
    });
  }

  dataDir = ideo.config.dataDir;
  organism = ideo.organisms[taxid].scientificName.toLowerCase();
  urlOrg = organism.replace(' ', '-');

  taxids = [taxid];

  var fullyBandedTaxids = ['9606', '10090', '10116'];
  if (fullyBandedTaxids.includes(taxid) && !ideo.config.showFullyBanded) {
    urlOrg += '-no-bands';
  }
  var chromosomesUrl = dataDir + urlOrg + '.json';

  var promise2 = new Promise(function(resolve, reject) {
    fetch(chromosomesUrl).then(function(response) {
      if (response.ok === false) {
        reject(Error('Fetch failed for ' + chromosomesUrl));
      } else {
        return response.json().then(function(json) {
          resolve(json.chrBands);
        });
      }
    });
  });

  return promise2
    .then(function(chrBands) {
      // Check if chromosome data exists locally.
      // This is used for pre-processed centromere data,
      // which is not accessible via EUtils.  See get_chromosomes.py.

      var asmAndChrTaxidsArray = [''],
        chromosomes = [],
        seenChrs = {},
        chr, maxLength, splitBand, length;

      ideo.bandData[taxid] = chrBands;

      for (var i = 0; i < chrBands.length; i++) {
        splitBand = chrBands[i].split(' ');
        chr = splitBand[0];
        length = splitBand.slice(-1)[0];
        if (chr in seenChrs) {
          continue;
        } else {
          chromosomes.push({name: chr, type: 'nuclear', length: length});
          seenChrs[chr] = 1;
        }
      }
      chromosomes = chromosomes.sort(Ideogram.sortChromosomes);
      maxLength = {bp: 0, iscn: 0};
      chromosomes.forEach(chr => {
        if (chr.length > maxLength.bp) maxLength.bp = chr.length;
      });
      ideo.maxLength[taxid] = maxLength;
      asmAndChrTaxidsArray.push(chromosomes);
      asmAndChrTaxidsArray.push(taxids);
      return asmAndChrTaxidsArray;
    },
    function() {
      // If request in `then` errs (404), fetch data from EUtils
      return new Promise(function(resolve) {
        ideo.coordinateSystem = 'bp';
        ideo.getAssemblyAndChromosomesFromEutils(taxid, resolve);
      });
    });
}

function setAssemblyAndChromosomes(taxid, resolve, ideo) {
  var assembly, chrs, originalChrs, orgName, filteredChrs,
    config = ideo.config;

  setTaxidData(taxid, ideo)
    .then(function(asmChrTaxidsArray) {
      assembly = asmChrTaxidsArray[0];
      chrs = asmChrTaxidsArray[1];

      if ('chromosomes' in config === false || config.chromosomes === null) {
        ideo.config.chromosomes = {};
        ideo.config.chromosomes[taxid] = chrs;
      } else {
        if (config.multiorganism) {
          if (taxid in config.chromosomes) {
            // Encountered when either organism has centromere data
            originalChrs = config.chromosomes[taxid];
          } else {
            // Encountered when neither organism has centromere data
            orgName = ideo.getScientificName(taxid).toLowerCase();
            ideo.config.chromosomes[taxid] =
              config.chromosomes[orgName].slice();
            originalChrs = ideo.config.chromosomes[taxid];
            // delete ideo.config.chromosomes[orgName];
          }
        } else {
          originalChrs = config.chromosomes;
        }

        filteredChrs = chrs.filter(d => originalChrs.includes(d.name));
        ideo.config.chromosomes[taxid] = filteredChrs;
      }
      ideo.chromosomes[taxid] = ideo.config.chromosomes[taxid].slice();
      ideo.organisms[taxid].assemblies = {
        default: assembly
      };
      resolve();
    });
}

/**
 * Determine if organism is natively supported, using its name.
 */
function isOrganismSupported(org, ideo) {
  var taxid, ideoOrg;

  for (taxid in ideo.organisms) {
    ideoOrg = ideo.organisms[taxid];
    if (
      taxid === org ||
      ideoOrg.commonName.toLowerCase() === org.toLowerCase() ||
      ideoOrg.scientificName.toLowerCase() === org.toLowerCase()
    ) {
      return true;
    }
  }

  return false;
}

/**
 * Augment "organisms" metadata with for any requested organism that is
 * not natively supported (i.e., not in organism-metadata.js).
*/
function populateNonNativeOrg(orgs, ideo) {
  var org, promise, i,
    getTaxidFromEutilsPromises = [],
    augmentedOrganismMetadata = {};

  for (i = 0; i < orgs.length; i++) {
    org = orgs[i];
    if (isOrganismSupported(org, ideo) === false) {
      promise = getTaxidFromEutils(org, ideo)
        .then(function(taxid) {

          augmentedOrganismMetadata[taxid] = {
            scientificName: org,
            scientificNameAbbr: '',
            commonName: '',
            assemblies: {default: ''}
          };

          Object.assign(ideo.organisms, augmentedOrganismMetadata);
        });
    } else {
      promise = new Promise(function(resolve) {
        var taxid = ideo.getTaxid(org);
        augmentedOrganismMetadata[taxid] = ideo.organisms[taxid];
        resolve();
      });
    }
    getTaxidFromEutilsPromises.push(promise);
  }

  return Promise.all(getTaxidFromEutilsPromises).then(function() {
    return augmentedOrganismMetadata;
  });
}

function prepareTmpChrsAndTaxids(ideo) {
  var orgs, taxids, tmpChrs, org, taxid,
    config = ideo.config;

  taxids = [];
  tmpChrs = {};
  orgs = (config.multiorganism) ? config.organism : [config.organism];

  return populateNonNativeOrg(orgs, ideo).then(function(orgMetadata) {
    var orgFields = orgMetadata[taxid];

    for (taxid in orgMetadata) {
      orgFields = orgMetadata[taxid];
      taxids.push(taxid);
      if (config.multiorganism) {
        if (typeof config.chromosomes !== 'undefined') {
          // Adjusts 'chromosomes' configuration parameter to make object
          // keys use taxid instead of common organism name
          if (orgFields.scientificName.toLowerCase() in config.chromosomes) {
            org = orgFields.scientificName;
          } else if (orgFields.commonName.toLowerCase() in config.chromosomes) {
            org = orgFields.commonName;
          }
          tmpChrs[taxid] = config.chromosomes[org.toLowerCase()];
        } else {
          tmpChrs = null;
        }
      }
    }
    return [tmpChrs, taxids];
  });
}

/**
 * Sort taxids by the "organism" configuration option
 *
 * TODO: Handle taxid being passed as organism
 */
function sortTaxidsByOriginalOrganismOption(ideo) {
  var configOrganisms, sortedTaxids, i;
  configOrganisms = ideo.config.organism;
  sortedTaxids = [];
  if (Array.isArray(configOrganisms)) {
    // Handling multi-organism ideogram
    for (i = 0; i < configOrganisms.length; i++) {
      sortedTaxids.push(ideo.getTaxid(configOrganisms[i]));
    }
  } else {
    // Handling single-organism ideogram
    sortedTaxids.push(ideo.getTaxid(configOrganisms));
  }
  return sortedTaxids;
}

function getTaxidsForOrganismsInConfig(callback, ideo) {

  prepareTmpChrsAndTaxids(ideo).then(function([tmpChrs, taxids]) {
    var i, taxid, promise, assemblies, asmAccs,
      config = ideo.config,
      asmAndChrPromises = [];

    for (i = 0; i < taxids.length; i++) {
      taxid = taxids[i];
      assemblies = ideo.organisms[taxid].assemblies;
      asmAccs = Object.values(assemblies);
      if (
        assemblies.default === '' ||
        ideo.assemblyIsAccession() && !asmAccs.includes(config.assembly)
      ) {
        promise = new Promise(function(resolve) {
          setAssemblyAndChromosomes(taxid, resolve, ideo);
        });
      } else {
        ideo.config.taxids = taxids;
        if (ideo.config.multiorganism) {
          ideo.config.chromosomes = tmpChrs;
        }
        promise = new Promise(function(resolve) {
          resolve();
        });
      }

      asmAndChrPromises.push(promise);
    }

    Promise.all(asmAndChrPromises).then(function() {
      taxids = sortTaxidsByOriginalOrganismOption(ideo);
      ideo.config.taxids = taxids;
      return callback(taxids);
    });
  });
}

function getIsMultiorganism(taxidInit, ideo) {
  return (
    ('organism' in ideo.config && ideo.config.organism instanceof Array) ||
    (taxidInit && ideo.config.taxid instanceof Array)
  );
}

/**
 * Configure Ideogram taxids when 'organism' is not in ideo.config
 */
function getTaxidsForOrganismsNotInConfig(taxidInit, callback, ideo) {
  var taxids;

  if (ideo.config.multiorganism) {
    if (taxidInit) {
      taxids = ideo.config.taxid;
    }
  } else {
    if (taxidInit) {
      taxids = [ideo.config.taxid];
    }
    ideo.config.taxids = taxids;
  }
  callback(taxids);
}

/**
 * Returns an array of taxids for the current ideogram
 * Also sets configuration parameters related to taxid(s), whether ideogram is
 * multiorganism, and adjusts chromosomes parameters as needed
 **/
function getTaxids(callback) {
  var taxidInit,
    ideo = this;

  taxidInit = 'taxid' in ideo.config;

  ideo.config.multiorganism = getIsMultiorganism(taxidInit, ideo);

  if (ideo.config.multiorganism) ideo.coordinateSystem = 'bp';

  if ('organism' in ideo.config) {
    getTaxidsForOrganismsInConfig(callback, ideo);
  } else {
    getTaxidsForOrganismsNotInConfig(taxidInit, callback, ideo);
  }
}

export {
  getTaxids, getOrganismFromEutils
};

1	import {d3} from '../lib';
2
3	/**
4	* Returns NCBI Taxonomy identifier (taxid) for organism name
5	*/
6	function getTaxidFromEutils(orgName, ideo) {
7	var taxonomySearch, taxid;
8
9	taxonomySearch = ideo.esearch + '&db=taxonomy&term=' + orgName;	4✔
10
11	return d3.json(taxonomySearch).then(function(data) {	4✔
12	taxid = data.esearchresult.idlist[0];	4✔
13	return taxid;	4✔
14	});
15	}
16
17	/**
18	* Returns organism common name given an NCBI Taxonomy ID
19	*
20	* @param taxid NCBI Taxonomy ID
21	* @param callback Function to call upon completing ESearch request
22	*/
23	function getOrganismFromEutils(taxid, callback) {
24	var organism, taxonomySearch,
25	ideo = this;	1✔
26
27	taxid = ideo.config.organism;	1✔
28
29	taxonomySearch = ideo.esummary + '&db=taxonomy&id=' + taxid;	1✔
30
31	d3.json(taxonomySearch).then(function(data) {	1✔
32	organism = data.result[String(taxid)].commonname;	1✔
33	ideo.config.organism = organism;	1✔
34	return callback(organism);	1✔
35	});
36	}
37
38	function setTaxidData(taxid, ideo) {
39
40	var dataDir, organism, urlOrg, taxids;
41
42	if (ideo.assemblyIsAccession()) {	6✔
43	return new Promise(function(resolve) {	1✔
44	ideo.coordinateSystem = 'bp';	1✔
45	ideo.getAssemblyAndChromosomesFromEutils(taxid, resolve);	1✔
46	});
47	}
48
49	dataDir = ideo.config.dataDir;	5✔
50	organism = ideo.organisms[taxid].scientificName.toLowerCase();	5✔
51	urlOrg = organism.replace(' ', '-');	5✔
52
53	taxids = [taxid];	5✔
54
55	var fullyBandedTaxids = ['9606', '10090', '10116'];	5✔
56	if (fullyBandedTaxids.includes(taxid) && !ideo.config.showFullyBanded) {	5✔
57	urlOrg += '-no-bands';	1✔
58	}
59	var chromosomesUrl = dataDir + urlOrg + '.json';	5✔
60
61	var promise2 = new Promise(function(resolve, reject) {	5✔
62	fetch(chromosomesUrl).then(function(response) {	5✔
63	if (response.ok === false) {	5✔
64	reject(Error('Fetch failed for ' + chromosomesUrl));	1✔
65	} else {
66	return response.json().then(function(json) {	4✔
67	resolve(json.chrBands);	4✔
68	});
69	}
70	});
71	});
72
73	return promise2	5✔
74	.then(function(chrBands) {
75	// Check if chromosome data exists locally.
76	// This is used for pre-processed centromere data,
77	// which is not accessible via EUtils. See get_chromosomes.py.
78
79	var asmAndChrTaxidsArray = [''],	4✔
80	chromosomes = [],	4✔
81	seenChrs = {},	4✔
82	chr, maxLength, splitBand, length;
83
84	ideo.bandData[taxid] = chrBands;	4✔
85
86	for (var i = 0; i < chrBands.length; i++) {	4✔
87	splitBand = chrBands[i].split(' ');	182✔
88	chr = splitBand[0];	182✔
89	length = splitBand.slice(-1)[0];	182✔
90	if (chr in seenChrs) {	182✔
91	continue;	88✔
92	} else {
93	chromosomes.push({name: chr, type: 'nuclear', length: length});	94✔
94	seenChrs[chr] = 1;	94✔
95	}
96	}
97	chromosomes = chromosomes.sort(Ideogram.sortChromosomes);	4✔
98	maxLength = {bp: 0, iscn: 0};	4✔
99	chromosomes.forEach(chr => {	4✔
100	if (chr.length > maxLength.bp) maxLength.bp = chr.length;	94✔
101	});
102	ideo.maxLength[taxid] = maxLength;	4✔
103	asmAndChrTaxidsArray.push(chromosomes);	4✔
104	asmAndChrTaxidsArray.push(taxids);	4✔
105	return asmAndChrTaxidsArray;	4✔
106	},
107	function() {
108	// If request in `then` errs (404), fetch data from EUtils
109	return new Promise(function(resolve) {	1✔
110	ideo.coordinateSystem = 'bp';	1✔
111	ideo.getAssemblyAndChromosomesFromEutils(taxid, resolve);	1✔
112	});
113	});
114	}
115
116	function setAssemblyAndChromosomes(taxid, resolve, ideo) {
117	var assembly, chrs, originalChrs, orgName, filteredChrs,
118	config = ideo.config;	6✔
119
120	setTaxidData(taxid, ideo)	6✔
121	.then(function(asmChrTaxidsArray) {
122	assembly = asmChrTaxidsArray[0];	6✔
123	chrs = asmChrTaxidsArray[1];	6✔
124
125	if ('chromosomes' in config === false \|\| config.chromosomes === null) {	6✔
126	ideo.config.chromosomes = {};	5✔
127	ideo.config.chromosomes[taxid] = chrs;	5✔
128	} else {
129	if (config.multiorganism) {	1!
130	if (taxid in config.chromosomes) {	1!
131	// Encountered when either organism has centromere data
132	originalChrs = config.chromosomes[taxid];	1✔
133	} else {
134	// Encountered when neither organism has centromere data
135	orgName = ideo.getScientificName(taxid).toLowerCase();	×
136	ideo.config.chromosomes[taxid] =	×
137	config.chromosomes[orgName].slice();
138	originalChrs = ideo.config.chromosomes[taxid];	×
139	// delete ideo.config.chromosomes[orgName];
140	}
141	} else {
142	originalChrs = config.chromosomes;	×
143	}
144
145	filteredChrs = chrs.filter(d => originalChrs.includes(d.name));	24✔
146	ideo.config.chromosomes[taxid] = filteredChrs;	1✔
147	}
148	ideo.chromosomes[taxid] = ideo.config.chromosomes[taxid].slice();	6✔
149	ideo.organisms[taxid].assemblies = {	6✔
150	default: assembly
151	};
152	resolve();	6✔
153	});
154	}
155
156	/**
157	* Determine if organism is natively supported, using its name.
158	*/
159	function isOrganismSupported(org, ideo) {
160	var taxid, ideoOrg;
161
162	for (taxid in ideo.organisms) {	59✔
163	ideoOrg = ideo.organisms[taxid];	1,010✔
164	if (	1,010✔
165	taxid === org \|\|	2,975✔
166	ideoOrg.commonName.toLowerCase() === org.toLowerCase() \|\|
167	ideoOrg.scientificName.toLowerCase() === org.toLowerCase()
168	) {
169	return true;	55✔
170	}
171	}
172
173	return false;	4✔
174	}
175
176	/**
177	* Augment "organisms" metadata with for any requested organism that is
178	* not natively supported (i.e., not in organism-metadata.js).
179	*/
180	function populateNonNativeOrg(orgs, ideo) {
181	var org, promise, i,
182	getTaxidFromEutilsPromises = [],	55✔
183	augmentedOrganismMetadata = {};	55✔
184
185	for (i = 0; i < orgs.length; i++) {	55✔
186	org = orgs[i];	59✔
187	if (isOrganismSupported(org, ideo) === false) {	59✔
188	promise = getTaxidFromEutils(org, ideo)	4✔
189	.then(function(taxid) {
190
191	augmentedOrganismMetadata[taxid] = {	4✔
192	scientificName: org,
193	scientificNameAbbr: '',
194	commonName: '',
195	assemblies: {default: ''}
196	};
197
198	Object.assign(ideo.organisms, augmentedOrganismMetadata);	4✔
199	});
200	} else {
201	promise = new Promise(function(resolve) {	55✔
202	var taxid = ideo.getTaxid(org);	55✔
203	augmentedOrganismMetadata[taxid] = ideo.organisms[taxid];	55✔
204	resolve();	55✔
205	});
206	}
207	getTaxidFromEutilsPromises.push(promise);	59✔
208	}
209
210	return Promise.all(getTaxidFromEutilsPromises).then(function() {	55✔
211	return augmentedOrganismMetadata;	55✔
212	});
213	}
214
215	function prepareTmpChrsAndTaxids(ideo) {
216	var orgs, taxids, tmpChrs, org, taxid,
217	config = ideo.config;	55✔
218
219	taxids = [];	55✔
220	tmpChrs = {};	55✔
221	orgs = (config.multiorganism) ? config.organism : [config.organism];	55✔
222
223	return populateNonNativeOrg(orgs, ideo).then(function(orgMetadata) {	55✔
224	var orgFields = orgMetadata[taxid];	55✔
225
226	for (taxid in orgMetadata) {	55✔
227	orgFields = orgMetadata[taxid];	59✔
228	taxids.push(taxid);	59✔
229	if (config.multiorganism) {	59✔
230	if (typeof config.chromosomes !== 'undefined') {	8✔
231	// Adjusts 'chromosomes' configuration parameter to make object
232	// keys use taxid instead of common organism name
233	if (orgFields.scientificName.toLowerCase() in config.chromosomes) {	6!
234	org = orgFields.scientificName;	×
235	} else if (orgFields.commonName.toLowerCase() in config.chromosomes) {	6!
236	org = orgFields.commonName;	6✔
237	}
238	tmpChrs[taxid] = config.chromosomes[org.toLowerCase()];	6✔
239	} else {
240	tmpChrs = null;	2✔
241	}
242	}
243	}
244	return [tmpChrs, taxids];	55✔
245	});
246	}
247
248	/**
249	* Sort taxids by the "organism" configuration option
250	*
251	* TODO: Handle taxid being passed as organism
252	*/
253	function sortTaxidsByOriginalOrganismOption(ideo) {
254	var configOrganisms, sortedTaxids, i;
255	configOrganisms = ideo.config.organism;	55✔
256	sortedTaxids = [];	55✔
257	if (Array.isArray(configOrganisms)) {	55✔
258	// Handling multi-organism ideogram
259	for (i = 0; i < configOrganisms.length; i++) {	4✔
260	sortedTaxids.push(ideo.getTaxid(configOrganisms[i]));	8✔
261	}
262	} else {
263	// Handling single-organism ideogram
264	sortedTaxids.push(ideo.getTaxid(configOrganisms));	51✔
265	}
266	return sortedTaxids;	55✔
267	}
268
269	function getTaxidsForOrganismsInConfig(callback, ideo) {
270
271	prepareTmpChrsAndTaxids(ideo).then(function([tmpChrs, taxids]) {	55✔
272	var i, taxid, promise, assemblies, asmAccs,
273	config = ideo.config,	55✔
274	asmAndChrPromises = [];	55✔
275
276	for (i = 0; i < taxids.length; i++) {	55✔
277	taxid = taxids[i];	59✔
278	assemblies = ideo.organisms[taxid].assemblies;	59✔
279	asmAccs = Object.values(assemblies);	59✔
280	if (	59✔
281	assemblies.default === '' \|\|	115✔
282	ideo.assemblyIsAccession() && !asmAccs.includes(config.assembly)
283	) {
284	promise = new Promise(function(resolve) {	6✔
285	setAssemblyAndChromosomes(taxid, resolve, ideo);	6✔
286	});
287	} else {
288	ideo.config.taxids = taxids;	53✔
289	if (ideo.config.multiorganism) {	53✔
290	ideo.config.chromosomes = tmpChrs;	7✔
291	}
292	promise = new Promise(function(resolve) {	53✔
293	resolve();	53✔
294	});
295	}
296
297	asmAndChrPromises.push(promise);	59✔
298	}
299
300	Promise.all(asmAndChrPromises).then(function() {	55✔
301	taxids = sortTaxidsByOriginalOrganismOption(ideo);	55✔
302	ideo.config.taxids = taxids;	55✔
303	return callback(taxids);	55✔
304	});
305	});
306	}
307
308	function getIsMultiorganism(taxidInit, ideo) {
309	return (	55✔
310	('organism' in ideo.config && ideo.config.organism instanceof Array) \|\|	161!
311	(taxidInit && ideo.config.taxid instanceof Array)
312	);
313	}
314
315	/**
316	* Configure Ideogram taxids when 'organism' is not in ideo.config
317	*/
318	function getTaxidsForOrganismsNotInConfig(taxidInit, callback, ideo) {
319	var taxids;
320
321	if (ideo.config.multiorganism) {	×
322	if (taxidInit) {	×
323	taxids = ideo.config.taxid;	×
324	}
325	} else {
326	if (taxidInit) {	×
327	taxids = [ideo.config.taxid];	×
328	}
329	ideo.config.taxids = taxids;	×
330	}
331	callback(taxids);	×
332	}
333
334	/**
335	* Returns an array of taxids for the current ideogram
336	* Also sets configuration parameters related to taxid(s), whether ideogram is
337	* multiorganism, and adjusts chromosomes parameters as needed
338	**/
339	function getTaxids(callback) {
340	var taxidInit,
341	ideo = this;	55✔
342
343	taxidInit = 'taxid' in ideo.config;	55✔
344
345	ideo.config.multiorganism = getIsMultiorganism(taxidInit, ideo);	55✔
346
347	if (ideo.config.multiorganism) ideo.coordinateSystem = 'bp';	55✔
348
349	if ('organism' in ideo.config) {	55!
350	getTaxidsForOrganismsInConfig(callback, ideo);	55✔
351	} else {
352	getTaxidsForOrganismsNotInConfig(taxidInit, callback, ideo);	×
353	}
354	}
355
356	export {
357	getTaxids, getOrganismFromEutils
358	};

eweitz / ideogram / 1470

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous