--- /dev/null
+/*
+ * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
+ * Copyright (C) $$Year-Rel$$ The Jalview Authors
+ *
+ * This file is part of Jalview.
+ *
+ * Jalview is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, either version 3
+ * of the License, or (at your option) any later version.
+ *
+ * Jalview is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ * PURPOSE. See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Jalview. If not, see <http://www.gnu.org/licenses/>.
+ * The Jalview Authors are detailed in the 'AUTHORS' file.
+ */
+package jalview.io;
+
+import jalview.analysis.AlignSeq;
+import jalview.api.DBRefEntryI;
+import jalview.api.SiftsClientI;
+import jalview.datamodel.DBRefEntry;
+import jalview.datamodel.SequenceI;
+import jalview.schemes.ResidueProperties;
+import jalview.structure.StructureMapping;
+import jalview.util.Format;
+import jalview.xml.binding.sifts.Entry;
+import jalview.xml.binding.sifts.Entry.Entity;
+import jalview.xml.binding.sifts.Entry.Entity.Segment;
+import jalview.xml.binding.sifts.Entry.Entity.Segment.ListMapRegion.MapRegion;
+import jalview.xml.binding.sifts.Entry.Entity.Segment.ListResidue.Residue;
+import jalview.xml.binding.sifts.Entry.Entity.Segment.ListResidue.Residue.CrossRefDb;
+import jalview.xml.binding.sifts.Entry.EntryDetail;
+import jalview.xml.binding.sifts.Entry.ListDB.Db;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PrintStream;
+import java.net.URL;
+import java.net.URLConnection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.zip.GZIPInputStream;
+
+import javax.xml.bind.JAXBContext;
+import javax.xml.bind.JAXBException;
+import javax.xml.bind.Unmarshaller;
+import javax.xml.stream.FactoryConfigurationError;
+import javax.xml.stream.XMLInputFactory;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+
+public class SiftsClient implements SiftsClientI
+{
+ private Entry siftsEntry;
+
+ private String pdbId;
+
+ private static final int BUFFER_SIZE = 4096;
+
+ private static final String SIFTS_FTP_BASE_URL = "ftp://ftp.ebi.ac.uk/pub/databases/msd/sifts/xml/";
+
+ public static final String DEFAULT_SIFTS_DOWNLOAD_DIR = System
+ .getProperty("user.home")
+ + File.separatorChar
+ + ".sifts_downloads" + File.separatorChar;
+
+ public static final String SIFTS_DOWNLOAD_DIR = jalview.bin.Cache
+ .getDefault("sifts_download_dir", DEFAULT_SIFTS_DOWNLOAD_DIR);
+
+ private final static String NEWLINE = System.lineSeparator();
+
+ /**
+ * Fetch SIFTs file for the given PDB Id and construct an instance of
+ * SiftsClient
+ *
+ * @param pdbId
+ */
+ public SiftsClient(String pdbId)
+ {
+ this.pdbId = pdbId;
+ try
+ {
+ File siftsFile = getSiftsFile(pdbId);
+ siftsEntry = parseSIFTs(siftsFile);
+ } catch (Exception e)
+ {
+ e.printStackTrace();
+ }
+ }
+
+ /**
+ * Construct an instance of SiftsClient using the supplied SIFTs file -
+ * the SIFTs file should correspond to the given PDB Id
+ *
+ * @param pdbId
+ * @param siftsFile
+ */
+ public SiftsClient(String pdbId, File siftsFile)
+ {
+ this.pdbId = pdbId;
+ try
+ {
+ siftsEntry = parseSIFTs(siftsFile);
+ } catch (Exception e)
+ {
+ e.printStackTrace();
+ }
+
+ }
+
+ /**
+ * Parse the given SIFTs File and return a JAXB POJO of parsed data
+ *
+ * @param siftFile
+ * - the GZipped SIFTs XML file to parse
+ * @return
+ * @throws Exception
+ * if a problem occurs while parsing the SIFTs XML
+ */
+ private Entry parseSIFTs(File siftFile) throws Exception
+ {
+ try
+ {
+ System.out.println("File : " + siftFile.getAbsolutePath());
+ JAXBContext jc = JAXBContext.newInstance("jalview.xml.binding.sifts");
+ InputStream in = new FileInputStream(siftFile);
+ GZIPInputStream gzis = new GZIPInputStream(in);
+ XMLStreamReader streamReader = XMLInputFactory.newInstance()
+ .createXMLStreamReader(gzis);
+ Unmarshaller um = jc.createUnmarshaller();
+ return (Entry) um.unmarshal(streamReader);
+ } catch (JAXBException e)
+ {
+ e.printStackTrace();
+ } catch (FileNotFoundException e)
+ {
+ e.printStackTrace();
+ } catch (XMLStreamException e)
+ {
+ e.printStackTrace();
+ } catch (FactoryConfigurationError e)
+ {
+ e.printStackTrace();
+ } catch (IOException e)
+ {
+ e.printStackTrace();
+ }
+ throw new Exception("Error parsing siftFile");
+ }
+
+ /**
+ * Get a SIFTs XML file for a given PDB Id
+ *
+ * @param pdbId
+ * @return SIFTs XML file
+ */
+ public static File getSiftsFile(String pdbId)
+ {
+ File siftsFile = new File(SIFTS_DOWNLOAD_DIR + pdbId.toLowerCase()
+ + ".xml.gz");
+ if (siftsFile.exists())
+ {
+ // TODO it may be worth performing a timestamp age check to determine if a
+ // new SIFTs file should be re-downloaded as SIFTs entries are usually
+ // updated weekly
+ System.out.println(">>> SIFTS File already downloaded for " + pdbId);
+ return siftsFile;
+ }
+ siftsFile = downloadSiftsFile(pdbId.toLowerCase());
+ return siftsFile;
+ }
+
+ /**
+ * Download a SIFTs XML file for a given PDB Id
+ *
+ * @param pdbId
+ * @return downloaded SIFTs XML file
+ */
+ public static File downloadSiftsFile(String pdbId)
+ {
+ String siftFile = pdbId + ".xml.gz";
+ String siftsFileFTPURL = SIFTS_FTP_BASE_URL + siftFile;
+ String downloadedSiftsFile = SIFTS_DOWNLOAD_DIR + siftFile;
+ File siftsDownloadDir = new File(SIFTS_DOWNLOAD_DIR);
+ if (!siftsDownloadDir.exists())
+ {
+ siftsDownloadDir.mkdirs();
+ }
+ try
+ {
+ System.out.println(">> Download ftp url : " + siftsFileFTPURL);
+ URL url = new URL(siftsFileFTPURL);
+ URLConnection conn = url.openConnection();
+ InputStream inputStream = conn.getInputStream();
+ FileOutputStream outputStream = new FileOutputStream(
+ downloadedSiftsFile);
+ byte[] buffer = new byte[BUFFER_SIZE];
+ int bytesRead = -1;
+ while ((bytesRead = inputStream.read(buffer)) != -1)
+ {
+ outputStream.write(buffer, 0, bytesRead);
+ }
+ outputStream.close();
+ inputStream.close();
+ System.out.println(">>> File downloaded : " + downloadedSiftsFile);
+ } catch (IOException ex)
+ {
+ ex.printStackTrace();
+ }
+ return new File(downloadedSiftsFile);
+ }
+
+ /**
+ * Delete the SIFTs file for the given PDB Id in the local SIFTs download
+ * directory
+ *
+ * @param pdbId
+ * @return true if the file was deleted or doesn't exist
+ */
+ public static boolean deleteSiftsFileByPDBId(String pdbId)
+ {
+ File siftsFile = new File(SIFTS_DOWNLOAD_DIR + pdbId.toLowerCase()
+ + ".xml.gz");
+ if (siftsFile.exists())
+ {
+ return siftsFile.delete();
+ }
+ return true;
+ }
+
+
+ /**
+ * Get a valid SIFTs DBRef for the given sequence current SIFTs entry
+ *
+ * @param seq
+ * - the target sequence for the operation
+ * @return a valid DBRefEntry that is SIFTs compatible
+ * @throws Exception
+ * if no valid source DBRefEntry was found for the given sequences
+ */
+ public DBRefEntryI getValidSourceDBRef(SequenceI seq) throws Exception
+ {
+ DBRefEntryI sourceDBRef = null;
+ sourceDBRef = seq.getSourceDBRef();
+ if (sourceDBRef != null && isValidDBRefEntry(sourceDBRef))
+ {
+ return sourceDBRef;
+ }
+ else
+ {
+ DBRefEntry[] dbRefs = seq.getDBRefs();
+ if (dbRefs == null || dbRefs.length < 1)
+ {
+ final SequenceI[] seqs = new SequenceI[] { seq };
+ new jalview.ws.DBRefFetcher(seqs, null, null, null, false)
+ .fetchDBRefs(true);
+ dbRefs = seq.getDBRefs();
+ }
+
+ if (dbRefs == null || dbRefs.length < 1)
+ {
+ throw new Exception("Could not get source DB Ref");
+ }
+
+ for (DBRefEntryI dbRef : dbRefs)
+ {
+ if (dbRef == null || dbRef.getAccessionId() == null
+ || dbRef.getSource() == null)
+ {
+ continue;
+ }
+ if (isFoundInSiftsEntry(dbRef.getAccessionId())
+ && (dbRef.getSource().equalsIgnoreCase("uniprot") || dbRef
+ .getSource().equalsIgnoreCase("pdb")))
+ {
+ return dbRef;
+ }
+ }
+ }
+ if (sourceDBRef != null && isValidDBRefEntry(sourceDBRef))
+ {
+ return sourceDBRef;
+ }
+ throw new Exception("Could not get source DB Ref");
+ }
+
+
+ /**
+ * Check that the DBRef Entry is properly populated and is available in the
+ * instantiated SIFTs Entry
+ *
+ * @param entry
+ * - DBRefEntry to validate
+ * @return true validation is successful otherwise false is returned.
+ */
+ private boolean isValidDBRefEntry(DBRefEntryI entry)
+ {
+ return entry != null && entry.getAccessionId() != null
+ && isFoundInSiftsEntry(entry.getAccessionId());
+ // & entry.getStartRes() > 0;
+ }
+
+ @Override
+ public HashSet<String> getAllMappingAccession()
+ {
+ HashSet<String> accessions = new HashSet<String>();
+ List<Entity> entities = siftsEntry.getEntity();
+ for (Entity entity : entities)
+ {
+ List<Segment> segments = entity.getSegment();
+ for (Segment segment : segments)
+ {
+ List<MapRegion> mapRegions = segment.getListMapRegion()
+ .getMapRegion();
+ for (MapRegion mapRegion : mapRegions)
+ {
+ accessions.add(mapRegion.getDb().getDbAccessionId());
+ }
+ }
+ }
+ return accessions;
+ }
+
+
+ @Override
+ public int[][] getGreedyMapping(String entityId, SequenceI seq,
+ java.io.PrintStream os)
+ throws Exception
+ {
+ System.out.println("Generating mappings for : " + entityId);
+ Entity entity = null;
+ entity = getEntityById(entityId);
+ String seqStr = AlignSeq.extractGaps(jalview.util.Comparison.GapChars,
+ seq.getSequenceAsString());
+ // StringBuilder mappedStrucSeq = new StringBuilder(seqStr.length());
+ String[] mappedStrucSeq = new String[seqStr.length()];
+ int mapping[][] = new int[seqStr.length()][2];
+ DBRefEntryI sourceDBRef = seq.getSourceDBRef();
+ if (sourceDBRef == null)
+ {
+ sourceDBRef = getValidSourceDBRef(seq);
+ // TODO if sourceDBRef is null at this point then throw an Exception
+
+ // TODO update sequence start/end with sourceDBRef start/end
+ // seq.setStart(sourceDBRef.getStartRes());
+ // seq.setEnd(sourceDBRef.getEndRes());
+ }
+
+ String crossRefAccessionId = sourceDBRef.getAccessionId();
+ int start = seq.getStart() - 1;
+ for (int residue[] : mapping)
+ {
+ residue[1] = start++;
+ }
+
+ HashMap<Integer, String> resNumMap = new HashMap<Integer, String>();
+ List<Segment> segments = entity.getSegment();
+ for (Segment segment : segments)
+ {
+ System.out.println("Mappging segments : " + segment.getSegId() + "\\"
+ + segment.getStart() + "-" + segment.getEnd());
+ List<Residue> residues = segment.getListResidue().getResidue();
+ for (Residue residue : residues)
+ {
+ int refDbResNum = -1;
+ List<CrossRefDb> cRefDbs = residue.getCrossRefDb();
+ for (CrossRefDb cRefDb : cRefDbs)
+ {
+ if (cRefDb.getDbAccessionId().equalsIgnoreCase(
+ crossRefAccessionId))
+ {
+ refDbResNum = Integer.valueOf(cRefDb.getDbResNum());
+ }
+ }
+ if (refDbResNum == -1)
+ {
+ continue;
+ }
+ for (int[] x : mapping)
+ {
+ if (x[1] == refDbResNum)
+ {
+ int resNum = Integer.valueOf(residue.getDbResNum());
+ x[0] = resNum;
+ String value = "x";
+ resNumMap.put(resNum, value);
+ }
+ }
+ }
+ }
+
+ //Generate visual mapping output
+ // StringBuilder strucSeq = new StringBuilder();
+ // for(int[] x : mapping){
+ // if(mapping[0] == 0){
+ // strucSeq.append(b)
+ // }
+ // }
+ mappedStrucSeq[1] = "x";
+ try
+ {
+ System.out.println(">>>> seq: " + seqStr + "\nlength "
+ + seqStr.length());
+ System.out.println(">>>> pdb: " + mappedStrucSeq.toString()
+ + "\nlength " + mappedStrucSeq.toString().length());
+
+ String printedMapping = getMappingOutput(mappedStrucSeq.toString(),
+ seqStr, "seqAccession", "strucAccession", "pep", 3)
+ .toString();
+ if (os != null)
+ {
+ os.print(printedMapping);
+ }
+ System.out.println();
+ } catch (Exception ex)
+ {
+ ex.printStackTrace();
+ }
+ return mapping;
+ }
+
+ @Override
+ public boolean isFoundInSiftsEntry(String accessionId)
+ {
+ return accessionId != null
+ && getAllMappingAccession().contains(accessionId);
+ }
+
+ @Override
+ public StructureMapping getSiftsStructureMapping(SequenceI seq,
+ String pdbFile, String chain)
+ {
+ System.out.println("Getting mapping for: " + pdbId + "|" + chain
+ + " : seq- " + seq.getName());
+
+ final StringBuilder mappingDetails = new StringBuilder(128);
+ PrintStream ps = new PrintStream(System.out)
+ {
+ @Override
+ public void print(String x)
+ {
+ mappingDetails.append(x);
+ }
+
+ @Override
+ public void println()
+ {
+ mappingDetails.append(NEWLINE);
+ }
+ };
+ int[][] mapping = null;
+ try
+ {
+ mapping = getGreedyMapping(chain, seq, ps);
+ } catch (Exception e)
+ {
+ e.printStackTrace();
+ }
+ // String mappingOutput = mappingDetails.toString();
+ String mappingOutput = null;
+ return new StructureMapping(seq, pdbFile, pdbId, chain, mapping,
+ mappingOutput);
+ }
+
+ @Override
+ public Entity getEntityById(String id) throws Exception
+ {
+ List<Entity> entities = siftsEntry.getEntity();
+ for (Entity entity : entities)
+ {
+ if (!entity.getEntityId().equalsIgnoreCase(id))
+ {
+ continue;
+ }
+ return entity;
+ }
+ throw new Exception("Entity " + id + " not found");
+ }
+
+ @Override
+ public String[] getEntryDBs()
+ {
+ System.out.println("\nListing DB entries...");
+ List<Db> dbs = siftsEntry.getListDB().getDb();
+ for (Db db : dbs)
+ {
+ System.out.println(db.getDbSource() + " | " + db.getDbCoordSys());
+ }
+ return null;
+ }
+
+ @Override
+ public void getEntryDetails()
+ {
+ List<EntryDetail> eds = siftsEntry.getEntryDetail();
+ for (EntryDetail ed : eds)
+ {
+ System.out.println("Entry Details: " + ed.getContent() + " "
+ + ed.getDbSource() + " " + ed.getProperty() + " "
+ + ed.toString());
+ }
+ }
+
+ @Override
+ public StringBuffer getMappingOutput(String astr1, String astr2, String s1id,
+ String s2id, String type, int nochunks)
+ {
+ int maxid = s1id.length();
+ int len = 72 - maxid - 1;
+ StringBuffer output = new StringBuffer();
+ // output mappings
+ float pid = 0;
+ for (int j = 0; j < nochunks; j++)
+ {
+ // Print the first aligned sequence
+ output.append(new Format("%" + (maxid) + "s").form(s1id)).append(" ");
+
+ for (int i = 0; i < len; i++)
+ {
+ if ((i + (j * len)) < astr1.length())
+ {
+ output.append(astr1.charAt(i + (j * len)));
+ }
+ }
+
+ output.append(NEWLINE);
+ output.append(new Format("%" + (maxid) + "s").form(" ")).append(" ");
+
+ // Print out the matching chars
+ for (int i = 0; i < len; i++)
+ {
+ if ((i + (j * len)) < astr1.length())
+ {
+ if (astr1.charAt(i + (j * len)) == astr2.charAt(i + (j * len))
+ && !jalview.util.Comparison.isGap(astr1.charAt(i
+ + (j * len))))
+ {
+ pid++;
+ output.append("|");
+ }
+ else if (type.equals("pep"))
+ {
+ if (ResidueProperties.getPAM250(astr1.charAt(i + (j * len)),
+ astr2.charAt(i + (j * len))) > 0)
+ {
+ output.append(".");
+ }
+ else
+ {
+ output.append(" ");
+ }
+ }
+ else
+ {
+ output.append(" ");
+ }
+ }
+ }
+ // Now print the second aligned sequence
+ output = output.append(NEWLINE);
+ output = output.append(new Format("%" + (maxid) + "s").form(s2id))
+ .append(" ");
+ for (int i = 0; i < len; i++)
+ {
+ if ((i + (j * len)) < astr2.length())
+ {
+ output.append(astr2.charAt(i + (j * len)));
+ }
+ }
+ output.append(NEWLINE).append(NEWLINE);
+ }
+ pid = pid / (astr1.length()) * 100;
+ System.out.println(output);
+ System.out.println(pid);
+ // TODO return output & pid
+ return output;
+ }
+
+ @Override
+ public int getEntityCount()
+ {
+ return siftsEntry.getEntity().size();
+ }
+
+ @Override
+ public String getDbAccessionId()
+ {
+ return siftsEntry.getDbAccessionId();
+ }
+
+ @Override
+ public String getDbCoordSys()
+ {
+ return siftsEntry.getDbCoordSys();
+ }
+
+ @Override
+ public String getDbEvidence()
+ {
+ return siftsEntry.getDbEvidence();
+ }
+
+ @Override
+ public String getDbSource()
+ {
+ return siftsEntry.getDbSource();
+ }
+
+ @Override
+ public String getDbVersion()
+ {
+ return siftsEntry.getDbVersion();
+ }
+}
git://source.jalview.org / jalview.git / blobdiff