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