9a07c3666042ac29c987da153183e3bab512e38e
[jalview.git] / src / jalview / datamodel / xdb / embl / EmblEntry.java
1 /*
2  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
3  * Copyright (C) $$Year-Rel$$ The Jalview Authors
4  * 
5  * This file is part of Jalview.
6  * 
7  * Jalview is free software: you can redistribute it and/or
8  * modify it under the terms of the GNU General Public License 
9  * as published by the Free Software Foundation, either version 3
10  * of the License, or (at your option) any later version.
11  *  
12  * Jalview is distributed in the hope that it will be useful, but 
13  * WITHOUT ANY WARRANTY; without even the implied warranty 
14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
15  * PURPOSE.  See the GNU General Public License for more details.
16  * 
17  * You should have received a copy of the GNU General Public License
18  * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
19  * The Jalview Authors are detailed in the 'AUTHORS' file.
20  */
21 package jalview.datamodel.xdb.embl;
22
23 import jalview.analysis.SequenceIdMatcher;
24 import jalview.bin.Cache;
25 import jalview.datamodel.DBRefEntry;
26 import jalview.datamodel.DBRefSource;
27 import jalview.datamodel.FeatureProperties;
28 import jalview.datamodel.Mapping;
29 import jalview.datamodel.Sequence;
30 import jalview.datamodel.SequenceFeature;
31 import jalview.datamodel.SequenceI;
32 import jalview.util.DBRefUtils;
33 import jalview.util.DnaUtils;
34 import jalview.util.MapList;
35 import jalview.util.MappingUtils;
36 import jalview.util.StringUtils;
37
38 import java.text.ParseException;
39 import java.util.Arrays;
40 import java.util.Hashtable;
41 import java.util.List;
42 import java.util.Map;
43 import java.util.Map.Entry;
44 import java.util.Vector;
45 import java.util.regex.Pattern;
46
47 /**
48  * Data model for one entry returned from an EMBL query, as marshalled by a
49  * Castor binding file
50  * 
51  * For example:
52  * http://www.ebi.ac.uk/Tools/dbfetch/dbfetch?db=ena_sequence&id=J03321
53  * &format=emblxml
54  * 
55  * @see embl_mapping.xml
56  */
57 public class EmblEntry
58 {
59   private static final Pattern SPACE_PATTERN = Pattern.compile(" ");
60
61   String accession;
62
63   String entryVersion;
64
65   String sequenceVersion;
66
67   String dataClass;
68
69   String moleculeType;
70
71   String topology;
72
73   String sequenceLength;
74
75   String taxonomicDivision;
76
77   String description;
78
79   String firstPublicDate;
80
81   String firstPublicRelease;
82
83   String lastUpdatedDate;
84
85   String lastUpdatedRelease;
86
87   Vector<String> keywords;
88
89   Vector<DBRefEntry> dbRefs;
90
91   Vector<EmblFeature> features;
92
93   EmblSequence sequence;
94
95   /**
96    * @return the accession
97    */
98   public String getAccession()
99   {
100     return accession;
101   }
102
103   /**
104    * @param accession
105    *          the accession to set
106    */
107   public void setAccession(String accession)
108   {
109     this.accession = accession;
110   }
111
112   /**
113    * @return the dbRefs
114    */
115   public Vector<DBRefEntry> getDbRefs()
116   {
117     return dbRefs;
118   }
119
120   /**
121    * @param dbRefs
122    *          the dbRefs to set
123    */
124   public void setDbRefs(Vector<DBRefEntry> dbRefs)
125   {
126     this.dbRefs = dbRefs;
127   }
128
129   /**
130    * @return the features
131    */
132   public Vector<EmblFeature> getFeatures()
133   {
134     return features;
135   }
136
137   /**
138    * @param features
139    *          the features to set
140    */
141   public void setFeatures(Vector<EmblFeature> features)
142   {
143     this.features = features;
144   }
145
146   /**
147    * @return the keywords
148    */
149   public Vector<String> getKeywords()
150   {
151     return keywords;
152   }
153
154   /**
155    * @param keywords
156    *          the keywords to set
157    */
158   public void setKeywords(Vector<String> keywords)
159   {
160     this.keywords = keywords;
161   }
162
163   /**
164    * @return the sequence
165    */
166   public EmblSequence getSequence()
167   {
168     return sequence;
169   }
170
171   /**
172    * @param sequence
173    *          the sequence to set
174    */
175   public void setSequence(EmblSequence sequence)
176   {
177     this.sequence = sequence;
178   }
179
180   /**
181    * Recover annotated sequences from EMBL file
182    * 
183    * @param sourceDb
184    * @param peptides
185    *          a list of protein products found so far (to add to)
186    * @return dna dataset sequence with DBRefs and features
187    */
188   public SequenceI getSequence(String sourceDb, List<SequenceI> peptides)
189   {
190     SequenceI dna = new Sequence(sourceDb + "|" + accession,
191             sequence.getSequence());
192     dna.setDescription(description);
193     DBRefEntry retrievedref = new DBRefEntry(sourceDb,
194             getSequenceVersion(), accession);
195     dna.addDBRef(retrievedref);
196     // add map to indicate the sequence is a valid coordinate frame for the
197     // dbref
198     retrievedref.setMap(new Mapping(null, new int[] { 1, dna.getLength() },
199             new int[] { 1, dna.getLength() }, 1, 1));
200     // TODO: transform EMBL Database refs to canonical form
201     if (dbRefs != null)
202     {
203       for (DBRefEntry dbref : dbRefs)
204       {
205         dna.addDBRef(dbref);
206       }
207     }
208
209     try
210     {
211       for (EmblFeature feature : features)
212       {
213         if (feature.dbRefs != null)
214         {
215           for (DBRefEntry dbref : feature.dbRefs)
216           {
217             dna.addDBRef(dbref);
218           }
219         }
220         if (FeatureProperties.isCodingFeature(sourceDb, feature.getName()))
221         {
222           parseCodingFeature(feature, sourceDb, dna, peptides);
223         }
224       }
225     } catch (Exception e)
226     {
227       System.err.println("EMBL Record Features parsing error!");
228       System.err
229               .println("Please report the following to help@jalview.org :");
230       System.err.println("EMBL Record " + accession);
231       System.err.println("Resulted in exception: " + e.getMessage());
232       e.printStackTrace(System.err);
233     }
234
235     return dna;
236   }
237
238   /**
239    * Extracts coding region and product from a CDS feature and properly decorate
240    * it with annotations.
241    * 
242    * @param feature
243    *          coding feature
244    * @param sourceDb
245    *          source database for the EMBLXML
246    * @param dna
247    *          parent dna sequence for this record
248    * @param peptides
249    *          list of protein product sequences for Embl entry
250    */
251   void parseCodingFeature(EmblFeature feature, String sourceDb,
252           SequenceI dna, List<SequenceI> peptides)
253   {
254     boolean isEmblCdna = sourceDb.equals(DBRefSource.EMBLCDS);
255
256     int[] exon = getCdsRanges(feature);
257
258     String prseq = null;
259     String prname = "";
260     String prid = null;
261     Map<String, String> vals = new Hashtable<String, String>();
262     SequenceIdMatcher matcher = new SequenceIdMatcher(peptides);
263
264     /*
265      * codon_start 1/2/3 in EMBL corresponds to phase 0/1/2 in CDS
266      * (phase is required for CDS features in GFF3 format)
267      */
268     int codonStart = 1;
269
270     /*
271      * parse qualifiers, saving protein translation, protein id,
272      * codon start position, product (name), and 'other values'
273      */
274     if (feature.getQualifiers() != null)
275     {
276       for (Qualifier q : feature.getQualifiers())
277       {
278         String qname = q.getName();
279         if (qname.equals("translation"))
280         {
281           // remove all spaces (precompiled String.replaceAll(" ", ""))
282           prseq = SPACE_PATTERN.matcher(q.getValues()[0]).replaceAll("");
283         }
284         else if (qname.equals("protein_id"))
285         {
286           prid = q.getValues()[0];
287         }
288         else if (qname.equals("codon_start"))
289         {
290           try
291           {
292             codonStart = Integer.parseInt(q.getValues()[0]);
293           } catch (NumberFormatException e)
294           {
295             System.err.println("Invalid codon_start in XML for "
296                     + accession + ": " + e.getMessage());
297           }
298         }
299         else if (qname.equals("product"))
300         {
301           // sometimes name is returned e.g. for V00488
302           prname = q.getValues()[0];
303         }
304         else
305         {
306           // throw anything else into the additional properties hash
307           String[] qvals = q.getValues();
308           if (qvals != null)
309           {
310             String commaSeparated = StringUtils.arrayToSeparatorList(qvals,
311                     ",");
312             vals.put(qname, commaSeparated);
313           }
314         }
315       }
316     }
317
318     DBRefEntry protEMBLCDS = null;
319     exon = MappingUtils.removeStartPositions(codonStart - 1, exon);
320     boolean noProteinDbref = true;
321
322     SequenceI product = null;
323     Mapping map = null;
324     if (prseq != null && prname != null && prid != null)
325     {
326       /*
327        * look for product in peptides list, if not found, add it
328        */
329       product = matcher.findIdMatch(prid);
330       if (product == null)
331       {
332         product = new Sequence(prid, prseq, 1, prseq.length());
333         product.setDescription(((prname.length() == 0) ? "Protein Product from "
334                 + sourceDb
335                 : prname));
336         peptides.add(product);
337         matcher.add(product);
338       }
339
340       // we have everything - create the mapping and perhaps the protein
341       // sequence
342       if (exon == null || exon.length == 0)
343       {
344         System.err
345                 .println("Implementation Notice: EMBLCDS records not properly supported yet - Making up the CDNA region of this sequence... may be incorrect ("
346                         + sourceDb + ":" + getAccession() + ")");
347         if (prseq.length() * 3 == (1 - codonStart + dna.getSequence().length))
348         {
349           System.err
350                   .println("Not allowing for additional stop codon at end of cDNA fragment... !");
351           // this might occur for CDS sequences where no features are
352           // marked.
353           exon = new int[] { dna.getStart() + (codonStart - 1),
354               dna.getEnd() };
355           map = new Mapping(product, exon, new int[] { 1, prseq.length() },
356                   3, 1);
357         }
358         if ((prseq.length() + 1) * 3 == (1 - codonStart + dna.getSequence().length))
359         {
360           System.err
361                   .println("Allowing for additional stop codon at end of cDNA fragment... will probably cause an error in VAMSAs!");
362           exon = new int[] { dna.getStart() + (codonStart - 1),
363               dna.getEnd() - 3 };
364           map = new Mapping(product, exon, new int[] { 1, prseq.length() },
365                   3, 1);
366         }
367       }
368       else
369       {
370         // Trim the exon mapping if necessary - the given product may only be a
371         // fragment of a larger protein. (EMBL:AY043181 is an example)
372
373         if (isEmblCdna)
374         {
375           // TODO: Add a DbRef back to the parent EMBL sequence with the exon
376           // map
377           // if given a dataset reference, search dataset for parent EMBL
378           // sequence if it exists and set its map
379           // make a new feature annotating the coding contig
380         }
381         else
382         {
383           // final product length truncation check
384           // TODO should from range include stop codon even if not in protein
385           // in order to include stop codon in CDS sequence (as done for
386           // Ensembl)?
387           int[] cdsRanges = adjustForProteinLength(prseq.length(), exon);
388           map = new Mapping(product, cdsRanges, new int[] { 1,
389               prseq.length() }, 3, 1);
390           // reconstruct the EMBLCDS entry
391           // TODO: this is only necessary when there codon annotation is
392           // complete (I think JBPNote)
393           DBRefEntry pcdnaref = new DBRefEntry();
394           pcdnaref.setAccessionId(prid);
395           pcdnaref.setSource(DBRefSource.EMBLCDS);
396           pcdnaref.setVersion(getSequenceVersion()); // same as parent EMBL
397                                                      // version.
398           MapList mp = new MapList(new int[] { 1, prseq.length() },
399                   new int[] { 1 + (codonStart - 1),
400                       (codonStart - 1) + 3 * prseq.length() }, 1, 3);
401           pcdnaref.setMap(new Mapping(mp));
402           if (product != null)
403           {
404             product.addDBRef(pcdnaref);
405             protEMBLCDS = new DBRefEntry(pcdnaref);
406             protEMBLCDS.setSource(DBRefSource.EMBLCDSProduct);
407             product.addDBRef(protEMBLCDS);
408           }
409         }
410       }
411       // add cds feature to dna seq - this may include the stop codon
412       for (int xint = 0; exon != null && xint < exon.length; xint += 2)
413       {
414         SequenceFeature sf = makeCdsFeature(exon, xint, prname, prid, vals,
415                 codonStart);
416         sf.setType(feature.getName()); // "CDS"
417         sf.setEnaLocation(feature.getLocation());
418         sf.setFeatureGroup(sourceDb);
419         dna.addSequenceFeature(sf);
420       }
421     }
422
423     /*
424      * add dbRefs to sequence, and mappings for Uniprot xrefs
425      */
426     if (feature.dbRefs != null)
427     {
428       boolean mappingUsed = false;
429       for (DBRefEntry ref : feature.dbRefs)
430       {
431         ref.setSource(DBRefUtils.getCanonicalName(ref.getSource()));
432         if (ref.getSource().equals(DBRefSource.UNIPROT))
433         {
434           String proteinSeqName = DBRefSource.UNIPROT + "|"
435                   + ref.getAccessionId();
436           if (map != null && map.getTo() != null)
437           {
438             if (mappingUsed)
439             {
440               /*
441                * two or more Uniprot xrefs for the same CDS - 
442                * each needs a distinct Mapping (as to a different sequence)
443                */
444               map = new Mapping(map);
445             }
446             mappingUsed = true;
447
448             /*
449              * try to locate the protein mapped to (possibly by a 
450              * previous CDS feature)
451              */
452             SequenceI proteinSeq = matcher.findIdMatch(proteinSeqName);
453             if (proteinSeq == null)
454             {
455               proteinSeq = new Sequence(proteinSeqName,
456                       product.getSequenceAsString());
457               matcher.add(proteinSeq);
458               peptides.add(proteinSeq);
459             }
460             map.setTo(proteinSeq);
461             map.getTo().addDBRef(
462                     new DBRefEntry(ref.getSource(), ref.getVersion(), ref
463                             .getAccessionId()));
464             ref.setMap(map);
465           }
466           noProteinDbref = false;
467         }
468         if (product != null)
469         {
470           DBRefEntry pref = new DBRefEntry(ref.getSource(),
471                   ref.getVersion(), ref.getAccessionId());
472           pref.setMap(null); // reference is direct
473           product.addDBRef(pref);
474           // Add converse mapping reference
475           if (map != null)
476           {
477             Mapping pmap = new Mapping(dna, map.getMap().getInverse());
478             pref = new DBRefEntry(sourceDb, getSequenceVersion(),
479                     this.getAccession());
480             pref.setMap(pmap);
481             if (map.getTo() != null)
482             {
483               map.getTo().addDBRef(pref);
484             }
485           }
486         }
487         dna.addDBRef(ref);
488       }
489       if (noProteinDbref && product != null)
490       {
491         // add protein coding reference to dna sequence so xref matches
492         if (protEMBLCDS == null)
493         {
494           protEMBLCDS = new DBRefEntry();
495           protEMBLCDS.setAccessionId(prid);
496           protEMBLCDS.setSource(DBRefSource.EMBLCDSProduct);
497           protEMBLCDS.setVersion(getSequenceVersion());
498           protEMBLCDS
499                   .setMap(new Mapping(product, map.getMap().getInverse()));
500         }
501         product.addDBRef(protEMBLCDS);
502
503         // Add converse mapping reference
504         if (map != null)
505         {
506           Mapping pmap = new Mapping(product, protEMBLCDS.getMap().getMap()
507                   .getInverse());
508           DBRefEntry ncMap = new DBRefEntry(protEMBLCDS);
509           ncMap.setMap(pmap);
510           if (map.getTo() != null)
511           {
512             dna.addDBRef(ncMap);
513           }
514         }
515       }
516     }
517   }
518
519   /**
520    * Helper method to construct a SequenceFeature for one cds range
521    * 
522    * @param exons
523    *          array of cds [start, end, ...] positions
524    * @param exonStartIndex
525    *          offset into the exons array
526    * @param proteinName
527    * @param proteinAccessionId
528    * @param vals
529    *          map of 'miscellaneous values' for feature
530    * @param codonStart
531    *          codon start position for CDS (1/2/3, normally 1)
532    * @return
533    */
534   protected SequenceFeature makeCdsFeature(int[] exons, int exonStartIndex,
535           String proteinName, String proteinAccessionId,
536           Map<String, String> vals, int codonStart)
537   {
538     int exonNumber = exonStartIndex / 2 + 1;
539     SequenceFeature sf = new SequenceFeature();
540     sf.setBegin(Math.min(exons[exonStartIndex], exons[exonStartIndex + 1]));
541     sf.setEnd(Math.max(exons[exonStartIndex], exons[exonStartIndex + 1]));
542     sf.setDescription(String.format("Exon %d for protein '%s' EMBLCDS:%s",
543             exonNumber, proteinName, proteinAccessionId));
544     sf.setPhase(String.valueOf(codonStart - 1));
545     sf.setStrand(exons[exonStartIndex] <= exons[exonStartIndex + 1] ? "+"
546             : "-");
547     sf.setValue(FeatureProperties.EXONPOS, exonNumber);
548     sf.setValue(FeatureProperties.EXONPRODUCT, proteinName);
549     if (!vals.isEmpty())
550     {
551       StringBuilder sb = new StringBuilder();
552       boolean first = true;
553       for (Entry<String, String> val : vals.entrySet())
554       {
555         if (!first)
556         {
557           sb.append(";");
558         }
559         sb.append(val.getKey()).append("=").append(val.getValue());
560         first = false;
561         sf.setValue(val.getKey(), val.getValue());
562       }
563       sf.setAttributes(sb.toString());
564     }
565     return sf;
566   }
567
568   /**
569    * Returns the CDS positions as a single array of [start, end, start, end...]
570    * positions. If on the reverse strand, these will be in descending order.
571    * 
572    * @param feature
573    * @return
574    */
575   protected int[] getCdsRanges(EmblFeature feature)
576   {
577     if (feature.location == null)
578     {
579       return new int[] {};
580     }
581
582     try
583     {
584       List<int[]> ranges = DnaUtils.parseLocation(feature.location);
585       return listToArray(ranges);
586     } catch (ParseException e)
587     {
588       Cache.log.warn(String.format(
589               "Not parsing inexact CDS location %s in ENA %s",
590               feature.location, this.accession));
591       return new int[] {};
592     }
593   }
594
595   /**
596    * Converts a list of [start, end] ranges to a single array of [start, end,
597    * start, end ...]
598    * 
599    * @param ranges
600    * @return
601    */
602   int[] listToArray(List<int[]> ranges)
603   {
604     int[] result = new int[ranges.size() * 2];
605     int i = 0;
606     for (int[] range : ranges)
607     {
608       result[i++] = range[0];
609       result[i++] = range[1];
610     }
611     return result;
612   }
613
614   /**
615    * truncate the last exon interval to the prlength'th codon
616    * 
617    * @param prlength
618    * @param exon
619    * @return new exon
620    */
621   static int[] adjustForProteinLength(int prlength, int[] exon)
622   {
623     if (prlength <= 0 || exon == null)
624     {
625       return exon;
626     }
627     int desiredCdsLength = prlength * 3;
628     int exonLength = MappingUtils.getLength(Arrays.asList(exon));
629
630     /*
631      * assuming here exon might include stop codon in addition to protein codons
632      */
633     if (desiredCdsLength == exonLength
634             || desiredCdsLength == exonLength - 3)
635     {
636       return exon;
637     }
638
639     int origxon[];
640     int sxpos = -1;
641     int endxon = 0;
642     origxon = new int[exon.length];
643     System.arraycopy(exon, 0, origxon, 0, exon.length);
644     int cdspos = 0;
645     for (int x = 0; x < exon.length; x += 2)
646     {
647       cdspos += Math.abs(exon[x + 1] - exon[x]) + 1;
648       if (desiredCdsLength <= cdspos)
649       {
650         // advanced beyond last codon.
651         sxpos = x;
652         if (desiredCdsLength != cdspos)
653         {
654           // System.err
655           // .println("Truncating final exon interval on region by "
656           // + (cdspos - cdslength));
657         }
658
659         /*
660          * shrink the final exon - reduce end position if forward
661          * strand, increase it if reverse
662          */
663         if (exon[x + 1] >= exon[x])
664         {
665           endxon = exon[x + 1] - cdspos + desiredCdsLength;
666         }
667         else
668         {
669           endxon = exon[x + 1] + cdspos - desiredCdsLength;
670         }
671         break;
672       }
673     }
674
675     if (sxpos != -1)
676     {
677       // and trim the exon interval set if necessary
678       int[] nxon = new int[sxpos + 2];
679       System.arraycopy(exon, 0, nxon, 0, sxpos + 2);
680       nxon[sxpos + 1] = endxon; // update the end boundary for the new exon
681                                 // set
682       exon = nxon;
683     }
684     return exon;
685   }
686
687   public String getSequenceVersion()
688   {
689     return sequenceVersion;
690   }
691
692   public void setSequenceVersion(String sequenceVersion)
693   {
694     this.sequenceVersion = sequenceVersion;
695   }
696
697   public String getSequenceLength()
698   {
699     return sequenceLength;
700   }
701
702   public void setSequenceLength(String sequenceLength)
703   {
704     this.sequenceLength = sequenceLength;
705   }
706
707   public String getEntryVersion()
708   {
709     return entryVersion;
710   }
711
712   public void setEntryVersion(String entryVersion)
713   {
714     this.entryVersion = entryVersion;
715   }
716
717   public String getMoleculeType()
718   {
719     return moleculeType;
720   }
721
722   public void setMoleculeType(String moleculeType)
723   {
724     this.moleculeType = moleculeType;
725   }
726
727   public String getTopology()
728   {
729     return topology;
730   }
731
732   public void setTopology(String topology)
733   {
734     this.topology = topology;
735   }
736
737   public String getTaxonomicDivision()
738   {
739     return taxonomicDivision;
740   }
741
742   public void setTaxonomicDivision(String taxonomicDivision)
743   {
744     this.taxonomicDivision = taxonomicDivision;
745   }
746
747   public String getDescription()
748   {
749     return description;
750   }
751
752   public void setDescription(String description)
753   {
754     this.description = description;
755   }
756
757   public String getFirstPublicDate()
758   {
759     return firstPublicDate;
760   }
761
762   public void setFirstPublicDate(String firstPublicDate)
763   {
764     this.firstPublicDate = firstPublicDate;
765   }
766
767   public String getFirstPublicRelease()
768   {
769     return firstPublicRelease;
770   }
771
772   public void setFirstPublicRelease(String firstPublicRelease)
773   {
774     this.firstPublicRelease = firstPublicRelease;
775   }
776
777   public String getLastUpdatedDate()
778   {
779     return lastUpdatedDate;
780   }
781
782   public void setLastUpdatedDate(String lastUpdatedDate)
783   {
784     this.lastUpdatedDate = lastUpdatedDate;
785   }
786
787   public String getLastUpdatedRelease()
788   {
789     return lastUpdatedRelease;
790   }
791
792   public void setLastUpdatedRelease(String lastUpdatedRelease)
793   {
794     this.lastUpdatedRelease = lastUpdatedRelease;
795   }
796
797   public String getDataClass()
798   {
799     return dataClass;
800   }
801
802   public void setDataClass(String dataClass)
803   {
804     this.dataClass = dataClass;
805   }
806 }