protk 1.1.0.pre

data/bin/xls_to_table.rb

@@ -0,0 +1,46 @@
+#!/usr/bin/env ruby
+#
+# This file is part of protk
+# Created by Ira Cooke 18/1/2011
+#
+# Converts an Excel Spreadsheet to a tab delimited table
+#
+#
+
+require 'protk/constants'
+require 'protk/command_runner'
+require 'protk/tool'
+require 'spreadsheet'
+
+# Setup command-line options for this tool. 
+#
+tool=Tool.new({:explicit_output=>true})
+tool.option_parser.banner = "Convert an xls file to a tab delimited table.\n\nUsage: xls_to_table.rb [options] file1.xls"
+
+tool.option_parser.parse!
+
+input_file=ARGV[0]
+
+output_file=tool.explicit_output
+output_file="#{input_file}.csv" unless ( output_file != nil )
+
+output_fh = File.new(output_file,'w')
+
+
+# Open the original excel workbook for reading
+Spreadsheet.client_encoding = 'UTF-8'   
+inputBook = Spreadsheet.open "#{input_file}"
+inputSheet = inputBook.worksheet 0
+
+inputSheet.each do |row|
+  line=""
+  row.each do |colv| 
+    line << "#{colv}\t" 
+  end
+  line.chop!
+  output_fh.write "#{line}\n"
+end
+
+output_fh.close
+
+

data/ext/protk/extconf.rb

@@ -0,0 +1,3 @@
+require 'mkmf'
+
+create_makefile('protk/protk')

data/ext/protk/protk.c

@@ -0,0 +1,235 @@
+#include <ruby.h>
+
+
+/*                                                                                                 */
+/* make_random.c - make random protein sequence database using Markov chain with transitional      */
+/* probabilities from amino acid frequencies in a real database in FASTA format                    */
+/*                                                                                                 */
+/* (c) Magnus Palmblad, Division of Ion Physics, Uppsala University, Sweden, 2001-                 */ 
+/*                                                                                                 */
+/* Usage: make_random <sequence database> <number of sequences to generate> <output file>          */
+/*                                                                                                 */
+/* Example: mmpi 562.fasta 1000000 562_random_1000000.fasta                                        */
+/*                                                                                                 */
+/* Compile with gcc -o make_random make_random.c -lm                                               */
+/*                                                                                                 */
+
+#include <stdio.h>
+#include <stdlib.h>  
+#include <ctype.h>
+#include <string.h>
+#include <math.h>
+
+#define AMINO_ACIDS "ARNDCEQGHILKMFPSTWYV"
+#define NOT_AMINO_ACIDS "BJOUXZ*"
+#define MAX_SEQUENCE_LENGTH 20000
+#define MAX_LINE_LENGTH 20000 /* large enough to read in long header lines */
+
+static VALUE protk_make_decoys(VALUE self,VALUE input_file_in,VALUE db_length_in,VALUE output_file_in,char *prefix_string_in) {
+  char *input_file = RSTRING_PTR(input_file_in);
+  long sequences_to_generate = NUM2INT(db_length_in);
+  char * output_file = RSTRING_PTR(output_file_in);
+
+  char line[MAX_LINE_LENGTH];      
+  char settings_line[60][70];
+  char infile[255], outfile[255]; /* for reading input and writing output */
+  char prefix_string[255];
+  char *p,**index;
+  char *sequence; 
+  char one_sequence[MAX_SEQUENCE_LENGTH],random_sequence[(int)(MAX_SEQUENCE_LENGTH*1.5)],random_sequence_output[(int)(MAX_SEQUENCE_LENGTH*1.5)];
+  char *temp_sequence;
+  int a;
+  FILE *inp, *outp;
+
+  long i, j, k, l, n, n_sequences, protein;
+  long MP[21][MAX_SEQUENCE_LENGTH];
+  long measured_aa_freq[21], generated_aa_freq[21], measured_pl_sum=0, generated_pl_sum=0;
+  long row_sum[MAX_SEQUENCE_LENGTH],partial_sum;
+  long one_index,pl;
+  double x;
+
+  /* scanning sequence database */
+  
+  strcpy(infile,input_file);
+  if ((inp = fopen(infile, "r"))==NULL) {printf("error opening sequence database %s\n",infile);return -1;}
+  printf("scanning sequence database %s",infile);fflush(stdout);
+  i=0;n=0;k=0;
+  while (fgets(line, MAX_LINE_LENGTH, inp) != NULL) {i++; if(line[0]=='>') {if (!(n%1000)) printf(".");fflush(stdout); n++;} }
+  
+  n_sequences=n;
+
+
+  /* reading sequence database */      
+  
+  temp_sequence=(char*)calloc(sizeof(char),MAX_SEQUENCE_LENGTH);
+  sequence=(char*)malloc(sizeof(char)*(i*80)); /* allocate enough memory for 80 characters per line in FASTA database */
+  index=(char**)malloc(sizeof(char*)*n_sequences);
+  index[0]=sequence; /* set first index pointer to beginning of first database sequence */
+  
+  if ((inp = fopen(infile, "r"))==NULL) {printf("error opening sequence database %s\n",infile);return -1;}
+
+  printf("done\nreading sequence database %s",infile);fflush(stdout);    
+  n=-1;
+  strcpy(temp_sequence,"\0");
+  while (fgets(line, MAX_LINE_LENGTH, inp) != NULL)
+  { 
+    if (strcmp(line,"\n")==0) {
+      continue;
+    }
+    if (line[0]=='>') { 
+      if (n>=0) { 
+        if (!(n%1000)&&n>0) { 
+          printf(".");fflush(stdout);
+        }
+        strcpy(index[n],temp_sequence);
+        n++; index[n]=index[n-1]+sizeof(char)*strlen(temp_sequence);
+        strcpy(temp_sequence,"\0");
+      }
+      else 
+      {
+        n++;
+        strcpy(temp_sequence,"\0");
+      }
+    }
+    else 
+    {
+      if ( (strlen(temp_sequence)+strlen(line))>=MAX_SEQUENCE_LENGTH ) continue; 
+      strncat(temp_sequence,line,strlen(line)-1);
+    }   
+  }
+
+  strcpy(index[n],temp_sequence);
+  fclose(inp);
+
+  n_sequences=n+1;
+
+  printf("done [read %li sequences (%li amino acids)]\n",n_sequences,(int)(index[n_sequences-1]-index[0])/sizeof(char)+strlen(temp_sequence));fflush(stdout);
+  measured_pl_sum=(int)(index[n_sequences-1]-index[0])/sizeof(char)+strlen(temp_sequence);
+
+
+
+  /* generating Markov probabilities */
+
+  printf("generating Markov probability matrix...");fflush(stdout);
+
+  srand(time(0)); /* replace with constant to re-generate identical random databases */
+
+  for(i=0;i<MAX_SEQUENCE_LENGTH;i++) {
+    for(j=0;j<=20;j++) {
+      MP[j][i]=0;
+    }
+  }
+  for(j=0;j<=20;j++) {
+    measured_aa_freq[j]=0;generated_aa_freq[j]=0;
+  }
+
+  for(protein=0;protein<n_sequences;protein++)
+  {
+    if (!(protein%1000)) {printf(".");fflush(stdout);}
+    if (protein<(n_sequences-1)) 
+    {
+     strncpy(one_sequence,index[protein],(index[protein+1]-index[protein])/sizeof(char));
+     one_sequence[(index[protein+1]-index[protein])/sizeof(char)]='\0';
+   }
+   else strcpy(one_sequence,index[protein]);
+   pl=strlen(one_sequence);
+   n=1;one_index=0;
+
+   for(i=0;i<pl;i++)
+   {
+     if(strpbrk(NOT_AMINO_ACIDS,(const char *)&one_sequence)==NULL)
+     {
+      if ( strchr(AMINO_ACIDS,one_sequence[i])==NULL)
+      {
+        printf("Unknown amino acid %c",one_sequence[i]);                
+      } else {
+                a=20-strlen(strchr(AMINO_ACIDS,one_sequence[i])); // current amino acid
+                MP[a][i]++;
+                measured_aa_freq[a]++;
+      }
+  }
+	  else {a=floor(20*(float)rand()/RAND_MAX);MP[a][i]++; measured_aa_freq[a]++;} // replace B, X, Z etc. with random amino acid to preserve size distribution
+  }
+  MP[20][pl]++;
+      measured_aa_freq[20]++; // MP[20][n] is the number of sequences of length n in the database 
+    }
+    printf("done\n"); fflush(stdout);
+
+  
+
+  for(i=0;i<MAX_SEQUENCE_LENGTH;i++) row_sum[i]=0;
+    for(i=0;i<MAX_SEQUENCE_LENGTH;i++) for(j=0;j<=20;j++) row_sum[i]+=MP[j][i];
+
+
+  /* generate random protein sequences through Markov chain */
+
+      strcpy(outfile,output_file);
+    if ((outp = fopen(outfile, "w"))==NULL) {printf("error opening output file %s\n",outfile); return -1;}
+    printf("generating %li random protein sequences",sequences_to_generate);fflush(stdout);
+
+    strcpy(prefix_string,RSTRING_PTR(prefix_string_in));
+
+    for(protein=0;protein<sequences_to_generate;protein++)
+    {
+      if (!(protein%1000)) {printf(".");fflush(stdout);}
+      i=0; j=0;
+      while (1)
+      {
+       x=(double)row_sum[j]*((double)rand()/RAND_MAX);
+       partial_sum=MP[0][j]; i=1;
+       while (partial_sum<x) {partial_sum+=MP[i][j]; i++;}
+	  if (j>=MAX_SEQUENCE_LENGTH) i=21; /* terminate when sequence has reached MAX_SEQUENCE_LENGTH */
+       if (i<21)
+       {
+         random_sequence[j]=AMINO_ACIDS[i-1];j++;generated_aa_freq[i-1]++;
+       }
+	  else /* i==21, i.e. protein sequence terminated */
+       {
+         k=0; generated_aa_freq[20]++; generated_pl_sum+=j;
+         for(l=0;l<j;l++) 
+         {
+          random_sequence_output[k]=random_sequence[l]; k++;
+          if (!((k+1)%61))
+          {
+            random_sequence_output[k]='\n'; k++;
+          }
+        }
+
+        random_sequence_output[k]='\0';
+	      if (!(k%61)) random_sequence_output[k-1]='\0'; /* remove extra newline for sequence length multiple of 60 */
+        fprintf(outp,">%srp%li\n%s\n",prefix_string,protein,random_sequence_output);
+        break;
+      }
+    }
+  }
+  
+  fclose(outp);
+
+
+  /* freeing some memory... */
+
+  free(index);  
+  
+  printf("done (wrote %li random protein sequences to %s)\n",sequences_to_generate,outfile);
+
+  k=0;l=0;
+  for(i=0;i<=20;i++) {k+=measured_aa_freq[i];l+=generated_aa_freq[i];}
+    printf("<f(aa) in %s> <f(aa) in %s>\n",infile,outfile);
+  for(i=0;i<=20;i++) printf("%f %f\n",(float)measured_aa_freq[i]/k,(float)generated_aa_freq[i]/l);
+    printf("<average sequence length in %s> = %f\n<average sequence length in %s> = %f\n",infile,measured_pl_sum/(float)n_sequences,outfile,generated_pl_sum/(float)sequences_to_generate);
+
+  return 0;
+
+}
+
+  /* ruby calls this to load the extension */
+void Init_protk(void) {
+  /* assume we haven't yet defined Hola */
+  VALUE klass = rb_define_class("Protk",
+    rb_cObject);
+
+  /* the hola_bonjour function can be called
+   * from ruby as "Hola.bonjour" */
+  rb_define_singleton_method(klass,
+    "make_decoys", protk_make_decoys, 4);
+}

data/lib/protk/big_search_rakefile.rake

@@ -0,0 +1,16 @@
+require 'protk/constants'
+
+$genv=Constants.new()
+
+ARGV.each do |fname| 
+
+	file fname do
+		puts fname
+	end
+
+	multitask :run => fname
+
+end
+
+
+task :default => :run

data/lib/protk/big_search_tool.rb

@@ -0,0 +1,23 @@
+# create rake dependencies
+# run rakefile
+#
+require 'optparse'
+require 'pathname'
+require 'protk/tool'
+require 'protk/command_runner'
+require 'pp'
+require 'rake'
+
+class BigSearchTool < Tool
+
+  def run input_files
+	command = "rake -f #{rakefile_path} #{input_files.join(" ")}"
+	runner=CommandRunner.new(Constants.new)
+    runner.run_local(command)
+  end
+
+  def rakefile_path
+    "#{File.dirname(__FILE__)}/big_search_rakefile.rake"
+  end
+
+end

data/lib/protk/bio_sptr_extensions.rb

@@ -0,0 +1,210 @@
+# Add methods to the Bio::SPTR class to retrieve objects using the keys defined in proteinannotator.rb
+#
+# newColumnKeys=['recname','cd','altnames','accessions','location','function','ipi','intact','pride','ensembl','refsMASS SPEC','refsNUCLEOTIDE SEQUENCE','refsX-RAY CRYSTALLOGRAPHY','refs3D-STRUCTURE MODELLING','refsPROTEIN SEQUENCE','refsGLYCOSYLATION','glycosites']
+#
+#
+
+## We start the columns off with the header name
+#newColumns={'recname'=>["Primary Name"],'cd'=>["CD Antigen Name"],'altnames'=>["Alternate Names"], 
+#  'accessions' =>["Swissprot Accessions"],
+#  'location' => ["Subcellular Location"],
+#  'function' => ["Known Function"],
+#  'ipi' => ["IPI"],
+#  'intact' => ["Interactions"],
+#  'pride' => ['Pride'],
+#  'ensembl'=> ['Ensembl'],
+#  'refsMASS SPEC'=>["MS Refs"], 
+#  'refsGLYCOSYLATION'=>["Glyco Refs"], 
+#  'refsNUCLEOTIDE SEQUENCE'=>["Nucleotide Refs"], 
+#  'refsX-RAY CRYSTALLOGRAPHY'=>["Crystallography Refs"],
+#  'refs3D-STRUCTURE MODELLING'=>["3D-Modelling Refs"],
+#  'refsPROTEIN SEQUENCE'=>["Protein sequence Refs"],
+#  'glycosites'=>["Glycosylation Sites"]    
+#}
+require 'rubygems'
+require 'bio'
+
+class Bio::SPTR < Bio::EMBLDB
+
+  #
+  # Functions corresponding to retrieving data for specific keys
+  #  
+
+  # The recommended name for the Protein
+  #
+  def recname
+    pname_field=self.de
+    entries=pname_field.split(";")
+    entries.each do |entry|
+      m=entry.match(/\s*(.*?):\s*(.*?)=(.*)/)
+      if ( m!=nil)
+        if ( m[1]=="RecName")
+          return m[3]
+        end
+      end
+    end   
+    return ""
+  end
+  
+  # The CD Antigen name
+  #
+  def cd
+    pname_field=self.de
+    entries=pname_field.split(";")
+    entries.each do |entry|
+      m=entry.match(/\s*(.*?):\s*(.*?)=(.*)/)
+      if ( m!=nil)
+        if ( (m[1]=="AltName") && (m[2]=="CD_antigen") )
+          return m[3]
+        end
+      end
+    end
+    
+    return ""
+  end
+
+  # All alternate names
+  #
+  def altnames
+    altnames=""
+    
+    pname_field=self.de
+    entries=pname_field.split(";")
+    entries.each do |entry|
+      m=entry.match(/\s*(.*?):\s*(.*?)=(.*)/)
+      if ( m!=nil)
+        if ( (m[1]=="AltName") && (m[2]!="CD_antigen") )
+          altnames << "#{m[3]}; "
+          
+        end
+      end
+    end
+    
+    if ( altnames!="") # Get ride of extraneous "; "
+      altnames.chop!.chop!
+    end
+    
+    return altnames
+  end
+  
+  # SwissProt Accessions
+  #
+  def accessions 
+    return ""
+  end
+
+  # Subcellular Location
+  #
+  def location
+    return self.cc["SUBCELLULAR LOCATION"].to_s
+  end
+
+  # Function
+  #
+  def function
+    return self.cc["FUNCTION"].to_s    
+  end
+
+  # Similarity
+  #
+  def similarity
+    return self.cc["SIMILARITY"].to_s    
+  end
+  
+  # Tissue Specificity
+  #
+  def tissues
+    return self.cc["TISSUE SPECIFICITY"].to_s
+  end
+  
+  # Disease
+  #
+  def disease
+    return self.cc["DISEASE"].to_s
+  end
+
+  # Subunit
+  def subunit
+    return self.cc["SUBUNIT"].to_s
+  end
+
+  # Domain
+  def domain
+    return self.cc["DOMAIN"].to_s
+  end
+  
+  # 
+  # Getting dr entry
+  # 
+
+  # Helper Function to create links
+  #
+  def safely_get_drentry_for_key(key)
+    if ( self.dr[key]==nil)
+      return ""
+    end
+
+    return dr[key][0][0]
+  end
+
+  # IPI Accession number
+  # 
+  def ipi
+    return self.safely_get_drentry_for_key("IPI")
+  end
+  
+  # Intact accession number
+  #
+  def intact
+    return self.safely_get_drentry_for_key("PRIDE")    
+  end
+
+  # Pride accession number
+  #
+  def pride
+    return self.safely_get_drentry_for_key("PRIDE")
+  end
+  
+  # Ensembl accession number
+  #
+  def ensembl
+    return self.safely_get_drentry_for_key("Ensembl")
+  end
+  
+  # NextBIO accession number
+  #
+  def nextbio
+    return self.safely_get_drentry_for_key("NextBio")
+  end
+  
+  
+  # Number of transmembrane regions
+  #
+  def num_transmem
+    begin
+      if ( self.ft["TRANSMEM"]==nil)
+        return 0.to_s
+      else
+        return self.ft["TRANSMEM"].length.to_s
+      end
+    rescue
+      p "Warning: Unable to parse feature table for entry #{self.accession}"
+    end
+  end
+
+
+  # Number of signal peptide features
+  #
+  def signalp
+    begin
+      if ( self.ft["SIGNAL"]==nil)
+        return 0.to_s
+      else
+        return self.ft["SIGNAL"].length.to_s
+      end
+    rescue
+      p "Warning: Unable to parse feature table for entry #{self.accession}"      
+    end
+  end
+  
+end

data/lib/protk/biotools_excel_converter.rb

@@ -0,0 +1,60 @@
+require 'rubygems'
+require 'spreadsheet'
+
+
+class BioToolsExcelConverter 
+  
+  def initialize(filename)
+    @inputBook = Spreadsheet.open File.new("#{filename}")
+  end
+  
+  def self.isBiotools(filename)
+    testBook = Spreadsheet.open File.new("#{filename}")
+    testSheet = testBook.worksheet 0
+    
+    isbiotools=FALSE
+    testSheet.each do |row|
+      if  (row[0].class==String) && row[0].match(/Digest Matches.*?Score:\s(.*)\)/)   
+        isbiotools=TRUE
+      end
+    end
+    
+    
+    isbiotools
+  end
+  
+  def get_rows
+    
+    sheet=@inputBook.worksheet 0
+    
+    protein_rows=[]
+
+    n_rows=sheet.dimensions[1]
+
+    protein_rows=(0...n_rows).collect do |row_i|      
+      new_row=nil
+      
+      row=sheet.row row_i      
+      if ( row[0]!=nil)
+        digmatch=row[0].match(/Digest Matches.*?Score:\s(.*)\)/)
+        if  ( digmatch!=nil )
+          new_row=[]          
+          text= sheet.row(row_i-1)[0] 
+          m=text.match(/\s(\S*)\s*$/)
+          throw "Badly formed protein line in biotools file ... could not parse protein name from #{text}" unless m!=nil
+          new_row[0]=m[1]
+          new_row[1]=digmatch[1]
+        end
+      end
+      
+      new_row
+    end
+    
+    protein_rows.compact!
+    protein_rows.insert(0,["Accession","Ion Scores"])
+    
+    protein_rows
+    
+  end
+  
+end

data/lib/protk/command_runner.rb

@@ -0,0 +1,84 @@
+#
+# This file is part of protk
+# Created by Ira Cooke 15/12/2010
+#
+# Runs system commands and provides methods for monitoring output
+#
+
+
+require 'open4'
+require 'protk/constants'
+
+class CommandRunner  
+  
+  # The protk environment in which to run commands
+  #
+  attr :env
+  
+  
+  
+  
+  def initialize(environment)
+    @env=environment
+  end
+  
+  
+  
+  
+  # Runs the given command in a local shell
+  #
+  def run_local(command_string)
+    @env.log("Command: #{command_string} started",:info)
+    status = Open4::popen4("#{command_string} ") do |pid, stdin, stdout, stderr|
+      puts "PID #{pid}" 
+      
+      stdout.each { |line| @env.log(line.chomp,:info) }
+
+      stderr.each { |line| @env.log(line.chomp,:warn) }
+
+    end
+    if ( status!=0 )
+      # We terminated with some error code so log as an error
+      @env.log( "Command: #{command_string} exited with status #{status.to_s}",:error)
+    else
+      @env.log( "Command: #{command_string} exited with status #{status.to_s}",:info)      
+    end
+    status     
+  end
+  
+  
+  
+  
+  # Runs the given command as a background job
+  # At present this sends the job to a PBS system, but in future we might support other types of background jobs
+  #
+  def run_batch(command_string,job_params,jobscript_path,autodelete)
+    @env.log("Creating batch file for command: #{command_string}",:info)
+
+    if ( autodelete )
+  #    command_string<<";rm #{jobscript_path}"
+    end
+
+    jobid=job_params[:jobid]
+    if ( job_params[:vmem]==nil)
+      job_params[:vmem]="900mb"
+    end
+    if (job_params[:queue] ==nil )
+      job_params[:queue]="lowmem"
+    end
+
+    job_script="#!/bin/bash
+    #PBS -N #{jobid}
+    #PBS -e pbs.#{jobid}.err 
+    #PBS -o pbs.#{jobid}.log
+    #PBS -l nodes=1:ppn=1,vmem=#{job_params[:vmem]}
+    #PBS -q #{job_params[:queue]}
+    #{command_string}"
+
+    p File.open(jobscript_path, 'w') {|f| f.write(job_script) }
+
+    self.run_local("qsub #{jobscript_path}")
+    
+  end
+  
+end