use Bio::DB::SeqHound;
    $sh = Bio::DB::SeqHound->new();

    $seq = $sh->get_Seq_by_acc("CAA28783"); # Accession Number

    # or ...

    $seq = $sh->get_Seq_by_gi(4557225); # GI Number

 The Blueprint Initiative
 Samuel Lunenfeld Research Institute
 Mount Sinai Hospital
 Toronto, Canada

        $HOSTBASE = 'http://dogboxonline.unleashedinformatics.com';
    $CGILOCATION = '/cgi-bin/seqrem?fnct=';
    $LOGFILENAME = 'shoundlog';

    	my ($class, @args ) = @_;
    	my $self = $class->SUPER::new(@args);
	if ($self->_init_SeqHound eq "TRUE"){
		return $self;
	}
	else {
		return;
	}

	my ($self, $id)= @_;
	if ($id =~ /^\d+$/){
		my $seqio= $self-> _get_Seq_from_gbff ($id);
		if (defined $seqio){
			return $seqio->next_seq;
		}
	}
	elsif ($id =~ /^\S+$/){
	    #print "id is string, try search by accession or name\n";
	    my $gi = $self ->_get_gi_from_acc ($id);
	    if (!defined $gi){
			my $gi = $self->_get_gi_from_name($id);
			if (defined $gi){
				my $seqio = $self->_get_Seq_from_gbff($gi);
				if (defined $seqio){
					return $seqio->next_seq;
				}
			}
		}
		else{
			my $seqio = $self->_get_Seq_from_gbff($gi);
			if (defined $seqio){
				return $seqio->next_seq;
			}
			else {
				my $gi = $self->_get_gi_from_name($id);
				if (defined $gi) {
					my $seqio = $self->_get_Seq_from_gbff($gi);
					if (defined $seqio){
						return $seqio->next_seq;
					}
				}
			}
			
		}
	}
    	else{
		$self->warn("[get_Seq_by_id]: invalid input id.");
		return;
	}
	$self->warn("[get_Seq_by_id]: id $id does not exist");
	return;

	my ($self, $acc) = @_;
	#exclude $acc is a number, since function does not accept gi as input
	if ($acc =~ /^\d+$/) {
		$self->warn ("[get_Seq_by_acc]: id $acc does not exist");
		return;
	}
	my ($ret, $gi);
	$gi= $self->_get_gi_from_acc($acc);
	#print "get_Seq_by_acc: gi = $gi\n";
    	if (defined $gi) {
		my $seqio = $self->_get_Seq_from_gbff($gi);
		if (defined $seqio){
			return $seqio->next_seq;
		}
	}
	#else, treat input as sequence name
	else {
		$gi = $self->_get_gi_from_name($acc);   	 	
		#print "in get_Seq_by_acc: else gi = $gi\n";
		if (defined $gi){
			my $seqio = $self->_get_Seq_from_gbff($gi);
			if (defined $seqio){
				return $seqio->next_seq;
			}
		}
	}
	$self->warn("[get_Seq_by_acc]: id $acc does not exist.");
	return;

    	my ($self, $gi) = @_;
    	return get_Seq_by_id($self, $gi);

	my ($self, $query) = @_;
	my @ids = $query->ids;
	#print join ",", @ids, "\n";
	return get_Stream_by_id($self,\@ ids);

	my ($self, $id) = @_;
	my (@gilist, @not_exist);
	if(!defined $id) {
		$self->warn("[get_Stream_by_id]: undefined input id");
		return;
    	}
	if (ref($id)=~ /array/i){
		foreach my $i (@$id){
			if ($i =~ /^\d+$/){
				push(@gilist, $i);
			}
			elsif ($i =~ /^\S+$/) {
				my $gi = _get_gi_from_acc($self, $i);
				if (!defined $gi){
					$gi = _get_gi_from_name($self, $i);
					if (!defined $gi){
					    $self->warn("[get_Stream_by_id]: id $i does not exist.");
						push (@not_exist, $i);
					}
					else {
						push (@gilist, $gi);
					}
				}
				else {
					push(@gilist, $gi);
				}
			}
			else {
			    $self->warn("[get_Stream_by_id]: id $i does not exist.");
				push (@not_exist, $i);
			}
		}
		my $seqio = _get_Seq_from_gbff($self,\@ gilist);
		return $seqio;
	}
	else {
		return;
	}

	my ($self, $acc) = @_;
	return get_Stream_by_id($self, $acc);

	my ($self, $gi) = @_;
	return get_Stream_by_id($self, $gi);

	my $self = shift;
    	my ( @qualifiers) = @_;
    	my ($funcname, $query, $uids, $other) = $self->_rearrange([qw(FUNCNAME QUERY UIDS OTHER)],
							@qualifiers);
	# print ("get funcname = $funcname, query = $query, uids= $uids\n"); 
	unless( defined $funcname ne '') {
	$self->throw("please specify the SeqHound function for query");
    	}
    	my $url = $HOSTBASE . $CGILOCATION . $funcname;
    	unless( defined $uids ne '') {
	$self->throw("please specify a uid or a list of uids to fetch");
    	}
    	unless ( defined $query && $query ne '') {
	$self->throw("please specify a valid query field");
	}
	
 	if (defined $uids && defined $query) {
		if( ref($uids) =~ /array/i ) {
	       	$uids = join(",", @$uids);
		}
		$url=$url."&".$query."=".$uids;
		if (defined $other){
			$url=$url."&".$other;
		}
		my $ua = LWP::UserAgent->new(env_proxy => 1);
		my $req = HTTP::Request->new ('GET', $url);
		my $res = $ua->request($req);
		if ($res->is_success){
			return $res->content;
		}
		else {
			my $result = "HTTP::Request error: ".$res->status_line."\n";
			$self->warn("$result");
			return $result;
		}
	}

    my ($self, @args) = @_;
    my ($funcname, $lcontent, $outtype) = $self->_rearrange(
                        [qw(FUNCNAME LCONTENT OUTTYPE)], @args);
    my $result;
	if (!defined $outtype){ 
		$self->throw("please specify the output type, string, Bio::SeqIO etc");
	}
        if (!defined $lcontent){
		$self->throw("please provide the result from SeqHound call");
	}
	if (!defined $funcname){
		$self->throw("Please provide the function name");
	}

	#set up verbosity level if need record in the log file
    my $log_msg = "Writing into '$LOGFILENAME' log file.\n";
    my $now = strftime("%a %b %e %H:%M:%S %Y", localtime);
    if ($lcontent eq "") {
        $self->debug($log_msg);
        open (my $LOG, '>>', $LOGFILENAME);
        print $LOG "$now		$funcname. No reply.\n";
        return;
    }
    elsif ($lcontent =~ /HTTP::Request error/) {
        $self->debug($log_msg);
        open (my $LOG, '>>', $LOGFILENAME);
        print $LOG "$now		$funcname. Http::Request error problem.\n";
        return;
    }
    elsif ($lcontent =~ /SEQHOUND_ERROR/) {
        $self->debug($log_msg);
        open (my $LOG, '>>', $LOGFILENAME);
        print $LOG "$now	$funcname error. SEQHOUND_ERROR found.\n";
        return;
    }
    elsif ($lcontent =~ /SEQHOUND_NULL/) {
        $self->debug($log_msg);
        open (my $LOG, '>>', $LOGFILENAME);
        print $LOG "$now	$funcname Value not found in the database. SEQHOUND_NULL found.\n";
        return;
    }
    else {
        chomp $lcontent;
        my @lines = split(/\n/, $lcontent, 2);
        if ($lines[1] =~ /^-1/) {
            $self->debug($log_msg);
            open (my $LOG, '>>', $LOGFILENAME);
            print $LOG "$now	$funcname Value not found in the database. -1 found.\n";
            return;
        }
        elsif ($lines[1]  =~ /^0/) {
            $self->debug($log_msg);
            open (my $LOG, '>>', $LOGFILENAME);
            print $LOG "$now	$funcname failed.\n";
            return;
        }
        else {
            $result = $lines[1];
        }
    }

	#a list of functions in SeqHound which can wrap into Bio::seqIO object
	if ($outtype eq 'Bio::SeqIO'){
		my $buf = IO::String->new($result);
		my $io = Bio::SeqIO->new (-format => 'genbank', -fh => $buf);
		if (defined $io && $io ne ''){
		    return $io;
		}
		else { return;}
   	}	
   	#return a string if outtype is "string"
   	return $result;

	my ($self, $name) = @_;
	my ($ret, $gi);
	$ret = $self->get_request( -funcname => 'SeqHoundFindName',
			               -query => 'name',
				       -uids  => $name);
	#print "_get_gi_from_name:  ret = $ret\n";
	$gi = $self->postprocess_data(-lcontent => $ret,
			                -funcname => 'SeqHoundFindName',
					-outtype => 'string');
	#print "_get_gi_from_name: gi = $gi\n";
	return $gi;

	my ($self, $acc) = @_;
	my ($ret, $gi);
	$ret = $self->get_request ( -funcname => 'SeqHoundFindAcc',
			               -query => 'acc',
				       -uids  => $acc);
	#print "_get_gi_from_acc:  ret = $ret\n";
	$gi = $self->postprocess_data(  -lcontent => $ret,
			                -funcname => 'SeqHoundFindAcc',
					-outtype => 'string');
	#print "_get_gi_from_acc:  gi = $gi\n";
	return $gi;

	my ($self, $gi) = @_;
	if(!defined $gi) {
		$self->warn("[_get_Seq_from_gbff]: undefined input gi");
		return;
    	}
	my $lcontent;
	if (ref($gi) =~ /array/i){
		my @copyArr = @$gi;
		my @tempArr;
		$lcontent = "SEQHOUND_OK\n";
		while ($#copyArr != -1){
			@tempArr =_MaxSizeArray(\@copyArr);
		    	#in order to keep the correct output order as GenBank does
			my $gi = join (",", reverse(@tempArr));
    			my $result;
    			my $ret = $self->get_request(  -funcname => 'SeqHoundGetGenBankffList',
            	                   			-query => 'pgi',
			 				-uids => $gi);
			if (defined $ret){
				my @lines = split(/\n/, $ret, 2);
      				if($lines[0] =~ /SEQHOUND_ERROR/ || $lines[0] =~ /SEQHOUND_NULL/){
      				}
	  			else {
					if ($lines[1] =~ /^(null)/ || $lines[1] eq ""){
     	 			}
         			else{
           				$result = $lines[1];
         			}
			}
			#append genbank flat files for long list
			$lcontent = $lcontent.$result;
			}
		}
	}
    	#else $gi is a single variable
	else {
		$lcontent = $self->get_request(  -funcname => 'SeqHoundGetGenBankffList',
            	                   		-query => 'pgi',
			 			-uids => $gi);
	}
     	my $seqio = $self->postprocess_data ( -lcontent => $lcontent,
                             			-funcname => 'SeqHoundGetGenBankffList',
				      		-outtype => 'Bio::SeqIO');
		
	return $seqio;

	my $self = shift;
	my $ret = $self->get_request(-funcname => 'SeqHoundInit',
						-query => 'NetEntrezOnToo',
						-uids => 'true',
						-other => 'appname=Bioperl');
	my $result = $self->postprocess_data(-lcontent => $ret,
					-funcname => 'SeqHoundInit',
					-outtype => 'string');
	return $result || 'FALSE';

  my $argArr = shift;
  my @copyArr;
  my $MAXQ = 5;
  my $len = scalar(@$argArr);
  for(my $i = 0; $i < $len;){
    $copyArr[$i++] = $$argArr[0]; 
    shift(@$argArr);
    if($i == $MAXQ) 
    {
       last;
    }
  }
  return @copyArr;
}

1;
__END__

 Title   : get_Seq_by_version
 Usage   : $seq = $db->get_Seq_by_version('X77802');
 Function: Gets a Bio::Seq object by sequence version
 Returns : A Bio::Seq object
 Args    : accession.version (as a string)
 Throws  : "acc.version does not exist" exception
 Note    : SeqHound only keeps the most up-to-date version of a sequence. So
           for the above example, use 
	   $seq = $db->get_Seq_by_acc('X77802'); 
	   instead of X77802.1