Bio::Tools::Run::BEDTools - Run wrapper for the BEDTools suite of programs *BETA*

BioPerl-Run documentation Contained in the BioPerl-Run distribution.

Index

Code Index:

NAME

Top

Bio::Tools::Run::BEDTools - Run wrapper for the BEDTools suite of programs *BETA*

SYNOPSIS

Top

 # use a BEDTools program
 $bedtools_fac = Bio::Tools::Run::BEDTools->new( -command => 'subtract' );
 $result_file = $bedtools_fac->run( -bed1 => 'genes.bed', -bed2 => 'mask.bed' );

 # if IO::Uncompress::Gunzip is available...
 $result_file = $bedtools_fac->run( -bed1 => 'genes.bed.gz', -bed2 => 'mask.bed.gz' );

 # be more strict
 $bedtools_fac->set_parameters( -strandedness => 1 );

 # and even more...
 $bedtools_fac->set_parameters( -minimum_overlap => 1e-6 );

 # create a Bio::SeqFeature::Collection object
 $features = $bedtools_fac->result( -want => 'Bio::SeqFeature::Collection' );

DEPRECATION WARNING

Top

Most executables from BEDTools v>=2.10.1 can read GFF and VCF formats in addition to BED format. This requires the use of a new input file param, shown in the following documentation, '-bgv', in place of '-bed' for the executables that can do this.

This behaviour breaks existing scripts.

DESCRIPTION

Top

This module provides a wrapper interface for Aaron R. Quinlan and Ira M. Hall's utilities BEDTools that allow for (among other things):

* Merging overlapping features.
* Screening for paired-end (PE) overlaps between PE sequences and existing genomic features.
* Calculating the depth and breadth of sequence coverage across defined "windows" in a genome.

(see http://code.google.com/p/bedtools/ for manuals and downloads).

OPTIONS

Top

BEDTools is a suite of 17 commandline executable. This module attempts to provide and options comprehensively. You can browse the choices like so:

 $bedtools_fac = Bio::Tools::Run::BEDTools->new;

 # all bowtie commands
 @all_commands = $bedtools_fac->available_parameters('commands');
 @all_commands = $bedtools_fac->available_commands; # alias

 # just for default command ('bam_to_bed')
 @btb_params = $bedtools_fac->available_parameters('params');
 @btb_switches = $bedtools_fac->available_parameters('switches');
 @btb_all_options = $bedtools_fac->available_parameters();

Reasonably mnemonic names have been assigned to the single-letter command line options. These are the names returned by available_parameters, and can be used in the factory constructor like typical BioPerl named parameters.

As a number of options are mutually exclusive, and the interpretation of intent is based on last-pass option reaching bowtie with potentially unpredicted results. This module will prevent inconsistent switches and parameters from being passed.

See http://code.google.com/p/bedtools/ for details of BEDTools options.

FILES

Top

When a command requires filenames, these are provided to the run method, not the constructor (new()). To see the set of files required by a command, use available_parameters('filespec') or the alias filespec():

  $bedtools_fac = Bio::Tools::Run::BEDTools->new( -command => 'pair_to_bed' );
  @filespec = $bedtools_fac->filespec;

This example returns the following array:

 #bedpe
 #bam
 bed
 #out

This indicates that the bed (BEDTools BED format) file MUST be specified, and that the out, bedpe (BEDTools BEDPE format) and bam (SAM binary format) file MAY be specified (Note that in this case you MUST provide ONE of bedpe OR bam, the module at this stage does not allow this information to be queried). Use these in the run call like so:

 $bedtools_fac->run( -bedpe => 'paired.bedpe',
                     -bgv => 'genes.bed',
                     -out => 'overlap' );

The object will store the programs STDERR output for you in the stderr() attribute:

 handle_bed_warning($bedtools_fac) if ($bedtools_fac->stderr =~ /Usage:/);

For the commands 'fasta_from_bed' and 'mask_fasta_from_bed' STDOUT will also be captured in the stdout() attribute by default and all other commands can be forced to capture program output in STDOUT by setting the -out filespec parameter to '-'.

FEEDBACK

Top

Mailing Lists

User feedback is an integral part of the evolution of this and other Bioperl modules. Send your comments and suggestions preferably to the Bioperl mailing list. Your participation is much appreciated.

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

Support

Please direct usage questions or support issues to the mailing list:

bioperl-l@bioperl.org

Rather than to the module maintainer directly. Many experienced and reponsive experts will be able look at the problem and quickly address it. Please include a thorough description of the problem with code and data examples if at all possible.

Reporting Bugs

Report bugs to the Bioperl bug tracking system to help us keep track of the bugs and their resolution. Bug reports can be submitted via the web:

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

AUTHOR - Dan Kortschak

Top

 Email dan.kortschak adelaide.edu.au

CONTRIBUTORS

Top

Additional contributors names and emails here

APPENDIX

Top

The rest of the documentation details each of the object methods. Internal methods are usually preceded with a _

new()

 Title   : new
 Usage   : my $obj = new Bio::Tools::Run::BEDTools();
 Function: Builds a new Bio::Tools::Run::BEDTools object
 Returns : an instance of Bio::Tools::Run::BEDTools
 Args    :

run()

 Title   : run
 Usage   : $result = $bedtools_fac->run(%params);
 Function: Run a BEDTools command.
 Returns : Command results (file, IO object or Bio object)
 Args    : Dependent on filespec for command. 
           See $bedtools_fac->filespec and BEDTools Manual.
           Also accepts -want => '(raw|format|<object_class>)' - see want().
 Note    : gzipped inputs are allowed if IO::Uncompress::Gunzip
           is available

           Command              	<in>			<out>

           annotate             bgv		ann(s)		#out

           graph_union	        bg_files			#out

           fasta_from_bed       seq		bgv		#out

           mask_fasta_from_bed  seq		bgv		#out

           bam_to_bed           bam 				#out

           bed_to_IGV           bgv 				#out

           merge                bgv 				#out

           sort                 bgv 				#out

           links                bgv 				#out

           b12_to_b6            bed 				#out

           overlap              bed 				#out

           group_by             bed 				#out

           bed_to_bam           bgv 				#out

           shuffle              bgv 		genome		#out

           slop                 bgv 		genome		#out

           complement           bgv 		genome		#out

           genome_coverage      bed 		genome		#out

           window               bgv1		bgv2		#out

           closest              bgv1		bgv2		#out

           coverage             bgv1		bgv2		#out

           subtract             bgv1		bgv2		#out

           pair_to_pair         bedpe1		bedpe2		#out

           intersect            bgv1|bam	bgv2		#out

           pair_to_bed          bedpe|bam	bgv		#out

           bgv* signifies any of BED, GFF or VCF. ann is a bgv.

           NOTE: Replace 'bgv' with 'bed' unless $use_bgv is set.

want()

 Title   : want
 Usage   : $bowtiefac->want( $class )
 Function: make factory return $class, or 'raw' results in file
           or 'format' for result format
           All commands can return Bio::Root::IO
           commands returning:       can return object:
           - BED or BEDPE            - Bio::SeqFeature::Collection
           - sequence                - Bio::SeqIO
 Returns : return wanted type
 Args    : [optional] string indicating class or raw of wanted result

result()

 Title   : result
 Usage   : $bedtoolsfac->result( [-want => $type|$format] )
 Function: return result in wanted format
 Returns : results
 Args    : [optional] hashref of wanted type
 Note    : -want arg does not persist between result() call when
           specified in result(), for persistence, use want()

_determine_format()

 Title   : _determine_format( $has_run )
 Usage   : $bedtools-fac->_determine_format
 Function: determine the format of output for current options
 Returns : format of bowtie output
 Args    : [optional] boolean to indicate result exists

_read_bed()

 Title   : _read_bed()
 Usage   : $bedtools_fac->_read_bed
 Function: return a Bio::SeqFeature::Collection object from a BED file 
 Returns : Bio::SeqFeature::Collection
 Args    :

_read_bedpe()

 Title   : _read_bedpe()
 Usage   : $bedtools_fac->_read_bedpe
 Function: return a Bio::SeqFeature::Collection object from a BEDPE file 
 Returns : Bio::SeqFeature::Collection
 Args    :

_validate_file_input()

 Title   : _validate_file_input
 Usage   : $bedtools_fac->_validate_file_input( -type => $file )
 Function: validate file type for file spec
 Returns : file type if valid type for file spec
 Args    : hash of filespec => file_name

version()

 Title   : version
 Usage   : $version = $bedtools_fac->version()
 Function: Returns the program version (if available)
 Returns : string representing location and version of the program
BioPerl-Run documentation Contained in the BioPerl-Run distribution. 
# $Id: BEDTools.pm kortsch $
#
# BioPerl module for Bio::Tools::Run::BEDTools
#
# Please direct questions and support issues to <bioperl-l@bioperl.org>
#
# Cared for by Dan Kortschak <dan.kortschak@adelaide.edu.au>
#
# Copyright Dan Kortschak
#
# 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::Run::BEDTools;
use strict;
our $HAVE_IO_UNCOMPRESS;

BEGIN {
    eval 'require IO::Uncompress::Gunzip; $HAVE_IO_UNCOMPRESS = 1';
}

use IPC::Run;

# Object preamble - inherits from Bio::Root::Root

use lib '../../..';
use Bio::Tools::Run::BEDTools::Config;
use Bio::Tools::Run::WrapperBase;
use Bio::Tools::Run::WrapperBase::CommandExts;
use Bio::Tools::GuessSeqFormat;
use Bio::SeqFeature::Generic;
use Bio::SeqFeature::Collection;
use Bio::SeqIO;
use File::Sort qw( sort_file );

use base qw( Bio::Tools::Run::WrapperBase );

## BEDTools
our $program_name = '*bedtools';
our $default_cmd = 'bam_to_bed';

# Note: Other globals imported from Bio::Tools::Run::BEDTools::Config
our $qual_param = undef;
our $use_dash = 'single';
our $join = ' ';

our %strand_translate = (
	'+' => 1,
	'-' => -1,
	'.' => 0
	);


sub new {
	my ($class,@args) = @_;
	unless (grep /command/, @args) {
		push @args, '-command', $default_cmd;
	}
	my $self = $class->SUPER::new(@args);
	foreach (keys %command_executables) {
		$self->executables($_, $self->_find_executable($command_executables{$_}));
	}
	$self->want($self->_rearrange([qw(WANT)],@args));
	$self->parameters_changed(1); # set on instantiation, per Bio::ParameterBaseI
	return $self;
}


sub run {
	my $self = shift;

	my ($ann, $bed, $bg, $bgv, $bgv1, $bgv2, $bam, $bedpe, $bedpe1, $bedpe2, $seq, $genome, $out);
	
	if (!(@_ % 2)) {
		my %args = @_;
		if ((grep /^-\w+/, keys %args) == keys %args) {
			($ann, $bed, $bg, $bgv, $bgv1, $bgv2, $bam, $bedpe, $bedpe1, $bedpe2, $seq, $genome, $out) =
				$self->_rearrange([qw( ANN BED BG BGV BGV1 BGV2 BAM 
				                       BEDPE BEDPE1 BEDPE2
				                       SEQ GENOME OUT )], @_);
		} else {
			$self->throw("Badly formed named args: ".join(' ',@_));
		}
	} else {
		if (grep /^-\w+/, @_) {
			$self->throw("Badly formed named args: ".join(' ',@_));
		} else {
			$self->throw("Require named args.");
		}
	}

	# Sanity checks
	$self->executable || $self->throw("No executable!");
	my $cmd = $self->command if $self->can('command');

	for ($cmd) {


		m/^annotate$/ && do {
			$bgv = $self->_uncompress($bgv);
			$self->_validate_file_input(-bgv => $bgv) || $self->throw("File '$bgv' not BED/GFF/VCF format.");
			@$ann = map {
				my $a = $_;
	            $a = $self->_uncompress($a);
				$self->_validate_file_input(-ann => $a) || $self->throw("File '$a' not BED/GFF/VCF format.");
				$a;
			} @$ann;
			last;
		};
		

		m/^graph_union$/ && do {
			@$bg = map {
				my $g = $_;
	            $g = $self->_uncompress($g);
				$self->_validate_file_input(-bg => $g) || $self->throw("File '$a' not BedGraph format.");
				$g;
			} @$bg;
			last;
		};
		

		m/fasta_from_bed$/ && do {
			($out // 0) eq '-' &&
				$self->throw("Cannot capture results in STDOUT with sequence commands.");
			$seq = $self->_uncompress($seq);
			$self->_validate_file_input(-seq => $seq) || $self->throw("File '$seq' not fasta format.");
			$bgv = $self->_uncompress($bgv);
			$self->_validate_file_input(-bgv => $bgv) || $self->throw("File '$bgv' not BED/GFF/VCF format.");
			last;
		};
		

		m/^bam_to_bed$/ && do {
			$bam = $self->_uncompress($bam);
			$self->_validate_file_input(-bam => $bam) || $self->throw("File '$bam' not BAM format.");
			last;
		};



		m/^(?:bed_to_IGV|merge|sort|links)$/ && do {
			$bgv = $self->_uncompress($bgv);
			$self->_validate_file_input(-bgv => $bgv) || $self->throw("File '$bgv' not BED/GFF/VCF format.");
		};


		m/^(?:b12_to_b6|overlap|group_by)$/ && do {
			$bed = $self->_uncompress($bed);
			$self->_validate_file_input(-bed => $bed) || $self->throw("File '$bgv' not BED format.");
			if ($cmd eq 'group_by') {
				my $c =(my @c)= split(",",$self->columns);
				my $o =(my @o)= split(",",$self->operations);
				unless ($c > 0 && $o == $c) {
					$self->throw("The command 'group_by' requires "."paired "x($o == $c)."'-columns' and '-operations' parameters");
				}
			}
			last;
		};


		m/^(?:bed_to_bam|shuffle|slop|complement)$/ && do {
			$bgv = $self->_uncompress($bgv);
			$self->_validate_file_input(-bgv => $bgv) || $self->throw("File '$bgv' not BED/GFF/VCF format.");
			$genome = $self->_uncompress($genome);
			$self->_validate_file_input(-genome => $genome) || $self->throw("File '$genome' not genome format.");
			if ($cmd eq 'slop') {
				my $l = defined $self->add_to_left;
				my $r = defined $self->add_to_right;
				my $b = defined $self->add_bidirectional;
				# I think I have a lisp
				unless (($l && $r) || ($b xor ($l || $r))) {
					$self->throw("The command 'slop' requires an unambiguous description of the slop you want");
				}
			}
			last;
		};


		m/^genome_coverage$/ && do {
			$bed = $self->_uncompress($bed);
			$self->_validate_file_input(-bed => $bed) || $self->throw("File '$bed' not BED format.");
			$genome = $self->_uncompress($genome);
			$self->_validate_file_input(-genome => $genome) || $self->throw("File '$genome' not genome format.");
			my ($th, $tf) = $self->io->tempfile( -dir => $self->tempdir(), -suffix => '.bed' );
			$th->close;
			sort_file({k => 1, I => $bed, o => $tf});
			$bed = $tf;
			last;
		};


		m/^(?:window|closest|coverage|subtract)$/ && do {
			$bgv1 = $self->_uncompress($bgv1);
			$self->_validate_file_input(-bgv1 => $bgv1) || $self->throw("File '$bgv1' not BED/GFF/VCF format.");
			$bgv2 = $self->_uncompress($bgv2);
			$self->_validate_file_input(-bgv2 => $bgv2) || $self->throw("File '$bgv2' not BED/GFF/VCF format.");
		};


		m/^pair_to_pair$/ && do {
			$bedpe1 = $self->_uncompress($bedpe1);
			$self->_validate_file_input(-bedpe1 => $bedpe1) || $self->throw("File '$bedpe1' not BEDPE format.");
			$bedpe2 = $self->_uncompress($bedpe2);
			$self->_validate_file_input(-bedpe2 => $bedpe2) || $self->throw("File '$bedpe2' not BEDPE format.");
			last;
		};


		m/^intersect$/ && do {
			$bgv1 = $self->_uncompress($bgv1);
			$bam = $self->_uncompress($bam);
			($bam && $self->_validate_file_input(-bam => $bam)) || ($bgv1 && $self->_validate_file_input(-bgv1 => $bgv1)) ||
				$self->throw("File in position 1. not correct format.");
			$bgv2 = $self->_uncompress($bgv2);
			$self->_validate_file_input(-bgv2 => $bgv2) || $self->throw("File '$bgv2' not BED/GFF/VCF format.");			
			last;
		};


		m/^pair_to_bed$/ && do {
			$bedpe = $self->_uncompress($bedpe);
			$bam = $self->_uncompress($bam);
			($bam && $self->_validate_file_input(-bam => $bam)) || ($bedpe && $self->_validate_file_input(-bedpe => $bedpe)) ||
				$self->throw("File in position 1. not correct format.");
			$bgv = $self->_uncompress($bgv);
			$self->_validate_file_input(-bgv => $bgv) || $self->throw("File '$bed' not BED/GFF/VCF format.");
			last;
		}
	}
	
	my %params = (    
		'-ann'        => $ann,
		'-bam'        => $bam,
		'-bed'        => $bed,
		'-bgv'        => $bgv,
		'-bg'         => $bg,
		'-bgv1'       => $bgv1,
		'-bgv2'       => $bgv2,
		'-bedpe'      => $bedpe,
		'-bedpe1'     => $bedpe1,
		'-bedpe2'     => $bedpe2,
		'-seq'        => $seq,
		'-genome'     => $genome
	);
	map {
		delete $params{$_} unless defined $params{$_}
	} keys %params;

	my $format = $self->_determine_format(\%params);
	my $suffix = '.'.$format;
	
	if (!defined $out) {
		my ($outh, $outf) = $self->io->tempfile( -dir => $self->tempdir(), -suffix => $suffix );
		$outh->close;
		$out = $outf;
	} elsif ($out ne '-') {
		$out .= $suffix;
	} else {
		undef $out;
	}
	$params{'-out'} = $out if defined $out;

	$self->_run(%params);

	$self->{'_result'}->{'file_name'} = $out // '-';
	$self->{'_result'}->{'format'} = $format;
	$self->{'_result'}->{'file'} = defined $out ? Bio::Root::IO->new( -file => $out ) : undef;
	
	return $self->result;
}

sub _uncompress {
        my ($self, $file) = @_;

	return if !defined $file;

        return $file unless ($file =~ m/\.gz[^.]*$/);

	return $file unless (-e $file && -r _); # other people will deal with this

        unless ($HAVE_IO_UNCOMPRESS) {
                croak( "IO::Uncompress::Gunzip not available, can't expand '$file'" );
        }
        my ($tfh, $tf) = $self->io->tempfile( -dir => $self->tempdir() );
        my $z = IO::Uncompress::Gunzip->new($file);
        while (my $block = $z->getline) { print $tfh $block }
        close $tfh;

        return $tf
}


sub want {
	my $self = shift;
	return $self->{'_want'} = shift if @_;
	return $self->{'_want'};
}


sub result {
	my ($self, @args) = @_;
	
	my $want = $self->_rearrange([qw(WANT)],@args);
	$want ||= $self->want;
	my $cmd = $self->command if $self->can('command');
	my $format = $self->{'_result'}->{'format'};
	my $file_name = $self->{'_result'}->{'file_name'};

	return $self->{'_result'}->{'format'} if (defined $want && $want eq 'format');
	return $self->{'_result'}->{'file_name'} if (!$want || $want eq 'raw');
	return $self->{'_result'}->{'file'} if ($want =~ m/^Bio::Root::IO/); # this will be undef if -out eq '-'
	
	for ($format) { # these are dissected more finely than seems resonable to allow easy extension 
		m/bed/ && do {
			for ($want) {
				m/Bio::SeqFeature::Collection/ && do {
					unless (defined $self->{'_result'}->{'object'} &&
						ref($self->{'_result'}->{'object'}) =~ m/^Bio::SeqFeature::Collection/) {
							$self->{'_result'}->{'object'} = $self->_read_bed;
					}
					return $self->{'_result'}->{'object'};
				};
				$self->warn("Cannot make '$_' for $format.");
				return;
			}
			last;
		};
		m/bedpe/ && do {
			for ($want) {
				m/Bio::SeqFeature::Collection/ && do {
					unless (defined $self->{'_result'}->{'object'} &&
						ref($self->{'_result'}->{'object'}) =~ m/^Bio::SeqFeature::Collection/) {
							$self->{'_result'}->{'object'} = $self->_read_bedpe;
					}
					return $self->{'_result'}->{'object'};
				};
				$self->warn("Cannot make '$_' for $format.");
				return;
			}
			last;
		};
		m/bam/ && do {
			$self->warn("Cannot make '$_' for $format.");
			return;
		};
		m/^(?:fasta|raw)$/ && do {
			for ($want) {
				m/Bio::SeqIO/ && do {
					$file_name eq '-' && $self->throw("Cannot make a SeqIO object from STDOUT.");
					unless (defined $self->{'_result'}->{'object'} &&
						ref($self->{'_result'}->{'object'}) =~ m/^Bio::SeqIO/) {
							$self->{'_result'}->{'object'} =
								Bio::SeqIO->new(-file => $file_name,
								                -format => $format);
					}
					return $self->{'_result'}->{'object'};
				};
				$self->warn("Cannot make '$_' for $format.");
				return;
			}
			last;
		};
		m/tab/ && do {
			$self->warn("Cannot make '$_' for $format.");
			return;
		};
		m/igv/ && do {
			$self->warn("Cannot make '$_' for $format.");
			return;
		};
		m/html/ && do {
			$self->warn("Cannot make '$_' for $format.");
			return;
		};
		do {
			$self->warn("Result format '$_' not recognised - have you called run() yet?");
		}
	}
}


sub _determine_format {
        my ($self, $params) = @_;

	my $cmd = $self->command if $self->can('command');
	my $format = $format_lookup{$cmd};
	
	#special cases - dependent on switches and files
	for ($cmd) {
		m/^intersect$/ && do {
			return 'bed' if !defined $$params{'-bam'} || $self->write_bed;
			return 'bam';
		};
		m/^pair_to_bed$/ && do {
			return 'bedpe' if !defined $$params{'-bam'} || $self->write_bedpe;
			return 'bam';
		};
		m/^fasta_from_bed$/ && do {
			return $self->output_tab_format ? 'tab' : 'fasta';
		}
	}

	return $format;
}


sub _read_bed {
	my ($self) = shift;
	
	my @features;
	
	if ($self->{'_result'}->{'file_name'} ne '-') {
		my $in = $self->{'_result'}->{'file'};
		while (my $feature = $in->_readline) {
			chomp $feature;
			push @features, _read_bed_line($feature);
		}
	} else {
		for my $feature (split("\cJ", $self->stdout)) {
			push @features, _read_bed_line($feature);
		}
	}
	
	my $collection = Bio::SeqFeature::Collection->new;
	$collection->add_features(\@features);
	
	return $collection;
}

sub _read_bed_line {
	my $feature = shift;

	my ($chr, $start, $end, $name, $score, $strand,
	    $thick_start, $thick_end, $item_RGB, $block_count, $block_size, $block_start) =
		split("\cI",$feature);
	$strand ||= '.'; # BED3 doesn't have strand data - for 'merge' and 'complement'
	
	return Bio::SeqFeature::Generic->new( -seq_id  => $chr,
	                                      -primary => $name,
	                                      -start   => $start,
	                                      -end     => $end,
	                                      -strand  => $strand_translate{$strand},
	                                      -score   => $score,
	                                      -tag     => { thick_start => $thick_start,
	                                                    thick_end   => $thick_end,
	                                                    item_RGB    => $item_RGB,
	                                                    block_count => $block_count,
	                                                    block_size  => $block_size,
	                                                    block_start => $block_size }
	                                    );
}


sub _read_bedpe {
	my ($self) = shift;
	
	my @features;
	
	if ($self->{'_result'}->{'file_name'} ne '-') {
		my $in = $self->{'_result'}->{'file'};
		while (my $feature = $in->_readline) {
			chomp $feature;
			push @features, _read_bedpe_line($feature);
		}
	} else {
		for my $feature (split("\cJ", $self->stdout)) {
			push @features, _read_bedpe_line($feature);
		}
	}
	
	my $collection = Bio::SeqFeature::Collection->new;
	$collection->add_features(\@features);
	
	return $collection;
}

sub _read_bedpe_line {
	my $feature = shift;
	
	my ($chr1, $start1, $end1, $chr2, $start2, $end2, $name, $score, $strand1, $strand2, @add) =
		split("\cI",$feature);
	$strand1 ||= '.';
	$strand2 ||= '.';
	
	return Bio::SeqFeature::FeaturePair->new( -primary       => $name,
	                                          -seq_id        => $chr1,
	                                          -start         => $start1,
	                                          -end           => $end1,
	                                          -strand        => $strand_translate{$strand1},

	                                          -hprimary_tag  => $name,
	                                          -hseqname      => $chr2,
	                                          -hstart        => $start2,
	                                          -hend          => $end2,
	                                          -hstrand       => $strand_translate{$strand2},
	
	                                          -score         => $score
	                                        );
}


sub _validate_file_input {
	my ($self, @args) = @_;
	my (%args);
	if (grep (/^-/, @args) && (@args > 1)) { # named parms
		$self->throw("Wrong number of args - requires one named arg") if (@args > 2);
		s/^-// for @args;
		%args = @args;
	} else {
		$self->throw("Must provide named filespec");
	}
	
	for (keys %args) {
		m/bam/ && do {
			return 'bam';
		};
		do {
			return unless ( -e $args{$_} && -r _ );
			my $guesser = Bio::Tools::GuessSeqFormat->new(-file=>$args{$_});
			return $guesser->guess if grep {$guesser->guess =~ m/$_/} @{$accepted_types{$_}};
		}
	}
	return;
}


sub version{
	my ($self) = @_;

	my $cmd = $self->command if $self->can('command');

	defined $cmd or $self->throw("No command defined - cannot determine program executable");

	# new bahaviour for some BEDTools executables - breaks previous approach to getting version
	# $dummy can be any non-recognised parameter - '-version' works for most
	my $dummy = '-version';
	$dummy = '-examples' if $cmd =~ /graph_union/;

	my ($in, $out, $err);
	my $dum;
	$in = \$dum;
	$out = \$self->{'stdout'};
	$err = \$self->{'stderr'};

	# Get program executable
	my $exe = $self->executable;

	my @ipc_args = ( $exe, $dummy );
	
	eval {
		IPC::Run::run(\@ipc_args, $in, $out, $err) or
			die ("There was a problem running $exe : $!");
	};
	# We don't bother trying to catch this: version is returned as an illegal file seek

	my @details = split("\n",$self->stderr);
	(my $version) = grep /^Program: .*$/, @details;
	$version =~ s/^Program: //;

	return $version;
}

sub available_commands { shift->available_parameters('commands') };

sub filespec { shift->available_parameters('filespec') };

1;