#!/bin/perl

use strict;
use Bio::SeqIO;

my $file         = shift; # get the file name, somehow
my $seqio_object = Bio::SeqIO->new(-file => $file);
my $seq_object   = $seqio_object->next_seq;

# first, bring in the SeqIO module

use Bio::SeqIO;

# Notice that you do not have to use any Bio:SeqI
# objects, because SeqIO does this for you. In fact, it
# even knows which SeqI object to use for the provided
# format.

# Bring in the file and format, or die with a nice
# usage statement if one or both arguments are missing.
my $usage  = "getaccs.pl file format\n";
my $file   = shift or die $usage;
my $format = shift or die $usage;

# Now create a new SeqIO object to bring in the input
# file. The new method takes arguments in the format
# key => value, key => value. The basic keys that it
# can accept values for are '-file' which expects some
# information on how to access your data, and '-format'
# which expects one of the Bioperl-format-labels mentioned
# above. Although it is optional, it is good
# programming practice to provide > and < in front of any
# filenames provided in the -file parameter. This makes the
# resulting filehandle created by SeqIO explicitly read (<)
# or write(>).  It will definitely help others reading your
# code understand the function of the SeqIO object.

my $inseq = Bio::SeqIO->new(
                            -file   => "<$file",
                            -format => $format,
                            );
# Now that we have a seq stream,
# we need to tell it to give us a $seq.
# We do this using the 'next_seq' method of SeqIO.

while (my $seq = $inseq->next_seq) {
    print $seq->accession_number,"\n";
}

use strict;
use Bio::SeqIO;

my $input_file = shift;

my $seq_in  = Bio::SeqIO->new(
                              -format => 'embl',
                              -file   => $input_file,
                              );

# loads the whole file into memory - be careful
# if this is a big file, then this script will
# use a lot of memory

my $seq;
my @seq_array;
while( $seq = $seq_in->next_seq() ) {
    push(@seq_array,$seq);
}

# now do something with these. First sort by length,
# find the average and median lengths and print them out

@seq_array = sort { $a->length <=> $b->length } @seq_array;

my $total = 0;
my $count = 0;
foreach my $seq ( @seq_array ) {
    $total += $seq->length;
    $count++;
}

print "Mean length ",$total/$count," Median ",$seq_array[$count/2]->length,"\n";

use Bio::SeqIO;
# get command-line arguments, or die with a usage statement
my $usage         = "x2y.pl infile infileformat outfile outfileformat\n";
my $infile        = shift or die $usage;
my $infileformat  = shift or die $usage;
my $outfile       = shift or die $usage;
my $outfileformat = shift or die $usage;

# create one SeqIO object to read in,and another to write out
my $seq_in = Bio::SeqIO->new(
                             -file   => "<$infile",
                             -format => $infileformat,
                             );
my $seq_out = Bio::SeqIO->new(
                              -file   => ">$outfile",
                              -format => $outfileformat,
                              );

# write each entry in the input file to the output file
while (my $inseq = $seq_in->next_seq) {
    $seq_out->write_seq($inseq);
}

use Bio::SeqIO;
# get command-line arguments, or die with a usage statement
my $usage     = "all2y.pl informat outfile outfileformat\n";
my $informat  = shift or die $usage;
my $outfile   = shift or die $usage;
my $outformat = shift or die $usage;

# create one SeqIO object to read in, and another to write out
# *STDIN is a 'globbed' filehandle with the contents of Standard In
my $seqin = Bio::SeqIO->new(
                            -fh     => \*STDIN,
                            -format => $informat,
                            );
my $seqout = Bio::SeqIO->new(
                             -file   => ">$outfile",
                             -format => $outformat,
                             );

# write each entry in the input file to the output file
while (my $inseq = $seqin->next_seq) {
    $seqout->write_seq($inseq);
}

use Bio::SeqIO;
# get command-line arguments, or die with a usage statement
my $usage     = "in2out.pl informat outformat\n";
my $informat  = shift or die $usage;
my $outformat = shift or die $usage;

# create one SeqIO object to read in, and another to write out
my $seqin = Bio::SeqIO->new(
                            -fh     => \*STDIN,
                            -format => $informat,
                            );
my $outseq = Bio::SeqIO->new(
                             -fh     => \*STDOUT,
                             -format => $outformat,
                             );

# write each entry in the input to the output
while (my $inseq = $seqin->next_seq) {
    $outseq->write_seq($inseq);
}

use IO::String;   # only needed for Perl versions previous to 5.8.0
use Bio::SeqIO;

## get a string into $string somehow, with its format in $format, say from a web form.
my $string   = ">SEQ1\nacgt\n>revseq1\ntgca\n";
my $format   = "fasta";

my $stringfh = IO::String->new($string);                                         # Use this for Perl BEFORE 5.8.0
open($stringfh, "<", \$string) or die "Could not open string for reading: $!";   # Use this for Perl AFTER 5.8.0 (inclusive)

my $seqio = Bio::SeqIO-> new(
                             -fh     => $stringfh,
                             -format => $format,
                             );

while( my $seq = $seqio->next_seq ) {
    # process each seq
    print $seq->id . ' = '.$seq->seq()."\n";
}

use IO::String;   # only needed for Perl versions BEFORE 5.8.0
use Bio::SeqIO;

my $string;
my $stringfh = IO::String->new(\$string);                                        # Use this for Perl BEFORE 5.8.0
open($stringfh, ">", \$string) or die "Could not open string for writing: $!";   # Use this for Perl AFTER 5.8.0 (inclusive)

my $seqOut = Bio::SeqIO->new(
                             -format => 'swiss',
                             -fh     => $io,
                             );
$seqOut->write_seq($seq_obj);
print $string;

use Bio::SeqIO;
# get command-line arguments, or die with a usage statement
my $usage    = "gzip2fasta.pl infile informat outfile\n";
my $infile   = shift or die $usage;
my $informat = shift or die $usage;
my $outfile  = shift or die $usage;

# create one SeqIO object to read in, and another to write out
my $seqin = Bio::SeqIO->new(
                            -file   => "/usr/local/bin/gunzip -c $infile |",
                            -format => $informat,
                            );

my $seqout = Bio::SeqIO->new(
                             -file   => ">$outfile",
                             -format => 'Fasta',
                             );

# write each entry in the input to the output file
while (my $inseq = $seqin->next_seq) {
    $seqout->write_seq($inseq);
}

use Bio::SeqIO;

# get command-line arguments, or die with a usage statement
my $usage     = "any2wublastable.pl infile informat outdbname outdbtype\n";
my $infile    = shift or die $usage;
my $informat  = shift or die $usage;
my $outdbname = shift or die $usage;
my $outdbtype = shift or die $usage;

# create one SeqIO object to read in, and another to write out
my $seqin = Bio::SeqIO->new(
                            -file   => "<$infile",
                            -format => $informat,
                            );
my $seqout = Bio::SeqIO->new(
                             -file => "| /usr/local/bin/xdformat -o $outdbname -${outdbtype} -- -",
                             -format => 'Fasta',
                             );

# write each entry in the input to the output
while (my $inseq = $seqin->next_seq) {
    $seqout->write_seq($inseq);
}

use Bio::SeqIO;

# get command-line argument, or die with a usage statement
my $usage  = "splitgb.pl infile\n";
my $infile = shift or die $usage;

my $inseq = Bio::SeqIO->new(
                            -file   => "<$infile",
                            -format => 'Genbank',
                            );

my %outfiles = (
                'human' => Bio::SeqIO->new(
                                           -file   => '>human.gb',
                                           -format => 'Genbank',
                                           ),
                'other' => Bio::SeqIO->new(
                                           -file   => '>other.gb',
                                           -format => 'Genbank',
                                           ),
                );

while (my $seqin = $inseq->next_seq) {
    # here we make use of the species attribute, which returns a
    # species object, which has a binomial attribute that
    # holds the binomial species name of the source of the sequence
    if ($seqin->species->binomial =~ m/Homo sapiens/) {
        $outfiles{'human'}->write_seq($seqin);
    } else {
        $outfiles{'other'}->write_seq($seqin);
    }
}

use Bio::SeqIO;
# get command-line argument, or die with a usage statement
my $usage  = "splitgb.pl infile\n";
my $infile = shift or die $usage;

my $inseq = Bio::SeqIO->new(
                            -file   => "<$infile",
                            -format => 'Genbank',
                            );

my %outfiles = (
                human => {
                          Genbank => Bio::SeqIO->new(
                                                     -file   => '>human.gb',
                                                     -format => 'Genbank',
                                                     ),
                          Fasta   => Bio::SeqIO->new(
                                                     -file   => '>human.fa',
                                                     -format => 'Fasta',
                                                     ),
                          },
                other => {
                          Genbank => Bio::SeqIO->new(
                                                     -file   => '>other.gb',
                                                     -format => 'Genbank',
                                                     ),
                          Fasta   => Bio::SeqIO->new(
                                                     -file => '>other.fa',
                                                     -format => 'Fasta',
                                                     ),
                          }
                );

while (my $seqin = $inseq->next_seq) {
    if ($seqin->species->binomial =~ m/Homo sapiens/) {
        $outfiles{'human'}->{'Genbank'}->write_seq($seqin);
        $outfiles{'human'}->{'Fasta'}->write_seq($seqin);
    } else {
        $outfiles{'other'}->{'Genbank'}->write_seq($seqin);
        $outfiles{'other'}->{'Fasta'}->write_seq($seqin);
    }
}

use strict;
use Bio::SeqIO;

my $input_file  = shift;
my $output_file = shift;

# we have to declare $seq_in and $seq_out before
# the eval block as we want to use them afterwards

my $seq_in;
my $seq_out;

eval {
    $seq_in   = Bio::SeqIO->new(
                                -format => 'genbank',
                                -file   => $input_file,
                                );

    $seq_out  = Bio::SeqIO->new(
                                -format => 'fasta',
                                -file   => ">$output_file",
                                );
};
if( $@ ) { # an error occurred
    print "Was not able to open files, sorry!\n";
    print "Full error is\n\n$@\n";
    exit(-1);
}
my $seq;
while( $seq = $seq_in->next_seq() ) {
    $seq_out->write_seq($seq);
}

#!/usr/bin/perl

use strict;
use Bio::SeqIO;
use Benchmark qw(:all);

my $file = "gbbct10.seq";

timethis(1, sub {
   my $in = Bio::SeqIO->new(-file => $file, -format => "genbank");
   for (1..1000) {
      my $seq = $in->next_seq;
   }
});

timethis(1, sub {
   my $in = Bio::SeqIO->new(-file => $file, -format => "genbank");
   my $builder = $in->sequence_builder();
   $builder->want_none();
   $builder->add_wanted_slot('display_id','desc','seq');
   for (1..1000) {
      my $seq = $in->next_seq;
   }
});

use Bio::Index::Fasta;
$ENV{BIOPERL_INDEX_TYPE} = "SDBM_File";

$ENV{BIOPERL_INDEX_TYPE} = "SDBM_File";
use Bio::Index::Fasta;

$file_name = "sequence.fa";
$id = "48882";
$inx = Bio::Index::Fasta->new (-filename => $file_name . ".idx", -write_flag => 1);
$inx->make_index($file_name);

$seq_obj = $inx->fetch($id)

$inx->id_parser(\&get_id);
$inx->make_index($file_name);

sub get_id {
    $header = shift;
    $header =~ /pdb\|(\S+)/;
    $1;
}

use Bio::DB::Fasta;
($file,$id,$start,$end) = ("genome.fa","CHROMOSOME_I",11250,11333);
$db = Bio::DB::Fasta->new($file);
$seq = $db->seq($id,$start,$end);
print $seq,"\n";