DUfd*ddlZddlmZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl m Z ddl Z ddlZddlZddlmZddlmZddlmZmZmZmZmZmZmZmZmZmZmZm Z ddl!mZdd l"m#Z#m$Z$m%Z%m&Z&m'Z'dd l!m(Z(ddl)Z)dd l!m*Z*dd l!m(Z(iZ+iZ,iZ-d Z.d Z/ ddZ0Gdde1Z2Gdde1Z3Gdde4Z5Gdde1Z6dZ7e8dkr$ddl9Z9e9j:e9j;e9j<zdSdS)N)dedent)islice)warn)Path) get_tempdir_tags call_bedtools _flatten_list_check_sequence_stderrisBAMisBGZIPisGZIP BEDToolsErrorpybedtoolsError_call_randomintersect SplitOutput)helpers) IntervalFileIntervalIteratorIntervalcreate_interval_from_listBedToolsFileError) filenames)settingsc t|tr"t|}nRt |dst |dr dd|D}nt d|z|\}}|}|}t|d|d<t|d|d<t|d|d<t|d |d <ttt||S) z jaccard method doesn't return an interval file, rather, it returns a short summary of results. Here, we simply parse it into a dict for convenience. next__next__cg|]}|Sr!.0is O/var/www/html/software/conda/lib/python3.11/site-packages/pybedtools/bedtool.py z+_jaccard_output_to_dict..;s^^^Aa^^^zUnexpected object %rrr) isinstancestropenreadhasattrjoin ValueError splitlinessplitintfloatdictlistzip)skwargs_sheaderdatas r%_jaccard_output_to_dictr=3s !S5 !WW\\^^ F  5wq*555 WW^^^^^ $ $/!3444==??LFD \\^^F ::<.s;W;W;WD1H;W;W;Wr'z"%s" does not appear to be installed or on the path, so this method is disabled. Please install a more recent version of BEDTools and re-import to use this method.Tct< t< t<rfd}|Sg}r)|t dddr"|t d fd}|jd}n|j}|d |zz|_|j|_|S) z Accepts a function to be wrapped; discards the original and returns a new, rebuilt-from-scratch function based on the kwargs passed to _wraps(). Nc"tN)NotImplementedError)argsr9help_strs r%not_implemented_funcz7_wraps..decorator..not_implemented_funcs)(333r'z For convenience, the file or stream this BedTool points to is implicitly passed as the `-z` argument to `z` a There are two alternatives for supplying a genome. Use `g="genome.filename"` if you have a genome's chrom sizes saved as a file. This is the what BEDTools expects when using it from the command line. Alternatively, use the `genome="assembly.name"` (for example, `genome="hg19"`) to use chrom sizes for that assembly without having to manage a separate file. The `genome` argument triggers a call `pybedtools.chromsizes`, so see that method for more details. ct|dkr t|dksJ|d|<|vr7|vr31|js |j|<n |j|<ntdz}rCr,D]}||vs|krd}rD]}||vs|kr d|vsd|vrd}rd}D]}||vs|krd}|r |jd i|}|vr||<|jd d |\}}}d}|jrd}d krd}.d kr(ttrg} n} | D] }||vrd}n rd}| } t|||| } r | fi|SLt D])\} } | d kr| }n|| }t|| ||}*nt| }||_||_~|S)zn A newly created function that will be returned by the _wraps() decorator rrNzE"%s" currently can't handle BAM input, please use bam_to_bed() first.FggenomeT)prog arg_orderALL)stdin check_stderr decode_outputrLr!)len_isbamfnr check_genome_tmp handle_kwargsr*r+r r6itemssetattrr@_cmds)selfrVr9check_for_genomer$cmdstmpr_ result_is_bam_nonbamrastreamkwattrvalueresultadd_to_bedtoolr]bamr`does_not_return_bedtool force_bam genome_ifgenome_none_if genome_ok_ifimplicitmake_tempfile_fornonbamotherr\ uses_genomes r%wrappedz*_wraps..decorator..wrappeds<4yy1}}4yyA~~~~ $Qu ''&&){'+wF8$$&*gs .DFJK +  4! <+55;;!x--/4, $.decorators$,4  $)OD ! ?"%M$   ( 4 4 4 4 4( '   OO  xx '      OO       K K K K K K K K K K K K K K K K K K K ^ < DD>$''78;W;Wh;W;W;WW99X&&-  "&  & OOOOOOOOOOOOOOOOOOOOOb sCCC*)C*c eZdZejZddZe ddZdZdZ dd Z d Z dd Z d Z ddZddZdZdZddZdZddZdZedZddZedZdZedZdZdZd Zd!Zd"Z d#Z!d$Z"d%Z#dd&Z$d'Z% dd(Z&d)Z'd*Z(ed+Z)dd-Z*dd.Z+dd/Z,ee-d0d1dd2d3Z.e.Z/ee-d4d1dd5d16d7Z0e0Z1e-d8d1d d 9d:Z2ed;Z3e3Z4ee-dd?d@d=d?gAdBZ5ee-dCd@ddDdEe6dEdFiGdHZ7e7Z8e9dIZ:ee-dJd@dDe6KdLZ;e;Zee-dPd=d>dQdRZ?ee-dSd1ddd TdUZ@ee-dVd1ddd TdWZAee-dXd1ddQdYZBee-dZd=d>dQd[ZCee-d\d=d>d?d@]d^ZDee-d_d1ddd Td`ZEee-dad1d dbdcgddeZFee-dfd1NdgZGee-dhd1d idjZHee-dkd1dldlgdlgd d5mdnZIeIZJee-dod=d>d?d5]dpZKee-dqd@dDdEdEdFie6rdsZLeLZMee-dtd1d iduZNee-dvd1NdwZOee-dxd=d>d?dy]dzZPePZQee-d{d=d>|d}ZReRZSee-d~d1NdZTee-dd1d1dZUeUZVee-dd=d>|dZWee-dd dgdZXeXZYee-dd dZZee-dd1d d dZ[e[Z\ee-dd1NdZ]ee-ddZ^e^Z_ee-dd d>gd>dgdZ`e`Zaee-dd1NdZbee-dd1ddidZcee-dd1ddidZdee-dd1d1dddidZeeeZfe-dd=d>egdZhe-dd=d>eidZje-dd1d1dZke-dd=d>d eljmdZne-dd1eljodZpe-dd1NdZqdZrdZsdZt ddZudZv ddZw ddZx ddZy ddZz ddZ{edZ|edd„Z}eddÄZ~eddĄZdńZedƄZdDŽZddɄZddʄZdd˄Zdd̄Zd̈́Zdd΄ZddτZdS)r@NFc |rtd||_d|_d|_|r|}|}t |d}|D]g}t|dkr(d | dz}| |h| ndtt|jvrt|}t!|t"r |j}nIt!|tr|rd |_nGt&j|sd |z}t-|t/||_|jrt1j|j}g} |D]9\} } t!| t8r| D]} t!| t:r[| d d | zgd t?| d Dzrt!| tr| | t!| t:r\| d d | zgdt?| d Dz,tdd | dz|_nRt!|t8t@fr4t#tC|"j}n|}||_d dtGdD} | |_$|tJ| <d|_&d|_'tQ|_)dS)aE Wrapper around Aaron Quinlan's ``BEDtools`` suite of programs (https://github.com/arq5x/bedtools); also contains many useful methods for more detailed work with BED files. *fn* is typically the name of a BED-like file, but can also be one of the following: * a string filename * another BedTool object * an iterable of Interval objects * an open file object * a "file contents" string (see below) If *from_string* is True, then you can pass a string that contains the contents of the BedTool you want to create. This will treat all spaces as TABs and write to tempfile, treating whatever you pass as *fn* as the contents of the bed file. This also strips empty lines. Typical usage is to point to an existing file:: a = BedTool('a.bed') But you can also create one from scratch from a string:: >>> s = ''' ... chrX 1 100 ... chrX 25 800 ... ''' >>> a = BedTool(s, from_string=True) Or use examples that come with pybedtools:: >>> example_files = pybedtools.list_example_files() >>> assert 'a.bed' in example_files >>> a = pybedtools.example_bedtool('a.bed') zCRemote BAM no longer supported (since BEDTools does not support it)FrwrrQrOzpathlib.PurePathTzFile "%s" does not exist@c^g|]*}dtt|+S:r/mapr+r#js r%r&z$BedTool.__init__..#s</././.4514S!0E0E/././.r'reversec^g|]*}dtt|+Srrrs r%r&z$BedTool.__init__..0s<'&'&'&,-),S!(=(='&'&'&r'zunhandled type in BAM headercJg|] }tjtj!Sr!randomchoicestringascii_lowercaser#rNs r%r&z$BedTool.__init__..Es%OOOv}V%;<<OOOr'N)*r0remoterc _bam_headerrfr,r1rbstripr/r2writecloser+type__mro__r*r@rdospathexistsFileNotFoundErrorr pysamSamfiler;rhr6r5rAsortedtupleitersaveasrange_tagr _hascounts _file_typeHistoryhistory)rkrd from_stringr bed_contentsfoutlinemsgr; txt_headerkvr$tags r%__init__zBedTool.__init__sN  X    ] LBC==D$//11 ! !tzz||$$))yy..5 4    JJLLLL"Sb)9%:%:::WW"g&&L UB$$H ,"&DKK7>>"--582=/444"'))DK;3D"]2..5F*"$J & MM1%a..M%& 9 9#-a#6#6 !9$.$5$5(, -01WI/./.9? SW9X9X9X/././.-.)*)*%&%&%&%&&03%7%7!9$.$5$5a$8$8$8 9(400 M&-- $ %(1WI'&'&17 41P1P1P'&'&'&%&!"!"#--K"L"LL'+yy'<'.generatorsY!% # # $] DT D D DV D D##H"NNNN# # #r'r@)rkrrVr9rs```` r%r2z BedTool.splitwsD # # # # # # # # yy{{###r'c t|tr|}n+t|tsJtj|}|}t |d5}t|D]V\}}|\}}t|}t|}| d |||gdzW dddn #1swxYwY| |S)a Ensure all features fall within chromosome limits. Some peak-callers extend peaks such that the boundaries overstep chromosome coordinates. Upon uploading such a file to a genome browser like UCSC, this results in an error like:: Error line 101 of custom track: chromEnd larger than chrom chr2 size Use this method to clean your file, truncating any out-of-bounds features to fit within the chromosome coordinates of `genome`. `genome` can be either an assembly name ('dm3') or a dictionary where keys are chrom and values are (start, stop) tuples. rrQrON) r*r5r+r chromsizesrfr,r6rhrr/ intersect) rkr[ chromdictrnrchromcoordsstartstops r%truncate_to_chromzBedTool.truncate_to_chromsM" fd # # 3IIfc** * * **622Iiikk #s^^ Ct!%ioo&7&7!8!8 C C v$ tE 4yy 499eUD%9::TABBBB  C C C C C C C C C C C C C C C C ~~c"""s(A9C..C25C2c |stdtj|j}t |t r|}|j|j|j }}}nbtj |}||}d\}}n9| ddd\}}}t|t|}} |t!||| n#t$r|rg YnwxYw fd} t#| } || S)a Retrieve all intervals within coordinates from a "tabixed" BedTool. Given either a string in "chrom:start-stop" format, or an interval-like object with chrom, start, stop attributes, return a *streaming* BedTool of the features in this BedTool that overlap the provided interval. If the coordinates are invalid, an empty generator is returned unless `check_coordinates=True` in which case a ValueError will be raised. MThis BedTool has not been indexed for tabix -- please use the .tabix() methodNNNrr(r)c3$KD] }|dzV dS)NrOr!)r$rCs r%genz$BedTool.tabix_intervals..gens/  $h  r')_tabixedr0r TabixFilerdr*rrrrrcoord_researchgroupr3fetchr+r@rr) rkinterval_or_stringcheck_coordinatestbxrrrendmatchrxrCs @r%tabix_intervalszBedTool.tabix_intervalssj}} 4 odg&& (( 3 3 2)H ( #5EE$++,>??E}*' ss%*KK1a$8$8!uc ZZSs iiE E377GG             CCEENN ! ! # # s$C33DDc|stdtj|j}|jS)zA Returns a list of contigs from the tabix index. r)rr0rrrdcontigs)rkrs r% tabix_contigszBedTool.tabix_contigssF}} 4  odg&&{r'Tc|r|s|S|||}tj|||jt |S)a Prepare a BedTool for use with Tabix. Returns a new BedTool that has been BGZIP compressed and indexed by tabix. Parameters ---------- in_place : bool If True (default), then assume the file is already sorted and replace the existing file with the BGZIPed version. force : bool If True (default is False), then overwrite both the index and the BGZIP file. is_sorted : bool If True (default is False), then assume the file is already sorted so that BedTool.bgzip() doesn't have to do that work. )in_placeforce)rpreset)rbgzipr tabix_index file_typer@)rkrr is_sortedrds r%tabixz BedTool.tabixs]. ==?? 5 KZZZ 7 7 "E$.AAAAr{{r'ct|jtr=t|jr+tj|jdzrdSdSdSdS)z Verifies that we're working with a tabixed file: a string filename pointing to a BGZIPed file with a .tbi file in the same dir. z.tbiTN)r*rdr+rrrrrks r%rzBedTool._tabixedsn tw $ $    tw/00  4       r'c|rd}nd}t|jtr|st|jr|jS|so|s|dj}n|}|dz}t j|tj ||||S|rZ|s.|d j}n|j}|jdz}tj ||||SdS)aR Helper function for more control over "tabixed" BedTools. Checks to see if we already have a BGZIP file; if not then prepare one. Always leaves the original file alone. You can always just make a BedTool out of an already sorted and BGZIPed file to avoid this step. `in_place` will put the BGZIPed file in the same dir (possibly after sorting to tempfile). If `is_sorted`, then assume the file is already sorted. Otherwise call bedtools sort with the `-header` option. `force` will overwrite without asking. z-frT)r;.gz)rN) r*rdr+rsortrfr@ TEMPFILESrArtabix_compressr)rkrrr  force_argrdoutfns r%rz BedTool.bgzips5  III dgs # # E tw w  !YYdY++.YY[[JE   $ $U + + +  U% 8 8 8 8L   YYdY++22447WGeOE  U% 8 8 8 8L  r'cFt|j}g}t}|D]}|j}|t jt j|dr*| dr| ||t}d|}|r=|d|z} | ddkstddS|D]}t j|dS) a Use at your own risk! This method will delete temp files. You will be prompted for deletion of files unless you specify *ask=False*. Deletes all temporary files created during the history of this BedTool up to but not including the file this current BedTool points to. Any filenames that are in the history and have the following pattern will be deleted:: /pybedtools.*.tmp (where is the result from get_tempdir() and is by default "/tmp") Any files that don't have this format will be left alone. (*raw_input_func* is used for testing) pybedtoolsz.tmpNz zDelete these files? %s (y/N) ryzOK, not deleting.)r rrrd startswithrrr/abspathendswithrAinputlowerprintunlink) rkaskraw_input_funcflattened_history to_deletetempdirr$rdstr_fnsanswers r%delete_temporary_historyz BedTool.delete_temporary_historyTs(*$,77 --" ) )AB}}RW\\"'//'*B*BLQQRR );;v&&)$$R(((  !"N++i((  #^$G'$QRRF<<>>!$++)***  B IbMMMMr'c*fd}j|_|S)z Decorator to add a method and its kwargs to the history. Assumes that you only add this decorator to bedtool instances that return other bedtool instances c|g|Ri|}|j}|j}t|||||}t|jdkr|j|j|j||S)Nr)r HistorySteprbrrA)rkrVr9ru parent_tag result_tag history_stepmethods r% decoratedz*BedTool._log_to_history..decoratedsVD24222622FJJ'fdJ L 4<  1$$%%dl333 N ! !, / / /Mr')r)r,r-s` r%_log_to_historyzBedTool._log_to_historys.     2#N r'cBtfd|DS)ao Filter features by user-defined function. Takes a function *func* that is called for each feature in the `BedTool` object and returns only those for which the function returns True. *args and **kwargs are passed directly to *func*. Returns a streaming BedTool; if you want the filename then use the .saveas() method. >>> a = pybedtools.example_bedtool('a.bed') >>> subset = a.filter(lambda b: b.chrom == 'chr1' and b.start < 150) >>> len(a), len(subset) (4, 2) so it has extracted 2 records from the original 4. c34K|]}|gRi|VdSrTr!)r#frVrr9s r% z!BedTool.filter..sBDDa44+CD+C+C+CF+C+CDDDDDDDr'r)rkrrVr9s ```r%filterzBedTool.filters0*DDDDDD4DDDEEEr' c|jdkrdSd}tg}|D]7}||krn.|dz }|t|jg8t|dks J|t |dS)a Number of fields in each line of this BedTool (checks `n` lines) Return the number of fields in the features this file contains. Checks the first *n* features. >>> a = pybedtools.example_bedtool('a.bed') >>> a.field_count() 6 emptyrr)rsetrrbfieldsr6)rknr$r8feats r% field_countzBedTool.field_counts >W $ $1 R . .D1uu FA MM3t{++, - - - -6{{aF||Ar'cHfd}t|S)a> Modify each feature with a user-defined function. Applies user-defined function *func* to each feature. *func* must accept an Interval as its first argument; *args and **kwargs will be passed to *func*. *func* must return an Interval object OR a value that evaluates to False, in which case the original feature will be removed from the output. This way, an additional "filter" call is not necessary. >>> def truncate_feature(feature, limit=0): ... feature.score = str(len(feature)) ... if len(feature) > limit: ... feature.stop = feature.start + limit ... feature.name = feature.name + '.short' ... return feature >>> a = pybedtools.example_bedtool('a.bed') >>> b = a.each(truncate_feature, limit=100) >>> print(b) #doctest: +NORMALIZE_WHITESPACE chr1 1 100 feature1 99 + chr1 100 200 feature2 100 + chr1 150 250 feature3.short 350 - chr1 900 950 feature4 50 + c3:KD]}|gRi}|r|VdSrTr!)r1rurVrr9rks r% _generatorz BedTool.each.._generatorsQ ! !a1$111&11! LLL ! !r'r)rkrrVr9r>s```` r%eachz BedTool.eachsD< ! ! ! ! ! ! ! ! zz||$$$r'geneexonc  |}|jdkr[tfd|D}tfd|D}n|jdkrf|dkr;|}|}n"|}d}t dt dttd 5}t|j }|D]V fd | d D}t|D]\} | d krTj j krDddd j} td j j j j| jfz|`| t%|dz krTj jkrDddd j} td jj j j| jfz|| t%|dz kr?j} || dzj } td j| | j jfz|!X dddn #1swxYwYt|jS)a Create intron features (requires specific input format). NOTE: this method assumes a simple file with non-overlapping exons. For more sophisticated features, consider the gffutils package instead. Given a BED12 or a GFF with exons, create a new `BedTool` with just introns. The output is a bed6 file with the score column (5) being one of 'intron'/'utr5'/'utr3' gffc34K|]}|dk|VdSr(Nr!)r#r1rAs r%r2z"BedTool.introns..+ > >q1 > >r'c34K|]}|dk|VdSrEr!)r#r1r@s r%r2z"BedTool.introns..rFr'bed Nz*.introns() only supported for bed12and GFFz).introns() only supported for BED and GFFrcTg|]$}|jjk|jjk"|%Sr!)rr)r#erZs r%r&z#BedTool.introns..s<w!'))aequnn.U " " > > > >A > > >??FFHHI > > > >A > > >??FFHHII ^u $ $}}"$$FFHHOO-- HHJJ   )C &&QRR R ',,..# & &# ")),77N  +221$2GG )//GAtAvv$*qw"6"6$*88B4 wQVS!(ST!# c%jj1n,,AE1A1A$*88B4 w!%ahOP!# c%jj1n,,!%$QU|18 wafahGH!#' # # # # # # # # # # # # # # # Hrws%E/J!!J%(J%cdt|dst|dr|St|S)z1 Returns an iterable of features rr)r.rr s r%featureszBedTool.features?s8 4  GD*$=$= KDzzr'ct|jtstd|jrd|_n? t t|j|_n#t$r d|_YnwxYw|jS)z Return the type of the current file. One of ('bed','vcf','gff', 'bam', 'sam', 'empty'). >>> a = pybedtools.example_bedtool('a.bed') >>> print(a.file_type) bed zcChecking file_type not supported for non-file BedTools. Use .saveas() to save as a temp file first.rwr6) r*rdr+r0rcrrrr StopIterationr s r%rzBedTool.file_typeGs$'3'' -  ; *#DOO *"&tDzz"2"2"<  * * *") *s&A!!A54A5c n|rtfd|DSt|d5}|D]Etdt t fdD|F dddn #1swxYwYt|jS)a Analagous to unix `cut`. Similar to unix `cut` except indexes are 0-based, must be a list and the columns are returned in the order requested. This method returns a BedTool of results, which means that the indexes returned must be valid GFF/GTF/BED/SAM features. If you would like arbitrary columns -- say, just chrom and featuretype of a GFF, which would not comprise a valid feature -- then instead of this method, simply use indexes on each feature, e.g, >>> gff = pybedtools.example_bedtool('d.gff') >>> results = [(f[0], f[2]) for f in gff] In addition, `indexes` can contain keys of the GFF/GTF attributes, in which case the values are returned. e.g. 'gene_name' will return the corresponding name from a GTF, or 'start' will return the start attribute of a BED Interval. c36K|]fdDVdS)c g|] }| Sr!r!r#rsr1s r%r&z)BedTool.cut...xs999QtW999r'Nr!)r#r1indexess @r%r2zBedTool.cut..xs9HHa9999999HHHHHHr'rrQc g|] }| Sr!r!rfs r%r&zBedTool.cut..|s-J-J-J$ag-J-J-Jr'rQN)r@r,rfrr/rr+r)rkrgrqrXr1s ` @r%cutz BedTool.cutas,  $HHHH4HHHII Idiikk3'' W2WWA$))C-J-J-J-J'-J-J-J$K$KLLSUVVVVVW W W W W W W W W W W W W W W W27## #sA BBBctjtjtjd}|j}t j||S)z Makes a tempfile and registers it in the BedTool.TEMPFILES class variable. Adds a "pybedtools." prefix and ".tmp" extension for easy deletion if you forget to call pybedtools.cleanup(). F)prefixsuffixdelete) tempfileNamedTemporaryFilertempfile_prefixtempfile_suffixrr@rrA)rktmpfns r%rfz BedTool._tmpsO+++       ''' r'c|jrt|jSt|jtrt j|js'td |jt|jr'ttj |jdStt|jdSt|jS)za Dispatches the right iterator depending on how this BedTool was created z{0} does not existrtr)rcBAMrdr*r+rrrrformatrrgzipr,r s r%__iter__zBedTool.__iter__s ; tw<<  dgs # # -7>>$'** N'(<(C(CDG(L(LMMMdg <' $'4(@(@AAA'TWc(:(:;;; $DG,, ,r'c|t|jtrt|jSt d)Nz3Please convert to a file-based BedTool using saveas)r*rdr+rr0r s r% intervalszBedTool.intervalss6 dgs # # T(( (RSS Sr'c>t|jtr?tj|js|jr d|jzSd|jzSt|jtrt|jSdt|jzS)Nz z) r*rdr+rrrrr@reprr s r%__repr__zBedTool.__repr__s dgs # # 3w~~dg&& ?$+ ?&004tw>>  ) ) 3== "T$']]2 2r'cg}t|D]P}t|}t|tr|d}||Qd|S)zJ Returns the string representation of the whole `BedTool` zUTF-8r)rr+r*bytesrrAr/)rkrhr$s r%__str__zBedTool.__str__smd  AAA!U## &HHW%% LLOOOOwwu~~r'c*|SrT)rFr s r%__len__zBedTool.__len__szz||r'c*t|tr|}nXt|trCt|jtrt|jtst dt|t|krdSdS)Nz@Testing equality only supported for BedTools that point to filesTF)r*r+r@rdrU)rkr other_strs r%__eq__zBedTool.__eq__s eS ! ! II w ' ' dgs++ :#44 *4 t99E " "4ur'c.|| SrT)r)rkrs r%__ne__zBedTool.__ne__s;;u%%%%r'ct|tr!t||j|j|jSt|t r'tt|||dzdStd)Nrrz;Only slices or integers allowed for indexing into a BedTool) r*slicerrrstepr3r6r0)rkkeys r% __getitem__zBedTool.__getitem__sx c5 ! ! $ 38SX>> > S ! ! tS#'2233A6 6P r'c ||d}nF#t$r9}|jdks |jdkrtjdd}n|Yd}~nd}~wwxYw|S)NTur6rr)rrrrr@)rkrrurKs r%__add__zBedTool.__add__s ^^ET^22FF   '))u'/I/I#+BDAAA   s A/AAc4 ||d}n~#t$rq|jdkr"|jdkrtjdd}nA|jdkr|}n!|jdkrtjdd}YnwxYw|S)NT)rr6rr)rrrrr@r)rkrrus r%__sub__zBedTool.__sub__s B^^ET^22FF B B B'))70J0J#+BDAAAG++7**#+BDAAA B sA8BBct|jtstd|r'dd|d|DS|jrtdt |jrtj}d}n t}d}||j|5}t|D]\}}||krnt|d ddddS#1swxYwYdS) a Prints the first *n* lines or returns them if as_string is True Note that this only opens the underlying file (gzipped or not), so it does not check to see if the file is a valid BED file. >>> a = pybedtools.example_bedtool('a.bed') >>> a.head(2) #doctest: +NORMALIZE_WHITESPACE chr1 1 100 feature1 0 + chr1 100 200 feature2 0 + z0head() not supported for non file-based BedToolsrc34K|]}t|VdSrTr+)r#rs r%r2zBedTool.head..s(::3t99::::::r'Nzhead() not supported for BAMrtru )r) r*rdr+rUr/rcrrxr,rTr)rkr9 as_stringopenfuncopenmodefinr$rs r%headz BedTool.headsS$'3'' %B   ;77::bqb::::: : ; )%&DEE Edg 9$'8,, )(~~))GAtQxx$C(((((  ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) )s&/C""C&)C&ct|trtj||_n,t|tr||_nt d|S)aY Prepare BedTool for operations that require chromosome coords. Set the chromsizes for this genome. If *chromsizes* is a string, it will be considered a genome assembly name. If that assembly name is not available in pybedtools.genome_registry, then it will be searched for on the UCSC Genome Browser. Example usage: >>> hg19 = pybedtools.chromsizes('hg19') >>> a = pybedtools.example_bedtool('a.bed') >>> a = a.set_chromsizes(hg19) >>> print(a.chromsizes['chr1']) (0, 249250621) zMNeed to specify chromsizes either as a string (assembly name) or a dictionary)r*r+rrr5r0)rkrs r%set_chromsizeszBedTool.set_chromsizes sc$ j# & & (3J??DOO  D ) ) (DOO3  r'cl||}|r tjnt}|r tjnt}t|tr||jru|rt dt|d5}|t|jd dddn #1swxYwY|St|trt|jtr||d5}tj dkr||jdd } n||jd} |r*|| d z|| | dddn #1swxYwYn||d5}|D]\} t| t t"frt%t!| } |t| ] dddn #1swxYwY|S) a Collapses an iterable into file *fn* (or a new tempfile if *fn* is None). Returns the newly created filename. Parameters ---------- iterable : iter Any iterable object whose items can be converted to an Interval. fn : str Output filename, if None then creates a temp file for output trackline : str If not None, string to be added to the top of the output. Newline will be added. in_compressed : bool Indicates whether the input is compressed out_compressed : bool Indicates whether the output should be compressed NzFtrackline provided, but input is a BAM file, which takes no track linewbrbwt)r)rrtignore)errorsrO)rfrxr,r*r@rcr0rrdr-r+sys version_infor writelinesrr6rr) rkrBrd trackline in_compressedout_compressed in_open_func out_open_funcout_in_r$s r% _collapsezBedTool._collapse=sB :B$1;tyyt %3=   h ( ( X_   6b$ 74 4..3355666 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7I h ( ( 'Z S-I-I 'r4(( D#e++&,x{DJJJCC&,x{D99C9JJy0047888$$$                r4(( 'D!''A!!dE]33?5d1gg>>JJs1vv&&&&' ' ' ' ' ' ' ' ' ' ' ' ' ' ' '  s8>;CC  C  B F$$F(+F(.s(33AQ333333r'rrQrqoutputadditional_argsrPTr)rloggerdebugpprintpformatrcrrr*r@rdr+KeyErrorrr6rrr2r IndexErrorpoprfrArrhboolrextendr/)rkr\r]r9default_list_delimiterlist_delimitersr_inarg1 instream1inarg2 instream2rNrnrrrmargvalrrtdelims r%rgzBedTool.handle_kwargss"  ;V^F=S=S   "%!$    { 2&t,+D1vI)W-- )%L )S)) 4!*v")v33333    D  + $T*FvI)W-- )%L )S)) ;!*vIe}55 ;*! c;; ;/1)A,2D2DT2J2JKKA%)^^I%>%>F6NN!///%.F6NNN/ "& !:!:v    D  ::h % % "CCZZ$//F "iikk **%6==v  I ! !Cf}}jjoo C#I&&& C   !fllnn!5!5tDDD ( (JC%&& (KKc ****E4(( (Jue,D,D (Se__--3+D1EE3332EEE3C<<KKc ***KK&&&&KKc ***KK 5 1 12222 C#I&&& CJJ''''  ) KK ( ( (S%s]A4B77 CCBF; AF F; FF;FF;; GG/L88 MMc Jd|vr.d|vr*t|dr |j|d<ntdd|vrd|vrtdd|vr^d|vrZt|dtr |d}nt j|d}t j|}||d<|d=t|dtrt j|d|d<tj |dsd|dz}t||S)z Handles the different ways of specifying a genome in kwargs: g='genome.file' specifies a file directly genome='dm3' gets the file from genome registry self.chromsizes could be a dict. rZr[rzXNo genome specified. Use the "g" or "genome" kwargs, or use the .set_chromsizes() methodz$Cannot specify both "g" and "genome"zGenome file "%s" does not exist) r.rr0r*r5rchromsizes_to_filerrrr)rkr9 genome_dict genome_filers r%rezBedTool.check_genome1sP v  HF$:$:t\** "os  / &==X//CDD D f  V!3!3&*D11 F$X. (3F84DEE $7 DDK%F3Kx fSk4 ( ( E$7s DDF3Kw~~fSk** )3vc{CC#C(( ( r'cj|}t|d}t|jtr#t t|jdn6|}t t|jdfd}t|S)a Remove invalid features that may break BEDTools programs. >>> a = pybedtools.BedTool("chr1 10 100\nchr1 10 1", ... from_string=True) >>> print(a.remove_invalid()) #doctest: +NORMALIZE_WHITESPACE chr1 10 100 rruc3K t}|j|jkr|Vn'n7#tj$rY9t $rYDt $rYOt$rYdSwxYw_rT)rrrrMalformedBedLineError OverflowErrorrrb)featurer$s r%r>z*BedTool.remove_invalid.._generatorws "1ggG} 44%  &"7H$H!H$EE s $,A  A  A  A A )rfr,r*rdr+rrr@)rkrnrr>r$s @r%remove_invalidzBedTool.remove_invalid`siikkC~~ dgs # # 4 dgs!3!344AA++--C cfc!2!233A     $zz||$$$r'cJt|tstd|j}t|ts|j}|jr|j}tj |}| |||S)a Return all intervals that overlap `interval`. Calls the `all_hits` method of an IntervalFile to return all intervals in this current BedTool that overlap `interval`. Require that overlaps have the same strand with same_strand=True. Notes: If this current BedTool is generator-based, it will be converted into a file first. If this current BedTool refers to a BAM file, it will be converted to a BED file first using default arguments. If you don't want this to happen, please convert to BED first before using this method. Need an Interval instance) r*rr0rdr+rrc bam_to_bedrrall_hitsrkrrLoverlaprd interval_files r%rzBedTool.all_hits$(H-- :899 9 W"c"" "!B ; &""%B"/33 %%h WEEEr'cJt|tstd|j}t|ts|j}|jr|j}tj |}| |||S)a Return whether or not any intervals overlap `interval`. Calls the `any_hits` method of an IntervalFile. If there were any hits within `interval` in this BedTool, then return 1; otherwise 0. Require that overlaps have the same strand with same_strand=True. Notes: If this current BedTool is generator-based, it will be converted into a file first. If this current BedTool refers to a BAM file, it will be converted to a BED file first using default arguments. If you don't want this to happen, please convert to BED first before using this method. r) r*rr0rdr+rrcrrrany_hitsrs r%rzBedTool.any_hitsrr'cJt|tstd|j}t|ts|j}|jr|j}tj |}| |||S)a Return the number of intervals that overlap `interval`. Calls the `count_hits` method of an IntervalFile. Returns the number of valid hits in this BedTool that overlap `interval`. Require that overlaps have the same strand with same_strand=True. Notes: If this current BedTool is generator-based, it will be converted into a file first. If this current BedTool refers to a BAM file, it will be converted to a BED file first using default arguments. If you don't want this to happen, please convert to BED first before using this method. r) r*rr0rdr+rrcrrr count_hitsrs r%rzBedTool.count_hitss$(H-- :899 9 W"c"" "!B ; &""%B"/33 ''+wGGGr' bed12ToBed6r$)r\r}rwrc dS)z/ Wraps `bedtools bed12tobed6`. Nr!rkr9s r%rSz BedTool.bed6s r'bamToBedr^)r\r}rrrwc dS)z, Wraps `bedtools bamtobed`. Nr!rs r%rzBedTool.bam_to_bedr'bedToBam)r\r}rrycdS)z Wraps bedToBam and is called internally for BED/GFF/VCF files by self.to_bam (which needs to do something different for SAM files...) Nr!r s r% _bed_to_bamzBedTool._bed_to_bamrr'c |jdkr|S|jdvr |jdi|S|jdkr|jdi|}tdt |dD}g}i}dg}t |D]g\}\}}|t|t||||<|d ||hd d i|d } d |d z}| } | } t | d 5} | ||D]E} | d tt| jd zF dddn #1swxYwYt!j| d}t!j| d|}|D]}| |||t'| }d|_|SdS)z Wraps `bedtools bedtobam` If self.fn is in BED/VCF/GFF format, call BEDTools' bedToBam. If self.fn is in SAM format, then create a header out of the genome file and then convert using `samtools`. rw)rHrCvcfsamc3>K|]}|VdSrT)r2r"s r%r2z!BedTool.to_bam..s*??!''))??????r'rZz @HD VN:1.0)SNLNz@SQ SN:{0} LN:{1}VNz1.0)HDSQrOrrQNrur)templateTr!)rrrer5r,rTrhrAr3rwr/rfrrr+r8r AlignmentFilerr@rc)rkr9r[rref_ids text_headerr$rrr;sam_tmpbam_tmprrsamfilebamfile alignment new_bedtools r%to_bamzBedTool.to_bams >U " "K >2 2 2#4#--f-- - >U " " 'T&0000F??T&+->->?????FBG(/K&v||~~66 G G 6Aq $!A///000 ""#8#?#?1#E#EFFFF"5M44F))K0047KiikkGiikkGgs## Lt ;''' $LLHJJtyyS(/)B)BCCdJKKKKL L L L L L L L L L L L L L L L )'377G)'4'JJJG$ ) )  i(((( MMOOO MMOOO!'**K!%K  ] # "sAF;;F?F?rababamrH)r\r}rrwrr]cdS)z- Wraps `bedtools intersect`. Nr!r s r%rzBedTool.intersect>rr' fastaFromBedfifoseqfn)r\r}rwrr~r`rvcdS)a Wraps `bedtools getfasta`. *fi* is passed in by the user; *bed* is automatically passed in as the bedfile of this object; *fo* by default is a temp file. Use save_seqs() to save as a file. The end result is that this BedTool will have an attribute, self.seqfn, that points to the new fasta file. Example usage: >>> a = pybedtools.BedTool(""" ... chr1 1 10 ... chr1 50 55""", from_string=True) >>> fasta = pybedtools.example_filename('test.fa') >>> a = a.sequence(fi=fasta) >>> print(open(a.seqfn).read()) >chr1:1-10 GATGAGTCT >chr1:50-55 CCATC Nr!r s r%sequencezBedTool.sequenceFrr'ct|trV|d\}}tt t |d\}}|dz}n|d|d|d}}}t d|||fzd}|| }d d t|j d DS) a  Return just the sequence from a region string or a single location >>> fn = pybedtools.example_filename('test.fa') >>> BedTool.seq('chr1:2-10', fn) 'GATGAGTCT' >>> BedTool.seq(('chr1', 1, 10), fn) 'GATGAGTCT' rrPrrr(z%s %i %iTr)rrcNg|]"}|ddk|#S)r>)rstrip)r#ls r%r&zBedTool.seq..s)QQQqQqTS[[ [[[r'ru) r*r+r2r6rr3r@r r/r,r )locfastar start_endrrlseqs r%seqz BedTool.seqns c3   7"yy~~ E9c#ys';';<<==JE3 QJEE #AAA#5EleUC%88dKKK||u|%%wwQQDS,A,AQQQRRRr'nucBed)r\r}rr`cdS)z Wraps `bedtools nuc`. Profiles nucleotide content. The returned BED file contains extra information about the nucleotide content Nr!r s r%nucleotide_contentzBedTool.nucleotide_contentrr' multiBamCov)r\r}cdS)zk Wraps `bedtools multicov`. Pass a list of sorted and indexed BAM files as `bams` Nr!r s r%multi_bam_coveragezBedTool.multi_bam_coveragerr' subtractBed)r\r}rrwcttd<dtvr|jtd<|jdddit\}}}t |||}t |S)a Wraps `bedtools subtract`. Subtracts from another BED file and returns a new BedTool object. Example usage: >>> a = pybedtools.example_bedtool('a.bed') >>> b = pybedtools.example_bedtool('b.bed') Do a "stranded" subtraction: >>> c = a.subtract(b, s=True) Require 50% of features in `a` to overlap: >>> c = a.subtract(b, f=0.5) rrr\rr_r!)rr9rdrgr r@)rkrmrnr_rqs r%subtractzBedTool.subtractsg*s f  'F3K-4-KK=KFKKc5tS666vr'slopBed)r\r}rrwrcdS)z( Wraps `bedtools slop`. Nr!r s r%slopz BedTool.sloprr'shiftBedcdS)a> Wraps `bedtools shift`. Shift each feature by user-defined number of bases. Returns a new BedTool object. Example usage: >>> a = pybedtools.example_bedtool('a.bed') Shift every feature by 5bp: >>> b = a.shift(genome='hg19', s=5) >>> print(b) #doctest: +NORMALIZE_WHITESPACE chr1 6 105 feature1 0 + chr1 105 205 feature2 0 + chr1 155 505 feature3 0 - chr1 905 955 feature4 0 + Shift features on the '+' strand by -1bp and on '-' strand by +3bp: >>> b = a.shift(genome='hg19', p=-1, m=3) >>> print(b) #doctest: +NORMALIZE_WHITESPACE chr1 0 99 feature1 0 + chr1 99 199 feature2 0 + chr1 153 503 feature3 0 - chr1 899 949 feature4 0 + # Disabling, see https://github.com/arq5x/bedtools2/issues/807 Shift features by a fraction of their length (0.50): #>>> b = a.shift(genome='hg19', pct=True, s=0.50) #>>> print(b) #doctest: +NORMALIZE_WHITESPACE #chr1 50 149 feature1 0 + #chr1 150 250 feature2 0 + #chr1 325 675 feature3 0 - #chr1 925 975 feature4 0 + # Nr!r s r%shiftz BedTool.shiftrr'rcdS)aS Wraps `bedtools merge`. Merge overlapping features together. Returns a new BedTool object. Example usage: >>> a = pybedtools.example_bedtool('a.bed') Merge: >>> c = a.merge() Allow merging of features 500 bp apart: >>> c = a.merge(d=500) Nr!r s r%mergez BedTool.mergerr' closestBedcdS)a Wraps `bedtools closest`. Return a new BedTool object containing closest features in *b*. Note that the resulting file is no longer a valid BED format; use the special "_closest" methods to work with the resulting file. Example usage:: a = BedTool('in.bed') # get the closest feature in 'other.bed' on the same strand b = a.closest('other.bed', s=True) Nr!r s r%closestzBedTool.closestrr' windowBed)r\r}rrwrcdS)a Wraps `bedtools window`. Example usage:: >>> a = pybedtools.example_bedtool('a.bed') >>> b = pybedtools.example_bedtool('b.bed') >>> print(a.window(b, w=1000)) #doctest: +NORMALIZE_WHITESPACE chr1 1 100 feature1 0 + chr1 155 200 feature5 0 - chr1 1 100 feature1 0 + chr1 800 901 feature6 0 + chr1 100 200 feature2 0 + chr1 155 200 feature5 0 - chr1 100 200 feature2 0 + chr1 800 901 feature6 0 + chr1 150 500 feature3 0 - chr1 155 200 feature5 0 - chr1 150 500 feature3 0 - chr1 800 901 feature6 0 + chr1 900 950 feature4 0 + chr1 155 200 feature5 0 - chr1 900 950 feature4 0 + chr1 800 901 feature6 0 + Nr!r s r%windowzBedTool.windowrr' shuffleBedcdS)a Wraps `bedtools shuffle`. Example usage: >>> a = pybedtools.example_bedtool('a.bed') >>> seed = 1 # so this test always returns the same results >>> b = a.shuffle(genome='hg19', chrom=True, seed=seed) >>> print(b) #doctest: +NORMALIZE_WHITESPACE chr1 123081365 123081464 feature1 0 + chr1 243444570 243444670 feature2 0 + chr1 194620241 194620591 feature3 0 - chr1 172792873 172792923 feature4 0 + Nr!r s r%shufflezBedTool.shuffle/rr'sortBedrZr[)r\r}rrzcdS)a Wraps `bedtools sort`. Note that chromosomes are sorted lexograpically, so chr12 will come before chr9. Example usage: >>> a = pybedtools.BedTool(''' ... chr9 300 400 ... chr1 100 200 ... chr1 1 50 ... chr12 1 100 ... chr9 500 600 ... ''', from_string=True) >>> print(a.sort()) #doctest: +NORMALIZE_WHITESPACE chr1 1 50 chr1 100 200 chr12 1 100 chr9 300 400 chr9 500 600 Nr!r s r%rz BedTool.sortBrr'rcdS)a Wraps `bedtools annotate`. Annotate this BedTool with a list of other files. Example usage: >>> a = pybedtools.example_bedtool('a.bed') >>> b_fn = pybedtools.example_filename('b.bed') >>> print(a.annotate(files=b_fn)) #doctest: +NORMALIZE_WHITESPACE chr1 1 100 feature1 0 + 0.000000 chr1 100 200 feature2 0 + 0.450000 chr1 150 500 feature3 0 - 0.128571 chr1 900 950 feature4 0 + 0.020000 Nr!r s r%annotatezBedTool.annotate]rr'flankBed)r\r}rc|jdi|}d|vr |j|d<|jdddi|\}}}t|||}t |S)a Wraps `bedtools flank`. Example usage: >>> a = pybedtools.example_bedtool('a.bed') >>> print(a.flank(genome='hg19', b=100)) #doctest: +NORMALIZE_WHITESPACE chr1 0 1 feature1 0 + chr1 100 200 feature1 0 + chr1 0 100 feature2 0 + chr1 200 300 feature2 0 + chr1 50 150 feature3 0 - chr1 500 600 feature3 0 - chr1 800 900 feature4 0 + chr1 950 1050 feature4 0 + r$r\r6rr!)rerdrgr r@)rkr9rmrnr_rqs r%flankz BedTool.flankpsv*#",,V,, f  'F3K-4-HH:HHHc5tS666vr'genomeCoverageBedibam)r\r}rwr{r|rrcdS)a Wraps `bedtools genomecov`. Note that some invocations of `bedtools genomecov` do not result in a properly-formatted BED file. For example, the default behavior is to report a histogram of coverage. Iterating over the resulting, non-BED-format file will raise exceptions in pybedtools' parser. Consider using the `BedTool.to_dataframe` method to convert these non-BED files into a pandas DataFrame for further use. Example usage: BAM file input does not require a genome: >>> a = pybedtools.example_bedtool('x.bam') >>> b = a.genome_coverage(bg=True) >>> b.head(3) #doctest: +NORMALIZE_WHITESPACE chr2L 9329 9365 1 chr2L 10212 10248 1 chr2L 10255 10291 1 Other input does require a genome: >>> a = pybedtools.example_bedtool('x.bed') >>> b = a.genome_coverage(bg=True, genome='dm3') >>> b.head(3) #doctest: +NORMALIZE_WHITESPACE chr2L 9329 9365 1 chr2L 10212 10248 1 chr2L 10255 10291 1 Non-BED format results: >>> a = pybedtools.example_bedtool('x.bed') >>> b = a.genome_coverage(genome='dm3') >>> df = b.to_dataframe(names=['chrom', 'depth', 'n', 'chromsize', 'fraction']) Nr!r s r%genome_coveragezBedTool.genome_coveragerr' coverageBedcdS)a Wraps `bedtools coverage`. Note that starting in version 2.24.0, BEDTools swapped the semantics of the "a" and "b" files. Example usage: >>> a = pybedtools.example_bedtool('a.bed') >>> b = pybedtools.example_bedtool('b.bed') >>> c = b.coverage(a) >>> c.head(3) #doctest: +NORMALIZE_WHITESPACE chr1 155 200 feature5 0 - 2 45 45 1.0000000 chr1 800 901 feature6 0 + 1 1 101 0.0099010 Nr!r s r%coveragezBedTool.coveragerr'maskFastaFromBed)r\r}rr~rvr`cdS)a Wraps `bedtools maskfasta`. Masks a fasta file at the positions in a BED file and saves result as 'out' and stores the filename in seqfn. >>> a = pybedtools.BedTool('chr1 100 110', from_string=True) >>> fasta_fn = pybedtools.example_filename('test.fa') >>> a = a.mask_fasta(fi=fasta_fn, fo='masked.fa.example') >>> b = a.slop(b=2, genome='hg19') >>> b = b.sequence(fi=a.seqfn) >>> print(open(b.seqfn).read()) >chr1:98-112 TTNNNNNNNNNNAT >>> os.unlink('masked.fa.example') >>> if os.path.exists('masked.fa.example.fai'): ... os.unlink('masked.fa.example.fai') Nr!r s r% mask_fastazBedTool.mask_fastarr' complementBedcdS)a= Wraps `bedtools complement`. Example usage: >>> a = pybedtools.example_bedtool('a.bed') >>> a.complement(genome='hg19').head(5) #doctest: +NORMALIZE_WHITESPACE chr1 0 1 chr1 500 900 chr1 950 249250621 chr2 0 243199373 chr3 0 198022430 Nr!r s r% complementzBedTool.complementrr'rcdS)a Wraps `bedtools overlap`. Example usage: >>> a = pybedtools.example_bedtool('a.bed') >>> b = pybedtools.example_bedtool('b.bed') >>> c = a.window(b, w=10).overlap(cols=[2,3,8,9]) >>> print(c) #doctest: +NORMALIZE_WHITESPACE chr1 100 200 feature2 0 + chr1 155 200 feature5 0 - 45 chr1 150 500 feature3 0 - chr1 155 200 feature5 0 - 45 chr1 900 950 feature4 0 + chr1 800 901 feature6 0 + 1 Nr!r s r%rzBedTool.overlap rr' pairToBedbedpecdS)z- Wraps `bedtools pairtobed`. Nr!r s r% pair_to_bedzBedTool.pair_to_bed rr' pairToPair)r\r}rcdS)z. Wraps `bedtools pairtopair`. Nr!r s r% pair_to_pairzBedTool.pair_to_pair" rr'rcdS)aC Wraps `bedtools groupby`. Example usage: >>> a = pybedtools.example_bedtool('gdc.gff') >>> b = pybedtools.example_bedtool('gdc.bed') >>> c = a.intersect(b, c=True) >>> d = c.groupby(g=[1, 4, 5], c=10, o=['sum']) >>> print(d) #doctest: +NORMALIZE_WHITESPACE chr2L 41 70 0 chr2L 71 130 2 chr2L 131 170 4 chr2L 171 200 0 chr2L 201 220 1 chr2L 41 130 2 chr2L 171 220 1 chr2L 41 220 7 chr2L 161 230 6 chr2L 41 220 7 Nr!r s r%groupbyzBedTool.groupby, rr'tagBam)r\r}rwcdS)zd Wraps `bedtools tag`. `files` and `labels` should lists of equal length. Nr!r s r%tag_bamzBedTool.tag_bamG rr'rcdS)zG Wraps `bedtools map`; See also :meth:`BedTool.each`. Nr!r s r%rz BedTool.mapT rr'rr6)r\rrzcdS)a Wraps `bedtools multiintersect`. Provide a list of filenames as the "i" argument. e.g. if you already have BedTool objects then use their `.fn` attribute, like this:: >>> x = pybedtools.BedTool() >>> a = pybedtools.example_bedtool('a.bed') >>> b = pybedtools.example_bedtool('b.bed') >>> result = x.multi_intersect(i=[a.fn, b.fn]) >>> print(result) #doctest: +NORMALIZE_WHITESPACE chr1 1 155 1 1 1 0 chr1 155 200 2 1,2 1 1 chr1 200 500 1 1 1 0 chr1 800 900 1 2 0 1 chr1 900 901 2 1,2 1 1 chr1 901 950 1 1 1 0 Nr!r s r%multi_intersectzBedTool.multi_intersect[ rr' randomBed)r\rcdS)a Wraps `bedtools random`. Since this method does not operate on an existing file, create a BedTool with no arguments and then call this method, e.g., >>> x = BedTool() >>> y = x.random(l=100, n=10, genome='hg19') Nr!r s r%rzBedTool.randomv rr' bedpeToBam)r}rrycdS)z. Wraps `bedtools bedpetobam`. Nr!r s r% bedpe_to_bamzBedTool.bedpe_to_bam rr' clusterBedcdS)z, Wraps `bedtools cluster`. Nr!r s r%clusterzBedTool.cluster rr'unionBedGraphs)r\cdS)z Wraps `bedtools unionbedg`. Warning: using the `header=True` kwarg will result in a file that is not in true BED format, which may break downstream analysis. Nr!r s r%union_bedgraphszBedTool.union_bedgraphs rr' windowMakerr)r\rr{rr]cdS)z/ Wraps `bedtools makewindows`. Nr!r s r% window_makerzBedTool.window_maker rr' expandColscdS)z) Wraps `bedtools expand` Nr!r s r%expandzBedTool.expand rr'linksBedrL links_html)r\r}rvcdS)z Wraps `linksBed`. The resulting BedTool will have a new attribute `links_html`. This attribute is a temp filename containing the HTML links. Nr!r s r%linksz BedTool.links rr'bedToIgv igv_scriptcdS)z Wraps `bedtools igv`. The resulting BedTool will have a new attribute `igv_script`. This attribute is a temp filename containing the IGV script. Nr!r s r%igvz BedTool.igv rr' bamToFastqfqfastq)r\r}rwr~rvcdS)z Wraps `bedtools bamtofastq`. The `fq` argument is required. The resulting BedTool will have a new attribute, `fastq`. Nr!r s r% bam_to_fastqzBedTool.bam_to_fastq rr'jaccard)r\r}rrxcdS)zP Returns a dictionary with keys (intersection, union, jaccard). Nr!r s r%rtzBedTool.jaccard rr'rEcdS)a If detail=False, then return a dictionary with keys (reldist, count, total, fraction), which is the summary of the bedtools reldist. Otherwise return a BedTool, with the relative distance for each interval in A in the last column. Nr!r s r%rEzBedTool.reldist rr'samplecdS)z! Wraps 'sample'. Nr!r s r%rwzBedTool.sample rr'fisher)r\r}rrrxcdS)a Wraps 'fisher'. Returns an object representing the output. >>> a = pybedtools.example_bedtool('a.bed') >>> b = pybedtools.example_bedtool('b.bed') >>> f = a.fisher(b, genome='hg19') >>> print(f) # doctest: +NORMALIZE_WHITESPACE # Number of query intervals: 4 # Number of db intervals: 2 # Number of overlaps: 3 # Number of possible intervals (estimated): 13958448 # phyper(3 - 1, 4, 13958448 - 4, 2, lower.tail=F) # Contingency Table Of Counts #_________________________________________ # | in -b | not in -b | # in -a | 3 | 1 | # not in -a | 0 | 13958444 | #_________________________________________ # p-values for fisher's exact test left right two-tail ratio 1 8.8247e-21 8.8247e-21 inf >>> f.table['not in -a']['in -b'] 0 >>> f.table['not in -a']['not in -b'] 13958444 >>> f.table['in -a']['in -b'] 3 >>> f.table['in -a']['not in -b'] 1 >>> f.two_tail 8.8247e-21 Nr!r s r%ryzBedTool.fisher rr'r2)r\r}rxcdS)a Wraps 'bedtools split'. BedTool objects have long had a `split` method which splits intervals according to a custom function. Now that BEDTools has a `split` tool, the method name conflicts. To maintain backwards compatibility, the method wrapping the BEDTools command is called `splitbed`. Since this tool does not return a single BED file, the method parses the output and returns a SplitOutput object, which includes an attribute, `bedtools`, that is a list of BedTool objects created from the split files. To keep the working directory clean, you may want to consider using `prefix=BedTool._tmp()` to get a temp file that will be deleted when Python exits cleanly. >>> a = pybedtools.example_bedtool('a.bed') >>> s = a.splitbed(n=2, p="split") >>> assert len(a) == 4, len(a) >>> assert len(s.bedtools) == 2 >>> print(s.bedtools[0]) # doctest: +NORMALIZE_WHITESPACE chr1 150 500 feature3 0 - >>> print(s.bedtools[1]) # doctest: +NORMALIZE_WHITESPACE chr1 100 200 feature2 0 + chr1 1 100 feature1 0 + chr1 900 950 feature4 0 + Nr!r s r%splitbedzBedTool.splitbed* rr'spacingcdS)a1 Wraps `bedtools spacing` >>> a = pybedtools.example_bedtool('a.bed') >>> print(a.spacing()) # doctest: +NORMALIZE_WHITESPACE chr1 1 100 feature1 0 + . chr1 100 200 feature2 0 + 0 chr1 150 500 feature3 0 - -1 chr1 900 950 feature4 0 + 400 Nr!r s r%r}zBedTool.spacingK rr'ct|dst|drtd|DStdt|DS)a Count the number features in this BedTool. Number of features in BED file. Does the same thing as len(self), which actually just calls this method. Only counts the actual features. Ignores any track lines, browser lines, lines starting with a "#", or blank lines. Example usage: >>> a = pybedtools.example_bedtool('a.bed') >>> a.count() 4 rrc3K|]}dVdSrNr!rs r%r2z BedTool.count..i s"''Qq''''''r'c3K|]}dVdSrr!rs r%r2z BedTool.count..j s"))1))))))r')r.sumrr s r%rFz BedTool.countX sg 4  (GD*$=$= (''$''''' '))d4jj))))))r'ct|dstdt|j}|}||S)z Print the sequence that was retrieved by BedTool.sequence. See usage example in :meth:`BedTool.sequence`. r .Use .sequence(fasta) to get the sequence first)r.r0r,r r-r)rkr1r8s r%print_sequencezBedTool.print_sequencel sT tW%% OMNN N    FFHH  r'cpt|dstdt|d5}t|j5}||dddn #1swxYwYdddn #1swxYwYt |j}||_|S)a  Save sequences, after calling BedTool.sequence. In order to use this function, you need to have called the :meth:`BedTool.sequence()` method. A new BedTool object is returned which references the newly saved file. Example usage: >>> a = pybedtools.BedTool(''' ... chr1 1 10 ... chr1 50 55''', from_string=True) >>> fasta = pybedtools.example_filename('test.fa') >>> a = a.sequence(fi=fasta) >>> print(open(a.seqfn).read()) >chr1:1-10 GATGAGTCT >chr1:50-55 CCATC >>> b = a.save_seqs('example.fa') >>> assert open(b.fn).read() == open(a.fn).read() >>> if os.path.exists('example.fa'): ... os.unlink('example.fa') r rrN)r.r0r,r rr-r@rd)rkrdrseqfilers r% save_seqszBedTool.save_seqsy s!8tW%% OMNN N "c]] +ddj!! +W 7<<>>*** + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +dg&&  s5B(A9- B9A= =BA= BBBc d|vs|dddi|d< ddln#t$rtdwxYwfd}t|trt |}nt|ts Jd|d}t |j|fi|} |s|j|fd |i|} n"|td |j |f||d |}  t| }  | } tt | } t| | k| z } t| | k| z }| | z }d }d }| ||g\}}|| | }d |d| d|jd|j|jt ||jt |dt |dt |d| d|d| d|d|d|z|d|z|i}|r| |d<n~ |S)a Dictionary of results from many randomly shuffled intersections. Sends args and kwargs to :meth:`BedTool.randomintersection` and compiles results into a dictionary with useful stats. Requires numpy. If `include_distribution` is True, then the dictionary will include the full distribution; otherwise, the distribution is deleted and cleaned up to save on memory usage. This is one possible way of assigning significance to overlaps between two files. See, for example: Negre N, Brown CD, Shah PK, Kheradpour P, Morrison CA, et al. 2010 A Comprehensive Map of Insulator Elements for the Drosophila Genome. PLoS Genet 6(1): e1000814. doi:10.1371/journal.pgen.1000814 Example usage: Make chromsizes a very small genome for this example: >>> chromsizes = {'chr1':(1,1000)} >>> a = pybedtools.example_bedtool('a.bed').set_chromsizes(chromsizes) >>> b = pybedtools.example_bedtool('b.bed') >>> try: ... results = a.randomstats(b, 100, debug=True) ... except ImportError: ... pass *results* is a dictionary that you can inspect. (Note that the following examples are not run as part of the doctests to avoid forcing users to install NumPy just to pass tests) The actual overlap:: print(results['actual']) 3 The median of all randomized overlaps:: print(results['median randomized']) 2.0 The percentile of the actual overlap in the distribution of randomized overlaps, which can be used to get an empirical p-value:: print(results['percentile']) 90.0 intersect_kwargsNrTrz"Need to install NumPy for stats...c :|}t|}||ksS||}t t t|}n?t t t|dz}|}t||kg}|||z dz}|S)zn copied from scipy.stats.percentileofscore, to avoid dependency on scipy. g?gY@) arrayrbanyrAr6rrrmean)rscorer9a_lenidxpctnps r%percentileofscorez.BedTool.randomstats..percentileofscore s  AAAFF1:&& <IIa''eCFFmm!4!455eCFFmm!4!455; Ae %%C775:&&*e3CJr'4Either filename or another BedTool instance required iterationszK`genome_fn` must be provided if using the new _randomintersection mechanism)r genome_fng@g`X@actualfile_afile_brkrzfrac randomized above actualzfrac randomized below actualzmedian randomized normalized percentilez lower_%sthz upper_%sth distribution)numpyrr*r+r@rbrrandomintersectionr0_randomintersectionrr6medianr4rrrd)rkrrnewrinclude_distributionr9ri_kwargsrr med_countr9 frac_above frac_belowr lower_thresh upper_threshrupperactual_percentilerIrs @r% randomstatszBedTool.randomstats sx f , ,&9K2L2T*-tF% & D      D D DBCC C D     & eS ! ! FENNEEw F FE F F F ,-^T^E66X6677  242",06LL   8443", EKLxx\ 2 233 IIl++ #l## $ $.//!3 .//!3 i'   }}\L,3OPP u--lFCC * f dg eh GSYY Hc%jj CII SZZ *J *J  * + < ' < ' "   ,An  s5c|j|i|S)zR For backwards compatibility; see BedTool.parallel_apply instead. )parallel_apply)rkrVr9s r% random_opzBedTool.random_op; s#t"D3F333r'rc#J K|dkr#t|D] }iV t|r| ntj| ||z g|z}|dxx||zz cc< fdt|D} | D]} | Vt)aD Generalized method for applying a function in parallel. Typically used when having to do many random shufflings. `func_args` and `func_kwargs` will be passed to `func` each time in `iterations`, and these iterations will be split across `processes` processes. Notes on the function, `func`: * the function should manually remove any tempfiles created. This is because the BedTool.TEMPFILES list of auto-created tempfiles does not share state across processes, so things will not get cleaned up automatically as they do in a single-process pybedtools session. * this includes deleting any "chromsizes" or genome files -- generally it will be best to require a genome filename in `func_kwargs` if you'll be using any BedTool methods that accept the `g` kwarg. * the function should be a module-level function (rather than a class method) because class methods can't be pickled across process boundaries * the function can have any signature and have any return value `_orig_pool` can be a previously-created multiprocessing.Pool instance; otherwise, a new Pool will be created with `processes` rc>g|]}Sr!) apply_async)r#itr func_args func_kwargsrs r%r&z*BedTool.parallel_apply..u s6   <>AMM$ ; 7 7   r')rrbmultiprocessingPoolget) rkrrrr processes _orig_poolriterations_eachrCrurs ``` @r%rzBedTool.parallel_applyA s D >>J'' 6 6dI5555555   0AA$Y//A% 12Y>zI55       BG BSBS     A%%''MMMMr'c |i}|i}|stdt||tjj||ft |||||S)a Computes the naive Jaccard statistic (intersection divided by union). .. note:: If you don't need the randomization functionality of this method, you can use the simpler BedTool.jaccard method instead. See Favorov et al. (2012) PLoS Comput Biol 8(5): e1002529 for more info on the Jaccard statistic for intersections. If `iterations` is None, then do not perform random shufflings. If `iterations` is an integer, perform `iterations` random shufflings, each time computing the Jaccard statistic to build an empirical distribution. `genome_fn` will also be needed; optional `processes` will split the iteations across multiple CPUs. Returns a tuple of the observed Jaccard statistic and a list of the randomized statistics (which will be an empty list if `iterations` was None). N8Need a genome filename in order to perform randomization)rshuffle_kwargsjaccard_kwargsrrrrrr)r0r6rrstatsrandom_jaccardr5)rkrrrrrrrs r%rzBedTool.random_jaccard| s@  !N  !N YWXX X   %%4- '#1#1 $%     r'c |i}|td}|stdt||tjj||ft|||||S)zj Re-implementation of BedTool.randomintersection using the new `random_op` method NTrrrrrr)r5r0r6rrrrandom_intersection)rkrrrrrrrs r%rzBedTool._randomintersection s  !N  ##d|||  YWXX X   %%9- '#1%5 $%     r'c |i}|i}|stdt||tjj||ft |||||S)z} Like randomintersection, but return the bp overlap instead of the number of intersecting intervals. Nrrr)r0r6rrrrandom_intersection_bpr5)rkrrrrrrrs r%randomintersection_bpzBedTool.randomintersection_bp s  !N  #!  YWXX X   %%<- '#1%5 $%     r'c #Kltj|zgz} | dxx|zz cc<fd| D} | D]} | D]} | Vtiddidvrdd<dd} t |D]}r|d<rT|d kr d |d ||z}nd |z}t j|t j| r"j di}| }n j di}|j fd di}t|V|j ~~dS)a| Perform `iterations` shufflings, each time intersecting with `other`. Returns a generator of integers where each integer is the number of intersections of a shuffled file with *other*. This distribution can be used in downstream analysis for things like empirical p-values. *intersect_kwargs* and *shuffle_kwargs* are passed to self.intersect() and self.shuffle() respectively. By default for intersect, u=True is specified -- but s=True might be a useful option for strand-specific work. Useful kwargs for *shuffle_kwargs* are chrom, excl, or incl. If you use the "seed" kwarg, that seed will be used *each* time shuffleBed is called -- so all your randomization results will be identical for each iteration. To get around this and to allow for tests, debug=True will set the seed to the iteration number. You may also break up the intersections across multiple processes with *processes* > 1. Example usage: >>> chromsizes = {'chr1':(0, 1000)} >>> a = pybedtools.example_bedtool('a.bed') >>> a = a.set_chromsizes(chromsizes) >>> b = pybedtools.example_bedtool('b.bed') >>> results = a.randomintersection(b, 10, debug=True) >>> print(list(results)) [1, 0, 1, 2, 4, 2, 2, 1, 2, 4] Nrc rg|]3}t|ft 4S))rrrreport_iterations_orig_processes)rrr5) r#rrrrrrrrkrs r%r&z.BedTool.randomintersection..$ sg    )5"%)9'5#*;(1      r'rTrFseedrz approx (total across z processes): z %srqr!)rrrrbrrrMrflushr1rrrbrdr)rkrrrrrrrrrrCrurtresortr$rtmp0rntmp2rs`` ````` @r%rzBedTool.randomintersection sTR  $Y//A)Y67)CO B   : #9 9              *   G  UUWW  EKKKK    !N  # #T{  & & &$( S !!%%h66z""! ! A +)*v& #"Q&&&'O++CC !1*C   %%%   """ 5#t|55n55iikk"dl44^44 3=HHtH7GHHDd))OOO GMMOOOC! ! r'c t|dks Jdg}|D]b}t|ttfrt |}nt|ts Jd||c|dd}|dd}|dd}|r|rtd |s |j }|g|z} t|j gd |Dz d g} t| gd |Dz d g dg} t| dk} tt| dk} n#t$rtdwxYw| }|s| r| r~t|d5}|D]$}|t|%|D])}|D]$}|t|%* d d d n #1swxYwYnH|s| rt!| }t|d5}|D]:}|d|jd |dz;|D]?}|D]:}|d|jd |dz;@ d d d n #1swxYwYnt|d5}|D],}|d|j|j|jfz-|D]1}|D],}|d|j|j|jfz-2 d d d n #1swxYwYt |}|r7|djdi|}t1j||S|S)a Concatenate interval files together. Concatenates two BedTool objects (or an object and a file) and does an optional post-merge of the features. *postmerge=True* by default; use *postmerge=False* if you want to keep features separate. *force_truncate=False* by default; *force_truncate=True* to truncate all files to chrom, start, stop. When *force_truncate=False* and *postmerge=False*, the output will contain the smallest number of fields observed across all inputs. This maintains compatibility with BEDTools programs, which assume constant number of fields in all lines of a file. Other kwargs are sent to :meth:`BedTool.merge` (and assuming that *postmerge=True*). Example usage: >>> a = pybedtools.example_bedtool('a.bed') >>> b = pybedtools.example_bedtool('b.bed') >>> print(a.cat(b)) #doctest: +NORMALIZE_WHITESPACE chr1 1 500 chr1 800 950 >>> print(a.cat(*[b,b], ... postmerge=False)) #doctest: +NORMALIZE_WHITESPACE chr1 1 100 feature1 0 + chr1 100 200 feature2 0 + chr1 150 500 feature3 0 - chr1 900 950 feature4 0 + chr1 155 200 feature5 0 - chr1 800 901 feature6 0 + chr1 155 200 feature5 0 - chr1 800 901 feature6 0 + rz,You must specify at least one other bedfile!r postmergeTforce_truncateFrqzThe post-merge step in the `cat()` method perfoms a sort, which uses stream=True. Using stream=True for the merge as well will result in a deadlock!cg|] }|j Sr!)rr"s r%r&zBedTool.cat.. s'H'H'H 'H'H'Hr'r6c6g|]}|Sr!)r;r"s r%r&zBedTool.cat.. s /T/T/TA /T/T/Tr'NrzCan't check filetype or field count -- is one of the files you're merging a 'streaming' BedTool? If so, use .saveas() to save to file firstrrQrOz %s %i %i )rqr!)rbr*r+rr@rArrr0rr7 differencer;rfr,rminr/r8rrrrr(rr)rkothersr9 other_bedsrrr stream_mergea_typefiles filetypes field_numssame_field_num same_typernTMPr1 minfieldscrIs r%catz BedTool.catd sT6{{Q N  % %E%#t-- J!7JJIJJJ   e $ $ $ $JJ{D11 $4e<<zz(E22  I    +^$'H'HZ'H'H'HH*gY''))++,/T/T/T/T/TTUUZ''Z__ "%ZA!5I//14     K iikk N) N Nc3 *3&&AIIc!ff%%%%'**E"** #a&&))))** * * * * * * * * * * * * * * *  NI NJIc3 J3FFAIIdii)(<==DEEEE'JJE"JJ $))AHZiZ,@"A"AD"HIIIIJJ J J J J J J J J J J J J J J Jc3 N3JJAIIn!%/HHIIII'NNE"NN .AGQWae3L"LMMMMNN N N N N N N N N N N N N N N N CLL  )d##)33F33A IcNNNHHsFC F++G2AIIIBLLL,A$NN!$N!c:||}|-tj|\}}|dkrd}nd}t |jt ot|j}||||||}t|S)aX Make a copy of the BedTool. Optionally adds `trackline` to the beginning of the file. Optionally compresses output using gzip. if the filename extension is .gz, or compressed=True, the output is compressed using gzip Returns a new BedTool for the newly saved file. A newline is automatically added to the trackline if it does not already have one. Example usage: >>> a = pybedtools.example_bedtool('a.bed') >>> b = a.saveas('other.bed') >>> b.fn 'other.bed' >>> print(b == a) True >>> b = a.saveas('other.bed', trackline="name='test run' color=0,55,0") >>> open(b.fn).readline() "name='test run' color=0,55,0\n" >>> if os.path.exists('other.bed'): ... os.unlink('other.bed') NrTF)rdrrr) rfrrsplitextr*rdr+rrr@)rkrdr compressed__ extensionrs r%rzBedTool.saveas s@ :B  G,,R00MB E!!! " "47C00DVDG__ ^^ '%   r{{r'ct|jts|||}nt j|j|t |S)a Move to a new filename (can be much quicker than BedTool.saveas()) Move BED file to new filename, `fn`. Returns a new BedTool for the new file. Example usage: >>> # make a copy so we don't mess up the example file >>> a = pybedtools.example_bedtool('a.bed').saveas() >>> a_contents = str(a) >>> b = a.moveto('other.bed') >>> b.fn 'other.bed' >>> b == a_contents True )rd)r*rdr+rshutilmover@rkrds r%movetozBedTool.moveto sO($'3'' %,,BB K $ $ $r{{r'c||||td|}|tj||rt t t |}tj||d|}t|d5}t|D]+\}}||vr"| t|, dddn #1swxYwYni|rgt|d5}|D];}tj|kr"| t|< dddn #1swxYwYt|S)a Return a BedTool containing a random subset. NOTE: using `n` will be slower and use more memory than using `f`. Parameters ---------- n : int Number of features to return. Only one of `n` or `f` can be provided. f : float, 0 <= f <= 1 Fraction of features to return. Cannot be provided with `n`. seed : float or int Set random.seed Example ------- >>> seed = 0 # only for test, otherwise use None `n` will always give the same number of returned features, but will be slower since it is creating an index and then shuffling it. >>> a = pybedtools.example_bedtool('a.bed') >>> b = a.random_subset(n=2) >>> len(b) 2 Using a fraction `f` will be faster but depending on seed will result in slightly different total numbers. >>> a = pybedtools.example_bedtool('x.bam') >>> len(a) 45593 >>> b = a.random_subset(f=0.4, seed=seed) >>> len(b) 18316 Check that we have approximately the right fraction >>> print('{0:.2f}'.format(len(b) / len(a))) 0.40 Nz*Exactly one of `n` or `f` must be providedr) r0rfrrr6rrbr1r,rTrr+r@) rkr9r1rrridxsrnr$rs r% random_subsetzBedTool.random_subset5 s^YQYam!-IJJ J    K    *c$ii(())D N4 8DeS!! 0S"+D//00JAwDyy #g,,///0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0  *eS!! *S**A}!++ #a&&)))* * * * * * * * * * * * * * * * u~~s$>> a = pybedtools.example_bedtool('a.bed') This does a merge() first, so this is what the total coverage is counting: >>> print(a.merge()) #doctest: +NORMALIZE_WHITESPACE chr1 1 500 chr1 900 950 >>> print(a.total_coverage()) 549 r)r(r`rb)rkrtotal_bprs r%total_coveragezBedTool.total_coverage| sD, JJLLzz|| % %G G $HHr'c vt|D]\}}t||||S)a Helper method for adding attributes in the middle of a pipeline. Given arbitrary keyword arguments, turns the keys and values into attributes. Useful for labeling BedTools at creation time. Example usage: >>> # add a "label" attribute to each BedTool >>> a = pybedtools.example_bedtool('a.bed') .with_attrs(label='transcription factor 1') >>> b = pybedtools.example_bedtool('b.bed') .with_attrs(label='transcription factor 2') >>> for i in [a, b]: ... print('{0} features for {1}'.format(i.count(), i.label)) 4 features for transcription factor 1 2 features for transcription factor 2 )r6rhri)rkr9rrts r% with_attrszBedTool.with_attrs sA*v||~~.. & &JC D#u % % % % r'ct|jts||j}n|j}t |S)zR Returns an IntervalFile of this BedTool for low-level interface. )r*rdr+rrrs r%as_intervalfilezBedTool.as_intervalfile sB$'3'' ((BBBBr'rct}|t}d||j|||g}tjd|t|S)a Returns a new BedTool of the liftedOver features, saving the unmapped ones as `unmapped`. If `unmapped` is None, then discards the unmapped features. `liftover_args` is a string of additional args that is passed, verbatim, to liftOver. Needs `liftOver` from UCSC to be on the path and a `chainfile` downloaded from UCSC. NliftOverr)r@rfrdrsystemr/)rk chainfileunmapped liftover_argsrurms r%liftoverzBedTool.liftover s^  ||~~HM47IvxP #((4..!!!vr'c#Kddlm}|ddi}d|vr#|td|r_||}||}|j|fddi|}n|j|fddi|}|D]}t|d VdS) a Returns an iterator of the *absolute* distances between features in self and other. If `use_midpoints` is True, then only use the midpoints of features (which will return values where features are overlapping). Otherwise, when features overlap the value will always be zero. `closest_kwargs` are passed to self.closest(); either `d` or 'D` are required in order to get back distance values (`d=True` is default) rmidpointNrITD)rIrqr) featurefuncsrrr5r?rr+r3) rkrclosest_kwargs use_midpointsrmid_self mid_otherrr$s r%absolute_distancezBedTool.absolute_distance s +*****  !!4[N n $ $  ! !$,,, / / /  Cyy**1133H 8,,3355I  JJ4J>JJAA UBB4B>BBA  Aae**      r'c#K||td|r|rtd|rt|}|rt|}ddlm}||jd i|}||}||dd }|D])} t| d t| z V*dS) a Returns an iterator of relative distances between features in self and other. First computes the midpoints of self and other, then returns distances of each feature in `other` relative to the distance between `self` features. Requires either `genome` (dictionary of chromsizes or assembly name) or `g` (filename of chromsizes file). Nz5Need either `genome` or `g` arg for relative distancez*Please specify only one of `genome` or `g`)r[)rZrrT)waorqrr!) r0r5rrr?rErrr4rb) rkrr[rZg_dictrrr hitsr$s r%relative_distancezBedTool.relative_distance s NTUU U  Ka KIJJ J  )(((F  AYYYF****** +DIIh   * 4 4V 4 4JJx((//11 {{5d4{88 ( (A",,Q' ' ' ' ' ( (r'c|}|jdks|dkrtdddl}ddl}|r|j}n|j}|d|Dt} | | | } | | ||r| | |}||_ ||r| | |}||_|S)aL Returns a normalization instance for use by featurefuncs.add_color(). Parameters ---------- vmin, vmax : float, int, or None `vmin` and `vmax` set the colormap bounds; if None then these will be determined from the scores in the BED file. log : bool If True, put the scores on a log scale; of course be careful if you have negative scores percentile : bool If True, interpret vmin and vmax as a percentile in the range [0,100] rather than absolute values. rHz5colorizing only works for BED files with score fieldsrNcg|] }|j Sr!)rr"s r%r&z.BedTool.colormap_normalize..*s111q17111r')dtype)r;rr0 matplotlibrcolorsLogNorm Normalizerr4isfinite autoscalervminvmax) rkrrrlogr;rrnormscoress r%colormap_normalizezBedTool.colormap_normalize s$$&&(( Ne # #qWXX X  1$,,..DD$..00D11D111?? F++, v   3}}VT22DI   3}}VT22DI r'ctfd}t|S)zK Returns a new BedTool with only intervals at lines `inds` c3vKd}tD]#\}}||kr|V|dz }|krdS$dS)Nrr)rT)rr$rindslengthrks r%_genzBedTool.at.._gen?s_A'oo   7Q<<!MMMFAF{{   r')rbr@r)rkr$r&r%s`` @r%atz BedTool.at9sUT       ttvv%%'''r'c ,|jrtdt|jtstd ddl}n#t $rt dwxYw|dd}||s tj |j d| }t|| kr2td|j d|d | d d}n#t$rd}YnwxYw||d<tj|jr@tj|jdkr|j|jg|Rd d i|S|S) a Create a pandas.DataFrame, passing args and kwargs to pandas.read_csv The separator kwarg `sep` is given a tab `\t` as value by default. Parameters ---------- disable_auto_names : bool By default, the created dataframe fills in column names automatically according to the detected filetype (e.g., "chrom", "start", "end" for a BED3 file). Set this argument to True to disable this behavior. z-BAM not supported for converting to DataFramez,use .saveas() to make sure self.fn is a filerNz7pandas must be installed to convert to pandas.DataFramenameszDefault names for filetype z are: z but file has z; fields; you can supply custom names with the `names` kwargrrQ)rcr0r*rdr+rrrr _column_namesrr;rbrrrrisfilegetsizeread_csv DataFrame)rkdisable_auto_namesrVr9rr)_namess r% to_dataframezBedTool.to_dataframeJs ; NLMM M$'3'' MKLL L Y MMMM Y Y YWXX X Y 7D)) =!3= !/?@T$BRBRBTBT@TUv;;!1!1!3!333D,0>>>6664CSCSCUCUCUCUW "F    $F7O 7>>$' " " &rwtw'?'?!'C'C"6?47FTFFFtFvFF F##%% %sAA >BD DDc~|jrtdt|jtstdd}|}t |jd}|dd|}g} ||kr|}|| d||}| | dt||ks||krn||z }|d d || d D} |r| St| d S) z Like `head`, but prints last 10 lines of the file by default. To avoid consuming iterables, this only works with file-based, non-BAM BedTool objects. Use `as_string=True` to return a string. z(tail() not yet implemented for BAM fileszVtail() not implemented for non-file-based BedTool objects. Please use saveas() first.i rrr(Trc6g|]}|Sr!)rr"s r%r&z BedTool.tail..s <<<!((**<<>9FBCC C(000r'c|SrTr!r s r%ryz BAM.__iter__s r'cP|t|jSrT)rfrrSr s r%rz BAM.__next__s!00d6H1I1IJJJr'c*|SrT)rr s r%rzBAM.nexts}}r'N)rr<r=rrfryrrr!r'r%rvrvsf 8 8 8H1H1H1T KKKr'rvceZdZdZdS)rc:t|dS)z{ Represents one or many HistorySteps. Mostly used for nicely formatting a series of HistorySteps. N)r6rr s r%rzHistory.__init__s dr'N)rr<r=rr!r'r%rrs#r'rc eZdZdZdZdZdS)r(c |j|_n#t$r|j|_YnwxYw||_||_|j|_ddtdD}||_ ||_ dS)z Class to represent one step in the history. Mostly used for its __repr__ method, to try and exactly replicate code that can be pasted to re-do history steps rc3RK|]"}tjtjV#dSrTrrs r%r2z'HistoryStep.__init__..s/NNfmF$:;;NNNNNNr'rN) rr,rrrVr9rdr/rr)r*)rkr,rVr9bedtool_instancer)r*rs r%rzHistoryStep.__init__ s . ,DKK . . .$o  .  "%ggNNU1XXNNNNN$$s ((c|t|tjr|j}t|trd|z}|S)zT Wrap strings in quotes and convert bedtool instances to filenames. z"%s")r*rr@rdr+)rkrs r% _clean_argzHistoryStep._clean_arg s@ c:- . . &C c3   3,C r'cd}|dz }tjjr|djzz }n|djzz }|djzz }dt jj}dfdtj D}t|dkr|d z }|||fz}|d j zz }|d jzz }|S) Nrz z$BedTool("%(fn)s").%(method)s(%%s%%s)zBedTool("MISSING FILE: %(fn)s")z.%(method)s(%%s%%s)rc\g|](}|dd|d)S)rrVr)rq)r#r$rks r%r&z(HistoryStep.__repr__..7s9 X X X!dooad333 4 X X Xr'rz, z, parent tag: %sz, result tag: %s)rrrrd__dict__r/rrqrVr6r9rhrbr)r*)rkr8 args_string kwargs_strings` r%r~zHistoryStep.__repr__*s   7>>$' " " 7 7$-G GAA 2T]B BA &6 6Ahhs4?DI>>??  X X X Xd4;CTCTCVCV>W>W X X X   {  a   4 K m, , $/ 11 $/ 11r'N)rr<r=rrqr~r!r'r%r(r( sA%%%&r'r(ctjtj|}tj|sd|z}t |t|S)z Return a bedtool using a bed file from the pybedtools examples directory. Use :func:`list_example_files` to see a list of files that are included. z%s does not exist)rrr/rdata_dirrrr@)rdrs r%example_bedtoolryCs\ i(**B / /B 7>>"  %!B&$$$ 2;;r'__main__) optionflags)NNNNFNNNNFNNNNN)=rntextwraprrroperatorrrrrr itertoolsrrrxrwarningsrpathlibrrrr r r r r rrrrrrr cbedtoolsrrrrrrrrrrrr=rJrobjectr@rvr6rr(ryrdoctesttestmodELLIPSISNORMALIZE_WHITESPACEr!r'r%rsp                                )))*4     PPPPf h3h3h3h3h3fh3h3h3Vgaaaaa&aaaHd44444&444n    zNNNGO 073O OPPPPPPr'