use Bio::DB::BioFetch;

 $bf = new Bio::DB::BioFetch;

 $seq = $sp->get_Seq_by_id('BUM');  # EMBL or SWALL ID

 # change formats, storage procedures
 $bf = new Bio::DB::BioFetch(-format        => 'fasta',
 			     -retrievaltype => 'tempfile',
  			     -db            => 'EMBL');

 $stream = $bf->get_Stream_by_id(['BUM','J00231']);
 while (my $s = $stream->next_seq) {
    print $s->seq,"\n";
 }
 # get a RefSeq entry
 $bf->db('refseq');
 eval {
     $seq = $bf->get_Seq_by_version('NM_006732.1'); # RefSeq VERSION
 };
 print "accession is ", $seq->accession_number, "\n" unless $@;

  %FORMATMAP = (
		'embl' => {
			   default => 'embl', # default BioFetch format/SeqIOmodule pair
			   embl => 'embl',    # alternative BioFetch format/module pair 
			   fasta => 'fasta',   # alternative BioFetch format/module pair 
			   namespace => 'embl',
			  },
		'swissprot' => {
				default => 'swiss',
				swissprot => 'swiss',
				fasta => 'fasta',
				namespace => 'swall',
			       },
		'refseq' => {
			     default => 'genbank',
			     genbank => 'genbank',
			     fasta => 'fasta',
			     namespace => 'RefSeq',
			    },
		'swall' => {
			    default => 'swiss',
			    swissprot => 'swiss',
			    fasta => 'fasta',
			    namespace => 'swall',
			   },
		'genbank' => {
			      default => 'genbank',
			      genbank => 'genbank',
			      namespace => 'genbank',
			     },
		'genpep' => {
			     default => 'genbank',
			     genbank => 'genbank',
			     namespace => 'genpep',
			    },
	       );

    my ($self, $id) = @_;

    # NT contigs can not be retrieved
    $self->throw("NT_ contigs are whole chromosome files which are not part of regular".
		 "database distributions. Go to ftp://ftp.ncbi.nih.gov/genomes/.") 
	if $id =~ /NT_/;

    # Asking for a RefSeq from EMBL/GenBank

    if ($id =~ /N._/ &&  $self->db ne 'refseq') {
	$self->warn("[$id] is not a normal sequence database but a RefSeq entry.".
		   " Redirecting the request.\n")
	    if $self->verbose >= 0;
	$self->db('RefSeq');
    }
}

1;

  my $self = shift;
  my $db = $self->db;
  return $FORMATMAP{$db}{namespace} or $db;

  my $self = shift;

  if (@_) {

      my $db = lc shift;
      $FORMATMAP{$db} or $self->throw("invalid db [$db], must be one of [".
				     join(' ',keys %FORMATMAP).  "]");
      $self->{_db} = $db;
  }
  return $self->{_db} || $self->default_db ;

 'embl'

     return 'default';

   my ($self,$seqid) = @_;
   return $self->get_Seq_by_acc($seqid);

    my ($self, $ids ) = @_;
    $self->_check_id($ids);
    return $self->get_seq_stream('-uids' => $ids, '-mode' => 'single');

    my ($self, @qualifiers) = @_;
    my ($uids, $format) = $self->_rearrange([qw(UIDS FORMAT)],
					    @qualifiers);
    my $db     = $self->db;
    my $namespace = $self->_namespace;

    $self->throw("Must specify a value for UIDs to fetch")
	unless defined $uids;
    my $tmp;
    my $format_string = '';

    $format ||= $self->default_format;
    ($format, $tmp) = $self->request_format($format);

    my $base = $self->url_base_address;
    my $uid = join('+', ref $uids ? @$uids : $uids);
    $self->debug("\n$base$format_string&id=$uid\n");
    return POST($base,
		[ db     => $namespace,
		  id     => join('+',ref $uids ? @$uids : $uids),
		  format => $format,
		  style  => 'raw'
	     ]);

  my ($class,@args) = @_;
  my $self = $class->SUPER::new(@args);
  my ($db) = $self->_rearrange([qw(DB)],@args);
  $db    ||= $self->default_db;
  $self->db($db);
  $self->url_base_address(DEFAULT_LOCATION) unless $self->url_base_address;
  $self;

    my ($class,%config)=@_;

    my $self = $class->SUPER::new(
				  -BASEADDRESS=>$config{'location'}
				  );
    $self->db($config{'dbname'}) if $config{dbname};
    return $self;
}

# from Bio::DB::RandomAccessI

  my ($self,%args) = @_;

  # check for errors in the stream
  if ($args{'type'} eq 'string') {
    my $stringref = $args{'location'};
    if ($$stringref =~ /^ERROR (\d+) (.+)/m) {
      $self->throw("BioFetch Error $1: $2");
    }
  }

  elsif ($args{'type'} eq 'file') {
    open (F,$args{'location'}) or $self->throw("Couldn't open $args{location}: $!");
    # this is dumb, but the error may be anywhere on the first three lines because the
    # CGI headers are sometimes printed out by the server...
    my @data = (scalar <F>,scalar <F>,scalar <F>);
    if (join('',@data) =~ /^ERROR (\d+) (.+)/m) {
      $self->throw("BioFetch Error $1: $2");
    }
    close F;
  }

  else {
    $self->throw("Don't know how to postprocess data of type $args{'type'}");
  }

    my ($self, $value) = @_;
    if ( defined $value ) { 
	my $db = $self->db;
	my $namespace = $self->_namespace;
	my $format = lc $value;
	print "format:", $format, " module:", $FORMATMAP{$db}->{$format}, " ($namespace)\n" 
	    if $self->verbose > 0; 
	$self->throw("Invalid format [$format], must be one of [".
		     join(' ',keys %{$FORMATMAP{$db}}). "]")
	    unless  $format eq 'default' || $FORMATMAP{$db}->{$format};

	$self->{'_format'} = [ $format, $FORMATMAP{$db}->{$format}];
    }
    return @{$self->{'_format'}};

  bioperl-l@bioperl.org                         - General discussion
  http://bio.perl.org/MailList.html             - About the mailing lists

  bioperl-bugs@bio.perl.org
  http://bugzilla.bioperl.org/

 Title   : get_Seq_by_id
 Usage   : $seq = $db->get_Seq_by_id('ROA1_HUMAN')
 Function: Gets a Bio::Seq object by its name
 Returns : a Bio::Seq object
 Args    : the id (as a string) of a sequence
 Throws  : "id does not exist" exception

 Title   : get_Seq_by_acc
 Usage   : $seq = $db->get_Seq_by_acc('X77802');
 Function: Gets a Bio::Seq object by accession number
 Returns : A Bio::Seq object
 Args    : accession number (as a string)
 Throws  : "acc does not exist" exception

 Title   : get_Seq_by_gi
 Usage   : $seq = $db->get_Seq_by_gi('405830');
 Function: Gets a Bio::Seq object by gi number
 Returns : A Bio::Seq object
 Args    : gi number (as a string)
 Throws  : "gi does not exist" exception

  Title   : get_Stream_by_id
  Usage   : $stream = $db->get_Stream_by_id( [$uid1, $uid2] );
  Function: Gets a series of Seq objects by unique identifiers
  Returns : a Bio::SeqIO stream object
  Args    : $ref : a reference to an array of unique identifiers for
                   the desired sequence entries

  Title   : get_Stream_by_gi
  Usage   : $seq = $db->get_Seq_by_gi([$gi1, $gi2]);
  Function: Gets a series of Seq objects by gi numbers
  Returns : a Bio::SeqIO stream object
  Args    : $ref : a reference to an array of gi numbers for
                   the desired sequence entries
  Note    : For GenBank, this just calls the same code for get_Stream_by_id()

  Title   : get_Stream_by_batch
  Usage   : $seq = $db->get_Stream_by_batch($ref);
  Function: Get a series of Seq objects by their IDs
  Example :
  Returns : a Bio::SeqIO stream object
  Args    : $ref : an array reference containing a list of unique
            ids/accession numbers.