src/jalview/io/IdentifyFile.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.io;
  22
  23 import java.util.Locale;
  24
  25 import java.io.File;
  26 import java.io.IOException;
  27
  28 /**
  29  * DOCUMENT ME!
  30  *
  31  * @author $author$
  32  * @version $Revision$
  33  */
  34 public class IdentifyFile
  35 {
  36
  37   public FileFormatI identify(Object file, DataSourceType protocol) throws FileFormatException
  38   {
  39     // BH 2018
  40     return (file instanceof File ? identify((File) file, protocol) : identify((String) file, protocol));
  41
  42   }
  43
  44   public FileFormatI identify(File file, DataSourceType sourceType)
  45           throws FileFormatException
  46   {
  47     // BH 2018
  48     String emessage = "UNIDENTIFIED FILE PARSING ERROR";
  49     FileParse parser = null;
  50     try
  51     {
  52       parser = new FileParse(file, sourceType);
  53       if (parser.isValid())
  54       {
  55         return identify(parser);
  56       }
  57     } catch (Exception e)
  58     {
  59       System.err.println("Error whilst identifying " + file);
  60       e.printStackTrace(System.err);
  61       emessage = e.getMessage();
  62     }
  63     if (parser != null)
  64     {
  65       throw new FileFormatException(parser.errormessage);
  66     }
  67     throw new FileFormatException(emessage);
  68   }
  69
  70   /**
  71    * Identify a datasource's file content.
  72    *
  73    * @note Do not use this method for stream sources - create a FileParse object
  74    *       instead.
  75    *
  76    * @param file
  77    * @param sourceType
  78    * @return
  79    * @throws FileFormatException
  80    */
  81   public FileFormatI identify(String file, DataSourceType sourceType)
  82           throws FileFormatException
  83   {
  84     String emessage = "UNIDENTIFIED FILE PARSING ERROR";
  85     FileParse parser = null;
  86     try
  87     {
  88       parser = new FileParse(file, sourceType);
  89       if (parser.isValid())
  90       {
  91         return identify(parser);
  92       }
  93     } catch (Exception e)
  94     {
  95       System.err.println("Error whilst identifying " + file);
  96       e.printStackTrace(System.err);
  97       emessage = e.getMessage();
  98     }
  99     if (parser != null)
 100     {
 101       throw new FileFormatException(parser.errormessage);
 102     }
 103     throw new FileFormatException(emessage);
 104   }
 105
 106   public FileFormatI identify(FileParse source) throws FileFormatException
 107   {
 108     return identify(source, true);
 109     // preserves original behaviour prior to version 2.3
 110   }
 111
 112   public FileFormatI identify(AlignmentFileReaderI file,
 113           boolean closeSource) throws IOException
 114   {
 115     FileParse fp = new FileParse(file.getInFile(),
 116             file.getDataSourceType());
 117     return identify(fp, closeSource);
 118   }
 119
 120   /**
 121    * Identify contents of source, closing it or resetting source to start
 122    * afterwards.
 123    *
 124    * @param source
 125    * @param closeSource
 126    * @return (best guess at) file format
 127    * @throws FileFormatException
 128    */
 129   public FileFormatI identify(FileParse source, boolean closeSource)
 130           throws FileFormatException
 131   {
 132     FileFormatI reply = FileFormat.Pfam;
 133     String data;
 134     int bytesRead = 0;
 135     int trimmedLength = 0;
 136     boolean lineswereskipped = false;
 137     boolean isBinary = false; // true if length is non-zero and non-printable
 138     // characters are encountered
 139
 140     try
 141     {
 142       if (!closeSource)
 143       {
 144         source.mark();
 145       }
 146       boolean aaIndexHeaderRead = false;
 147
 148       while ((data = source.nextLine()) != null)
 149       {
 150         bytesRead += data.length();
 151         trimmedLength += data.trim().length();
 152         if (!lineswereskipped)
 153         {
 154           for (int i = 0; !isBinary && i < data.length(); i++)
 155           {
 156             char c = data.charAt(i);
 157             isBinary = (c < 32 && c != '\t' && c != '\n' && c != '\r'
 158                     && c != 5 && c != 27); // nominal binary character filter
 159             // excluding CR, LF, tab,DEL and ^E
 160             // for certain blast ids
 161           }
 162         }
 163         if (isBinary)
 164         {
 165           // jar files are special - since they contain all sorts of random
 166           // characters.
 167           if (source.inFile != null)
 168           {
 169             String fileStr = source.inFile.getName();
 170             if (fileStr.contains(".jar")
 171                     || fileStr.contains(".zip") || fileStr.contains(".jvp"))
 172             {
 173               // possibly a Jalview archive (but check further)
 174               reply = FileFormat.Jalview;
 175             }
 176           }
 177           if (!lineswereskipped && data.startsWith("PK"))
 178           {
 179             reply = FileFormat.Jalview; // archive
 180             break;
 181           }
 182         }
 183         data = data.toUpperCase(Locale.ROOT);
 184
 185         if (data.startsWith(ScoreMatrixFile.SCOREMATRIX))
 186         {
 187           reply = FileFormat.ScoreMatrix;
 188           break;
 189         }
 190         if (data.startsWith("LOCUS"))
 191         {
 192           reply = FileFormat.GenBank;
 193           break;
 194         }
 195         if (data.startsWith("ID "))
 196         {
 197           if (data.substring(2).trim().split(";").length == 7)
 198           {
 199             reply = FileFormat.Embl;
 200             break;
 201           }
 202         }
 203         if (data.startsWith("H ") && !aaIndexHeaderRead)
 204         {
 205           aaIndexHeaderRead = true;
 206         }
 207         if (data.startsWith("D ") && aaIndexHeaderRead)
 208         {
 209           reply = FileFormat.ScoreMatrix;
 210           break;
 211         }
 212         if (data.startsWith("##GFF-VERSION"))
 213         {
 214           // GFF - possibly embedded in a Jalview features file!
 215           reply = FileFormat.Features;
 216           break;
 217         }
 218         if (looksLikeFeatureData(data))
 219         {
 220           reply = FileFormat.Features;
 221           break;
 222         }
 223         if (data.indexOf("# STOCKHOLM") > -1)
 224         {
 225           reply = FileFormat.Stockholm;
 226           break;
 227         }
 228         if (data.indexOf("_ENTRY.ID") > -1
 229                 || data.indexOf("_AUDIT_AUTHOR.NAME") > -1
 230                 || data.indexOf("_ATOM_SITE.") > -1)
 231         {
 232           reply = FileFormat.MMCif;
 233           break;
 234         }
 235         // if (data.indexOf(">") > -1)
 236         if (data.startsWith(">"))
 237         {
 238           // FASTA, PIR file or BLC file
 239           boolean checkPIR = false, starterm = false;
 240           if ((data.indexOf(">P1;") > -1) || (data.indexOf(">DL;") > -1))
 241           {
 242             // watch for PIR file attributes
 243             checkPIR = true;
 244             reply = FileFormat.PIR;
 245           }
 246           // could also be BLC file, read next line to confirm
 247           data = source.nextLine();
 248
 249           if (data.indexOf(">") > -1)
 250           {
 251             reply = FileFormat.BLC;
 252           }
 253           else
 254           {
 255             // Is this a single line BLC file?
 256             String data1 = source.nextLine();
 257             String data2 = source.nextLine();
 258             int c1;
 259             if (checkPIR)
 260             {
 261               starterm = (data1 != null && data1.indexOf("*") > -1)
 262                       || (data2 != null && data2.indexOf("*") > -1);
 263             }
 264             if (data2 != null && (c1 = data.indexOf("*")) > -1)
 265             {
 266               if (c1 == 0 && c1 == data2.indexOf("*"))
 267               {
 268                 reply = FileFormat.BLC;
 269               }
 270               else
 271               {
 272                 reply = FileFormat.Fasta; // possibly a bad choice - may be
 273                                           // recognised as
 274                 // PIR
 275               }
 276               // otherwise can still possibly be a PIR file
 277             }
 278             else
 279             {
 280               reply = FileFormat.Fasta;
 281               // TODO : AMSA File is indicated if there is annotation in the
 282               // FASTA file - but FASTA will automatically generate this at the
 283               // mo.
 284               if (!checkPIR)
 285               {
 286                 break;
 287               }
 288             }
 289           }
 290           // final check for PIR content. require
 291           // >P1;title\n<blah>\nterminated sequence to occur at least once.
 292
 293           // TODO the PIR/fasta ambiguity may be the use case that is needed to
 294           // have
 295           // a 'Parse as type XXX' parameter for the applet/application.
 296           if (checkPIR)
 297           {
 298             String dta = null;
 299             if (!starterm)
 300             {
 301               do
 302               {
 303                 try
 304                 {
 305                   dta = source.nextLine();
 306                 } catch (IOException ex)
 307                 {
 308                 }
 309                 if (dta != null && dta.indexOf("*") > -1)
 310                 {
 311                   starterm = true;
 312                 }
 313               } while (dta != null && !starterm);
 314             }
 315             if (starterm)
 316             {
 317               reply = FileFormat.PIR;
 318               break;
 319             }
 320             else
 321             {
 322               reply = FileFormat.Fasta; // probably a bad choice!
 323             }
 324           }
 325           // read as a FASTA (probably)
 326           break;
 327         }
 328         if (data.indexOf("{\"") > -1)
 329         {
 330           reply = FileFormat.Json;
 331           break;
 332         }
 333         int lessThan = data.indexOf("<");
 334         if ((lessThan > -1)) // possible Markup Language data i.e HTML,
 335                              // RNAML, XML
 336         {
 337           String upper = data.toUpperCase(Locale.ROOT);
 338           if (upper.substring(lessThan).startsWith("<HTML"))
 339           {
 340             reply = FileFormat.Html;
 341             break;
 342           }
 343           if (upper.substring(lessThan).startsWith("<RNAML"))
 344           {
 345             reply = FileFormat.Rnaml;
 346             break;
 347           }
 348         }
 349
 350         if ((data.length() < 1) || (data.indexOf("#") == 0))
 351         {
 352           lineswereskipped = true;
 353           continue;
 354         }
 355
 356         if (data.indexOf("PILEUP") > -1)
 357         {
 358           reply = FileFormat.Pileup;
 359
 360           break;
 361         }
 362
 363         if ((data.indexOf("//") == 0) || ((data.indexOf("!!") > -1) && (data
 364                 .indexOf("!!") < data.indexOf("_MULTIPLE_ALIGNMENT "))))
 365         {
 366           reply = FileFormat.MSF;
 367
 368           break;
 369         }
 370         else if (data.indexOf("CLUSTAL") > -1)
 371         {
 372           reply = FileFormat.Clustal;
 373
 374           break;
 375         }
 376
 377         else if (data.indexOf("HEADER") == 0 || data.indexOf("ATOM") == 0)
 378         {
 379           reply = FileFormat.PDB;
 380           break;
 381         }
 382         else if (data.matches("\\s*\\d+\\s+\\d+\\s*"))
 383         {
 384           reply = FileFormat.Phylip;
 385           break;
 386         }
 387         else
 388         {
 389           if (!lineswereskipped && looksLikeJnetData(data))
 390           {
 391             reply = FileFormat.Jnet;
 392             break;
 393           }
 394         }
 395
 396         lineswereskipped = true; // this means there was some junk before any
 397         // key file signature
 398       }
 399       if (closeSource)
 400       {
 401         source.close();
 402       }
 403       else
 404       {
 405         source.reset(bytesRead); // so the file can be parsed from the mark
 406       }
 407     } catch (Exception ex)
 408     {
 409       System.err.println("File Identification failed!\n" + ex);
 410       throw new FileFormatException(source.errormessage);
 411     }
 412     if (trimmedLength == 0)
 413     {
 414       System.err.println(
 415               "File Identification failed! - Empty file was read.");
 416       throw new FileFormatException("EMPTY DATA FILE");
 417     }
 418     System.out.println("File format identified as " + reply.toString());
 419     return reply;
 420   }
 421
 422   /**
 423    * Returns true if the data appears to be Jnet concise annotation format
 424    *
 425    * @param data
 426    * @return
 427    */
 428   protected boolean looksLikeJnetData(String data)
 429   {
 430     char firstChar = data.charAt(0);
 431     int colonPos = data.indexOf(":");
 432     int commaPos = data.indexOf(",");
 433     boolean isJnet = firstChar != '*' && firstChar != ' ' && colonPos > -1
 434             && commaPos > -1 && colonPos < commaPos;
 435     // && data.indexOf(",")<data.indexOf(",", data.indexOf(","))) / ??
 436     return isJnet;
 437   }
 438
 439   /**
 440    * Returns true if the data has at least 6 tab-delimited fields _and_ fields 4
 441    * and 5 are integer (start/end)
 442    *
 443    * @param data
 444    * @return
 445    */
 446   protected boolean looksLikeFeatureData(String data)
 447   {
 448     if (data == null)
 449     {
 450       return false;
 451     }
 452     String[] columns = data.split("\t");
 453     if (columns.length < 6)
 454     {
 455       return false;
 456     }
 457     for (int col = 3; col < 5; col++)
 458     {
 459       try
 460       {
 461         Integer.parseInt(columns[col]);
 462       } catch (NumberFormatException e)
 463       {
 464         return false;
 465       }
 466     }
 467     return true;
 468   }
 469
 470   /**
 471    *
 472    * @param args
 473    * @j2sIgnore
 474    */
 475   public static void main(String[] args)
 476   {
 477     for (int i = 0; args != null && i < args.length; i++)
 478     {
 479       IdentifyFile ider = new IdentifyFile();
 480       FileFormatI type = null;
 481       try
 482       {
 483         type = ider.identify(args[i], DataSourceType.FILE);
 484       } catch (FileFormatException e)
 485       {
 486         System.err.println(
 487                 String.format("Error '%s' identifying file type for %s",
 488                         args[i], e.getMessage()));
 489       }
 490       System.out.println("Type of " + args[i] + " is " + type);
 491     }
 492     if (args == null || args.length == 0)
 493     {
 494       System.err.println("Usage: <Filename> [<Filename> ...]");
 495     }
 496   }
 497
 498
 499 }