src/jalview/ws/jws1/JPredThread.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.ws.jws1;
  22
  23 import jalview.analysis.AlignSeq;
  24 import jalview.bin.Cache;
  25 import jalview.datamodel.Alignment;
  26 import jalview.datamodel.AlignmentAnnotation;
  27 import jalview.datamodel.AlignmentI;
  28 import jalview.datamodel.AlignmentView;
  29 import jalview.datamodel.ColumnSelection;
  30 import jalview.datamodel.SequenceI;
  31 import jalview.gui.AlignFrame;
  32 import jalview.gui.Desktop;
  33 import jalview.gui.WebserviceInfo;
  34 import jalview.io.FormatAdapter;
  35 import jalview.util.Comparison;
  36 import jalview.util.MessageManager;
  37 import jalview.ws.AWsJob;
  38 import jalview.ws.JobStateSummary;
  39 import jalview.ws.WSClientI;
  40
  41 import java.util.Hashtable;
  42 import java.util.List;
  43
  44 import vamsas.objects.simple.JpredResult;
  45
  46 class JPredThread extends JWS1Thread implements WSClientI
  47 {
  48   // TODO: put mapping between JPredJob input and input data here -
  49   // JNetAnnotation adding is done after result parsing.
  50   class JPredJob extends WSJob
  51   {
  52     // TODO: make JPredJob deal only with what was sent to and received from a
  53     // JNet service
  54     int[] predMap = null; // mapping from sequence(i) to the original
  55
  56     // sequence(predMap[i]) being predicted on
  57
  58     vamsas.objects.simple.Sequence sequence;
  59
  60     vamsas.objects.simple.Msfalignment msa;
  61
  62     java.util.Hashtable SequenceInfo = null;
  63
  64     int msaIndex = 0; // the position of the original sequence in the array of
  65
  66     // Sequences in the input object that this job holds a
  67     // prediction for
  68
  69     /**
  70      *
  71      * @return true if getResultSet will return a valid alignment and prediction
  72      *         result.
  73      */
  74     public boolean hasResults()
  75     {
  76       if (subjobComplete && result != null && result.isFinished()
  77               && ((JpredResult) result).getPredfile() != null
  78               && ((JpredResult) result).getAligfile() != null)
  79       {
  80         return true;
  81       }
  82       return false;
  83     }
  84
  85     public boolean hasValidInput()
  86     {
  87       if (sequence != null)
  88       {
  89         return true;
  90       }
  91       return false;
  92     }
  93
  94     /**
  95      *
  96      * @return null or Object[] { annotated alignment for this prediction,
  97      *         ColumnSelection for this prediction} or null if no results
  98      *         available.
  99      * @throws Exception
 100      */
 101     public Object[] getResultSet() throws Exception
 102     {
 103       if (result == null || !result.isFinished())
 104       {
 105         return null;
 106       }
 107       AlignmentI al = null;
 108       ColumnSelection alcsel = null;
 109       int FirstSeq = -1; // the position of the query sequence in Alignment al
 110
 111       JpredResult result = (JpredResult) this.result;
 112
 113       jalview.bin.Cache.log.debug("Parsing output from JNet job.");
 114       // JPredFile prediction = new JPredFile("C:/JalviewX/files/jpred.txt",
 115       // "File");
 116       jalview.io.JPredFile prediction = new jalview.io.JPredFile(
 117               result.getPredfile(), "Paste");
 118       SequenceI[] preds = prediction.getSeqsAsArray();
 119       jalview.bin.Cache.log.debug("Got prediction profile.");
 120
 121       if ((this.msa != null) && (result.getAligfile() != null))
 122       {
 123         jalview.bin.Cache.log.debug("Getting associated alignment.");
 124         // we ignore the returned alignment if we only predicted on a single
 125         // sequence
 126         String format = new jalview.io.IdentifyFile().identify(
 127                 result.getAligfile(), "Paste");
 128
 129         if (jalview.io.FormatAdapter.isValidFormat(format))
 130         {
 131           SequenceI sqs[];
 132           if (predMap != null)
 133           {
 134             Object[] alandcolsel = input
 135                     .getAlignmentAndColumnSelection(getGapChar());
 136             sqs = (SequenceI[]) alandcolsel[0];
 137             al = new Alignment(sqs);
 138             alcsel = (ColumnSelection) alandcolsel[1];
 139           }
 140           else
 141           {
 142             al = new FormatAdapter().readFile(result.getAligfile(),
 143                     "Paste", format);
 144             sqs = new SequenceI[al.getHeight()];
 145
 146             for (int i = 0, j = al.getHeight(); i < j; i++)
 147             {
 148               sqs[i] = al.getSequenceAt(i);
 149             }
 150             if (!jalview.analysis.SeqsetUtils.deuniquify(SequenceInfo, sqs))
 151             {
 152               throw (new Exception(
 153                       MessageManager
 154                               .getString("exception.couldnt_recover_sequence_properties_for_alignment")));
 155             }
 156           }
 157           FirstSeq = 0;
 158           if (currentView.getDataset() != null)
 159           {
 160             al.setDataset(currentView.getDataset());
 161
 162           }
 163           else
 164           {
 165             al.setDataset(null);
 166           }
 167           jalview.io.JnetAnnotationMaker.add_annotation(prediction, al,
 168                   FirstSeq, false, predMap);
 169
 170         }
 171         else
 172         {
 173           throw (new Exception(MessageManager.formatMessage(
 174                   "exception.unknown_format_for_file", new String[] {
 175                       format, result.getAligfile() })));
 176         }
 177       }
 178       else
 179       {
 180         al = new Alignment(preds);
 181         FirstSeq = prediction.getQuerySeqPosition();
 182         if (predMap != null)
 183         {
 184           char gc = getGapChar();
 185           SequenceI[] sqs = (SequenceI[]) input
 186                   .getAlignmentAndColumnSelection(gc)[0];
 187           if (this.msaIndex >= sqs.length)
 188           {
 189             throw new Error(
 190                     MessageManager
 191                             .getString("error.implementation_error_invalid_msa_index_for_job"));
 192           }
 193
 194           // ///
 195           // Uses RemoveGapsCommand
 196           // ///
 197           new jalview.commands.RemoveGapsCommand(
 198                   MessageManager.getString("label.remove_gaps"),
 199                   new SequenceI[] { sqs[msaIndex] }, currentView);
 200
 201           SequenceI profileseq = al.getSequenceAt(FirstSeq);
 202           profileseq.setSequence(sqs[msaIndex].getSequenceAsString());
 203         }
 204
 205         if (!jalview.analysis.SeqsetUtils.SeqCharacterUnhash(
 206                 al.getSequenceAt(FirstSeq), SequenceInfo))
 207         {
 208           throw (new Exception(
 209                   MessageManager
 210                           .getString("exception.couldnt_recover_sequence_props_for_jnet_query")));
 211         }
 212         else
 213         {
 214           if (currentView.getDataset() != null)
 215           {
 216             al.setDataset(currentView.getDataset());
 217
 218           }
 219           else
 220           {
 221             al.setDataset(null);
 222           }
 223           jalview.io.JnetAnnotationMaker.add_annotation(prediction, al,
 224                   FirstSeq, true, predMap);
 225           SequenceI profileseq = al.getSequenceAt(0); // this includes any gaps.
 226           alignToProfileSeq(al, profileseq);
 227           if (predMap != null)
 228           {
 229             // Adjust input view for gaps
 230             // propagate insertions into profile
 231             alcsel = ColumnSelection.propagateInsertions(profileseq, al,
 232                     input);
 233           }
 234         }
 235       }
 236       // transfer to dataset
 237       for (AlignmentAnnotation alant : al.getAlignmentAnnotation())
 238       {
 239         if (alant.sequenceRef != null)
 240         {
 241           replaceAnnotationOnAlignmentWith(alant, alant.label,
 242                   "jalview.jws1.Jpred" + (this.msa == null ? "" : "MSA"),
 243                   alant.sequenceRef);
 244         }
 245       }
 246       return new Object[] { al, alcsel }; // , FirstSeq, noMsa};
 247     }
 248
 249     /**
 250      * copied from JabawsCalcWorker
 251      *
 252      * @param newAnnot
 253      * @param typeName
 254      * @param calcId
 255      * @param aSeq
 256      */
 257     protected void replaceAnnotationOnAlignmentWith(
 258             AlignmentAnnotation newAnnot, String typeName, String calcId,
 259             SequenceI aSeq)
 260     {
 261       SequenceI dsseq = aSeq.getDatasetSequence();
 262       while (dsseq.getDatasetSequence() != null)
 263       {
 264         dsseq = dsseq.getDatasetSequence();
 265       }
 266       // look for same annotation on dataset and lift this one over
 267       List<AlignmentAnnotation> dsan = dsseq.getAlignmentAnnotations(
 268               calcId, typeName);
 269       if (dsan != null && dsan.size() > 0)
 270       {
 271         for (AlignmentAnnotation dssan : dsan)
 272         {
 273           dsseq.removeAlignmentAnnotation(dssan);
 274         }
 275       }
 276       AlignmentAnnotation dssan = new AlignmentAnnotation(newAnnot);
 277       dsseq.addAlignmentAnnotation(dssan);
 278       dssan.adjustForAlignment();
 279     }
 280
 281     /**
 282      * Given an alignment where all other sequences except profileseq are
 283      * aligned to the ungapped profileseq, insert gaps in the other sequences to
 284      * realign them with the residues in profileseq
 285      *
 286      * @param al
 287      * @param profileseq
 288      */
 289     private void alignToProfileSeq(AlignmentI al, SequenceI profileseq)
 290     {
 291       char gc = al.getGapCharacter();
 292       int[] gapMap = profileseq.gapMap();
 293       // insert gaps into profile
 294       for (int lp = 0, r = 0; r < gapMap.length; r++)
 295       {
 296         if (gapMap[r] - lp > 1)
 297         {
 298           StringBuffer sb = new StringBuffer();
 299           for (int s = 0, ns = gapMap[r] - lp; s < ns; s++)
 300           {
 301             sb.append(gc);
 302           }
 303           for (int s = 1, ns = al.getHeight(); s < ns; s++)
 304           {
 305             String sq = al.getSequenceAt(s).getSequenceAsString();
 306             int diff = gapMap[r] - sq.length();
 307             if (diff > 0)
 308             {
 309               // pad gaps
 310               sq = sq + sb;
 311               while ((diff = gapMap[r] - sq.length()) > 0)
 312               {
 313                 sq = sq
 314                         + ((diff >= sb.length()) ? sb.toString() : sb
 315                                 .substring(0, diff));
 316               }
 317               al.getSequenceAt(s).setSequence(sq);
 318             }
 319             else
 320             {
 321               al.getSequenceAt(s).setSequence(
 322                       sq.substring(0, gapMap[r]) + sb.toString()
 323                               + sq.substring(gapMap[r]));
 324             }
 325           }
 326         }
 327         lp = gapMap[r];
 328       }
 329     }
 330
 331     public JPredJob(Hashtable SequenceInfo, SequenceI seq, int[] delMap)
 332     {
 333       super();
 334       this.predMap = delMap;
 335       String sq = AlignSeq.extractGaps(Comparison.GapChars,
 336               seq.getSequenceAsString());
 337       if (sq.length() >= 20)
 338       {
 339         this.SequenceInfo = SequenceInfo;
 340         sequence = new vamsas.objects.simple.Sequence();
 341         sequence.setId(seq.getName());
 342         sequence.setSeq(sq);
 343       }
 344       else
 345       {
 346         errorMessage = "Sequence is too short to predict with JPred - need at least 20 amino acids.";
 347       }
 348     }
 349
 350     public JPredJob(Hashtable SequenceInfo, SequenceI[] msf, int[] delMap)
 351     {
 352       this(SequenceInfo, msf[0], delMap);
 353       if (sequence != null)
 354       {
 355         if (msf.length > 1)
 356         {
 357           msa = new vamsas.objects.simple.Msfalignment();
 358           jalview.io.PileUpfile pileup = new jalview.io.PileUpfile();
 359           msa.setMsf(pileup.print(msf));
 360         }
 361       }
 362     }
 363
 364     String errorMessage = "";
 365
 366     public String getValidationMessages()
 367     {
 368       return errorMessage + "\n";
 369     }
 370   }
 371
 372   ext.vamsas.Jpred server;
 373
 374   String altitle = "";
 375
 376   JPredThread(WebserviceInfo wsinfo, String altitle,
 377           ext.vamsas.Jpred server, String wsurl, AlignmentView alview,
 378           AlignFrame alframe)
 379   {
 380     super(alframe, wsinfo, alview, wsurl);
 381     this.altitle = altitle;
 382     this.server = server;
 383   }
 384
 385   JPredThread(WebserviceInfo wsinfo, String altitle,
 386           ext.vamsas.Jpred server, String wsurl, Hashtable SequenceInfo,
 387           SequenceI seq, int[] delMap, AlignmentView alview,
 388           AlignFrame alframe)
 389   {
 390     this(wsinfo, altitle, server, wsurl, alview, alframe);
 391     JPredJob job = new JPredJob(SequenceInfo, seq, delMap);
 392     if (job.hasValidInput())
 393     {
 394       OutputHeader = wsInfo.getProgressText();
 395       jobs = new WSJob[] { job };
 396       job.setJobnum(0);
 397     }
 398     else
 399     {
 400       wsInfo.appendProgressText(job.getValidationMessages());
 401     }
 402   }
 403
 404   JPredThread(WebserviceInfo wsinfo, String altitle,
 405           ext.vamsas.Jpred server, Hashtable SequenceInfo, SequenceI[] msf,
 406           int[] delMap, AlignmentView alview, AlignFrame alframe,
 407           String wsurl)
 408   {
 409     this(wsinfo, altitle, server, wsurl, alview, alframe);
 410     JPredJob job = new JPredJob(SequenceInfo, msf, delMap);
 411     if (job.hasValidInput())
 412     {
 413       jobs = new WSJob[] { job };
 414       OutputHeader = wsInfo.getProgressText();
 415       job.setJobnum(0);
 416     }
 417     else
 418     {
 419       wsInfo.appendProgressText(job.getValidationMessages());
 420     }
 421   }
 422
 423   public void StartJob(AWsJob j)
 424   {
 425     if (!(j instanceof JPredJob))
 426     {
 427       throw new Error(MessageManager.formatMessage(
 428               "error.implementation_error_startjob_called",
 429               new String[] { j.getClass().toString() }));
 430     }
 431     try
 432     {
 433       JPredJob job = (JPredJob) j;
 434       if (job.msa != null)
 435       {
 436         job.setJobId(server.predictOnMsa(job.msa));
 437       }
 438       else if (job.sequence != null)
 439       {
 440         job.setJobId(server.predict(job.sequence)); // debug like : job.jobId =
 441         // "/jobs/www-jpred/jp_Yatat29";//
 442       }
 443
 444       if (job.getJobId() != null)
 445       {
 446         if (job.getJobId().startsWith("Broken"))
 447         {
 448           job.result = new JpredResult();
 449           job.result.setInvalid(true);
 450           job.result.setStatus(MessageManager.formatMessage(
 451                   "label.submission_params", new String[] { job.getJobId()
 452                           .toString() }));
 453           throw new Exception(job.getJobId());
 454         }
 455         else
 456         {
 457           job.setSubmitted(true);
 458           job.setSubjobComplete(false);
 459           Cache.log.info(WsUrl + " Job Id '" + job.getJobId() + "'");
 460         }
 461       }
 462       else
 463       {
 464         throw new Exception(
 465                 MessageManager
 466                         .getString("exception.server_timeout_try_later"));
 467       }
 468     } catch (Exception e)
 469     {
 470       // kill the whole job.
 471       wsInfo.setStatus(WebserviceInfo.STATE_STOPPED_SERVERERROR);
 472       if (e.getMessage().indexOf("Exception") > -1)
 473       {
 474         wsInfo.setStatus(j.getJobnum(),
 475                 WebserviceInfo.STATE_STOPPED_SERVERERROR);
 476         wsInfo.setProgressText(
 477                 j.getJobnum(),
 478                 "Failed to submit the prediction. (Just close the window)\n"
 479                         + "It is most likely that there is a problem with the server.\n");
 480         System.err
 481                 .println("JPredWS Client: Failed to submit the prediction. Quite possibly because of a server error - see below)\n"
 482                         + e.getMessage() + "\n");
 483
 484         jalview.bin.Cache.log.warn("Server Exception", e);
 485       }
 486       else
 487       {
 488         wsInfo.setStatus(j.getJobnum(), WebserviceInfo.STATE_STOPPED_ERROR);
 489         // JBPNote - this could be a popup informing the user of the problem.
 490         wsInfo.appendProgressText(j.getJobnum(), MessageManager
 491                 .formatMessage(
 492                         "info.failed_to_submit_prediction",
 493                         new String[] { e.getMessage(),
 494                             wsInfo.getProgressText() }));
 495
 496         jalview.bin.Cache.log.debug(
 497                 "Failed Submission of job " + j.getJobnum(), e);
 498
 499       }
 500       j.setAllowedServerExceptions(-1);
 501       j.setSubjobComplete(true);
 502     }
 503   }
 504
 505   public void parseResult()
 506   {
 507     int results = 0; // number of result sets received
 508     JobStateSummary finalState = new JobStateSummary();
 509     try
 510     {
 511       for (int j = 0; j < jobs.length; j++)
 512       {
 513         finalState.updateJobPanelState(wsInfo, OutputHeader, jobs[j]);
 514         if (jobs[j].isSubmitted() && jobs[j].isSubjobComplete()
 515                 && jobs[j].hasResults())
 516         {
 517           results++;
 518         }
 519       }
 520     } catch (Exception ex)
 521     {
 522
 523       Cache.log.error("Unexpected exception when processing results for "
 524               + altitle, ex);
 525       wsInfo.setStatus(WebserviceInfo.STATE_STOPPED_ERROR);
 526     }
 527     if (results > 0)
 528     {
 529       wsInfo.showResultsNewFrame
 530               .addActionListener(new java.awt.event.ActionListener()
 531               {
 532                 public void actionPerformed(java.awt.event.ActionEvent evt)
 533                 {
 534                   displayResults(true);
 535                 }
 536               });
 537       wsInfo.mergeResults
 538               .addActionListener(new java.awt.event.ActionListener()
 539               {
 540                 public void actionPerformed(java.awt.event.ActionEvent evt)
 541                 {
 542                   displayResults(false);
 543                 }
 544               });
 545       wsInfo.setResultsReady();
 546     }
 547     else
 548     {
 549       wsInfo.setStatus(wsInfo.STATE_STOPPED_ERROR);
 550       wsInfo.appendInfoText("No jobs ran.");
 551       wsInfo.setFinishedNoResults();
 552     }
 553   }
 554
 555   void displayResults(boolean newWindow)
 556   {
 557     // TODO: cope with multiple subjobs.
 558     if (jobs != null)
 559     {
 560       Object[] res = null;
 561       boolean msa = false;
 562       for (int jn = 0; jn < jobs.length; jn++)
 563       {
 564         Object[] jobres = null;
 565         JPredJob j = (JPredJob) jobs[jn];
 566
 567         if (j.hasResults())
 568         {
 569           // hack - we only deal with all single seuqence predictions or all
 570           // profile predictions
 571           msa = (j.msa != null) ? true : msa;
 572           try
 573           {
 574             jalview.bin.Cache.log.debug("Parsing output of job " + jn);
 575             jobres = j.getResultSet();
 576             jalview.bin.Cache.log.debug("Finished parsing output.");
 577             if (jobs.length == 1)
 578             {
 579               res = jobres;
 580             }
 581             else
 582             {
 583               // do merge with other job results
 584               throw new Error(
 585                       MessageManager
 586                               .getString("error.multiple_jnet_subjob_merge_not_implemented"));
 587             }
 588           } catch (Exception e)
 589           {
 590             jalview.bin.Cache.log.error(
 591                     "JNet Client: JPred Annotation Parse Error", e);
 592             wsInfo.setStatus(j.getJobnum(),
 593                     WebserviceInfo.STATE_STOPPED_ERROR);
 594             wsInfo.appendProgressText(j.getJobnum(), MessageManager
 595                     .formatMessage("info.invalid_jnet_job_result_data",
 596                             new String[] { OutputHeader.toString(),
 597                                 j.result.getStatus(), e.getMessage() }));
 598             j.result.setBroken(true);
 599           }
 600         }
 601       }
 602
 603       if (res != null)
 604       {
 605         if (newWindow)
 606         {
 607           AlignFrame af;
 608           ((AlignmentI) res[0]).setSeqrep(((AlignmentI) res[0])
 609                   .getSequenceAt(0));
 610           if (input == null)
 611           {
 612             if (res[1] != null)
 613             {
 614               af = new AlignFrame((Alignment) res[0],
 615                       (ColumnSelection) res[1], AlignFrame.DEFAULT_WIDTH,
 616                       AlignFrame.DEFAULT_HEIGHT);
 617             }
 618             else
 619             {
 620               af = new AlignFrame((Alignment) res[0],
 621                       AlignFrame.DEFAULT_WIDTH, AlignFrame.DEFAULT_HEIGHT);
 622             }
 623           }
 624           else
 625           {
 626             /*
 627              * java.lang.Object[] alandcolsel =
 628              * input.getAlignmentAndColumnSelection
 629              * (alignFrame.getViewport().getGapCharacter()); if
 630              * (((SequenceI[])alandcolsel[0])[0].getLength()!=res.getWidth()) {
 631              * if (msa) { throw new Error("Implementation Error! ColumnSelection
 632              * from input alignment will not map to result alignment!"); } } if
 633              * (!msa) { // update hidden regions to account for loss of gaps in
 634              * profile. - if any // gapMap returns insert list, interpreted as
 635              * delete list by pruneDeletions //((ColumnSelection)
 636              * alandcolsel[1]).pruneDeletions(ShiftList.parseMap(((SequenceI[])
 637              * alandcolsel[0])[0].gapMap())); }
 638              */
 639
 640             af = new AlignFrame((Alignment) res[0],
 641                     (ColumnSelection) res[1], AlignFrame.DEFAULT_WIDTH,
 642                     AlignFrame.DEFAULT_HEIGHT);
 643           }
 644           Desktop.addInternalFrame(af, altitle, AlignFrame.DEFAULT_WIDTH,
 645                   AlignFrame.DEFAULT_HEIGHT);
 646         }
 647         else
 648         {
 649           Cache.log.info("Append results onto existing alignment.");
 650         }
 651       }
 652     }
 653   }
 654
 655   public void pollJob(AWsJob job) throws Exception
 656   {
 657     ((JPredJob) job).result = server.getresult(job.getJobId());
 658   }
 659
 660   public boolean isCancellable()
 661   {
 662     return false;
 663   }
 664
 665   public void cancelJob()
 666   {
 667     throw new Error(MessageManager.getString("error.implementation_error"));
 668   }
 669
 670   public boolean canMergeResults()
 671   {
 672     return false;
 673   }
 674
 675 }