src/jalview/ws/dbsources/EBIAlfaFold.java

   1
   2 /*
   3  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
   4  * Copyright (C) $$Year-Rel$$ The Jalview Authors
   5  *
   6  * This file is part of Jalview.
   7  *
   8  * Jalview is free software: you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License
  10  * as published by the Free Software Foundation, either version 3
  11  * of the License, or (at your option) any later version.
  12  *
  13  * Jalview is distributed in the hope that it will be useful, but
  14  * WITHOUT ANY WARRANTY; without even the implied warranty
  15  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  16  * PURPOSE.  See the GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
  20  * The Jalview Authors are detailed in the 'AUTHORS' file.
  21  */
  22 package jalview.ws.dbsources;
  23
  24 import java.io.File;
  25 import java.io.FileInputStream;
  26 import java.io.FileNotFoundException;
  27 import java.io.IOException;
  28 import java.io.InputStream;
  29 import java.util.ArrayList;
  30 import java.util.List;
  31 import java.util.Map;
  32
  33 import org.json.simple.JSONArray;
  34 import org.json.simple.JSONObject;
  35 import org.json.simple.parser.ParseException;
  36
  37 import com.stevesoft.pat.Regex;
  38
  39 import jalview.api.FeatureSettingsModelI;
  40 import jalview.bin.Console;
  41 import jalview.datamodel.AlignedCodonFrame;
  42 import jalview.datamodel.AlignmentAnnotation;
  43 import jalview.datamodel.AlignmentI;
  44 import jalview.datamodel.ContactMatrixI;
  45 import jalview.datamodel.DBRefEntry;
  46 import jalview.datamodel.PDBEntry;
  47 import jalview.datamodel.SequenceFeature;
  48 import jalview.datamodel.SequenceI;
  49 import jalview.gui.Desktop;
  50 import jalview.io.DataSourceType;
  51 import jalview.io.FileFormat;
  52 import jalview.io.FileFormatI;
  53 import jalview.io.FormatAdapter;
  54 import jalview.io.PDBFeatureSettings;
  55 import jalview.structure.StructureMapping;
  56 import jalview.structure.StructureSelectionManager;
  57 import jalview.util.MessageManager;
  58 import jalview.util.Platform;
  59 import jalview.ws.datamodel.alphafold.PAEContactMatrix;
  60 import jalview.ws.utils.UrlDownloadClient;
  61
  62 /**
  63  * @author JimP
  64  *
  65  */
  66 public class EBIAlfaFold extends EbiFileRetrievedProxy
  67 {
  68   private static final String SEPARATOR = "|";
  69
  70   private static final String COLON = ":";
  71
  72   private static final int PDB_ID_LENGTH = 4;
  73
  74   private static String AF_VERSION = "3";
  75
  76   public EBIAlfaFold()
  77   {
  78     super();
  79   }
  80
  81   /*
  82    * (non-Javadoc)
  83    *
  84    * @see jalview.ws.DbSourceProxy#getAccessionSeparator()
  85    */
  86   @Override
  87   public String getAccessionSeparator()
  88   {
  89     return null;
  90   }
  91
  92   /*
  93    * (non-Javadoc)
  94    *
  95    * @see jalview.ws.DbSourceProxy#getAccessionValidator()
  96    */
  97   @Override
  98   public Regex getAccessionValidator()
  99   {
 100     Regex validator = new Regex("(AF-[A-Z]+[0-9]+[A-Z0-9]+-F1)");
 101     validator.setIgnoreCase(true);
 102     return validator;
 103   }
 104
 105   /*
 106    * (non-Javadoc)
 107    *
 108    * @see jalview.ws.DbSourceProxy#getDbSource()
 109    */
 110   @Override
 111   public String getDbSource()
 112   {
 113     return "ALPHAFOLD";
 114   }
 115
 116   /*
 117    * (non-Javadoc)
 118    *
 119    * @see jalview.ws.DbSourceProxy#getDbVersion()
 120    */
 121   @Override
 122   public String getDbVersion()
 123   {
 124     return "1";
 125   }
 126
 127   public static String getAlphaFoldCifDownloadUrl(String id, String vnum)
 128   {
 129     if (vnum == null || vnum.length() == 0)
 130     {
 131       vnum = AF_VERSION;
 132     }
 133     return "https://alphafold.ebi.ac.uk/files/" + id + "-model_v" + vnum
 134             + ".cif";
 135   }
 136
 137   public static String getAlphaFoldPaeDownloadUrl(String id, String vnum)
 138   {
 139     if (vnum == null || vnum.length() == 0)
 140     {
 141       vnum = AF_VERSION;
 142     }
 143     return "https://alphafold.ebi.ac.uk/files/" + id
 144             + "-predicted_aligned_error_v" + vnum + ".json";
 145   }
 146
 147   /*
 148    * (non-Javadoc)
 149    *
 150    * @see jalview.ws.DbSourceProxy#getSequenceRecords(java.lang.String[])
 151    */
 152   @Override
 153   public AlignmentI getSequenceRecords(String queries) throws Exception
 154   {
 155     return getSequenceRecords(queries, null);
 156   }
 157
 158   public AlignmentI getSequenceRecords(String queries, String retrievalUrl)
 159           throws Exception
 160   {
 161     AlignmentI pdbAlignment = null;
 162     String chain = null;
 163     String id = null;
 164     if (queries.indexOf(COLON) > -1)
 165     {
 166       chain = queries.substring(queries.indexOf(COLON) + 1);
 167       id = queries.substring(0, queries.indexOf(COLON));
 168     }
 169     else
 170     {
 171       id = queries;
 172     }
 173
 174     if (!isValidReference(id))
 175     {
 176       System.err.println(
 177               "(AFClient) Ignoring invalid alphafold query: '" + id + "'");
 178       stopQuery();
 179       return null;
 180     }
 181     String alphaFoldCif = getAlphaFoldCifDownloadUrl(id, AF_VERSION);
 182     if (retrievalUrl != null)
 183     {
 184       alphaFoldCif = retrievalUrl;
 185     }
 186
 187     try
 188     {
 189       File tmpFile = File.createTempFile(id, ".cif");
 190       Console.debug("Retrieving structure file for " + id + " from "
 191               + alphaFoldCif);
 192       UrlDownloadClient.download(alphaFoldCif, tmpFile);
 193
 194       // may not need this check ?
 195       file = tmpFile.getAbsolutePath();
 196       if (file == null)
 197       {
 198         return null;
 199       }
 200
 201       pdbAlignment = importDownloadedStructureFromUrl(alphaFoldCif, tmpFile,
 202               id, chain, getDbSource(), getDbVersion());
 203
 204       if (pdbAlignment == null || pdbAlignment.getHeight() < 1)
 205       {
 206         throw new Exception(MessageManager.formatMessage(
 207                 "exception.no_pdb_records_for_chain", new String[]
 208                 { id, ((chain == null) ? "' '" : chain) }));
 209       }
 210       // done during structure retrieval
 211       // retrieve_AlphaFold_pAE(id, pdbAlignment, retrievalUrl);
 212
 213     } catch (Exception ex) // Problem parsing PDB file
 214     {
 215       stopQuery();
 216       throw (ex);
 217     }
 218     return pdbAlignment;
 219   }
 220
 221   /**
 222    * get an alphafold pAE for the given id, and add it to sequence 0 in
 223    * pdbAlignment (assuming it came from structurefile parser).
 224    *
 225    * @param id
 226    * @param pdbAlignment
 227    * @param retrievalUrl
 228    *          - URL of .mmcif from EBI-AlphaFold - will be used to generate the
 229    *          pAE URL automatically
 230    * @throws IOException
 231    * @throws Exception
 232    */
 233   public static void retrieve_AlphaFold_pAE(String id,
 234           AlignmentI pdbAlignment, String retrievalUrl) throws IOException
 235   {
 236     // import PAE as contact matrix - assume this will work if there was a
 237     // model
 238     String paeURL = getAlphaFoldPaeDownloadUrl(id, AF_VERSION);
 239
 240     if (retrievalUrl != null)
 241     {
 242       // manufacture the PAE url from a url like ...-model-vN.cif
 243       paeURL = retrievalUrl.replace("model", "predicted_aligned_error")
 244               .replace(".cif", ".json");
 245     }
 246
 247     File pae = null;
 248     try
 249     {
 250       pae = File.createTempFile(id == null ? "af_pae" : id, "pae_json");
 251     } catch (IOException e)
 252     {
 253       e.printStackTrace();
 254     }
 255     Console.debug("Downloading pae from " + paeURL + " to " + pae.toString()
 256             + "");
 257     UrlDownloadClient.download(paeURL, pae);
 258     addAlphaFoldPAEToSequence(pdbAlignment, pae, 0, null);
 259   }
 260
 261   public static void addAlphaFoldPAEToSequence(AlignmentI pdbAlignment,
 262           File pae, int index, String seqId)
 263   {
 264     addAlphaFoldPAE(pdbAlignment, pae, index, seqId, false, false);
 265   }
 266
 267   public static void addAlphaFoldPAEToStructure(AlignmentI pdbAlignment,
 268           File pae, int index, String structIdOrFile, boolean isStructId)
 269   {
 270     addAlphaFoldPAE(pdbAlignment, pae, index, structIdOrFile, true,
 271             isStructId);
 272   }
 273
 274   public static void addAlphaFoldPAE(AlignmentI pdbAlignment, File pae,
 275           int index, String id, boolean isStruct, boolean isStructId)
 276   {
 277     FileInputStream paeInput = null;
 278     try
 279     {
 280       paeInput = new FileInputStream(pae);
 281     } catch (FileNotFoundException e)
 282     {
 283       Console.error(
 284               "Could not find pAE file '" + pae.getAbsolutePath() + "'", e);
 285       return;
 286     }
 287
 288     if (isStruct)
 289     {
 290       StructureSelectionManager ssm = StructureSelectionManager
 291               .getStructureSelectionManager(Desktop.instance);
 292       if (ssm != null)
 293       {
 294         String structFile = isStructId ? ssm.findFileForPDBId(id) : id;
 295
 296         StructureMapping[] smArray = ssm.getMapping(structFile);
 297
 298         try
 299         {
 300           if (!importPaeJSONAsContactMatrixToStructure(smArray, paeInput))
 301           {
 302             Console.warn("Could not import contact matrix from '"
 303                     + pae.getAbsolutePath() + "' to structure.");
 304           }
 305         } catch (IOException e1)
 306         {
 307           Console.error("Error when importing pAE file '"
 308                   + pae.getAbsolutePath() + "'", e1);
 309         } catch (ParseException e2)
 310         {
 311           Console.error("Error when parsing pAE file '"
 312                   + pae.getAbsolutePath() + "'", e2);
 313         }
 314       }
 315
 316     }
 317     else
 318     {
 319       // attach to sequence?!
 320       try
 321       {
 322         if (!importPaeJSONAsContactMatrixToSequence(pdbAlignment, paeInput,
 323                 index, id))
 324         {
 325           Console.warn("Could not import contact matrix from '"
 326                   + pae.getAbsolutePath() + "' to sequence.");
 327         }
 328       } catch (IOException e1)
 329       {
 330         Console.error("Error when importing pAE file '"
 331                 + pae.getAbsolutePath() + "'", e1);
 332       } catch (ParseException e2)
 333       {
 334         Console.error("Error when parsing pAE file '"
 335                 + pae.getAbsolutePath() + "'", e2);
 336       }
 337     }
 338
 339   }
 340
 341   /**
 342    * parses the given pAE matrix and adds it to sequence 0 in the given
 343    * alignment
 344    *
 345    * @param pdbAlignment
 346    * @param pae_input
 347    * @return true if there was a pAE matrix added
 348    * @throws ParseException
 349    * @throws IOException
 350    * @throws Exception
 351    */
 352   public static boolean importPaeJSONAsContactMatrixToSequence(
 353           AlignmentI pdbAlignment, InputStream pae_input)
 354           throws IOException, ParseException
 355   {
 356     return importPaeJSONAsContactMatrixToSequence(pdbAlignment, pae_input,
 357             0, null);
 358   }
 359
 360   public static boolean importPaeJSONAsContactMatrixToSequence(
 361           AlignmentI pdbAlignment, InputStream pae_input, int index,
 362           String seqId) throws IOException, ParseException
 363   {
 364     SequenceI sequence = null;
 365     if (seqId == null)
 366     {
 367       int seqToGet = index > 0 ? index : 0;
 368       sequence = pdbAlignment.getSequenceAt(seqToGet);
 369     }
 370     if (sequence == null)
 371     {
 372       SequenceI[] sequences = pdbAlignment.findSequenceMatch(seqId);
 373       if (sequences == null || sequences.length < 1)
 374       {
 375         Console.warn("Could not find sequence with id '" + seqId
 376                 + "' to attach pAE matrix to. Ignoring matrix.");
 377         return false;
 378       }
 379       else
 380       {
 381         sequence = sequences[0]; // just use the first sequence with this seqId
 382       }
 383     }
 384
 385     JSONObject paeDict = parseJSONtoPAEContactMatrix(pae_input);
 386     if (paeDict == null)
 387     {
 388       Console.debug("JSON file did not parse properly.");
 389       return false;
 390     }
 391     ContactMatrixI matrix = new PAEContactMatrix(sequence,
 392             (Map<String, Object>) paeDict);
 393
 394     AlignmentAnnotation cmannot = sequence.addContactList(matrix);
 395     pdbAlignment.addAnnotation(cmannot);
 396
 397     return true;
 398   }
 399
 400   public static JSONObject parseJSONtoPAEContactMatrix(
 401           InputStream pae_input) throws IOException, ParseException
 402   {
 403     Object paeJson = Platform.parseJSON(pae_input);
 404     JSONObject paeDict = null;
 405     if (paeJson instanceof JSONObject)
 406     {
 407       paeDict = (JSONObject) paeJson;
 408     }
 409     else if (paeJson instanceof JSONArray)
 410     {
 411       JSONArray jsonArray = (JSONArray) paeJson;
 412       if (jsonArray.size() > 0)
 413         paeDict = (JSONObject) jsonArray.get(0);
 414     }
 415
 416     return paeDict;
 417   }
 418
 419   public static boolean importPaeJSONAsContactMatrixToStructure(
 420           StructureMapping[] smArray, InputStream paeInput)
 421           throws IOException, ParseException
 422   {
 423     boolean someDone = false;
 424     for (StructureMapping sm : smArray)
 425     {
 426       boolean thisDone = importPaeJSONAsContactMatrixToStructure(sm,
 427               paeInput);
 428       someDone |= thisDone;
 429     }
 430     return someDone;
 431   }
 432
 433   public static boolean importPaeJSONAsContactMatrixToStructure(
 434           StructureMapping sm, InputStream paeInput)
 435           throws IOException, ParseException
 436   {
 437
 438     JSONObject pae_obj = parseJSONtoPAEContactMatrix(paeInput);
 439     if (pae_obj == null)
 440     {
 441       Console.debug("JSON file did not parse properly.");
 442       return false;
 443     }
 444
 445     ContactMatrixI matrix = new PAEContactMatrix(sm.getSequence(),
 446             (Map<String, Object>) pae_obj);
 447
 448     AlignmentAnnotation cmannot = sm.getSequence().addContactList(matrix);
 449     // sm.getSequence().addAlignmentAnnotation(cmannot);
 450     sm.transfer(cmannot);
 451     // return true;
 452
 453     StructureSelectionManager ssm = StructureSelectionManager
 454             .getStructureSelectionManager(Desktop.instance);
 455     List<AlignedCodonFrame> acfList = ssm.getSequenceMappings();
 456
 457     return true;
 458   }
 459
 460   /**
 461    * general purpose structure importer - designed to yield alignment useful for
 462    * transfer of annotation to associated sequences
 463    *
 464    * @param alphaFoldCif
 465    * @param tmpFile
 466    * @param id
 467    * @param chain
 468    * @param dbSource
 469    * @param dbVersion
 470    * @return
 471    * @throws Exception
 472    */
 473   public static AlignmentI importDownloadedStructureFromUrl(
 474           String alphaFoldCif, File tmpFile, String id, String chain,
 475           String dbSource, String dbVersion) throws Exception
 476   {
 477     String file = tmpFile.getAbsolutePath();
 478     // todo get rid of Type and use FileFormatI instead?
 479     FileFormatI fileFormat = FileFormat.MMCif;
 480     AlignmentI pdbAlignment = new FormatAdapter().readFile(tmpFile,
 481             DataSourceType.FILE, fileFormat);
 482     if (pdbAlignment != null)
 483     {
 484       List<SequenceI> toremove = new ArrayList<SequenceI>();
 485       for (SequenceI pdbcs : pdbAlignment.getSequences())
 486       {
 487         String chid = null;
 488         // Mapping map=null;
 489         for (PDBEntry pid : pdbcs.getAllPDBEntries())
 490         {
 491           if (pid.getFile() == file)
 492           {
 493             chid = pid.getChainCode();
 494
 495           }
 496         }
 497         if (chain == null || (chid != null && (chid.equals(chain)
 498                 || chid.trim().equals(chain.trim())
 499                 || (chain.trim().length() == 0 && chid.equals("_")))))
 500         {
 501           // FIXME seems to result in 'PDB|1QIP|1qip|A' - 1QIP is redundant.
 502           // TODO: suggest simplify naming to 1qip|A as default name defined
 503           pdbcs.setName(id + SEPARATOR + pdbcs.getName());
 504           // Might need to add more metadata to the PDBEntry object
 505           // like below
 506           /*
 507            * PDBEntry entry = new PDBEntry(); // Construct the PDBEntry
 508            * entry.setId(id); if (entry.getProperty() == null)
 509            * entry.setProperty(new Hashtable());
 510            * entry.getProperty().put("chains", pdbchain.id + "=" +
 511            * sq.getStart() + "-" + sq.getEnd());
 512            * sq.getDatasetSequence().addPDBId(entry);
 513            */
 514           // Add PDB DB Refs
 515           // We make a DBRefEtntry because we have obtained the PDB file from
 516           // a
 517           // verifiable source
 518           // JBPNote - PDB DBRefEntry should also carry the chain and mapping
 519           // information
 520           if (dbSource != null)
 521           {
 522             DBRefEntry dbentry = new DBRefEntry(dbSource,
 523
 524                     dbVersion, (chid == null ? id : id + chid));
 525             // dbentry.setMap()
 526             pdbcs.addDBRef(dbentry);
 527             // update any feature groups
 528             List<SequenceFeature> allsf = pdbcs.getFeatures()
 529                     .getAllFeatures();
 530             List<SequenceFeature> newsf = new ArrayList<SequenceFeature>();
 531             if (allsf != null && allsf.size() > 0)
 532             {
 533               for (SequenceFeature f : allsf)
 534               {
 535                 if (file.equals(f.getFeatureGroup()))
 536                 {
 537                   f = new SequenceFeature(f, f.type, f.begin, f.end, id,
 538                           f.score);
 539                 }
 540                 newsf.add(f);
 541               }
 542               pdbcs.setSequenceFeatures(newsf);
 543             }
 544           }
 545         }
 546         else
 547         {
 548           // mark this sequence to be removed from the alignment
 549           // - since it's not from the right chain
 550           toremove.add(pdbcs);
 551         }
 552       }
 553       // now remove marked sequences
 554       for (SequenceI pdbcs : toremove)
 555       {
 556         pdbAlignment.deleteSequence(pdbcs);
 557         if (pdbcs.getAnnotation() != null)
 558         {
 559           for (AlignmentAnnotation aa : pdbcs.getAnnotation())
 560           {
 561             pdbAlignment.deleteAnnotation(aa);
 562           }
 563         }
 564       }
 565     }
 566     return pdbAlignment;
 567   }
 568
 569   /*
 570    * (non-Javadoc)
 571    *
 572    * @see jalview.ws.DbSourceProxy#isValidReference(java.lang.String)
 573    */
 574   @Override
 575   public boolean isValidReference(String accession)
 576   {
 577     Regex r = getAccessionValidator();
 578     return r.search(accession.trim());
 579   }
 580
 581   /**
 582    * human glyoxalase
 583    */
 584   @Override
 585   public String getTestQuery()
 586   {
 587     return "AF-O15552-F1";
 588   }
 589
 590   @Override
 591   public String getDbName()
 592   {
 593     return "ALPHAFOLD"; // getDbSource();
 594   }
 595
 596   @Override
 597   public int getTier()
 598   {
 599     return 0;
 600   }
 601
 602   /**
 603    * Returns a descriptor for suitable feature display settings with
 604    * <ul>
 605    * <li>ResNums or insertions features visible</li>
 606    * <li>insertions features coloured red</li>
 607    * <li>ResNum features coloured by label</li>
 608    * <li>Insertions displayed above (on top of) ResNums</li>
 609    * </ul>
 610    */
 611   @Override
 612   public FeatureSettingsModelI getFeatureColourScheme()
 613   {
 614     return new PDBFeatureSettings();
 615   }
 616
 617 }