src/jalview/ws/SequenceFetcher.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8)
   3  * Copyright (C) 2012 J Procter, AM Waterhouse, LM Lui, J Engelhardt, G Barton, M Clamp, S Searle
   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 of the License, or (at your option) any later version.
  10  *
  11  * Jalview is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty
  13  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  14  * PURPOSE.  See the GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
  17  */
  18 package jalview.ws;\r
  19 \r
  20 import jalview.datamodel.Alignment;\r
  21 import jalview.datamodel.AlignmentI;\r
  22 import jalview.datamodel.DBRefSource;\r
  23 import jalview.datamodel.SequenceI;\r
  24 import jalview.ws.dbsources.das.api.jalviewSourceI;\r
  25 import jalview.ws.seqfetcher.ASequenceFetcher;\r
  26 import jalview.ws.seqfetcher.DbSourceProxy;\r
  27 \r
  28 import java.util.ArrayList;\r
  29 import java.util.Enumeration;\r
  30 import java.util.List;\r
  31 import java.util.Vector;\r
  32 \r
  33 /**\r
  34  * This is the the concrete implementation of the sequence retrieval interface\r
  35  * and abstract class in jalview.ws.seqfetcher. This implements the run-time\r
  36  * discovery of sequence database clients, and provides a hardwired main for\r
  37  * testing all registered handlers.\r
  38  * \r
  39  */\r
  40 public class SequenceFetcher extends ASequenceFetcher\r
  41 {\r
  42   /**\r
  43    * Thread safe construction of database proxies TODO: extend to a configurable\r
  44    * database plugin mechanism where classes are instantiated by reflection and\r
  45    * queried for their DbRefSource and version association.\r
  46    * \r
  47    */\r
  48   public SequenceFetcher()\r
  49   {\r
  50     this(true);\r
  51   }\r
  52   public SequenceFetcher(boolean addDas)\r
  53   {\r
  54     addDBRefSourceImpl(jalview.ws.dbsources.EmblSource.class);\r
  55     addDBRefSourceImpl(jalview.ws.dbsources.EmblCdsSouce.class);\r
  56     addDBRefSourceImpl(jalview.ws.dbsources.Uniprot.class);\r
  57     addDBRefSourceImpl(jalview.ws.dbsources.UnprotName.class);\r
  58     addDBRefSourceImpl(jalview.ws.dbsources.Pdb.class);\r
  59     addDBRefSourceImpl(jalview.ws.dbsources.PfamFull.class);\r
  60     addDBRefSourceImpl(jalview.ws.dbsources.PfamSeed.class); // ensures Seed\r
  61     // alignment is\r
  62     // 'default' for\r
  63     // PFAM\r
  64     addDBRefSourceImpl(jalview.ws.dbsources.RfamFull.class);\r
  65     addDBRefSourceImpl(jalview.ws.dbsources.RfamSeed.class);\r
  66     if (addDas) {\r
  67       registerDasSequenceSources();\r
  68     }\r
  69   }\r
  70 \r
  71   /**\r
  72    * return an ordered list of database sources where non-das database classes\r
  73    * appear before das database classes\r
  74    */\r
  75   public String[] getOrderedSupportedSources()\r
  76   {\r
  77     String[] srcs = this.getSupportedDb();\r
  78     ArrayList<String> dassrc = new ArrayList<String>(), nondas = new ArrayList<String>();\r
  79     for (int i = 0; i < srcs.length; i++)\r
  80     {\r
  81       boolean das = false, skip = false;\r
  82       String nm;\r
  83       for (DbSourceProxy dbs : getSourceProxy(srcs[i]))\r
  84       {\r
  85         // Skip the alignment databases for the moment - they're not useful for\r
  86         // verifying a single sequence against its reference source\r
  87         if (dbs.isA(DBRefSource.ALIGNMENTDB))\r
  88         {\r
  89           skip = true;\r
  90         }\r
  91         else\r
  92         {\r
  93           nm = dbs.getDbName();\r
  94           if (getSourceProxy(srcs[i]) instanceof jalview.ws.dbsources.das.datamodel.DasSequenceSource)\r
  95           {\r
  96             if (nm.startsWith("das:"))\r
  97             {\r
  98               nm = nm.substring(4);\r
  99               das = true;\r
 100             }\r
 101             break;\r
 102           }\r
 103         }\r
 104       }\r
 105       if (skip)\r
 106       {\r
 107         continue;\r
 108       }\r
 109       if (das)\r
 110       {\r
 111         dassrc.add(srcs[i]);\r
 112       }\r
 113       else\r
 114       {\r
 115         nondas.add(srcs[i]);\r
 116       }\r
 117     }\r
 118     String[] tosort = nondas.toArray(new String[0]), sorted = nondas\r
 119             .toArray(new String[0]);\r
 120     for (int j = 0, jSize = sorted.length; j < jSize; j++)\r
 121     {\r
 122       tosort[j] = tosort[j].toLowerCase();\r
 123     }\r
 124     jalview.util.QuickSort.sort(tosort, sorted);\r
 125     // construct array with all sources listed\r
 126 \r
 127     srcs = new String[sorted.length + dassrc.size()];\r
 128     int i = 0;\r
 129     for (int j = sorted.length - 1; j >= 0; j--, i++)\r
 130     {\r
 131       srcs[i] = sorted[j];\r
 132       sorted[j] = null;\r
 133     }\r
 134 \r
 135     sorted = dassrc.toArray(new String[0]);\r
 136     tosort = dassrc.toArray(new String[0]);\r
 137     for (int j = 0, jSize = sorted.length; j < jSize; j++)\r
 138     {\r
 139       tosort[j] = tosort[j].toLowerCase();\r
 140     }\r
 141     jalview.util.QuickSort.sort(tosort, sorted);\r
 142     for (int j = sorted.length - 1; j >= 0; j--, i++)\r
 143     {\r
 144       srcs[i] = sorted[j];\r
 145     }\r
 146     return srcs;\r
 147   }\r
 148 \r
 149   /**\r
 150    * return plaintext databse list suitable for using in a GUI element\r
 151    */\r
 152   public String[] _getOrderedSupportedSources()\r
 153   {\r
 154     String[] srcs = this.getSupportedDb();\r
 155     ArrayList dassrc = new ArrayList(), nondas = new ArrayList();\r
 156     for (int i = 0; i < srcs.length; i++)\r
 157     {\r
 158       for (DbSourceProxy dbs : getSourceProxy(srcs[i]))\r
 159       {\r
 160         String nm = dbs.getDbName();\r
 161         if (getSourceProxy(srcs[i]) instanceof jalview.ws.dbsources.das.datamodel.DasSequenceSource)\r
 162         {\r
 163           if (nm.startsWith("das:"))\r
 164           {\r
 165             nm = nm.substring(4);\r
 166           }\r
 167           dassrc.add(new String[]\r
 168           { srcs[i], nm.toUpperCase() });\r
 169         }\r
 170         else\r
 171         {\r
 172           nondas.add(new String[]\r
 173           { srcs[i], nm.toUpperCase() });\r
 174         }\r
 175       }\r
 176     }\r
 177     Object[] sorted = nondas.toArray();\r
 178     String[] tosort = new String[sorted.length];\r
 179     nondas.clear();\r
 180     for (int j = 0; j < sorted.length; j++)\r
 181     {\r
 182       tosort[j] = ((String[]) sorted[j])[1];\r
 183     }\r
 184     jalview.util.QuickSort.sort(tosort, sorted);\r
 185     int i = 0;\r
 186     // construct array with all sources listed\r
 187     srcs = new String[sorted.length + dassrc.size()];\r
 188     for (int j = sorted.length - 1; j >= 0; j--, i++)\r
 189     {\r
 190       srcs[i] = ((String[]) sorted[j])[0];\r
 191       sorted[j] = null;\r
 192     }\r
 193 \r
 194     sorted = dassrc.toArray();\r
 195     tosort = new String[sorted.length];\r
 196     dassrc.clear();\r
 197     for (int j = 0; j < sorted.length; j++)\r
 198     {\r
 199       tosort[j] = ((String[]) sorted[j])[1];\r
 200     }\r
 201     jalview.util.QuickSort.sort(tosort, sorted);\r
 202     for (int j = sorted.length - 1; j >= 0; j--, i++)\r
 203     {\r
 204       srcs[i] = ((String[]) sorted[j])[0];\r
 205       sorted[j] = null;\r
 206     }\r
 207     return srcs;\r
 208   }\r
 209 \r
 210   /**\r
 211    * simple run method to test dbsources.\r
 212    * \r
 213    * @param argv\r
 214    */\r
 215   public static void main(String[] argv)\r
 216   {\r
 217     AlignmentI ds = null;\r
 218     Vector noProds = new Vector();\r
 219     String usage = "SequenceFetcher.main [-nodas] [<DBNAME> [<ACCNO>]]\n"\r
 220             + "With no arguments, all DbSources will be queried with their test Accession number.\n"\r
 221             + "With one argument, the argument will be resolved to one or more db sources and each will be queried with their test accession only.\n"\r
 222             + "If given two arguments, SequenceFetcher will try to find the DbFetcher corresponding to <DBNAME> and retrieve <ACCNO> from it.\n"\r
 223             + "The -nodas option will exclude DAS sources from the database fetchers Jalview will try to use.";\r
 224     boolean withDas=true;\r
 225     if (argv!=null && argv.length>0 && argv[0].toLowerCase().startsWith("-nodas"))\r
 226     {\r
 227       withDas=false;\r
 228       String targs[] = new String[argv.length-1];\r
 229       System.arraycopy(argv, 1, targs, 0, targs.length);\r
 230       argv=targs;\r
 231     }\r
 232     if (argv != null && argv.length > 0)\r
 233     {\r
 234       List<DbSourceProxy> sps = new SequenceFetcher(withDas)\r
 235               .getSourceProxy(argv[0]);\r
 236 \r
 237       if (sps != null)\r
 238       {\r
 239         for (DbSourceProxy sp : sps)\r
 240         {\r
 241           AlignmentI al = null;\r
 242           try\r
 243           {\r
 244             al = sp.getSequenceRecords(argv.length>1 ? argv[1] : sp.getTestQuery());\r
 245           } catch (Exception e)\r
 246           {\r
 247             e.printStackTrace();\r
 248             System.err.println("Error when retrieving " + (argv.length>1 ? argv[1] : sp.getTestQuery())\r
 249                     + " from " + argv[0] + "\nUsage: " + usage);\r
 250           }\r
 251           SequenceI[] prod = al.getSequencesArray();\r
 252           if (al != null)\r
 253           {\r
 254             for (int p = 0; p < prod.length; p++)\r
 255             {\r
 256               System.out.println("Prod " + p + ": "\r
 257                       + prod[p].getDisplayId(true) + " : "\r
 258                       + prod[p].getDescription());\r
 259             }\r
 260           }\r
 261         }\r
 262         return;\r
 263       }\r
 264       else\r
 265       {\r
 266         System.err.println("Can't resolve " + argv[0]\r
 267                 + " as a database name. Allowed values are :\n"\r
 268                 + new SequenceFetcher().getSupportedDb());\r
 269       }\r
 270       System.out.println(usage);\r
 271       return;\r
 272     }\r
 273     ASequenceFetcher sfetcher = new SequenceFetcher(withDas);\r
 274     String[] dbSources = sfetcher.getSupportedDb();\r
 275     for (int dbsource = 0; dbsource < dbSources.length; dbsource++)\r
 276     {\r
 277       String db = dbSources[dbsource];\r
 278       // skip me\r
 279       if (db.equals(DBRefSource.PDB))\r
 280         continue;\r
 281       for (DbSourceProxy sp : sfetcher.getSourceProxy(db))\r
 282       {\r
 283         System.out.println("Source: " + sp.getDbName() + " (" + db\r
 284                 + "): retrieving test:" + sp.getTestQuery());\r
 285         AlignmentI al = null;\r
 286         try\r
 287         {\r
 288           al = sp.getSequenceRecords(sp.getTestQuery());\r
 289           if (al != null && al.getHeight() > 0\r
 290                   && sp.getDbSourceProperties() != null)\r
 291           {\r
 292             boolean dna = sp.getDbSourceProperties().containsKey(\r
 293                     DBRefSource.DNACODINGSEQDB)\r
 294                     || sp.getDbSourceProperties().containsKey(\r
 295                             DBRefSource.DNASEQDB)\r
 296                     || sp.getDbSourceProperties().containsKey(\r
 297                             DBRefSource.CODINGSEQDB);\r
 298             // try and find products\r
 299             String types[] = jalview.analysis.CrossRef\r
 300                     .findSequenceXrefTypes(dna, al.getSequencesArray());\r
 301             if (types != null)\r
 302             {\r
 303               System.out.println("Xref Types for: "\r
 304                       + (dna ? "dna" : "prot"));\r
 305               for (int t = 0; t < types.length; t++)\r
 306               {\r
 307                 System.out.println("Type: " + types[t]);\r
 308                 SequenceI[] prod = jalview.analysis.CrossRef\r
 309                         .findXrefSequences(al.getSequencesArray(), dna,\r
 310                                 types[t]).getSequencesArray();\r
 311                 System.out.println("Found "\r
 312                         + ((prod == null) ? "no" : "" + prod.length)\r
 313                         + " products");\r
 314                 if (prod != null)\r
 315                 {\r
 316                   for (int p = 0; p < prod.length; p++)\r
 317                   {\r
 318                     System.out.println("Prod " + p + ": "\r
 319                             + prod[p].getDisplayId(true));\r
 320                   }\r
 321                 }\r
 322               }\r
 323             }\r
 324             else\r
 325             {\r
 326               noProds.addElement((dna ? new Object[]\r
 327               { al, al } : new Object[]\r
 328               { al }));\r
 329             }\r
 330 \r
 331           }\r
 332         } catch (Exception ex)\r
 333         {\r
 334           System.out.println("ERROR:Failed to retrieve test query.");\r
 335           ex.printStackTrace(System.out);\r
 336         }\r
 337 \r
 338         if (al == null)\r
 339         {\r
 340           System.out.println("ERROR:No alignment retrieved.");\r
 341           StringBuffer raw = sp.getRawRecords();\r
 342           if (raw != null)\r
 343             System.out.println(raw.toString());\r
 344           else\r
 345             System.out.println("ERROR:No Raw results.");\r
 346         }\r
 347         else\r
 348         {\r
 349           System.out.println("Retrieved " + al.getHeight() + " sequences.");\r
 350           for (int s = 0; s < al.getHeight(); s++)\r
 351           {\r
 352             SequenceI sq = al.getSequenceAt(s);\r
 353             while (sq.getDatasetSequence() != null)\r
 354             {\r
 355               sq = sq.getDatasetSequence();\r
 356 \r
 357             }\r
 358             if (ds == null)\r
 359             {\r
 360               ds = new Alignment(new SequenceI[]\r
 361               { sq });\r
 362 \r
 363             }\r
 364             else\r
 365             {\r
 366               ds.addSequence(sq);\r
 367             }\r
 368           }\r
 369         }\r
 370         System.out.flush();\r
 371         System.err.flush();\r
 372 \r
 373       }\r
 374       if (noProds.size() > 0)\r
 375       {\r
 376         Enumeration ts = noProds.elements();\r
 377         while (ts.hasMoreElements())\r
 378 \r
 379         {\r
 380           Object[] typeSq = (Object[]) ts.nextElement();\r
 381           boolean dna = (typeSq.length > 1);\r
 382           AlignmentI al = (AlignmentI) typeSq[0];\r
 383           System.out.println("Trying getProducts for "\r
 384                   + al.getSequenceAt(0).getDisplayId(true));\r
 385           System.out.println("Search DS Xref for: "\r
 386                   + (dna ? "dna" : "prot"));\r
 387           // have a bash at finding the products amongst all the retrieved\r
 388           // sequences.\r
 389           SequenceI[] seqs = al.getSequencesArray();\r
 390           Alignment prodal = jalview.analysis.CrossRef.findXrefSequences(\r
 391                   seqs, dna, null, ds);\r
 392           System.out.println("Found "\r
 393                   + ((prodal == null) ? "no" : "" + prodal.getHeight())\r
 394                   + " products");\r
 395           if (prodal != null)\r
 396           {\r
 397             SequenceI[] prod = prodal.getSequencesArray(); // note\r
 398             // should\r
 399             // test\r
 400             // rather\r
 401             // than\r
 402             // throw\r
 403             // away\r
 404             // codon\r
 405             // mapping\r
 406             // (if\r
 407             // present)\r
 408             for (int p = 0; p < prod.length; p++)\r
 409             {\r
 410               System.out.println("Prod " + p + ": "\r
 411                       + prod[p].getDisplayId(true));\r
 412             }\r
 413           }\r
 414         }\r
 415 \r
 416       }\r
 417 \r
 418     }\r
 419   }\r
 420 \r
 421   /**\r
 422    * query the currently defined DAS source registry for sequence sources and\r
 423    * add a DasSequenceSource instance for each source to the SequenceFetcher\r
 424    * source list.\r
 425    */\r
 426   public void registerDasSequenceSources()\r
 427   {\r
 428     // TODO: define a context as a registry provider (either desktop,\r
 429     // jalview.bin.cache, or something else).\r
 430     for (jalviewSourceI source : jalview.bin.Cache.getDasSourceRegistry()\r
 431             .getSources())\r
 432     {\r
 433       if (source.isSequenceSource())\r
 434       {\r
 435         List<DbSourceProxy> dassources = source.getSequenceSourceProxies();\r
 436         for (DbSourceProxy seqsrc : dassources)\r
 437         {\r
 438           addDbRefSourceImpl(seqsrc);\r
 439         }\r
 440       }\r
 441     }\r
 442   }\r
 443 \r
 444 }\r