Bio::Tools::Analysis::Protein::NetPhos - a wrapper around NetPhos server

  use Bio::Tools::Analysis::Protein::NetPhos;

  my $seq; # a Bio::PrimarySeqI object
  my $threshold  = "0.90";

  my $netphos = Bio::Tools::Analysis::Protein::NetPhos->new
     ( -seq => $seq,
       -threshold => $threshold );

  # run NetPhos prediction on a sequence
  my $netphos->run();

  # alternatively you can say
  $netphos->seq($seq)->threshold($threshold)->run;

  die "Could not get a result" unless $netphos->status =~ /^COMPLETED/;

  print $netphos->result;     # print raw prediction to STDOUT

  foreach my $feat ( $netphos->result('Bio::SeqFeatureI') ) {

      # do something to SeqFeature
      # e.g. print as GFF
      print $feat->gff_string, "\n";
      # or store within the sequence - if it is a Bio::RichSeqI
      $seq->add_SeqFeature($feat)

 }

  bioperl-l@bioperl.org                  - General discussion
  http://bioperl.org/wiki/Mailing_lists  - About the mailing lists

  https://redmine.open-bio.org/projects/bioperl/

 Name    : result
 Usage   : $job->result (...)
 Returns : a result created by running an analysis
 Args    : none (but an implementation may choose
           to add arguments for instructions how to process
           the raw result)

 Usage   : $job->threshold(...)
 Returns  : The significance threshold of a prediction
 Args     : None (retrieves value) or a value beween 0 and 1.
 Purpose  : Get/setter of the threshold to be sumitted for analysis.

#
# BioPerl module for Bio::Tools::Analysis::Protein::NetPhos
#
# Please direct questions and support issues to <bioperl-l@bioperl.org> 
#
# Cared for by Heikki Lehvaslaiho <heikki-at-bioperl-dot-org>
#
# Copyright Richard Adams
#
# You may distribute this module under the same terms as perl itself

# POD documentation - main docs before the code

# Let the code begin...


package Bio::Tools::Analysis::Protein::NetPhos;
use vars qw($FLOAT);
use strict;
use IO::String;
use Bio::SeqIO;
use HTTP::Request::Common qw (POST);
use Bio::SeqFeature::Generic;

use base qw(Bio::Tools::Analysis::SimpleAnalysisBase);

    $FLOAT = '[+-]?\d*\.\d*';
    my $URL = 'http://www.cbs.dtu.dk/cgi-bin/nph-webface';


    my $ANALYSIS_SPEC =
        {
         'name'        => 'NetPhos',
         'type'        => 'Protein',
         'version'     => '2.0',
         'supplier'    => 'Center for Biological Sequence Analysis,
                                                      Technical University of Denmark',
         'description' => 'Prediction of serine, threonine and tyrosine
                                                          phosphorylation sites in eukaryotic proteins',
        };

    my $INPUT_SPEC =
        [
         {
          'mandatory' => 'true',
          'type'      => 'Bio::PrimarySeqI',
          'name'      => 'seq',
         },
         {
          'mandatory' => 'false',
          'type'      => 'float',
          'name'      => 'threshold',
          'default'   => 0.8,
         }
        ];

    my $RESULT_SPEC =
        {
         ''                 => 'bulk',  # same as undef
         'Bio::SeqFeatureI' => 'ARRAY of Bio::SeqFeeature::Generic',
         'raw'              => 'Array of [ position, score, residue ]'
        };

sub result {
    my ($self,$value) = @_;

    my @predictions;
    my @fts;

    if ($value ) {

        my $result = IO::String->new($self->{'_result'});
        while (<$result>) {
            next if /^____/;
            /^\S+ +(\d+) +\w+ +(0\.\d+) +.([STY])/;
            next unless $3 and $2 > $self->threshold;
            push @predictions, [$1, $2, $3];
        }
        if ($value eq 'Bio::SeqFeatureI') {
            foreach  (@predictions) {
                push @fts, Bio::SeqFeature::Generic->new
                    (-start   => $_->[0],
                     -end     => $_->[0] ,
                     -source  => 'NetPhos',
                     -primary => 'Site',
                     -tag     => {
                               score   => $_->[1],
                               residue => $_->[2] });
            }
            return @fts;
        }
        return \@predictions;
    }

    return $self->{'_result'};
}

sub threshold {
   my ($self,$value) = @_;
   if( defined $value) {
       if ( $value !~ /$FLOAT/ or $value < 0 or $value > 1 ) {
           $self->throw("I need a value between 0 and 1 , not  [". $value. "]")
       }
       $self->{'_threshold'} = $value;
       return $self;
   }
   return $self->{'_threshold'} || $self->input_spec->[1]{'default'} ;
}

sub _init 
		{
	my $self = shift;
	$self->url($URL);
	$self->{'_ANALYSIS_SPEC'} =$ANALYSIS_SPEC;
	$self->{'_INPUT_SPEC'} =$INPUT_SPEC;
	$self->{'_RESULT_SPEC'} =$RESULT_SPEC;
	$self->{'_ANALYSIS_NAME'} =$ANALYSIS_SPEC->{name};
	return $self;
}

sub _run {
    my $self = shift;

    # format the sequence into fasta
    my $seq_fasta;
    my $stringfh = new IO::String($seq_fasta);
    my $seqout = Bio::SeqIO->new(-fh => $stringfh,
                                -format => 'fasta');
    $seqout->write_seq($self->seq);
    $self->debug($seq_fasta);

    # delay repeated calls by default by 3 sec, set delay() to change
    $self->sleep;

    $self->status('TERMINATED_BY_ERROR');

    my $request = POST $self->url,
            Content_Type => 'form-data',
            Content      => [configfile => '/usr/opt/www/pub/CBS/services/NetPhos-2.0/NetPhos.cf',
                             SEQPASTE   => $seq_fasta];
    my $content = $self->request($request);
    my $text    = $content->content;

    my ($result_url) = $text =~ /follow <a href="(.*?)"/;
    return 0 unless $result_url;
    $self->debug("url is $result_url\n\n");

    my $ua2      = $self->clone;
    my $content2 = $ua2->request(POST $result_url);

    my $ua3      = $self->clone;
    $result_url  =~ s/&.*//;
    $self->debug("final result url is $result_url\n");
    my $content3 = $ua3->request(POST $result_url);
    #print Dumper $content3;
    my $response = $content3->content;


    $response =~ s/.*<pre>(.*)<\/pre>.*/$1/s;
    $response =~ s/<.*?>//gs;

    $self->{'_result'} = $response;

    $self->status('COMPLETED') if $response ne '';

}

1;