I may be misreading the code (little wonder), but it looks to me that even if you pass a reference to an array or Bio object, the module you're using writes that data to a temporary file in order to pass it to the executable anyway.

From my (limited) perspective, it looks like it might be a whole lot easier to start the executable directly using a piped open and pass the data through yourself. At least you'd know what was going on.

I may be misreading the code (little wonder)

Huh? is my code that terrible? Or is it because its hard to understand if one is not familiar with BioPerl? Because that I can understand :)

But your making a good point, even though it still don't explain the error. But I think that it will definitely improve my workaround. Thanks!

Huh? is my code that terrible?

Not your code (actually I didn't look at it that closely:); I was referring to the code inside Bio::Tools::Run::StandAloneBlast which I find extremely opaque.

---

Examine what is said, not who speaks -- Silence betokens consent -- Love the truth but pardon error.

"Science is about questioning the status quo. Questioning authority".

In the absence of evidence, opinion is indistinguishable from prejudice.

RIP PCW

$blast_report->next_result();
[download]

StandAloneBlast is a module in BioPerl (www.bioperl.org) and therefore kind of a black box..
With that said, it should only return undef if the blast search that it did returns empty handed. But from doing the blast search manually (in my workaround) it can be seen that the search is not empty.

Than it indicates a bug in that module. (That could be a documentation bug if its just not matching what you did by hand)

If you tried running this code for a single sequence, translating it into the 6 frames and then tried blasting it what would come??

Unfortunately I get the exact same error :(

Ok I might have been a little unclear on this. I translate one nucleotide sequence into six amino acid sequences. A stop codon in the nucleotide sequence will be translated into an asterisk *. It is therefore easier to sort out the sequences after translating them.

I'm sorry I don't understand your concern regarding my use of blastp. I am blasting protein sequences (amino acids).

get the six different reading frames from the nucleotides, decide on which ones to remove because they got any one of the three stop codons, do that first, then translate the rest of the sequences into proteins and do the blasting. that would save you from using the * to mark where a stop codon is...I know I am not able to give you a solution but I am just suggesting something that could land you anywhere near it... I will really advice you to use the * only in Typeglob notations in Perl.. I had a feeling that you used blastp on a protein sequence cuz I did not read your code in a clear way. Be a bit more neat instead of repeating the same if statement over and over, your program could be a way shorter and effective too...
Excellence is an Endeavor of Persistence. Chance Favors a Prepared Mind

    my $stringfh = new IO::String($sequence_string);
    my $seqio = new Bio::SeqIO(-fh => $stringfh, -format => 'fasta');

    my $blaster = Bio::Tools::Run::StandAloneBlast->new(@params);
[download]

while( my $seq = $seqio->next_seq ) {
  my $blast_report = $blaster->blastall($seq);
  ...
  while( my $BLAST_result = $blast_report->next_result ) {
    ...
    while( my $hit = $BLAST_result->next_hit ) {
    ... 
    }
  }
}
[download]

You have to tell StandAloneBlast it will be returning blasttable format, the default is 'blast' format and the parser doesn't try to guess.

I'm really confused why you are doing the translation yourself and not running BLASTX, but anyways the code for doing translation is described below?

The StandAloneBlast module is pretty fragile unfortunately - I really prefer to just code the cmdline parameters myself. But I think the problem from before is that it assumes you are passing in a Bio::Seq object (or Bio::PrimarySeqI interface object).

Here's a part of a script to generate your query sequences in FASTA format and then run your blast with a system call or better yet do the parsing on the fly... The translate function has a lot of capabilities as well like finding ORFs for you.

use Bio::SeqIO;
use Bio::SearchIO;
my $input = Bio::SeqIO->new(-format => 'fasta', -file => "inputseqs.fa
+");
my $output = Bio::SeqIO->new(-format => 'fasta', -file => ">translated
+.fa");
while(my $seq = $input->next_seq ){
 my $id = $seq->id;
 # fwd strand
 for my $frame ( 0..3 ) {
  my $translated = $seq->translate($frame);
  $translated->id($id. "_F$frame");
  $output->write_seq($translated);
 } 
 # rev strand
 my $revcom = $seq->revcom;
 for my $frame ( 0..3 ) {
  my $translated = $revcom->translate($frame);
  $translated->id($id. "_R$frame");
  $output->write_seq($translated);
 } 
 $output->close();
}
my $blastexe = "blastall -p blastp -d swissprot -e 1e-3 -i translated.
+fa -m 9";
open(my $fh => "$blastexe |" ) || die $!;
my $blastparser = Bio::SearchIO->new(-format => 'blasttable', -fh => $
+fh);
# now do something with this as a SearchIO object
# if you wanted the full alignment details, change blasttable to 'blas
+t' and remove the '-m 9' in the exe string.
# OR
`$blastexe -o result.BLASTP.tab`;
[download]