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, File paeFile, int index, String seqId)
 362           throws FileNotFoundException, IOException, ParseException
 363   {
 364     return importPaeJSONAsContactMatrixToSequence(pdbAlignment,
 365             new FileInputStream(paeFile), index, seqId);
 366   }
 367
 368   public static boolean importPaeJSONAsContactMatrixToSequence(
 369           AlignmentI pdbAlignment, InputStream pae_input, int index,
 370           String seqId) throws IOException, ParseException
 371   {
 372     SequenceI sequence = null;
 373     if (seqId == null)
 374     {
 375       int seqToGet = index > 0 ? index : 0;
 376       sequence = pdbAlignment.getSequenceAt(seqToGet);
 377     }
 378     if (sequence == null)
 379     {
 380       SequenceI[] sequences = pdbAlignment.findSequenceMatch(seqId);
 381       if (sequences == null || sequences.length < 1)
 382       {
 383         Console.warn("Could not find sequence with id '" + seqId
 384                 + "' to attach pAE matrix to. Ignoring matrix.");
 385         return false;
 386       }
 387       else
 388       {
 389         sequence = sequences[0]; // just use the first sequence with this seqId
 390       }
 391     }
 392
 393     JSONObject paeDict = parseJSONtoPAEContactMatrix(pae_input);
 394     if (paeDict == null)
 395     {
 396       Console.debug("JSON file did not parse properly.");
 397       return false;
 398     }
 399     ContactMatrixI matrix = new PAEContactMatrix(sequence,
 400             (Map<String, Object>) paeDict);
 401
 402     AlignmentAnnotation cmannot = sequence.addContactList(matrix);
 403     pdbAlignment.addAnnotation(cmannot);
 404
 405     return true;
 406   }
 407
 408   public static JSONObject parseJSONtoPAEContactMatrix(
 409           InputStream pae_input) throws IOException, ParseException
 410   {
 411     Object paeJson = Platform.parseJSON(pae_input);
 412     JSONObject paeDict = null;
 413     if (paeJson instanceof JSONObject)
 414     {
 415       paeDict = (JSONObject) paeJson;
 416     }
 417     else if (paeJson instanceof JSONArray)
 418     {
 419       JSONArray jsonArray = (JSONArray) paeJson;
 420       if (jsonArray.size() > 0)
 421         paeDict = (JSONObject) jsonArray.get(0);
 422     }
 423
 424     return paeDict;
 425   }
 426
 427   public static boolean importPaeJSONAsContactMatrixToStructure(
 428           StructureMapping[] smArray, InputStream paeInput)
 429           throws IOException, ParseException
 430   {
 431     boolean someDone = false;
 432     for (StructureMapping sm : smArray)
 433     {
 434       boolean thisDone = importPaeJSONAsContactMatrixToStructure(sm,
 435               paeInput);
 436       someDone |= thisDone;
 437     }
 438     return someDone;
 439   }
 440
 441   public static boolean importPaeJSONAsContactMatrixToStructure(
 442           StructureMapping sm, File paeFile)
 443           throws FileNotFoundException, IOException, ParseException
 444   {
 445     return importPaeJSONAsContactMatrixToStructure(sm,
 446             new FileInputStream(paeFile));
 447   }
 448
 449   public static boolean importPaeJSONAsContactMatrixToStructure(
 450           StructureMapping sm, InputStream paeInput)
 451           throws IOException, ParseException
 452   {
 453     JSONObject pae_obj = parseJSONtoPAEContactMatrix(paeInput);
 454     if (pae_obj == null)
 455     {
 456       Console.debug("JSON file did not parse properly.");
 457       return false;
 458     }
 459
 460     ContactMatrixI matrix = new PAEContactMatrix(sm.getSequence(),
 461             (Map<String, Object>) pae_obj);
 462
 463     AlignmentAnnotation cmannot = sm.getSequence().addContactList(matrix);
 464     // sm.getSequence().addAlignmentAnnotation(cmannot);
 465     sm.transfer(cmannot);
 466     // return true;
 467
 468     StructureSelectionManager ssm = StructureSelectionManager
 469             .getStructureSelectionManager(Desktop.instance);
 470     List<AlignedCodonFrame> acfList = ssm.getSequenceMappings();
 471
 472     return true;
 473   }
 474
 475   /**
 476    * general purpose structure importer - designed to yield alignment useful for
 477    * transfer of annotation to associated sequences
 478    *
 479    * @param alphaFoldCif
 480    * @param tmpFile
 481    * @param id
 482    * @param chain
 483    * @param dbSource
 484    * @param dbVersion
 485    * @return
 486    * @throws Exception
 487    */
 488   public static AlignmentI importDownloadedStructureFromUrl(
 489           String alphaFoldCif, File tmpFile, String id, String chain,
 490           String dbSource, String dbVersion) throws Exception
 491   {
 492     String file = tmpFile.getAbsolutePath();
 493     // todo get rid of Type and use FileFormatI instead?
 494     FileFormatI fileFormat = FileFormat.MMCif;
 495     AlignmentI pdbAlignment = new FormatAdapter().readFile(tmpFile,
 496             DataSourceType.FILE, fileFormat);
 497     if (pdbAlignment != null)
 498     {
 499       List<SequenceI> toremove = new ArrayList<SequenceI>();
 500       for (SequenceI pdbcs : pdbAlignment.getSequences())
 501       {
 502         String chid = null;
 503         // Mapping map=null;
 504         for (PDBEntry pid : pdbcs.getAllPDBEntries())
 505         {
 506           if (pid.getFile() == file)
 507           {
 508             chid = pid.getChainCode();
 509
 510           }
 511         }
 512         if (chain == null || (chid != null && (chid.equals(chain)
 513                 || chid.trim().equals(chain.trim())
 514                 || (chain.trim().length() == 0 && chid.equals("_")))))
 515         {
 516           // FIXME seems to result in 'PDB|1QIP|1qip|A' - 1QIP is redundant.
 517           // TODO: suggest simplify naming to 1qip|A as default name defined
 518           pdbcs.setName(id + SEPARATOR + pdbcs.getName());
 519           // Might need to add more metadata to the PDBEntry object
 520           // like below
 521           /*
 522            * PDBEntry entry = new PDBEntry(); // Construct the PDBEntry
 523            * entry.setId(id); if (entry.getProperty() == null)
 524            * entry.setProperty(new Hashtable());
 525            * entry.getProperty().put("chains", pdbchain.id + "=" +
 526            * sq.getStart() + "-" + sq.getEnd());
 527            * sq.getDatasetSequence().addPDBId(entry);
 528            */
 529           // Add PDB DB Refs
 530           // We make a DBRefEtntry because we have obtained the PDB file from
 531           // a
 532           // verifiable source
 533           // JBPNote - PDB DBRefEntry should also carry the chain and mapping
 534           // information
 535           if (dbSource != null)
 536           {
 537             DBRefEntry dbentry = new DBRefEntry(dbSource,
 538
 539                     dbVersion, (chid == null ? id : id + chid));
 540             // dbentry.setMap()
 541             pdbcs.addDBRef(dbentry);
 542             // update any feature groups
 543             List<SequenceFeature> allsf = pdbcs.getFeatures()
 544                     .getAllFeatures();
 545             List<SequenceFeature> newsf = new ArrayList<SequenceFeature>();
 546             if (allsf != null && allsf.size() > 0)
 547             {
 548               for (SequenceFeature f : allsf)
 549               {
 550                 if (file.equals(f.getFeatureGroup()))
 551                 {
 552                   f = new SequenceFeature(f, f.type, f.begin, f.end, id,
 553                           f.score);
 554                 }
 555                 newsf.add(f);
 556               }
 557               pdbcs.setSequenceFeatures(newsf);
 558             }
 559           }
 560         }
 561         else
 562         {
 563           // mark this sequence to be removed from the alignment
 564           // - since it's not from the right chain
 565           toremove.add(pdbcs);
 566         }
 567       }
 568       // now remove marked sequences
 569       for (SequenceI pdbcs : toremove)
 570       {
 571         pdbAlignment.deleteSequence(pdbcs);
 572         if (pdbcs.getAnnotation() != null)
 573         {
 574           for (AlignmentAnnotation aa : pdbcs.getAnnotation())
 575           {
 576             pdbAlignment.deleteAnnotation(aa);
 577           }
 578         }
 579       }
 580     }
 581     return pdbAlignment;
 582   }
 583
 584   /*
 585    * (non-Javadoc)
 586    *
 587    * @see jalview.ws.DbSourceProxy#isValidReference(java.lang.String)
 588    */
 589   @Override
 590   public boolean isValidReference(String accession)
 591   {
 592     Regex r = getAccessionValidator();
 593     return r.search(accession.trim());
 594   }
 595
 596   /**
 597    * human glyoxalase
 598    */
 599   @Override
 600   public String getTestQuery()
 601   {
 602     return "AF-O15552-F1";
 603   }
 604
 605   @Override
 606   public String getDbName()
 607   {
 608     return "ALPHAFOLD"; // getDbSource();
 609   }
 610
 611   @Override
 612   public int getTier()
 613   {
 614     return 0;
 615   }
 616
 617   /**
 618    * Returns a descriptor for suitable feature display settings with
 619    * <ul>
 620    * <li>ResNums or insertions features visible</li>
 621    * <li>insertions features coloured red</li>
 622    * <li>ResNum features coloured by label</li>
 623    * <li>Insertions displayed above (on top of) ResNums</li>
 624    * </ul>
 625    */
 626   @Override
 627   public FeatureSettingsModelI getFeatureColourScheme()
 628   {
 629     return new PDBFeatureSettings();
 630   }
 631
 632 }