sequenceserver 0.8.3 → 0.8.4

data/lib/blast.rb~

@@ -0,0 +1,200 @@
+require 'tempfile'
+require 'open3'
+
+module SequenceServer
+  # Simple ncbi-blast wrapper. Check examples below.
+  class Blast
+    # blast method
+    attr_accessor :method
+
+    # database name
+    attr_accessor :db
+
+    # query sequence string
+    attr_accessor :qstring
+
+    # query file name
+    attr_accessor :qfile
+
+    # advanced blast options
+    attr_accessor :options
+
+    # command string to be executed
+    attr_reader   :command
+
+    # result of executing command
+    attr_reader   :result
+
+    # blast archive file output
+    attr_reader   :blast_archive_tempfile
+
+    # errors if any while executing command
+    attr_reader   :error
+
+    # Initialize a new blast search.
+    # ---
+    # Arguments(optional):
+    # * method(String)  - blast executable (shell executable, or absolute path)
+    # * db(String)      - database name as returned by 'blastdbcmd -list'
+    # * query(Hash)     - query string/file, and options.
+    #
+    # In the query Hash, use:
+    # * :qfile(String)   - to run Blast against a file.
+    # * :qstrin(String)  - to run Blast against a string.
+    # * :options(String) - to specify multiple blast options.
+    #
+    # Either :qfile, or :qstring should be used. If both are given, by design
+    # :qstring will be used to run blast.
+    # ---
+    # Examples:
+    #
+    #   b = Blast.new("blastn", "S.cdna.fasta", :qfile => 'query.seq', :options => "-html -num_threads 4")
+    #   b = Blast.new("blastn", "S.cdna.fasta", :qstring => 'ATGTCCGCGAATCGATTGAACGTGCTGGTGACCCTGATGCTCGCCGTCGCGCTTCTTGTG')
+    #
+    #   b.run!        => true
+    #   b.result      => "blast output"
+    #
+    #   # change the blast method.
+    #   b.method = 'blastp'
+    #
+    #   b.run!        => false
+    #   b.error       => "blast error output"
+    def initialize(method = nil, db = nil, query = {})
+      @method  = method
+      @db      = db
+      @qstring = query[:qstring]
+      @qfile   = query[:qfile]
+      @options = query[:options]
+    end
+
+    # Run blast everytime it is called. Returns the success
+    # status - true, or false. Blast method, db, and qfile/qstring
+    # need to be set before calling this method, else blast will fail.
+    #
+    #   b = Blast.new
+    #   b.run!   => false
+    #
+    #   # set blast method, and db
+    #   b.method = 'blastn'
+    #   b.db     = 'S.cdna.fasta'
+    #
+    #   b.run!   => false
+    #   b.errors => "blast error output"
+    #
+    #   # set qfile
+    #   b.qfile  = 'query1.seq'    
+    #
+    #   b.run!   => true
+    #   b.reuslt => "blast output"
+    def run!
+      # can not run blast if method is not specified
+      return false unless @method
+
+      # create a tempfile if qstring is given
+      if @qstring
+      @tempfile = Tempfile.new('qfile')
+      @tempfile.puts(qstring)
+      @tempfile.close
+      @qfile    = @tempfile.path
+      end
+
+      # form command to execute
+      @command = to_s
+
+      # execute command and capture both stdout, and stderr
+      Open3.popen3(@command) do |stdin, stdout, stderr|
+      @result = stdout.readlines # convert to string?
+      @error  = stderr.readlines
+      end
+
+      # set and return success status
+      return @success = @error.empty?
+
+    ensure
+      # delete tempfile if it was created
+      @tempfile.unlink if @tempfile
+    end
+
+    # Return the blast type used as a String.
+    #
+    #   b.method = '/home/yeban/opt/blastn'
+    #   b.type   => 'blastn'
+    def type
+      @type ||= @method[(@method.rindex('/') + 1)..-1]
+    end
+
+    # Return success status - true, false, or nil.
+    # 'nil' implies that blast has not been run yet.
+    def success?
+      @success
+    end
+
+    # String representation of the blast object - same as
+    # the command to be executed.
+    def to_s
+      s = "#@method "
+      s << "-db '#@db' " if @db
+      s << "-query #@qfile " if @qfile
+      s << @options.to_s if @options
+      s
+    end
+
+    # Especially helpful in irb - "status : command"
+    def inspect
+      return to_s if success?.nil?
+      (success? ? "success : " : "fail : ") + @command
+    end
+
+    # Run the blast with the options specified by the user, returning a blast archive file, which can be further transformed into other formats
+    def run_to_blast_archive!
+      @blast_archive_tempfile = Tempfile.open('seqserve_formatter')
+
+      # Add -outfmt 11 to list of options so that it outputs a blast archive
+      @options ||= ''
+      @options += " -outfmt 11 -out #{@blast_archive_tempfile.path}"
+
+      # Run the blast
+      run!
+      return @success unless @success
+    end
+
+    # convert the blast archive to a regular HTML result, stored
+    # as an instance variable Blast#result
+    def convert_blast_archive_to_html_result(blast_formatter_path)
+      @command = "#{blast_formatter_path} -archive #{blast_archive_tempfile.path} -html"
+
+      # execute command and capture both stdout, and stderr
+      Open3.popen3(@command) do |stdin, stdout, stderr|
+      @result = stdout.readlines # convert to string?
+      @error  = stderr.readlines
+      end
+    end
+
+    class << self
+      # shortcut method to run blast against a query file
+      def blast_file(method, db, qfile, options = nil)
+        b = Blast.new(method, db, :qfile => qfile, :options => options)
+        b.run!
+        b
+      end
+
+      # shortcut method to run blast against a query string
+      def blast_string(method, db, qstring, options = nil)
+        b = Blast.new(method, db, :qstring => qstring, :options => options)
+        b.run!
+        b
+      end
+
+      # shortcut method to run blast with a query string and return a
+      # blast archive, which can then be further processed into other useful
+      # output forms (e.g. HTML, GFF). If it ran successfully, the blast archive
+      # is a Tempfile accessible as an instance variable of the returned
+      # Blast object.
+      def blast_string_to_blast_archive(method, db, qstring, options = nil)
+        b = Blast.new(method, db, :qstring => qstring, :options => options)
+        b.run_to_blast_archive!
+        b
+      end
+    end
+  end
+end

data/lib/sequenceserver/database_formatter.rb~

@@ -0,0 +1,190 @@
+# copyright yannick . wurm at unil . ch
+# Finds files, reads first char. if its '>', read 500 lines. Guess sequence type, ask user for title to format as blast database.
+
+# TODO: bring it under SequenceServer namespace
+# TODO: move the file to a 'command/' sub-directory (probably makes more sense if we have several subcommands)
+# TODO: needs more love (read refactoring) overall
+
+require 'ptools' # for File.binary?(file)
+require 'find'
+require 'logger'
+require 'optparse'
+require 'sequenceserver'
+require 'sequenceserver/helpers.rb'
+require 'sequenceserver/sequencehelpers.rb'
+
+LOG = Logger.new(STDOUT)
+LOG.level = Logger::INFO
+
+class DatabaseFormatter
+    include SequenceServer
+	include Helpers
+    include SystemHelpers
+    include SequenceHelpers
+    
+    attr_accessor :db_path
+
+    def initialize(db_path = nil)
+      @app = SequenceServer::App
+      @app.config = @app.parse_config
+      @app.binaries = @app.scan_blast_executables(@app.bin).freeze
+
+      @db_path = (db_path or @app.database)
+    end
+
+    def format_databases
+      unless File.directory?(db_path)
+        LOG.fatal("Database directory #{db_path} not found. See './database_formatter --help' for instructions.")
+        exit
+      end
+
+        formatted_dbs = %x|#{@app.binaries['blastdbcmd']} -recursive -list #{db_path} -list_outfmt "%f" 2>&1|.split("\n")
+        commands = []
+        Find.find(db_path) do |file|
+            LOG.debug("Assessing file #{file}..")
+            if File.directory?(file)
+              LOG.debug("Ignoring file #{file} since it is a directory")
+              next
+            end
+            if formatted_dbs.include?(file)
+              LOG.debug("Ignoring file #{file} since it is already a blast database")
+              next
+            end
+            if File.binary?(file)
+              LOG.debug("Ignoring file #{file} since it is a binary file, not plaintext as FASTA files are")
+              next
+            end
+
+                if probably_fasta?(file)
+                    LOG.info("Found #{file}")
+                    ## guess whether protein or nucleotide based on first 500 lines
+                    first_lines = ''
+                    File.open(file, 'r') do |file_stream|
+                        file_stream.each do |line|
+                            first_lines += line
+                            break if file_stream.lineno == 500
+                        end
+                    end
+                    begin
+                        sequence_type = type_of_sequences(first_lines) # returns :protein or :nucleotide
+                    rescue
+                        LOG.warn("Unable to guess sequence type for #{file}. Skipping") 
+                    end
+                    if [ :protein, :nucleotide ].include?(sequence_type)
+                        command = ask_make_db_command(file, sequence_type)
+                        unless command.nil?
+                            commands.push(command)
+                        end
+                    else 
+                        LOG.warn("Unable to guess sequence type for #{file}. Skipping") 
+                    end
+                else
+                  LOG.debug("Ignoring file #{file} since it was not judged to be a FASTA file.")
+                end
+        end
+        LOG.info("Will now create DBs")
+        if commands.empty?
+          puts "", "#{db_path} does not contain any unformatted database."
+          exit
+        end
+        commands.each do |command|
+			LOG.info("Will run: " + command.to_s)
+            system(command)
+        end
+        LOG.info("Done formatting databases. ")
+        db_table(db_path)
+    end
+
+    def db_table(db_path)
+        LOG.info("Summary of formatted blast databases:\n")
+        output = %x|#{@app.binaries['blastdbcmd']} -recursive -list #{db_path} -list_outfmt "%p %f %t" &2>1 |
+        LOG.info(output)
+    end
+
+    def probably_fasta?(file)
+		return FALSE if File.zero?(file)
+        File.open(file, 'r') do |file_stream|
+            first_line = file_stream.readline
+            if first_line.slice(0,1) == '>'
+                return TRUE
+            else 
+                return FALSE
+            end
+        end
+    end
+
+
+    # returns command than needs to be run to make db
+    def ask_make_db_command(file, type)
+        LOG.info("FASTA file: #{file}")
+        LOG.info("Fasta type: " + type.to_s)
+        
+        response = ''
+        until response.match(/^[yn]$/i) do
+            LOG.info("Proceed? [y/n]: ")
+            response = STDIN.gets.chomp
+        end
+
+        if response.match(/y/i)
+            LOG.info("Enter a database title (or will use '#{File.basename(file)})'")
+            title = STDIN.gets.chomp
+			title.gsub!('"', "'")
+            title = File.basename(file)  if title.empty?
+            
+            return make_db_command(file,type,title)
+        end
+    end
+
+    def make_db_command(file,type, title)
+        LOG.info("Will make #{type.to_s} database from #{file} with #{title}")
+        command = %|#{@app.binaries['makeblastdb']} -in #{file} -dbtype #{ type.to_s.slice(0,4)} -title "#{title}" -parse_seqids|
+        LOG.info("Returning: #{command}")
+        return(command)
+    end
+end
+
+OptionParser.new do |opts|
+  opts.banner =<<BANNER
+
+SUMMARY
+
+  prepare BLAST databases for SequenceServer
+
+USAGE
+
+  sequenceserver format-databases [--verbose] [blast_database_directory]
+
+  Example:
+
+    $ sequenceserver format-databases ~/db  # explicitly specify a database directory
+    $ sequenceserver format-databases      # use the database directory in config.yml
+
+DESCRIPTION
+
+  Recursively scan the given 'blast_database_directory' for BLAST databases and
+  formats them for use with SequenceServer.
+
+  It automagically detects the database type, and ignores non-db files and
+  pre-formatted databases. The 'parse_seqids' makeblastdb options is used.
+
+  'blast_database_directory' can be passed as a command line parameter or
+  through a configuration file by setting the 'database' key (the same option
+  used by SequenceServer). Configuration file will be checked only if the
+  command line parameter is missing.
+
+OPTIONS
+
+BANNER
+
+  opts.on_tail('-h', '--help', 'Show this message') do
+    puts opts
+    exit
+  end
+
+  opts.on('-v', '--verbose', 'Print lots of output') do
+    LOG.level = Logger::DEBUG
+  end
+end.parse!
+
+app = DatabaseFormatter.new(ARGV[0])
+app.format_databases

data/public/css/beige.css.css

@@ -0,0 +1,254 @@
+body {
+	background-color: #2B3E42;
+	/*background: #3f4555;*/
+	font-family: Tahoma, Arial, sans-serif;
+}
+
+.container {
+	width: 800px;  
+	margin: 50px auto;
+	background-color: white;
+	border: 2px solid white;
+	border-radius: 10px;
+	-moz-border-radius: 10px;
+}
+
+h1 {
+    margin: 0px;
+	padding: 0px;
+}
+
+.banner {
+	font-weight: bold;
+	background: #ebcd7b;
+	font-size: 300%;
+	font-family: Tahoma, Arial, sans-serif;
+	color: black;
+	padding: 2%;
+	margin-bottom: 2%;
+
+	border-bottom-left-radius: 0px;
+	border-bottom-right-radius: 0px;
+	border-top-left-radius: 10px;
+	border-top-right-radius: 10px;
+
+	-moz-border-radius-bottomleft: 0px;
+	-moz-border-radius-bottomright: 0px;
+	-moz-border-radius-topleft: 10px;
+	-moz-border-radius-topright: 10px;
+
+}
+
+.underbar { 
+	background-color: #ebcd7b; 
+	font-family:arial;
+	font-size: 12px;
+	text-align: center;
+	color: #333333;
+	padding: 1px 1px 1px 1px;
+	margin: 2% 0 0 0;
+	border-bottom-left-radius: 10px;
+	border-bottom-right-radius: 10px;
+}
+
+
+.entryfield {
+	padding:0;
+	margin:0;
+}
+
+.entryfield textarea {
+	padding:0;
+	margin:0;
+	width:100%;
+	height: 168px;
+	border-color:black;
+}
+
+.blastmethods {
+	float					: right;
+	background				: #222222;
+	border					: none;
+	height                  :  150px;
+
+	border-top-right-radius	: 10px;
+	border-top-left-radius	: 0px;
+	border-bottom-right-radius: 10px;
+	border-bottom-left-radius	:  0px;
+
+	-moz-border-radius-topright: 10px;
+	-moz-border-radius-topleft: 0px;
+	-moz-border-radius-bottomright: 10px;
+	-moz-border-radius-bottomleft:  0px;
+
+
+	font-size					: 1.5em; 
+	font-family: Tahoma, Arial, sans-serif; 
+	color: black;
+	margin:0;
+	padding:0;
+}
+
+fieldset {
+	margin:0;
+	padding:0;
+}
+
+.horizontal {
+	margin: 2%;
+	padding-bottom:15px;
+	padding-top:15px;
+	width: 96%;
+	clear:both;
+}
+
+.rounded {
+	border-radius  :10px;
+	-moz-border-radius:10px;
+}
+
+.box {
+	background  : #D5E1DD;
+	/* background: -webkit-gradient(linear, left top, left bottom, from(#ccc), to(#000));   */
+
+	border      : none;
+
+	padding     : 10px;
+	margin: 0;
+	font-family : Tahoma, Arial, sans-serif;
+	color       : black;
+}
+
+.databases {
+	width       :46.5%;
+}
+.nucleotide {
+	float    :left;
+}
+.protein {
+	float    : right;
+}
+
+.radiobutton{
+	margin: 9px 5px 0px 0px;
+	padding: 0;
+	vertical-align: top;
+}
+.dbcheckbox {   /* within each "database box" */
+float:left;
+clear:both;
+margin: 5px 10px 0 0;
+padding: 0;
+}
+.dbdescription {
+	float:left;
+}
+
+.advanced {
+	float:left;
+	width: 78%;
+}
+
+.greytext {
+  color: #A9A9A9;
+}
+
+.pointer {
+	cursor:pointer;
+}
+
+.advanced pre {
+	display: none;
+}
+.advanced input {
+	float:right;
+	width: 60%;
+}
+
+.submit_button {
+	float:right;
+	width: 17.5%;
+}
+.submit_button input {
+	width: 100%;
+	background-color	: #323292;
+	background: -webkit-gradient(linear, left top, right bottom, from(#0066CC), to(#192D53));
+	background: -moz-linear-gradient(45deg,#0066CC,#192D53);
+
+	border			: 2px solid #192D53;
+	border-radius		: 10px;
+	-moz-border-radius: 10px;
+	color				: white;
+	padding			: 2.5px 10px 2.5px 10px;
+	cursor			: pointer;
+	font-size			: 1.8em;
+	font-family		: Tahoma, Arial, sans-serif;
+	margin: 0 0 0 0;
+
+}
+.submit_button input:active {
+	color: #1f2126;
+
+}
+.submit_button input:hover {
+	background: -webkit-gradient(linear, left top, right bottom, from(#009cff), to(#0261c2));
+	background: -moz-linear-gradient(45deg,#009cff,#0261c2);
+
+}
+
+h2, .bigtext{
+	font-family: Tahoma, Arial, serif;
+	font-weight: bold;
+	font-size: 20px;
+	color: black;
+	margin:0;
+	padding: 0px;
+	/*	margin: 8px 0 10px 0;*/
+}
+
+h3{
+	font-family: Tahoma, Arial, serif;
+	font-weight: bold;
+	font-size: 16px;
+	color: black;
+	margin:0;
+	padding: 0px;
+	/*	margin: 8px 0 10px 0;*/
+}
+
+.smalltext{
+	font-size:10px;
+}
+
+
+#result{
+	clear:both;
+	background-color: white;
+}
+.result_even_true{
+	background-color: #ffe0f9;
+   margin: 0 18px 0 18px;
+	border-radius  :10px;
+	-moz-border-radius:10px;
+	padding-left: 3%;
+	padding-top: 3%;
+}
+.result_even_false{
+	background-color: #dfefe6;
+	margin: 0 18px 0 18px;
+	border-radius  :10px;
+	-moz-border-radius:10px;
+	padding-left: 3%;
+	padding-top: 3%;
+}
+.blast_result{
+	font-family: "Lucida Console", Lucida, monospace;
+	background-color: #A9A9A9;
+	border-radius  :10px;
+	-moz-border-radius:10px;
+	padding-left: 2%;
+}
+
+a {
+    color: #b22222;
+}