Command builders

BEDTools.Bindings

A command builder for every subcommand of BEDTools, generated from the help of the bedtools of BEDTools_jll.

Each builder, such as BEDTools.Bindings.intersect(a = "a.bed", b = "b.bed", wa = true), takes the subcommand's options as keywords, checks them against those that its help lists, and returns the Cmd, without running it. Run it with BEDTools.lines, or compose it with Julia's process functions, such as eachline, read and pipeline. The builders are public but not exported, since many of their names, such as sort, merge and map, are also functions of Base.

BEDTools.Bindings.GENERAL_OPTIONS

The general parameters of BEDTools, which every builder takes and which come before the subcommand, by keyword and spelling:

• cram-ref: Reference used by a CRAM input

BEDTools.Bindings.GENERATED_VERSION

The version of BEDTools whose help the command builders are generated from.

BEDTools.Bindings.SUBCOMMANDS

The subcommands of BEDTools, each with a command builder of its name.

BEDTools.Bindings.annotate(; options...)::Cmd

Annotates the depth & breadth of coverage of features from mult. files on the intervals in -i.

The bedtools annotate command with options, checked against those that its help lists, to run with BEDTools.lines or any of Julia's process functions. It needs i and files: BEDTools.Bindings.annotate(i = …, files = …). Its usage, in BEDTools 2.31.1, is bedtools annotate [OPTIONS] -i <bed/gff/vcf> -files FILE1 FILE2..FILEn.

An option of true is a flag, false and nothing leave it out, a vector gives it each element as an argument, and another value gives it that value. An option with several spellings, such as a short and a long form, takes any one of them, and each emits its own.

Options:

• i: <bed/gff/vcf>, from the usage line.
• files: FILE1, from the usage line.
• names: A list of names (one / file) to describe each file in -i. These names will be printed as a header line.
• counts: Report the count of features in each file that overlap -i. - Default is to report the fraction of -i covered by each file.
• both: Report the counts followed by the % coverage. - Default is to report the fraction of -i covered by each file.
• s: Require same strandedness. That is, only counts overlaps on the same strand. - By default, overlaps are counted without respect to strand.
• S: Require different strandedness. That is, only count overlaps on the opposite strand. - By default, overlaps are counted without respect to strand.

It also takes the general parameters of BEDTools, in BEDTools.Bindings.GENERAL_OPTIONS, which come before the subcommand.

BEDTools.Bindings.bamtobed(; options...)::Cmd

Converts BAM alignments to BED6 or BEDPE format.

The bedtools bamtobed command with options, checked against those that its help lists, to run with BEDTools.lines or any of Julia's process functions. It needs i: BEDTools.Bindings.bamtobed(i = …). Its usage, in BEDTools 2.31.1, is bedtools bamtobed [OPTIONS] -i <bam>.

An option of true is a flag, false and nothing leave it out, a vector gives it each element as an argument, and another value gives it that value. An option with several spellings, such as a short and a long form, takes any one of them, and each emits its own.

Options:

• i: <bam>, from the usage line.
• bedpe: Write BEDPE format. - Requires BAM to be grouped or sorted by query.
• mate1: When writing BEDPE (-bedpe) format, always report mate one as the first BEDPE "block".
• bed12: Write "blocked" BED format (aka "BED12"). Forces -split.
• split: Report "split" BAM alignments as separate BED entries. Splits only on N CIGAR operations.
• splitD: Split alignments based on N and D CIGAR operators. Forces -split.
• ed: Use BAM edit distance (NM tag) for BED score. - Default for BED is to use mapping quality. - Default for BEDPE is to use the minimum of the two mapping qualities for the pair. - When -ed is used with -bedpe, the total edit distance from the two mates is reported.
• tag: Use other NUMERIC BAM alignment tag for BED score. - Default for BED is to use mapping quality. Disallowed with BEDPE output.
• color: An R,G,B string for the color used with BED12 format. Default is (255,0,0).
• cigar: Add the CIGAR string to the BED entry as a 7th column.

It also takes the general parameters of BEDTools, in BEDTools.Bindings.GENERAL_OPTIONS, which come before the subcommand.

BEDTools.Bindings.bamtofastq(; options...)::Cmd

Convert BAM alignments to FASTQ files.

The bedtools bamtofastq command with options, checked against those that its help lists, to run with BEDTools.lines or any of Julia's process functions. It needs i and fq: BEDTools.Bindings.bamtofastq(i = …, fq = …). Its usage, in BEDTools 2.31.1, is bamToFastq [OPTIONS] -i <BAM> -fq <FQ>.

An option of true is a flag, false and nothing leave it out, a vector gives it each element as an argument, and another value gives it that value. An option with several spellings, such as a short and a long form, takes any one of them, and each emits its own.

Options:

• i: <BAM>, from the usage line.
• fq: <FQ>, from the usage line.
• fq2: FASTQ for second end. Used if BAM contains paired-end data. BAM should be sorted by query name is creating paired FASTQ.
• tags: Create FASTQ based on the mate info in the BAM R2 and Q2 tags.

It also takes the general parameters of BEDTools, in BEDTools.Bindings.GENERAL_OPTIONS, which come before the subcommand.

BEDTools.Bindings.bed12tobed6(; options...)::Cmd

Splits BED12 features into discrete BED6 features.

The bedtools bed12tobed6 command with options, checked against those that its help lists, to run with BEDTools.lines or any of Julia's process functions. It needs i: BEDTools.Bindings.bed12tobed6(i = …). Its usage, in BEDTools 2.31.1, is bedtools bed12tobed6 [OPTIONS] -i <bed12>.

An option of true is a flag, false and nothing leave it out, a vector gives it each element as an argument, and another value gives it that value. An option with several spellings, such as a short and a long form, takes any one of them, and each emits its own.

Options:

• i: <bed12>, from the usage line.
• n: Force the score to be the (1-based) block number from the BED12.

It also takes the general parameters of BEDTools, in BEDTools.Bindings.GENERAL_OPTIONS, which come before the subcommand.

BEDTools.Bindings.bedpetobam(; options...)::Cmd

Converts feature records to BAM format.

The bedtools bedpetobam command with options, checked against those that its help lists, to run with BEDTools.lines or any of Julia's process functions. It needs i and g: BEDTools.Bindings.bedpetobam(i = …, g = …). Its usage, in BEDTools 2.31.1, is bedpetobam [OPTIONS] -i <bed/gff/vcf> -g <genome>.

An option of true is a flag, false and nothing leave it out, a vector gives it each element as an argument, and another value gives it that value. An option with several spellings, such as a short and a long form, takes any one of them, and each emits its own.

Options:

• i: <bed/gff/vcf>, from the usage line.
• g: <genome>, from the usage line.
• mapq: Set the mappinq quality for the BAM records. (INT) Default: 255
• ubam: Write uncompressed BAM output. Default writes compressed BAM.

It also takes the general parameters of BEDTools, in BEDTools.Bindings.GENERAL_OPTIONS, which come before the subcommand.

BEDTools.Bindings.bedtobam(; options...)::Cmd

Converts feature records to BAM format.

The bedtools bedtobam command with options, checked against those that its help lists, to run with BEDTools.lines or any of Julia's process functions. It needs i and g: BEDTools.Bindings.bedtobam(i = …, g = …). Its usage, in BEDTools 2.31.1, is bedtools bedtobam [OPTIONS] -i <bed/gff/vcf> -g <genome>.

An option of true is a flag, false and nothing leave it out, a vector gives it each element as an argument, and another value gives it that value. An option with several spellings, such as a short and a long form, takes any one of them, and each emits its own.

Options:

• i: <bed/gff/vcf>, from the usage line.
• g: <genome>, from the usage line.
• mapq: Set the mappinq quality for the BAM records. (INT) Default: 255
• bed12: The BED file is in BED12 format. The BAM CIGAR string will reflect BED "blocks".
• ubam: Write uncompressed BAM output. Default writes compressed BAM.

It also takes the general parameters of BEDTools, in BEDTools.Bindings.GENERAL_OPTIONS, which come before the subcommand.

BEDTools.Bindings.closest(; options...)::Cmd

For each feature in A, finds the closest feature (upstream or downstream) in B.

The bedtools closest command with options, checked against those that its help lists, to run with BEDTools.lines or any of Julia's process functions. It needs a and b: BEDTools.Bindings.closest(a = …, b = …). Its usage, in BEDTools 2.31.1, is bedtools closest [OPTIONS] -a <bed/gff/vcf> -b <bed/gff/vcf>.

An option of true is a flag, false and nothing leave it out, a vector gives it each element as an argument, and another value gives it that value. An option with several spellings, such as a short and a long form, takes any one of them, and each emits its own.

Options:

• a: <bed/gff/vcf>, from the usage line.
• b: <bed/gff/vcf>, from the usage line.
• d: In addition to the closest feature in B, report its distance to A as an extra column. - The reported distance for overlapping features will be 0.
• D: Like -d, report the closest feature in B, and its distance to A as an extra column. Unlike -d, use negative distances to report upstream features. The options for defining which orientation is "upstream" are: - "ref" Report distance with respect to the reference genome. B features with a lower (start, stop) are upstream - "a" Report distance with respect to A. When A is on the - strand, "upstream" means B has a higher (start,stop). - "b" Report distance with respect to B. When B is on the - strand, "upstream" means A has a higher (start,stop).
• io: Ignore features in B that overlap A. That is, we want close, yet not touching features only.
• iu: Ignore features in B that are upstream of features in A. This option requires -D and follows its orientation rules for determining what is "upstream".
• id: Ignore features in B that are downstream of features in A. This option requires -D and follows its orientation rules for determining what is "downstream".
• fu: Choose first from features in B that are upstream of features in A. This option requires -D and follows its orientation rules for determining what is "upstream".
• fd: Choose first from features in B that are downstream of features in A. This option requires -D and follows its orientation rules for determining what is "downstream".
• t: How ties for closest feature are handled. This occurs when two features in B have exactly the same "closeness" with A. By default, all such features in B are reported. Here are all the options: - "all" Report all ties (default). - "first" Report the first tie that occurred in the B file. - "last" Report the last tie that occurred in the B file.
• mdb: How multiple databases are resolved. - "each" Report closest records for each database (default). - "all" Report closest records among all databases.
• k: Report the k closest hits. Default is 1. If tieMode = "all", - all ties will still be reported.
• N: Require that the query and the closest hit have different names. For BED, the 4th column is compared.
• s: Require same strandedness. That is, only report hits in B that overlap A on the same strand. - By default, overlaps are reported without respect to strand.
• S: Require different strandedness. That is, only report hits in B that overlap A on the opposite strand. - By default, overlaps are reported without respect to strand.
• f: Minimum overlap required as a fraction of A. - Default is 1E-9 (i.e., 1bp). - FLOAT (e.g. 0.50)
• F: Minimum overlap required as a fraction of B. - Default is 1E-9 (i.e., 1bp). - FLOAT (e.g. 0.50)
• r: Require that the fraction overlap be reciprocal for A AND B. - In other words, if -f is 0.90 and -r is used, this requires that B overlap 90% of A and A also overlaps 90% of B.
• e: Require that the minimum fraction be satisfied for A OR B. - In other words, if -e is used with -f 0.90 and -F 0.10 this requires that either 90% of A is covered OR 10% of B is covered. Without -e, both fractions would have to be satisfied.
• split: Treat "split" BAM or BED12 entries as distinct BED intervals.
• g: Provide a genome file to enforce consistent chromosome sort order across input files. Only applies when used with -sorted option.
• nonamecheck: For sorted data, don't throw an error if the file has different naming conventions for the same chromosome. ex. "chr1" vs "chr01".
• names: When using multiple databases, provide an alias for each that will appear instead of a fileId when also printing the DB record.
• filenames: When using multiple databases, show each complete filename instead of a fileId when also printing the DB record.
• sortout: When using multiple databases, sort the output DB hits for each record.
• bed: If using BAM input, write output as BED.
• header: Print the header from the A file prior to results.
• nobuf: Disable buffered output. Using this option will cause each line of output to be printed as it is generated, rather than saved in a buffer. This will make printing large output files noticeably slower, but can be useful in conjunction with other software tools and scripts that need to process one line of bedtools output at a time.
• iobuf: Specify amount of memory to use for input buffer. Takes an integer argument. Optional suffixes K/M/G supported. Note: currently has no effect with compressed files.

It also takes the general parameters of BEDTools, in BEDTools.Bindings.GENERAL_OPTIONS, which come before the subcommand.

BEDTools.Bindings.cluster(; options...)::Cmd

Clusters overlapping/nearby BED/GFF/VCF intervals.

The bedtools cluster command with options, checked against those that its help lists, to run with BEDTools.lines or any of Julia's process functions. It needs i: BEDTools.Bindings.cluster(i = …). Its usage, in BEDTools 2.31.1, is bedtools cluster [OPTIONS] -i <bed/gff/vcf>.

An option of true is a flag, false and nothing leave it out, a vector gives it each element as an argument, and another value gives it that value. An option with several spellings, such as a short and a long form, takes any one of them, and each emits its own.

Options:

• i: <bed/gff/vcf>, from the usage line.
• s: Force strandedness. That is, only merge features that are the same strand. - By default, merging is done without respect to strand.
• d: Maximum distance between features allowed for features to be merged. - Def. 0. That is, overlapping & book-ended features are merged. - (INTEGER)

It also takes the general parameters of BEDTools, in BEDTools.Bindings.GENERAL_OPTIONS, which come before the subcommand.

BEDTools.Bindings.complement(; options...)::Cmd

Returns the base pair complement of a feature file.

The bedtools complement command with options, checked against those that its help lists, to run with BEDTools.lines or any of Julia's process functions. It needs i and g: BEDTools.Bindings.complement(i = …, g = …). Its usage, in BEDTools 2.31.1, is bedtools complement [OPTIONS] -i <bed/gff/vcf> -g <genome>.

An option of true is a flag, false and nothing leave it out, a vector gives it each element as an argument, and another value gives it that value. An option with several spellings, such as a short and a long form, takes any one of them, and each emits its own.

Options:

• i: <bed/gff/vcf>, from the usage line.
• g: <genome>, from the usage line.
• L: Limit output to solely the chromosomes with records in the input file.

It also takes the general parameters of BEDTools, in BEDTools.Bindings.GENERAL_OPTIONS, which come before the subcommand.

BEDTools.Bindings.coverage(; options...)::Cmd

Returns the depth and breadth of coverage of features from B on the intervals in A.

The bedtools coverage command with options, checked against those that its help lists, to run with BEDTools.lines or any of Julia's process functions. It needs a and b: BEDTools.Bindings.coverage(a = …, b = …). Its usage, in BEDTools 2.31.1, is bedtools coverage [OPTIONS] -a <bed/gff/vcf> -b <bed/gff/vcf>.

An option of true is a flag, false and nothing leave it out, a vector gives it each element as an argument, and another value gives it that value. An option with several spellings, such as a short and a long form, takes any one of them, and each emits its own.

Options:

• a: <bed/gff/vcf>, from the usage line.
• b: <bed/gff/vcf>, from the usage line.
• hist: Report a histogram of coverage for each feature in A as well as a summary histogram for all features in A.
• d: Report the depth at each position in each A feature. Positions reported are one based. Each position and depth follow the complete A feature.
• counts: Only report the count of overlaps, don't compute fraction, etc.
• mean: Report the mean depth of all positions in each A feature.
• s: Require same strandedness. That is, only report hits in B that overlap A on the same strand. - By default, overlaps are reported without respect to strand.
• S: Require different strandedness. That is, only report hits in B that overlap A on the opposite strand. - By default, overlaps are reported without respect to strand.
• f: Minimum overlap required as a fraction of A. - Default is 1E-9 (i.e., 1bp). - FLOAT (e.g. 0.50)
• F: Minimum overlap required as a fraction of B. - Default is 1E-9 (i.e., 1bp). - FLOAT (e.g. 0.50)
• r: Require that the fraction overlap be reciprocal for A AND B. - In other words, if -f is 0.90 and -r is used, this requires that B overlap 90% of A and A also overlaps 90% of B.
• e: Require that the minimum fraction be satisfied for A OR B. - In other words, if -e is used with -f 0.90 and -F 0.10 this requires that either 90% of A is covered OR 10% of B is covered. Without -e, both fractions would have to be satisfied.
• split: Treat "split" BAM or BED12 entries as distinct BED intervals.
• g: Provide a genome file to enforce consistent chromosome sort order across input files. Only applies when used with -sorted option.
• nonamecheck: For sorted data, don't throw an error if the file has different naming conventions for the same chromosome. ex. "chr1" vs "chr01".
• sorted: Use the "chromsweep" algorithm for sorted (-k1,1 -k2,2n) input.
• bed: If using BAM input, write output as BED.
• header: Print the header from the A file prior to results.
• nobuf: Disable buffered output. Using this option will cause each line of output to be printed as it is generated, rather than saved in a buffer. This will make printing large output files noticeably slower, but can be useful in conjunction with other software tools and scripts that need to process one line of bedtools output at a time.
• iobuf: Specify amount of memory to use for input buffer. Takes an integer argument. Optional suffixes K/M/G supported. Note: currently has no effect with compressed files.

It also takes the general parameters of BEDTools, in BEDTools.Bindings.GENERAL_OPTIONS, which come before the subcommand.

BEDTools.Bindings.expand(; options...)::Cmd

Replicate lines in a file based on columns of comma-separated values.

The bedtools expand command with options, checked against those that its help lists, to run with BEDTools.lines or any of Julia's process functions. It needs c: BEDTools.Bindings.expand(c = …). Its usage, in BEDTools 2.31.1, is bedtools expand -c [COLS].

An option of true is a flag, false and nothing leave it out, a vector gives it each element as an argument, and another value gives it that value. An option with several spellings, such as a short and a long form, takes any one of them, and each emits its own.

Options:

• i: Input file. Assumes "stdin" if omitted.
• c: Specify the column (1-based) that should be summarized. - Required.

It also takes the general parameters of BEDTools, in BEDTools.Bindings.GENERAL_OPTIONS, which come before the subcommand.

BEDTools.Bindings.fisher(; options...)::Cmd

Calculate Fisher statistic b/w two feature files.

The bedtools fisher command with options, checked against those that its help lists, to run with BEDTools.lines or any of Julia's process functions. It needs a, b and g: BEDTools.Bindings.fisher(a = …, b = …, g = …). Its usage, in BEDTools 2.31.1, is bedtools fisher [OPTIONS] -a <bed/gff/vcf> -b <bed/gff/vcf> -g <genome file>.

An option of true is a flag, false and nothing leave it out, a vector gives it each element as an argument, and another value gives it that value. An option with several spellings, such as a short and a long form, takes any one of them, and each emits its own.

Options:

• a: <bed/gff/vcf>, from the usage line.
• b: <bed/gff/vcf>, from the usage line.
• m: Merge overlapping intervals before - looking at overlap.
• s: Require same strandedness. That is, only report hits in B that overlap A on the same strand. - By default, overlaps are reported without respect to strand.
• S: Require different strandedness. That is, only report hits in B that overlap A on the opposite strand. - By default, overlaps are reported without respect to strand.
• f: Minimum overlap required as a fraction of A. - Default is 1E-9 (i.e., 1bp). - FLOAT (e.g. 0.50)
• F: Minimum overlap required as a fraction of B. - Default is 1E-9 (i.e., 1bp). - FLOAT (e.g. 0.50)
• r: Require that the fraction overlap be reciprocal for A AND B. - In other words, if -f is 0.90 and -r is used, this requires that B overlap 90% of A and A also overlaps 90% of B.
• e: Require that the minimum fraction be satisfied for A OR B. - In other words, if -e is used with -f 0.90 and -F 0.10 this requires that either 90% of A is covered OR 10% of B is covered. Without -e, both fractions would have to be satisfied.
• split: Treat "split" BAM or BED12 entries as distinct BED intervals.
• g: Provide a genome file to enforce consistent chromosome sort order across input files. Only applies when used with -sorted option.
• nonamecheck: For sorted data, don't throw an error if the file has different naming conventions for the same chromosome. ex. "chr1" vs "chr01".
• bed: If using BAM input, write output as BED.
• header: Print the header from the A file prior to results.
• nobuf: Disable buffered output. Using this option will cause each line of output to be printed as it is generated, rather than saved in a buffer. This will make printing large output files noticeably slower, but can be useful in conjunction with other software tools and scripts that need to process one line of bedtools output at a time.
• iobuf: Specify amount of memory to use for input buffer. Takes an integer argument. Optional suffixes K/M/G supported. Note: currently has no effect with compressed files.

It also takes the general parameters of BEDTools, in BEDTools.Bindings.GENERAL_OPTIONS, which come before the subcommand.

BEDTools.Bindings.flank(; options...)::Cmd

Creates flanking interval(s) for each BED/GFF/VCF feature.

The bedtools flank command with options, checked against those that its help lists, to run with BEDTools.lines or any of Julia's process functions. It needs i and g: BEDTools.Bindings.flank(i = …, g = …). Its usage, in BEDTools 2.31.1, is bedtools flank [OPTIONS] -i <bed/gff/vcf> -g <genome> [-b <int> or (-l and -r)].

An option of true is a flag, false and nothing leave it out, a vector gives it each element as an argument, and another value gives it that value. An option with several spellings, such as a short and a long form, takes any one of them, and each emits its own.

Options:

• i: <bed/gff/vcf>, from the usage line.
• g: <genome>, from the usage line.
• b: Create flanking interval(s) using -b base pairs in each direction. - (Integer) or (Float, e.g. 0.1) if used with -pct.
• l: The number of base pairs that a flank should start from orig. start coordinate. - (Integer) or (Float, e.g. 0.1) if used with -pct.
• r: The number of base pairs that a flank should end from orig. end coordinate. - (Integer) or (Float, e.g. 0.1) if used with -pct.
• s: Define -l and -r based on strand. E.g. if used, -l 500 for a negative-stranded feature, it will start the flank 500 bp downstream. Default = false.
• pct: Define -l and -r as a fraction of the feature's length. E.g. if used on a 1000bp feature, -l 0.50, will add 500 bp "upstream". Default = false.
• header: Print the header from the input file prior to results.

It also takes the general parameters of BEDTools, in BEDTools.Bindings.GENERAL_OPTIONS, which come before the subcommand.

BEDTools.Bindings.genomecov(; options...)::Cmd

Compute the coverage of a feature file among a genome.

The bedtools genomecov command with options, checked against those that its help lists, to run with BEDTools.lines or any of Julia's process functions. Its usage, in BEDTools 2.31.1, is bedtools genomecov [OPTIONS] -i <bed/gff/vcf> -g <genome> OR -ibam <bam/cram>.

An option of true is a flag, false and nothing leave it out, a vector gives it each element as an argument, and another value gives it that value. An option with several spellings, such as a short and a long form, takes any one of them, and each emits its own. Options whose names aren't Julia names are given as var"name", such as var"5" = true.

Options:

• i: <bed/gff/vcf>, from the usage line.
• ibam: The input file is in BAM format. Note: BAM must be sorted by position
• g: Provide a genome file to define chromosome lengths. Note:Required when not using -ibam option.
• d: Report the depth at each genome position (with one-based coordinates). Default behavior is to report a histogram.
• dz: Report the depth at each genome position (with zero-based coordinates). Reports only non-zero positions. Default behavior is to report a histogram.
• bg: Report depth in BedGraph format. For details, see: genome.ucsc.edu/goldenPath/help/bedgraph.html
• bga: Report depth in BedGraph format, as above (-bg). However with this option, regions with zero coverage are also reported. This allows one to quickly extract all regions of a genome with 0 coverage by applying: "grep -w 0$" to the output.
• split: Treat "split" BAM or BED12 entries as distinct BED intervals. when computing coverage. For BAM files, this uses the CIGAR "N" and "D" operations to infer the blocks for computing coverage. For BED12 files, this uses the BlockCount, BlockStarts, and BlockEnds fields (i.e., columns 10,11,12).
• ignoreD: Ignore local deletions (CIGAR "D" operations) in BAM entries when computing coverage.
• strand: Calculate coverage of intervals from a specific strand. With BED files, requires at least 6 columns (strand is column 6). - (STRING): can be + or -
• pc: Calculate coverage of pair-end fragments. Works for BAM files only
• fs: Force to use provided fragment size instead of read length Works for BAM files only
• du: Change strand af the mate read (so both reads from the same strand) useful for strand specific Works for BAM files only
• 5: Calculate coverage of 5" positions (instead of entire interval).
• 3: Calculate coverage of 3" positions (instead of entire interval).
• max: Combine all positions with a depth >= max into a single bin in the histogram. Irrelevant for -d and -bedGraph - (INTEGER)
• scale: Scale the coverage by a constant factor. Each coverage value is multiplied by this factor before being reported. Useful for normalizing coverage by, e.g., reads per million (RPM). - Default is 1.0; i.e., unscaled. - (FLOAT)
• trackline: Adds a UCSC/Genome-Browser track line definition in the first line of the output. - See here for more details about track line definition: http://genome.ucsc.edu/goldenPath/help/bedgraph.html - NOTE: When adding a trackline definition, the output BedGraph can be easily uploaded to the Genome Browser as a custom track, BUT CAN NOT be converted into a BigWig file (w/o removing the first line).
• trackopts: Writes additional track line definition parameters in the first line. - Example: -trackopts 'name="My Track" visibility=2 color=255,30,30' Note the use of single-quotes if you have spaces in your parameters. - (TEXT)

It also takes the general parameters of BEDTools, in BEDTools.Bindings.GENERAL_OPTIONS, which come before the subcommand.

BEDTools.Bindings.getfasta(; options...)::Cmd

Extract DNA sequences from a fasta file based on feature coordinates.

The bedtools getfasta command with options, checked against those that its help lists, to run with BEDTools.lines or any of Julia's process functions. It needs fi and bed: BEDTools.Bindings.getfasta(fi = …, bed = …). Its usage, in BEDTools 2.31.1, is bedtools getfasta [OPTIONS] -fi <fasta> -bed <bed/gff/vcf>.

An option of true is a flag, false and nothing leave it out, a vector gives it each element as an argument, and another value gives it that value. An option with several spellings, such as a short and a long form, takes any one of them, and each emits its own. Options whose names aren't Julia names are given as var"name", such as var"name+" = true.

Options:

• fi: Input FASTA file
• fo: Output file (opt., default is STDOUT
• bed: BED/GFF/VCF file of ranges to extract from -fi
• name: Use the name field and coordinates for the FASTA header
• name+: (deprecated) Use the name field and coordinates for the FASTA header
• nameOnly: Use the name field for the FASTA header
• split: Given BED12 fmt., extract and concatenate the sequences from the BED "blocks" (e.g., exons)
• tab: Write output in TAB delimited format.
• bedOut: Report extract sequences in a tab-delimited BED format instead of in FASTA format. - Default is FASTA format.
• s: Force strandedness. If the feature occupies the antisense, strand, the sequence will be reverse complemented. - By default, strand information is ignored.
• fullHeader: Use full fasta header. - By default, only the word before the first space or tab is used.
• rna: The FASTA is RNA not DNA. Reverse complementation handled accordingly.

It also takes the general parameters of BEDTools, in BEDTools.Bindings.GENERAL_OPTIONS, which come before the subcommand.

BEDTools.Bindings.groupby(; options...)::Cmd

Summarizes a dataset column based upon common column groupings. Akin to the SQL "group by" command.

The bedtools groupby command with options, checked against those that its help lists, to run with BEDTools.lines or any of Julia's process functions. It needs g, c and o: BEDTools.Bindings.groupby(g = …, c = …, o = …). Its usage, in BEDTools 2.31.1, is bedtools groupby -g [group_column(s)] -c [op_column(s)] -o [ops].

An option of true is a flag, false and nothing leave it out, a vector gives it each element as an argument, and another value gives it that value. An option with several spellings, such as a short and a long form, takes any one of them, and each emits its own.

Options:

• i: Input file. Assumes "stdin" if omitted.
• g: -grp Specify the columns (1-based) for the grouping. The columns must be comma separated. - Default: 1,2,3
• c: -opCols Specify the column (1-based) that should be summarized. - Required.
• o: -ops Specify the operation that should be applied to opCol. Valid operations: sum, count, countdistinct, min, max, mean, median, mode, antimode, stdev, sstdev (sample standard dev.), collapse (i.e., print a comma separated list (duplicates allowed)), distinct (i.e., print a comma separated list (NO duplicates allowed)), distinctsortnum (as distinct, but sorted numerically, ascending), distinctsortnumdesc (as distinct, but sorted numerically, descending), concat (i.e., merge values into a single, non-delimited string), freqdesc (i.e., print desc. list of values:freq) freqasc (i.e., print asc. list of values:freq) first (i.e., print first value) last (i.e., print last value) - Default: sum
• full: Print all columns from input file. The first line in the group is used. Default: print only grouped columns.
• inheader: Input file has a header line - the first line will be ignored.
• outheader: Print header line in the output, detailing the column names. If the input file has headers (-inheader), the output file will use the input's column names. If the input file has no headers, the output file will use "col1", "col2", etc. as the column names.
• header: same as '-inheader -outheader'
• ignorecase: Group values regardless of upper/lower case.
• prec: Sets the decimal precision for output (Default: 5)
• delim: Specify a custom delimiter for the collapse operations. - Example: -delim "|" - Default: ",".

It also takes the general parameters of BEDTools, in BEDTools.Bindings.GENERAL_OPTIONS, which come before the subcommand.

BEDTools.Bindings.igv(; options...)::Cmd

Creates a batch script to create IGV images at each interval defined in a BED/GFF/VCF file.

The bedtools igv command with options, checked against those that its help lists, to run with BEDTools.lines or any of Julia's process functions. It needs i: BEDTools.Bindings.igv(i = …). Its usage, in BEDTools 2.31.1, is bedtools igv [OPTIONS] -i <bed/gff/vcf>.

An option of true is a flag, false and nothing leave it out, a vector gives it each element as an argument, and another value gives it that value. An option with several spellings, such as a short and a long form, takes any one of them, and each emits its own.

Options:

• i: <bed/gff/vcf>, from the usage line.
• path: The full path to which the IGV snapshots should be written. (STRING) Default: ./
• sess: The full path to an existing IGV session file to be loaded prior to taking snapshots.
• sort: The type of BAM sorting you would like to apply to each image. Options: base, position, strand, quality, sample, and readGroup Default is to apply no sorting at all.
• clps: Collapse the aligned reads prior to taking a snapshot. Default is to no collapse.
• name: Use the "name" field (column 4) for each image's filename. Default is to use the "chr:start-pos.ext".
• slop: Number of flanking base pairs on the left & right of the image. - (INT) Default = 0.
• img: The type of image to be created. Options: png, eps, svg Default is png.

It also takes the general parameters of BEDTools, in BEDTools.Bindings.GENERAL_OPTIONS, which come before the subcommand.

BEDTools.Bindings.intersect(; options...)::Cmd

Report overlaps between two feature files.

The bedtools intersect command with options, checked against those that its help lists, to run with BEDTools.lines or any of Julia's process functions. It needs a and b: BEDTools.Bindings.intersect(a = …, b = …). Its usage, in BEDTools 2.31.1, is bedtools intersect [OPTIONS] -a <bed/gff/vcf/bam> -b <bed/gff/vcf/bam>.

An option of true is a flag, false and nothing leave it out, a vector gives it each element as an argument, and another value gives it that value. An option with several spellings, such as a short and a long form, takes any one of them, and each emits its own.

Options:

• a: <bed/gff/vcf/bam>, from the usage line.
• b: <bed/gff/vcf/bam>, from the usage line.
• wa: Write the original entry in A for each overlap.
• wb: Write the original entry in B for each overlap. - Useful for knowing what A overlaps. Restricted by -f and -r.
• loj: Perform a "left outer join". That is, for each feature in A report each overlap with B. If no overlaps are found, report a NULL feature for B.
• wo: Write the original A and B entries plus the number of base pairs of overlap between the two features. - Overlaps restricted by -f and -r. Only A features with overlap are reported.
• wao: Write the original A and B entries plus the number of base pairs of overlap between the two features. - Overlapping features restricted by -f and -r. However, A features w/o overlap are also reported with a NULL B feature and overlap = 0.
• u: Write the original A entry once if any overlaps found in B. - In other words, just report the fact >=1 hit was found. - Overlaps restricted by -f and -r.
• c: For each entry in A, report the number of overlaps with B. - Reports 0 for A entries that have no overlap with B. - Overlaps restricted by -f, -F, -r, and -s.
• C: For each entry in A, separately report the number of - overlaps with each B file on a distinct line. - Reports 0 for A entries that have no overlap with B. - Overlaps restricted by -f, -F, -r, and -s.
• v: Only report those entries in A that have no overlaps with B. - Similar to "grep -v" (an homage).
• ubam: Write uncompressed BAM output. Default writes compressed BAM.
• s: Require same strandedness. That is, only report hits in B that overlap A on the same strand. - By default, overlaps are reported without respect to strand.
• S: Require different strandedness. That is, only report hits in B that overlap A on the opposite strand. - By default, overlaps are reported without respect to strand.
• f: Minimum overlap required as a fraction of A. - Default is 1E-9 (i.e., 1bp). - FLOAT (e.g. 0.50)
• F: Minimum overlap required as a fraction of B. - Default is 1E-9 (i.e., 1bp). - FLOAT (e.g. 0.50)
• r: Require that the fraction overlap be reciprocal for A AND B. - In other words, if -f is 0.90 and -r is used, this requires that B overlap 90% of A and A also overlaps 90% of B.
• e: Require that the minimum fraction be satisfied for A OR B. - In other words, if -e is used with -f 0.90 and -F 0.10 this requires that either 90% of A is covered OR 10% of B is covered. Without -e, both fractions would have to be satisfied.
• split: Treat "split" BAM or BED12 entries as distinct BED intervals.
• g: Provide a genome file to enforce consistent chromosome sort order across input files. Only applies when used with -sorted option.
• nonamecheck: For sorted data, don't throw an error if the file has different naming conventions for the same chromosome. ex. "chr1" vs "chr01".
• sorted: Use the "chromsweep" algorithm for sorted (-k1,1 -k2,2n) input.
• names: When using multiple databases, provide an alias for each that will appear instead of a fileId when also printing the DB record.
• filenames: When using multiple databases, show each complete filename instead of a fileId when also printing the DB record.
• sortout: When using multiple databases, sort the output DB hits for each record.
• bed: If using BAM input, write output as BED.
• header: Print the header from the A file prior to results.
• nobuf: Disable buffered output. Using this option will cause each line of output to be printed as it is generated, rather than saved in a buffer. This will make printing large output files noticeably slower, but can be useful in conjunction with other software tools and scripts that need to process one line of bedtools output at a time.
• iobuf: Specify amount of memory to use for input buffer. Takes an integer argument. Optional suffixes K/M/G supported. Note: currently has no effect with compressed files.

It also takes the general parameters of BEDTools, in BEDTools.Bindings.GENERAL_OPTIONS, which come before the subcommand.

BEDTools.Bindings.jaccard(; options...)::Cmd

Calculate Jaccard statistic b/w two feature files. Jaccard is the length of the intersection over the union. Values range from 0 (no intersection) to 1 (self intersection).

The bedtools jaccard command with options, checked against those that its help lists, to run with BEDTools.lines or any of Julia's process functions. It needs a and b: BEDTools.Bindings.jaccard(a = …, b = …). Its usage, in BEDTools 2.31.1, is bedtools jaccard [OPTIONS] -a <bed/gff/vcf> -b <bed/gff/vcf>.

An option of true is a flag, false and nothing leave it out, a vector gives it each element as an argument, and another value gives it that value. An option with several spellings, such as a short and a long form, takes any one of them, and each emits its own.

Options:

• a: <bed/gff/vcf>, from the usage line.
• b: <bed/gff/vcf>, from the usage line.
• s: Require same strandedness. That is, only report hits in B that overlap A on the same strand. - By default, overlaps are reported without respect to strand.
• S: Require different strandedness. That is, only report hits in B that overlap A on the opposite strand. - By default, overlaps are reported without respect to strand.
• f: Minimum overlap required as a fraction of A. - Default is 1E-9 (i.e., 1bp). - FLOAT (e.g. 0.50)
• F: Minimum overlap required as a fraction of B. - Default is 1E-9 (i.e., 1bp). - FLOAT (e.g. 0.50)
• r: Require that the fraction overlap be reciprocal for A AND B. - In other words, if -f is 0.90 and -r is used, this requires that B overlap 90% of A and A also overlaps 90% of B.
• e: Require that the minimum fraction be satisfied for A OR B. - In other words, if -e is used with -f 0.90 and -F 0.10 this requires that either 90% of A is covered OR 10% of B is covered. Without -e, both fractions would have to be satisfied.
• split: Treat "split" BAM or BED12 entries as distinct BED intervals.
• g: Provide a genome file to enforce consistent chromosome sort order across input files. Only applies when used with -sorted option.
• nonamecheck: For sorted data, don't throw an error if the file has different naming conventions for the same chromosome. ex. "chr1" vs "chr01".
• bed: If using BAM input, write output as BED.
• header: Print the header from the A file prior to results.
• nobuf: Disable buffered output. Using this option will cause each line of output to be printed as it is generated, rather than saved in a buffer. This will make printing large output files noticeably slower, but can be useful in conjunction with other software tools and scripts that need to process one line of bedtools output at a time.
• iobuf: Specify amount of memory to use for input buffer. Takes an integer argument. Optional suffixes K/M/G supported. Note: currently has no effect with compressed files.

It also takes the general parameters of BEDTools, in BEDTools.Bindings.GENERAL_OPTIONS, which come before the subcommand.

BEDTools.Bindings.links(; options...)::Cmd

Creates HTML links to an UCSC Genome Browser from a feature file.

The bedtools links command with options, checked against those that its help lists, to run with BEDTools.lines or any of Julia's process functions. It needs i: BEDTools.Bindings.links(i = …). Its usage, in BEDTools 2.31.1, is bedtools links [OPTIONS] -i <bed/gff/vcf> > out.html.

An option of true is a flag, false and nothing leave it out, a vector gives it each element as an argument, and another value gives it that value. An option with several spellings, such as a short and a long form, takes any one of them, and each emits its own.

Options:

• i: <bed/gff/vcf>, from the usage line.
• base: The browser basename. Default: http://genome.ucsc.edu
• org: The organism. Default: human
• db: The build. Default: hg18

It also takes the general parameters of BEDTools, in BEDTools.Bindings.GENERAL_OPTIONS, which come before the subcommand.

BEDTools.Bindings.makewindows(; options...)::Cmd

Makes adjacent or sliding windows across a genome or BED file.

The bedtools makewindows command with options, checked against those that its help lists, to run with BEDTools.lines or any of Julia's process functions. Its usage, in BEDTools 2.31.1, is bedtools makewindows [OPTIONS] [-g <genome> OR -b <bed>].

An option of true is a flag, false and nothing leave it out, a vector gives it each element as an argument, and another value gives it that value. An option with several spellings, such as a short and a long form, takes any one of them, and each emits its own.

Options:

• g: <genome> Genome file size (see notes below). Windows will be created for each chromosome in the file.
• b: <bed> BED file (with chrom,start,end fields). Windows will be created for each interval in the file.
• w: <windowsize> Divide each input interval (either a chromosome or a BED interval) to fixed-sized windows (i.e. same number of nucleotide in each window). Can be combined with -s <stepsize>
• s: <step_size> Step size: i.e., how many base pairs to step before creating a new window. Used to create "sliding" windows. - Defaults to window size (non-sliding windows).
• n: <numberofwindows> Divide each input interval (either a chromosome or a BED interval) to fixed number of windows (i.e. same number of windows, with varying window sizes).
• reverse: Reverse numbering of windows in the output, i.e. report windows in decreasing order
• i: src|winnum|srcwinnum The default output is 3 columns: chrom, start, end . With this option, a name column will be added. "-i src" - use the source interval's name. "-i winnum" - use the window number as the ID (e.g. 1,2,3,4...). "-i srcwinnum" - use the source interval's name with the window number. See below for usage examples.

It also takes the general parameters of BEDTools, in BEDTools.Bindings.GENERAL_OPTIONS, which come before the subcommand.

BEDTools.Bindings.map(; options...)::Cmd

Apply a function to a column from B intervals that overlap A.

The bedtools map command with options, checked against those that its help lists, to run with BEDTools.lines or any of Julia's process functions. It needs a and b: BEDTools.Bindings.map(a = …, b = …). Its usage, in BEDTools 2.31.1, is bedtools map [OPTIONS] -a <bed/gff/vcf> -b <bed/gff/vcf>.

An option of true is a flag, false and nothing leave it out, a vector gives it each element as an argument, and another value gives it that value. An option with several spellings, such as a short and a long form, takes any one of them, and each emits its own.

Options:

• a: <bed/gff/vcf>, from the usage line.
• b: <bed/gff/vcf>, from the usage line.
• c: Specify columns from the B file to map onto intervals in A. Default: 5. Multiple columns can be specified in a comma-delimited list.
• o: Specify the operation that should be applied to -c. Valid operations: sum, min, max, absmin, absmax, mean, median, mode, antimode stdev, sstdev collapse (i.e., print a delimited list (duplicates allowed)), distinct (i.e., print a delimited list (NO duplicates allowed)), distinctsortnum (as distinct, sorted numerically, ascending), distinctsortnumdesc (as distinct, sorted numerically, desscending), distinctonly (delimited list of only unique values), count count_distinct (i.e., a count of the unique values in the column), first (i.e., just the first value in the column), last (i.e., just the last value in the column), Default: sum Multiple operations can be specified in a comma-delimited list.
• delim: Specify a custom delimiter for the collapse operations. - Example: -delim "|" - Default: ",".
• prec: Sets the decimal precision for output (Default: 5)
• s: Require same strandedness. That is, only report hits in B that overlap A on the same strand. - By default, overlaps are reported without respect to strand.
• S: Require different strandedness. That is, only report hits in B that overlap A on the opposite strand. - By default, overlaps are reported without respect to strand.
• f: Minimum overlap required as a fraction of A. - Default is 1E-9 (i.e., 1bp). - FLOAT (e.g. 0.50)
• F: Minimum overlap required as a fraction of B. - Default is 1E-9 (i.e., 1bp). - FLOAT (e.g. 0.50)
• r: Require that the fraction overlap be reciprocal for A AND B. - In other words, if -f is 0.90 and -r is used, this requires that B overlap 90% of A and A also overlaps 90% of B.
• e: Require that the minimum fraction be satisfied for A OR B. - In other words, if -e is used with -f 0.90 and -F 0.10 this requires that either 90% of A is covered OR 10% of B is covered. Without -e, both fractions would have to be satisfied.
• split: Treat "split" BAM or BED12 entries as distinct BED intervals.
• g: Provide a genome file to enforce consistent chromosome sort order across input files. Only applies when used with -sorted option.
• nonamecheck: For sorted data, don't throw an error if the file has different naming conventions for the same chromosome. ex. "chr1" vs "chr01".
• bed: If using BAM input, write output as BED.
• header: Print the header from the A file prior to results.
• nobuf: Disable buffered output. Using this option will cause each line of output to be printed as it is generated, rather than saved in a buffer. This will make printing large output files noticeably slower, but can be useful in conjunction with other software tools and scripts that need to process one line of bedtools output at a time.
• iobuf: Specify amount of memory to use for input buffer. Takes an integer argument. Optional suffixes K/M/G supported. Note: currently has no effect with compressed files.

It also takes the general parameters of BEDTools, in BEDTools.Bindings.GENERAL_OPTIONS, which come before the subcommand.

BEDTools.Bindings.maskfasta(; options...)::Cmd

Mask a fasta file based on feature coordinates.

The bedtools maskfasta command with options, checked against those that its help lists, to run with BEDTools.lines or any of Julia's process functions. It needs fi, fo and bed: BEDTools.Bindings.maskfasta(fi = …, fo = …, bed = …). Its usage, in BEDTools 2.31.1, is bedtools maskfasta [OPTIONS] -fi <fasta> -fo <fasta> -bed <bed/gff/vcf>.

An option of true is a flag, false and nothing leave it out, a vector gives it each element as an argument, and another value gives it that value. An option with several spellings, such as a short and a long form, takes any one of them, and each emits its own.

Options:

• fi: Input FASTA file
• bed: BED/GFF/VCF file of ranges to mask in -fi
• fo: Output FASTA file
• soft: Enforce "soft" masking. Mask with lower-case bases, instead of masking with Ns.
• mc: Replace masking character. Use another character, instead of masking with Ns.
• fullHeader: Use full fasta header. By default, only the word before the first space or tab is used.

It also takes the general parameters of BEDTools, in BEDTools.Bindings.GENERAL_OPTIONS, which come before the subcommand.

BEDTools.Bindings.merge(; options...)::Cmd

Merges overlapping BED/GFF/VCF entries into a single interval.

The bedtools merge command with options, checked against those that its help lists, to run with BEDTools.lines or any of Julia's process functions. It needs i: BEDTools.Bindings.merge(i = …). Its usage, in BEDTools 2.31.1, is bedtools merge [OPTIONS] -i <bed/gff/vcf>.

An option of true is a flag, false and nothing leave it out, a vector gives it each element as an argument, and another value gives it that value. An option with several spellings, such as a short and a long form, takes any one of them, and each emits its own.

Options:

• i: <bed/gff/vcf>, from the usage line.
• s: Force strandedness. That is, only merge features that are on the same strand. - By default, merging is done without respect to strand.
• S: Force merge for one specific strand only. Follow with + or - to force merge from only the forward or reverse strand, respectively. - By default, merging is done without respect to strand.
• d: Maximum distance between features allowed for features to be merged. - Def. 0. That is, overlapping & book-ended features are merged. - (INTEGER) - Note: negative values enforce the number of b.p. required for overlap.
• c: Specify columns from the B file to map onto intervals in A. Default: 5. Multiple columns can be specified in a comma-delimited list.
• o: Specify the operation that should be applied to -c. Valid operations: sum, min, max, absmin, absmax, mean, median, mode, antimode stdev, sstdev collapse (i.e., print a delimited list (duplicates allowed)), distinct (i.e., print a delimited list (NO duplicates allowed)), distinctsortnum (as distinct, sorted numerically, ascending), distinctsortnumdesc (as distinct, sorted numerically, desscending), distinctonly (delimited list of only unique values), count count_distinct (i.e., a count of the unique values in the column), first (i.e., just the first value in the column), last (i.e., just the last value in the column), Default: sum Multiple operations can be specified in a comma-delimited list.
• delim: Specify a custom delimiter for the collapse operations. - Example: -delim "|" - Default: ",".
• prec: Sets the decimal precision for output (Default: 5)
• bed: If using BAM input, write output as BED.
• header: Print the header from the A file prior to results.
• nobuf: Disable buffered output. Using this option will cause each line of output to be printed as it is generated, rather than saved in a buffer. This will make printing large output files noticeably slower, but can be useful in conjunction with other software tools and scripts that need to process one line of bedtools output at a time.
• iobuf: Specify amount of memory to use for input buffer. Takes an integer argument. Optional suffixes K/M/G supported. Note: currently has no effect with compressed files.

It also takes the general parameters of BEDTools, in BEDTools.Bindings.GENERAL_OPTIONS, which come before the subcommand.

BEDTools.Bindings.multicov(; options...)::Cmd

Counts sequence coverage for multiple bams at specific loci.

The bedtools multicov command with options, checked against those that its help lists, to run with BEDTools.lines or any of Julia's process functions. It needs bams and bed: BEDTools.Bindings.multicov(bams = …, bed = …). Its usage, in BEDTools 2.31.1, is bedtools multicov [OPTIONS] -bams aln.1.bam aln.2.bam ... aln.n.bam -bed <bed/gff/vcf>.

An option of true is a flag, false and nothing leave it out, a vector gives it each element as an argument, and another value gives it that value. An option with several spellings, such as a short and a long form, takes any one of them, and each emits its own.

Options:

• bams: The bam files.
• bed: The bed file.
• split: Treat "split" BAM or BED12 entries as distinct BED intervals.
• s: Require same strandedness. That is, only report hits in B that overlap A on the same strand. - By default, overlaps are reported without respect to strand.
• S: Require different strandedness. That is, only report hits in B that overlap A on the opposite strand. - By default, overlaps are reported without respect to strand.
• f: Minimum overlap required as a fraction of each -bed record. - Default is 1E-9 (i.e., 1bp). - FLOAT (e.g. 0.50)
• r: Require that the fraction overlap be reciprocal for each -bed and B. - In other words, if -f is 0.90 and -r is used, this requires that B overlap 90% of each -bed and the -bed record also overlaps 90% of B.
• q: Minimum mapping quality allowed. Default is 0.
• D: Include duplicate reads. Default counts non-duplicates only
• F: Include failed-QC reads. Default counts pass-QC reads only
• p: Only count proper pairs. Default counts all alignments with MAPQ > -q argument, regardless of the BAM FLAG field.

It also takes the general parameters of BEDTools, in BEDTools.Bindings.GENERAL_OPTIONS, which come before the subcommand.

BEDTools.Bindings.multiinter(; options...)::Cmd

Identifies common intervals among multiple BED/GFF/VCF files.

The bedtools multiinter command with options, checked against those that its help lists, to run with BEDTools.lines or any of Julia's process functions. It needs i: BEDTools.Bindings.multiinter(i = …). Its usage, in BEDTools 2.31.1, is bedtools multiinter [OPTIONS] -i FILE1 FILE2 .. FILEn.

An option of true is a flag, false and nothing leave it out, a vector gives it each element as an argument, and another value gives it that value. An option with several spellings, such as a short and a long form, takes any one of them, and each emits its own.

Options:

• i: FILE1, from the usage line.
• cluster: Invoke Ryan Layers's clustering algorithm.
• header: Print a header line. (chrom/start/end + names of each file).
• names: A list of names (one/file) to describe each file in -i. These names will be printed in the header line.
• g: Use genome file to calculate empty regions. - STRING.
• empty: Report empty regions (i.e., start/end intervals w/o values in all files). - Requires the '-g FILE' parameter.
• filler: TEXT Use TEXT when representing intervals having no value. - Default is '0', but you can use 'N/A' or any text.
• examples: Show detailed usage examples.

It also takes the general parameters of BEDTools, in BEDTools.Bindings.GENERAL_OPTIONS, which come before the subcommand.

BEDTools.Bindings.nuc(; options...)::Cmd

Profiles the nucleotide content of intervals in a fasta file.

The bedtools nuc command with options, checked against those that its help lists, to run with BEDTools.lines or any of Julia's process functions. It needs fi and bed: BEDTools.Bindings.nuc(fi = …, bed = …). Its usage, in BEDTools 2.31.1, is bedtools nuc [OPTIONS] -fi <fasta> -bed <bed/gff/vcf>.

An option of true is a flag, false and nothing leave it out, a vector gives it each element as an argument, and another value gives it that value. An option with several spellings, such as a short and a long form, takes any one of them, and each emits its own.

Options:

• fi: Input FASTA file
• bed: BED/GFF/VCF file of ranges to extract from -fi
• s: Profile the sequence according to strand.
• seq: Print the extracted sequence
• pattern: Report the number of times a user-defined sequence is observed (case-sensitive).
• C: Ignore case when matching -pattern. By defaulty, case matters.
• fullHeader: Use full fasta header. - By default, only the word before the first space or tab is used.

It also takes the general parameters of BEDTools, in BEDTools.Bindings.GENERAL_OPTIONS, which come before the subcommand.

BEDTools.Bindings.overlap(; options...)::Cmd

Computes the amount of overlap (positive values) or distance (negative values) between genome features and reports the result at the end of the same line.

The bedtools overlap command with options, checked against those that its help lists, to run with BEDTools.lines or any of Julia's process functions.

An option of true is a flag, false and nothing leave it out, a vector gives it each element as an argument, and another value gives it that value. An option with several spellings, such as a short and a long form, takes any one of them, and each emits its own.

Options:

• i: Input file. Use "stdin" for pipes.
• cols: Specify the columns (1-based) for the starts and ends of the features for which you'd like to compute the overlap/distance. The columns must be listed in the following order:

It also takes the general parameters of BEDTools, in BEDTools.Bindings.GENERAL_OPTIONS, which come before the subcommand.

BEDTools.Bindings.pairtobed(; options...)::Cmd

Report overlaps between a BEDPE file and a BED/GFF/VCF file.

The bedtools pairtobed command with options, checked against those that its help lists, to run with BEDTools.lines or any of Julia's process functions. It needs a and b: BEDTools.Bindings.pairtobed(a = …, b = …). Its usage, in BEDTools 2.31.1, is bedtools pairtobed [OPTIONS] -a <bedpe> -b <bed/gff/vcf>.

An option of true is a flag, false and nothing leave it out, a vector gives it each element as an argument, and another value gives it that value. An option with several spellings, such as a short and a long form, takes any one of them, and each emits its own.

Options:

• a: <bedpe>, from the usage line.
• b: <bed/gff/vcf>, from the usage line.
• abam: The A input file is in BAM format. Output will be BAM as well. Replaces -a. - Requires BAM to be grouped or sorted by query.
• ubam: Write uncompressed BAM output. Default writes compressed BAM.
• bedpe: When using BAM input (-abam), write output as BEDPE. The default is to write output in BAM when using -abam.
• ed: Use BAM total edit distance (NM tag) for BEDPE score. - Default for BEDPE is to use the minimum of of the two mapping qualities for the pair. - When -ed is used the total edit distance from the two mates is reported as the score.
• f: Minimum overlap required as fraction of A (e.g. 0.05). Default is 1E-9 (effectively 1bp).
• s: Require same strandedness when finding overlaps. Default is to ignore stand. Not applicable with -type inspan or -type outspan.
• S: Require different strandedness when finding overlaps. Default is to ignore stand. Not applicable with -type inspan or -type outspan.
• type: Approach to reporting overlaps between BEDPE and BED.

It also takes the general parameters of BEDTools, in BEDTools.Bindings.GENERAL_OPTIONS, which come before the subcommand.

BEDTools.Bindings.pairtopair(; options...)::Cmd

Report overlaps between two paired-end BED files (BEDPE).

The bedtools pairtopair command with options, checked against those that its help lists, to run with BEDTools.lines or any of Julia's process functions. It needs a and b: BEDTools.Bindings.pairtopair(a = …, b = …). Its usage, in BEDTools 2.31.1, is bedtools pairtopair [OPTIONS] -a <BEDPE> -b <BEDPE>.

An option of true is a flag, false and nothing leave it out, a vector gives it each element as an argument, and another value gives it that value. An option with several spellings, such as a short and a long form, takes any one of them, and each emits its own.

Options:

• a: <BEDPE>, from the usage line.
• b: <BEDPE>, from the usage line.
• f: Minimum overlap required as fraction of A (e.g. 0.05). Default is 1E-9 (effectively 1bp).
• type: Approach to reporting overlaps between A and B.
• slop: The amount of slop (in b.p.). to be added to each footprint of A. Note: Slop is subtracted from start1 and start2 and added to end1 and end2.
• ss: Add slop based to each BEDPE footprint based on strand. - If strand is "+", slop is only added to the end coordinates. - If strand is "-", slop is only added to the start coordinates. - By default, slop is added in both directions.
• is: Ignore strands when searching for overlaps. - By default, strands are enforced.
• rdn: Require the hits to have different names (i.e. avoid self-hits). - By default, same names are allowed.

It also takes the general parameters of BEDTools, in BEDTools.Bindings.GENERAL_OPTIONS, which come before the subcommand.

BEDTools.Bindings.random(; options...)::Cmd

Generate random intervals among a genome.

The bedtools random command with options, checked against those that its help lists, to run with BEDTools.lines or any of Julia's process functions. It needs g: BEDTools.Bindings.random(g = …). Its usage, in BEDTools 2.31.1, is bedtools random [OPTIONS] -g <genome>.

An option of true is a flag, false and nothing leave it out, a vector gives it each element as an argument, and another value gives it that value. An option with several spellings, such as a short and a long form, takes any one of them, and each emits its own.

Options:

• g: <genome>, from the usage line.
• l: The length of the intervals to generate. - Default = 100. - (INTEGER)
• n: The number of intervals to generate. - Default = 1,000,000. - (INTEGER)
• seed: Supply an integer seed for the shuffling. - By default, the seed is chosen automatically. - (INTEGER)

It also takes the general parameters of BEDTools, in BEDTools.Bindings.GENERAL_OPTIONS, which come before the subcommand.

BEDTools.Bindings.reldist(; options...)::Cmd

Calculate the relative distance distribution b/w two feature files.

The bedtools reldist command with options, checked against those that its help lists, to run with BEDTools.lines or any of Julia's process functions. It needs a and b: BEDTools.Bindings.reldist(a = …, b = …). Its usage, in BEDTools 2.31.1, is bedtools reldist [OPTIONS] -a <bed/gff/vcf> -b <bed/gff/vcf>.

An option of true is a flag, false and nothing leave it out, a vector gives it each element as an argument, and another value gives it that value. An option with several spellings, such as a short and a long form, takes any one of them, and each emits its own.

Options:

• a: <bed/gff/vcf>, from the usage line.
• b: <bed/gff/vcf>, from the usage line.
• detail: Report the relativedistance for each interval in A

It also takes the general parameters of BEDTools, in BEDTools.Bindings.GENERAL_OPTIONS, which come before the subcommand.

BEDTools.Bindings.sample(; options...)::Cmd

Take sample of input file(s) using reservoir sampling algorithm.

The bedtools sample command with options, checked against those that its help lists, to run with BEDTools.lines or any of Julia's process functions. It needs i: BEDTools.Bindings.sample(i = …). Its usage, in BEDTools 2.31.1, is bedtools sample [OPTIONS] -i <bed/gff/vcf/bam>.

An option of true is a flag, false and nothing leave it out, a vector gives it each element as an argument, and another value gives it that value. An option with several spellings, such as a short and a long form, takes any one of them, and each emits its own.

Options:

• i: <bed/gff/vcf/bam>, from the usage line.
• n: The number of records to generate. - Default = 1,000,000. - (INTEGER)
• seed: Supply an integer seed for the shuffling. - By default, the seed is chosen automatically. - (INTEGER)
• ubam: Write uncompressed BAM output. Default writes compressed BAM.
• s: Require same strandedness. That is, only give records that have the same strand. Use '-s forward' or '-s reverse' for forward or reverse strand records, respectively. - By default, records are reported without respect to strand.
• header: Print the header from the input file prior to results.
• bed: If using BAM input, write output as BED.
• nobuf: Disable buffered output. Using this option will cause each line of output to be printed as it is generated, rather than saved in a buffer. This will make printing large output files noticeably slower, but can be useful in conjunction with other software tools and scripts that need to process one line of bedtools output at a time.
• iobuf: Specify amount of memory to use for input buffer. Takes an integer argument. Optional suffixes K/M/G supported. Note: currently has no effect with compressed files.

It also takes the general parameters of BEDTools, in BEDTools.Bindings.GENERAL_OPTIONS, which come before the subcommand.

BEDTools.Bindings.shift(; options...)::Cmd

Shift each feature by requested number of base pairs.

The bedtools shift command with options, checked against those that its help lists, to run with BEDTools.lines or any of Julia's process functions. It needs i and g: BEDTools.Bindings.shift(i = …, g = …). Its usage, in BEDTools 2.31.1, is bedtools shift [OPTIONS] -i <bed/gff/vcf> -g <genome> [-s <int> or (-p and -m)].

An option of true is a flag, false and nothing leave it out, a vector gives it each element as an argument, and another value gives it that value. An option with several spellings, such as a short and a long form, takes any one of them, and each emits its own.

Options:

• i: <bed/gff/vcf>, from the usage line.
• g: <genome>, from the usage line.
• s: Shift the BED/GFF/VCF entry -s base pairs. - (Integer) or (Float, e.g. 0.1) if used with -pct.
• p: Shift features on the + strand by -p base pairs. - (Integer) or (Float, e.g. 0.1) if used with -pct.
• m: Shift features on the - strand by -m base pairs. - (Integer) or (Float, e.g. 0.1) if used with -pct.
• pct: Define -s, -m and -p as a fraction of the feature's length. E.g. if used on a 1000bp feature, -s 0.50, will shift the feature 500 bp "upstream". Default = false.
• header: Print the header from the input file prior to results.

It also takes the general parameters of BEDTools, in BEDTools.Bindings.GENERAL_OPTIONS, which come before the subcommand.

BEDTools.Bindings.shuffle(; options...)::Cmd

Randomly permute the locations of a feature file among a genome.

The bedtools shuffle command with options, checked against those that its help lists, to run with BEDTools.lines or any of Julia's process functions. It needs i and g: BEDTools.Bindings.shuffle(i = …, g = …). Its usage, in BEDTools 2.31.1, is bedtools shuffle [OPTIONS] -i <bed/gff/vcf> -g <genome>.

An option of true is a flag, false and nothing leave it out, a vector gives it each element as an argument, and another value gives it that value. An option with several spellings, such as a short and a long form, takes any one of them, and each emits its own.

Options:

• i: <bed/gff/vcf>, from the usage line.
• g: <genome>, from the usage line.
• excl: A BED/GFF/VCF file of coordinates in which features in -i should not be placed (e.g. gaps.bed).
• incl: Instead of randomly placing features in a genome, the -incl options defines a BED/GFF/VCF file of coordinates in which features in -i should be randomly placed (e.g. genes.bed). Larger -incl intervals will contain more shuffled regions. This method DISABLES -chromFirst.
• chrom: Keep features in -i on the same chromosome. - By default, the chrom and position are randomly chosen. - NOTE: Forces use of -chromFirst (see below).
• seed: Supply an integer seed for the shuffling. - By default, the seed is chosen automatically. - (INTEGER)
• f: Maximum overlap (as a fraction of the -i feature) with an -excl feature that is tolerated before searching for a new, randomized locus. For example, -f 0.10 allows up to 10% of a randomized feature to overlap with a given feature in the -excl file. Cannot be used with -incl file. - Default is 1E-9 (i.e., 1bp). - FLOAT (e.g. 0.50)
• chromFirst: Instead of choosing a position randomly among the entire genome (the default), first choose a chrom randomly, and then choose a random start coordinate on that chrom. This leads to features being ~uniformly distributed among the chroms, as opposed to features being distribute as a function of chrom size.
• bedpe: Indicate that the A file is in BEDPE format.
• maxTries: Max. number of attempts to find a home for a shuffled interval in the presence of -incl or -excl. Default = 1000.
• noOverlapping: Don't allow shuffled intervals to overlap.
• allowBeyondChromEnd: Allow shuffled intervals to be relocated to a position in which the entire original interval cannot fit w/o exceeding the end of the chromosome. In this case, the end coordinate of the shuffled interval will be set to the chromosome's length. By default, an interval's original length must be fully-contained within the chromosome.

It also takes the general parameters of BEDTools, in BEDTools.Bindings.GENERAL_OPTIONS, which come before the subcommand.

BEDTools.Bindings.slop(; options...)::Cmd

Add requested base pairs of "slop" to each feature.

The bedtools slop command with options, checked against those that its help lists, to run with BEDTools.lines or any of Julia's process functions. It needs i and g: BEDTools.Bindings.slop(i = …, g = …). Its usage, in BEDTools 2.31.1, is bedtools slop [OPTIONS] -i <bed/gff/vcf> -g <genome> [-b <int> or (-l and -r)].

An option of true is a flag, false and nothing leave it out, a vector gives it each element as an argument, and another value gives it that value. An option with several spellings, such as a short and a long form, takes any one of them, and each emits its own.

Options:

• i: <bed/gff/vcf>, from the usage line.
• g: <genome>, from the usage line.
• b: Increase the BED/GFF/VCF entry -b base pairs in each direction. - (Integer) or (Float, e.g. 0.1) if used with -pct.
• l: The number of base pairs to subtract from the start coordinate. - (Integer) or (Float, e.g. 0.1) if used with -pct.
• r: The number of base pairs to add to the end coordinate. - (Integer) or (Float, e.g. 0.1) if used with -pct.
• s: Define -l and -r based on strand. E.g. if used, -l 500 for a negative-stranded feature, it will add 500 bp downstream. Default = false.
• pct: Define -l and -r as a fraction of the feature's length. E.g. if used on a 1000bp feature, -l 0.50, will add 500 bp "upstream". Default = false.
• header: Print the header from the input file prior to results.

It also takes the general parameters of BEDTools, in BEDTools.Bindings.GENERAL_OPTIONS, which come before the subcommand.

BEDTools.Bindings.sort(; options...)::Cmd

Sorts a feature file in various and useful ways.

The bedtools sort command with options, checked against those that its help lists, to run with BEDTools.lines or any of Julia's process functions. It needs i: BEDTools.Bindings.sort(i = …). Its usage, in BEDTools 2.31.1, is bedtools sort [OPTIONS] -i <bed/gff/vcf>.

An option of true is a flag, false and nothing leave it out, a vector gives it each element as an argument, and another value gives it that value. An option with several spellings, such as a short and a long form, takes any one of them, and each emits its own.

Options:

• i: <bed/gff/vcf>, from the usage line.
• sizeA: Sort by feature size in ascending order.
• sizeD: Sort by feature size in descending order.
• chrThenSizeA: Sort by chrom (asc), then feature size (asc).
• chrThenSizeD: Sort by chrom (asc), then feature size (desc).
• chrThenScoreA: Sort by chrom (asc), then score (asc).
• chrThenScoreD: Sort by chrom (asc), then score (desc).
• g: (names.txt) Sort according to the chromosomes declared in "genome.txt"
• faidx: (names.txt) Sort according to the chromosomes declared in "names.txt"
• header: Print the header from the A file prior to results.

It also takes the general parameters of BEDTools, in BEDTools.Bindings.GENERAL_OPTIONS, which come before the subcommand.

BEDTools.Bindings.spacing(; options...)::Cmd

Report (last col.) the gap lengths between intervals in a file.

The bedtools spacing command with options, checked against those that its help lists, to run with BEDTools.lines or any of Julia's process functions. It needs i: BEDTools.Bindings.spacing(i = …). Its usage, in BEDTools 2.31.1, is bedtools spacing [OPTIONS] -i <bed/gff/vcf/bam>.

An option of true is a flag, false and nothing leave it out, a vector gives it each element as an argument, and another value gives it that value. An option with several spellings, such as a short and a long form, takes any one of them, and each emits its own.

Options:

• i: <bed/gff/vcf/bam>, from the usage line.
• bed: If using BAM input, write output as BED.
• header: Print the header from the A file prior to results.
• nobuf: Disable buffered output. Using this option will cause each line of output to be printed as it is generated, rather than saved in a buffer. This will make printing large output files noticeably slower, but can be useful in conjunction with other software tools and scripts that need to process one line of bedtools output at a time.
• iobuf: Specify amount of memory to use for input buffer. Takes an integer argument. Optional suffixes K/M/G supported. Note: currently has no effect with compressed files.

It also takes the general parameters of BEDTools, in BEDTools.Bindings.GENERAL_OPTIONS, which come before the subcommand.

BEDTools.Bindings.split(; options...)::Cmd

Split a Bed file.

The bedtools split command with options, checked against those that its help lists, to run with BEDTools.lines or any of Julia's process functions. It needs i or input and n or number: BEDTools.Bindings.split(i = …, n = …). Its usage, in BEDTools 2.31.1, is bedtools split [OPTIONS] -i <bed> -n number-of-files.

An option of true is a flag, false and nothing leave it out, a vector gives it each element as an argument, and another value gives it that value. An option with several spellings, such as a short and a long form, takes any one of them, and each emits its own.

Options:

• i, input: (file) BED input file (req'd).
• n, number: (int) Number of files to create (req'd).
• p, prefix: (string) Output BED file prefix.
• a, algorithm: (string) Algorithm used to split data. * size (default): uses a heuristic algorithm to group the items so all files contain the ~ same number of bases * simple : route records such that each split file has approximately equal records (like Unix split).

It also takes the general parameters of BEDTools, in BEDTools.Bindings.GENERAL_OPTIONS, which come before the subcommand.

BEDTools.Bindings.subtract(; options...)::Cmd

Removes the portion(s) of an interval that is overlapped by another feature(s).

The bedtools subtract command with options, checked against those that its help lists, to run with BEDTools.lines or any of Julia's process functions. It needs a and b: BEDTools.Bindings.subtract(a = …, b = …). Its usage, in BEDTools 2.31.1, is bedtools subtract [OPTIONS] -a <bed/gff/vcf> -b <bed/gff/vcf>.

An option of true is a flag, false and nothing leave it out, a vector gives it each element as an argument, and another value gives it that value. An option with several spellings, such as a short and a long form, takes any one of them, and each emits its own.

Options:

• a: <bed/gff/vcf>, from the usage line.
• b: <bed/gff/vcf>, from the usage line.
• A: Remove entire feature if any overlap. That is, by default, only subtract the portion of A that overlaps B. Here, if any overlap is found (or -f amount), the entire feature is removed.
• N: Same as -A except when used with -f, the amount is the sum of all features (not any single feature).
• wb: Write the original entry in B for each overlap. - Useful for knowing what A overlaps. Restricted by -f and -r.
• wo: Write the original A and B entries plus the number of base pairs of overlap between the two features. - Overlaps restricted by -f and -r. Only A features with overlap are reported.
• s: Require same strandedness. That is, only report hits in B that overlap A on the same strand. - By default, overlaps are reported without respect to strand.
• S: Require different strandedness. That is, only report hits in B that overlap A on the opposite strand. - By default, overlaps are reported without respect to strand.
• f: Minimum overlap required as a fraction of A. - Default is 1E-9 (i.e., 1bp). - FLOAT (e.g. 0.50)
• F: Minimum overlap required as a fraction of B. - Default is 1E-9 (i.e., 1bp). - FLOAT (e.g. 0.50)
• r: Require that the fraction overlap be reciprocal for A AND B. - In other words, if -f is 0.90 and -r is used, this requires that B overlap 90% of A and A also overlaps 90% of B.
• e: Require that the minimum fraction be satisfied for A OR B. - In other words, if -e is used with -f 0.90 and -F 0.10 this requires that either 90% of A is covered OR 10% of B is covered. Without -e, both fractions would have to be satisfied.
• split: Treat "split" BAM or BED12 entries as distinct BED intervals.
• g: Provide a genome file to enforce consistent chromosome sort order across input files. Only applies when used with -sorted option.
• nonamecheck: For sorted data, don't throw an error if the file has different naming conventions for the same chromosome. ex. "chr1" vs "chr01".
• sorted: Use the "chromsweep" algorithm for sorted (-k1,1 -k2,2n) input.
• bed: If using BAM input, write output as BED.
• header: Print the header from the A file prior to results.
• nobuf: Disable buffered output. Using this option will cause each line of output to be printed as it is generated, rather than saved in a buffer. This will make printing large output files noticeably slower, but can be useful in conjunction with other software tools and scripts that need to process one line of bedtools output at a time.
• iobuf: Specify amount of memory to use for input buffer. Takes an integer argument. Optional suffixes K/M/G supported. Note: currently has no effect with compressed files.

It also takes the general parameters of BEDTools, in BEDTools.Bindings.GENERAL_OPTIONS, which come before the subcommand.

BEDTools.Bindings.summary(; options...)::Cmd

Report summary statistics of the intervals in a file

The bedtools summary command with options, checked against those that its help lists, to run with BEDTools.lines or any of Julia's process functions. It needs i and g: BEDTools.Bindings.summary(i = …, g = …). Its usage, in BEDTools 2.31.1, is bedtools summary [OPTIONS] -i <bed/gff/vcf/bam> -g <genome>.

An option of true is a flag, false and nothing leave it out, a vector gives it each element as an argument, and another value gives it that value. An option with several spellings, such as a short and a long form, takes any one of them, and each emits its own.

Options:

• i: <bed/gff/vcf/bam>, from the usage line.
• g: <genome>, from the usage line.

It also takes the general parameters of BEDTools, in BEDTools.Bindings.GENERAL_OPTIONS, which come before the subcommand.

BEDTools.Bindings.tag(; options...)::Cmd

Annotates a BAM file based on overlaps with multiple BED/GFF/VCF files on the intervals in -i.

The bedtools tag command with options, checked against those that its help lists, to run with BEDTools.lines or any of Julia's process functions. It needs i, files and labels: BEDTools.Bindings.tag(i = …, files = …, labels = …). Its usage, in BEDTools 2.31.1, is bedtools tag [OPTIONS] -i <BAM> -files FILE1 .. FILEn -labels LAB1 .. LABn.

An option of true is a flag, false and nothing leave it out, a vector gives it each element as an argument, and another value gives it that value. An option with several spellings, such as a short and a long form, takes any one of them, and each emits its own.

Options:

• i: <BAM>, from the usage line.
• files: FILE1, from the usage line.
• labels: LAB1, from the usage line.
• s: Require overlaps on the same strand. That is, only tag alignments that have the same strand as a feature in the annotation file(s).
• S: Require overlaps on the opposite strand. That is, only tag alignments that have the opposite strand as a feature in the annotation file(s).
• f: Minimum overlap required as a fraction of the alignment. - Default is 1E-9 (i.e., 1bp). - FLOAT (e.g. 0.50)
• tag: Dictate what the tag should be. Default is YB. - STRING (two characters, e.g., YK)
• names: Use the name field from the annotation files to populate tags. By default, the -labels values are used.
• scores: Use the score field from the annotation files to populate tags. By default, the -labels values are used.
• intervals: Use the full interval (including name, score, and strand) to populate tags. Requires the -labels option to identify from which file the interval came.

It also takes the general parameters of BEDTools, in BEDTools.Bindings.GENERAL_OPTIONS, which come before the subcommand.

BEDTools.Bindings.unionbedg(; options...)::Cmd

Combines multiple BedGraph files into a single file, allowing coverage comparisons between them.

The bedtools unionbedg command with options, checked against those that its help lists, to run with BEDTools.lines or any of Julia's process functions. It needs i: BEDTools.Bindings.unionbedg(i = …). Its usage, in BEDTools 2.31.1, is bedtools unionbedg [OPTIONS] -i FILE1 FILE2 .. FILEn.

An option of true is a flag, false and nothing leave it out, a vector gives it each element as an argument, and another value gives it that value. An option with several spellings, such as a short and a long form, takes any one of them, and each emits its own.

Options:

• i: FILE1, from the usage line.
• header: Print a header line. (chrom/start/end + names of each file).
• names: A list of names (one/file) to describe each file in -i. These names will be printed in the header line.
• g: Use genome file to calculate empty regions. - STRING.
• empty: Report empty regions (i.e., start/end intervals w/o values in all files). - Requires the '-g FILE' parameter.
• filler: TEXT Use TEXT when representing intervals having no value. - Default is '0', but you can use 'N/A' or any text.
• examples: Show detailed usage examples.

It also takes the general parameters of BEDTools, in BEDTools.Bindings.GENERAL_OPTIONS, which come before the subcommand.

BEDTools.Bindings.window(; options...)::Cmd

Examines a "window" around each feature in A and reports all features in B that overlap the window. For each overlap the entire entry in A and B are reported.

The bedtools window command with options, checked against those that its help lists, to run with BEDTools.lines or any of Julia's process functions. It needs a and b: BEDTools.Bindings.window(a = …, b = …). Its usage, in BEDTools 2.31.1, is bedtools window [OPTIONS] -a <bed/gff/vcf> -b <bed/gff/vcf>.

An option of true is a flag, false and nothing leave it out, a vector gives it each element as an argument, and another value gives it that value. An option with several spellings, such as a short and a long form, takes any one of them, and each emits its own.

Options:

• a: <bed/gff/vcf>, from the usage line.
• b: <bed/gff/vcf>, from the usage line.
• abam: The A input file is in BAM format. Output will be BAM as well. Replaces -a.
• ubam: Write uncompressed BAM output. Default writes compressed BAM.
• bed: When using BAM input (-abam), write output as BED. The default is to write output in BAM when using -abam.
• w: Base pairs added upstream and downstream of each entry in A when searching for overlaps in B. - Creates symmetrical "windows" around A. - Default is 1000 bp. - (INTEGER)
• l: Base pairs added upstream (left of) of each entry in A when searching for overlaps in B. - Allows one to define asymmetrical "windows". - Default is 1000 bp. - (INTEGER)
• r: Base pairs added downstream (right of) of each entry in A when searching for overlaps in B. - Allows one to define asymmetrical "windows". - Default is 1000 bp. - (INTEGER)
• sw: Define -l and -r based on strand. For example if used, -l 500 for a negative-stranded feature will add 500 bp downstream. - Default = disabled.
• sm: Only report hits in B that overlap A on the same strand. - By default, overlaps are reported without respect to strand.
• Sm: Only report hits in B that overlap A on the opposite strand. - By default, overlaps are reported without respect to strand.
• u: Write the original A entry once if any overlaps found in B. - In other words, just report the fact >=1 hit was found.
• c: For each entry in A, report the number of overlaps with B. - Reports 0 for A entries that have no overlap with B. - Overlaps restricted by -w, -l, and -r.
• v: Only report those entries in A that have no overlaps with B. - Similar to "grep -v."
• header: Print the header from the A file prior to results.

It also takes the general parameters of BEDTools, in BEDTools.Bindings.GENERAL_OPTIONS, which come before the subcommand.