DBPeaks 0.0.3__py3-none-any.whl

DBPeaks.py

@@ -0,0 +1,810 @@
+#/usr/bin/python
+
+__author__		= "Sander Granneman"
+__copyright__	= "Copyright 2024"
+__version__		= "0.0.3"
+__credits__		= ["Sander Granneman"]
+__maintainer__	= "Sander Granneman"
+__email__		= "Sander.Granneman@ed.ac.uk"
+__status__		= "beta"
+
+import os
+import re
+import csv
+import sys
+import pybedtools
+import argparse
+import subprocess
+import numpy as np
+import pandas as pd
+
+from concurrent.futures import ThreadPoolExecutor
+from collections import defaultdict
+from pydeseq2.dds import DeseqDataSet
+from pydeseq2.default_inference import DefaultInference
+from pydeseq2.ds import DeseqStats
+from pyCRAC.Parsers import GTF2
+from pyCRAC.Methods import numpy_overlap
+from pyCRAC.Classes.NGSFormatWriters import NGSFileWriter
+
+def getGeneIDs(string):
+    """Finds all the gene_ids in a given string"""
+    gene_ids = list(set(re.findall(r'gene_id\s+"([^"]+)"', string)))
+    return gene_ids
+
+def getGeneNames(string):
+    """Finds all the gene_names in a given string"""
+    gene_names = list(set(re.findall(r'gene_name\s+"([^"]+)"', string)))
+    return gene_names
+
+def rowToGTF(row):
+    """ Returns the results from the mergeGTFfiles function as a GTF file string """
+    return f"{row['chrom']}\tcluster\tinterval\t{row['start']}\t{row['end']}\t.\t{row['name']}\t.\tgene_id \"{row['gene_ids']}\"; gene_name \"{row['gene_names']}\";"
+
+def mergeGTFintervals(gtf_files, reproducibility=0.9, output_file_name=None):
+    """Concatenates the files and then uses pybedtools to find intervals/peaks that are found in all replicates.
+    The user can decide whether only some replicates should contain the peaks or all. This can be done by setting
+    the 'reproducibility' variable in the function, which is set to 0.9 (i.e., 90% by default).
+    """
+
+    if not output_file_name:
+        output_file_name = "merged.gtf"
+
+    if not os.path.exists(output_file_name):
+        ### Concatenating the files and storing them in a pandas dataframe:
+        data_frames = [pd.read_csv(i, sep='\t', comment='#', index_col=None, header=None) for i in gtf_files]
+        merged_data = pd.concat(data_frames, ignore_index=True)
+
+        ### Sorting the merged data:
+        merged_data = merged_data.sort_values(by=[0, 1, 2, 3, 8])
+
+        ### Loading the dataframe into pybedtools:
+        bedtools_data = pybedtools.BedTool.from_dataframe(merged_data)
+
+        ### Merging the data using bedtools:
+        bedtools_data_merged = bedtools_data.merge(s=True, c=[7, 9], o='collapse', delim='')
+
+        ### Converting the results back into a dataframe:
+        bedtools_data_merged = pybedtools.BedTool.to_dataframe(bedtools_data_merged)
+
+        ### Now only keeping peaks that were found in multiple replicates, based on the threshold:
+        number_of_reps = len(gtf_files)    
+        must_be_seen_in_reps = number_of_reps * float(reproducibility)
+
+        ### Filter rows where the length of the string in the 'name' column exceeds the threshold:
+        bedtools_data_merged = bedtools_data_merged[bedtools_data_merged['name'].apply(len) >= must_be_seen_in_reps]
+
+        ### Keep only the first character of the strand column:
+        bedtools_data_merged['name'] = bedtools_data_merged['name'].str[0]  # Keep only the first character
+
+        ### Now extracting the gene_ids and gene_names, only keeping the unique ones:
+        bedtools_data_merged['gene_ids'] = bedtools_data_merged['score'].apply((getGeneIDs))
+        bedtools_data_merged['gene_ids'] = bedtools_data_merged['gene_ids'].apply(lambda x: '|'.join(x))
+        
+        bedtools_data_merged['gene_names'] = bedtools_data_merged['score'].apply((getGeneNames))
+        bedtools_data_merged['gene_names'] = bedtools_data_merged['gene_names'].apply(lambda x: '|'.join(x))
+
+        ### Now dropping the score column
+        bedtools_data_merged.drop(columns=['score'],inplace=True)
+
+        ### Resetting the index:
+        bedtools_data_merged = bedtools_data_merged.reset_index()
+
+        gtf_file_lines = list()
+        gtf_file_lines = bedtools_data_merged.apply(rowToGTF,axis=1).to_list()
+
+        if gtf_file_lines:
+            outfile = open(output_file_name,'w')
+            outfile.write("##gff-version 2\n")
+            
+            for i in gtf_file_lines:
+                outfile.write(f"{i}\n")
+            outfile.close()
+            return True
+
+        else:
+            sys.stderr.write("ERROR! The data could not be merged!\n")
+            return False
+    else:
+        sys.stderr.write(f"\tOutput file {output_file_name} already exists!\n")
+        return False
+
+def countReadsBam(bam_files,gtf_annotation_file,no_cpus=1,output_dir="bam_read_counts",blocks=False):
+    """ Runs the pyReadCounter analyses on the bam files"""
+
+    ### Creating the directory where the results will be stored:  
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    def run_command(file_name,gtf_file,outfile_name):
+        cmd = [
+                "pyReadCounters.py",
+                "-f",
+                file_name,
+                "--file_type",
+                "sam",
+                "--gtf",
+                gtf_file,
+                "-v",
+                "--gtffile",
+                "-o",
+                outfile_name
+            ]
+
+        if blocks:
+            cmd.extend(["--blocks",
+                        "--mutations",
+                        "nomuts"
+                       ]
+                      )
+        subprocess.run(cmd)
+
+
+    data_type = "reads"
+    if blocks:
+        data_type = "cDNAs"
+
+    ### Running pyReadCounters over multiple processors.
+    with ThreadPoolExecutor(no_cpus) as executor:
+        futures = []
+        for file_name in bam_files:
+            basename = getFileBaseName(file_name)
+            # The name of the output file path that should be submitted to pyReadCounters:
+            output_file_name = f"{output_dir}/{basename}"
+            # The name of the output file path produced by pyReadCounters:
+            output_file_path = f"{output_file_name}_count_output_{data_type}.gtf"
+            # If the file already exists, don't overwrite it.
+            if not os.path.exists(output_file_path):
+                future = executor.submit(run_command,file_name,gtf_annotation_file,output_file_name)
+                futures.append(future)
+            else:
+                sys.stderr.write(f"\tOutput file {output_file_path} already exists!\n")
+
+    # Wait for all commands to complete
+    if futures:
+        for future in futures:
+            future.result()
+
+    return True
+
+def countReadsGTF(bam_files,gtf_annotation_file,no_cpus=1,output_dir="peak_hittables",blocks=False):
+    """ Runs the pyReadCounter analyses on the bam files"""
+    
+    ### Creating the directory where the results will be stored:    
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+    
+    def run_command(file_name,gtf_file,outfile_name):
+        cmd = [
+                "pyReadCounters.py",
+                "-f",
+                file_name,
+                "--file_type",
+                "sam",
+                "--gtf",
+                gtf_file,
+                "-v",
+                "--hittable",
+                "-o",
+                outfile_name
+            ]
+
+        if blocks:
+            cmd.extend(["--blocks",
+                        "--mutations",
+                        "nomuts"
+                       ]
+                      )
+        subprocess.run(cmd)
+
+    data_type = "reads"
+    if blocks:
+        data_type = "cDNAs"
+    
+    ### Running pyReadCounters over multiple processors.
+    with ThreadPoolExecutor(no_cpus) as executor:
+        futures = []
+        for file_name in bam_files:
+            basename = getFileBaseName(file_name)
+            # The name of the output file path that should be submitted to pyReadCounters:
+            output_file_name = f"{output_dir}/{basename}"
+            # The name of the output file path produced by pyReadCounters:
+            output_file_path = f"{output_file_name}_hittable_{data_type}.txt"
+            # If the file already exists, don't overwrite it.
+            if not os.path.exists(output_file_path):
+                future = executor.submit(run_command, file_name, gtf_annotation_file, output_file_name)
+                futures.append(future)
+            else:
+                sys.stderr.write(f"\tOutput file {output_file_path} already exists!\n")
+
+    # Wait for all commands to complete
+    if futures:
+        for future in futures:
+            future.result()
+
+def getPeaks(gtf_files,gtf_annotation_file,chromosome_file,no_cpus=1,min_peak_height=5,min_fdr=0.05,output_dir="peak_gtf_files"):
+    """ Runs pyCalculateFDRs to get peaks enriched in the data relative to random control dataset """
+    
+    ### Creating the directory where the results will be stored:   
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    def run_command(file_name,gtf_annotation_file,chromosome_file,min_peak_height,min_fdr,output_file_name):
+        cmd = [
+                "pyCalculateFDRs.py",
+                "-f",
+                file_name,
+                "--gtf",
+                gtf_annotation_file,
+                "-c",
+                chromosome_file,
+                "--min",
+                str(min_peak_height),
+                "-m",
+                str(min_fdr),
+                "-v",
+                "-o",
+                output_file_name
+            ]
+        subprocess.run(cmd)
+
+    ### Running pyCalculateFDRs over multiple processors.
+    with ThreadPoolExecutor(no_cpus) as executor:
+        futures = []
+        for file_name in gtf_files:
+            basename = getFileBaseName(file_name)
+            output_file_name = f"{output_dir}/{basename}_FDR_{str(min_fdr)}_min_peak_height_{str(min_peak_height)}.gtf"
+            if not os.path.exists(output_file_name):
+                future = executor.submit(run_command,
+                                         file_name,
+                                         gtf_annotation_file,
+                                         chromosome_file,
+                                         min_peak_height,
+                                         min_fdr,
+                                         output_file_name)
+                futures.append(future)
+            else:
+                sys.stderr.write(f"\tOutput file {output_file_name} already exists!\n")
+
+    # Wait for all commands to complete
+    if futures:
+        for future in futures:
+            future.result()
+
+def filterPeaks(peak_gtf_files,by=None,output_dir="filtered_peak_files"):
+    """ Filters all the peaks in gtf files by a specific threshold. This
+     threshold could be the mean, median or mean plus one standard devation 
+    (mean_plus_std) peak heights. Default is mean. """
+
+    ### Creating the directory where the results will be stored:  
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    peak_heights = defaultdict(list)
+    data_thresholds = defaultdict(float)
+
+    for file_name in peak_gtf_files:
+        with open(file_name,'r') as infile:
+            for line in infile:
+                if not line.startswith("#"):
+                    fld = line.strip().split('\t')
+                    peak_height = float(fld[5])
+                    peak_heights[file_name].append(peak_height)
+
+    ### Calculating thresholds:
+    data_thresholds = defaultdict(float)
+
+    for file_name, value in peak_heights.items():
+        ### Calculate the mean and use mean+stdev as the threshold:
+        threshold = float()
+
+        if by == 'mean':
+            threshold = np.mean(value)
+        elif by == 'median':
+            threshold = np.median(value)
+        elif by == 'mean_plus_std':
+            threshold = np.mean(value) + np.std(value)
+        elif by == "None":
+            threshold = 0
+        else:
+            sys.stderr.write("ERROR! Cannot figure out how you want to filter the peaks! Please use mean, median, mean_plus_std, or None\n")
+            threshold = 0
+            
+        data_thresholds[file_name] = threshold
+
+    ### Using these thresholds to remove peaks
+    for file_name, value in peak_heights.items():
+        basename = getFileBaseName(file_name)
+        output_file_name = f"{output_dir}/{basename}_filtered_by_{by}_threshold.gtf"
+        if not os.path.exists(output_file_name) and os.path.exists(file_name):
+            outfile = open(output_file_name,"w")
+            threshold = data_thresholds[file_name]
+            with open(file_name) as peak_file:
+                for line in peak_file:
+                    if not line.startswith("#"):
+                        fld = line.strip().split('\t')
+                        peak_height = float(fld[5])
+                        if peak_height >= threshold:
+                            outfile.write(line)
+                    else:
+                        outfile.write(line)
+            outfile.close()
+        else:
+            sys.stderr.write(f"\tOutput file {output_file_name} already exists!\n")
+
+    return True
+        
+def adjustPeakWidths(peak_gtf_files,chromosome_file,min_width=20,no_cpus=1,output_dir = "filtered_peak_files"):
+    """ Normalises the peak widths to a minimum length. """
+
+    ### Creating the directory where the results will be stored: 
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    def run_command(file_name,chromosome_file,outfile_name=None,min_width=20):
+        cmd = [
+                "pyNormalizeIntervalLengths.py",
+                "-f",
+                file_name,
+                "-c",
+                chromosome_file,
+                "--min",
+                str(min_width),
+                "-o",
+                outfile_name
+            ]
+        subprocess.run(cmd)
+
+    ### Running pyNormalizeIntervalLengths over multiple processors.
+    with ThreadPoolExecutor(no_cpus) as executor:
+        futures = []
+        for file_name in peak_gtf_files:
+            basename = getFileBaseName(file_name)
+            output_file_name = f"{output_dir}/{basename}_min_width_{str(min_width)}.gtf"
+            if not os.path.exists(output_file_name):
+                future = executor.submit(run_command,file_name,chromosome_file,output_file_name,min_width)
+                futures.append(future)
+            else:
+                sys.stderr.write(f"\tOutput file {output_file_name} already exists!\n")
+    
+    # Wait for all commands to complete
+    if futures:
+        for future in futures:
+            future.result()
+
+    return True
+
+def numberPeaks(peak_gtf_files,output_dir="filtered_peak_files"):
+    """ Gives each peak a unique number to avoid a scenario where peaks end up having the same names, 
+    which can cause problems with downstream data analysis steps. """
+
+    ### Creating the directory where the results will be stored:
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    for gtf_file in peak_gtf_files:
+        basename = getFileBaseName(gtf_file)
+        output_file_name = f"{output_dir}/{basename}_numbered.gtf"
+        if not os.path.exists(output_file_name):
+            outfile = open(output_file_name,"w")
+            with open(gtf_file,'r') as infile:
+                peak_number = 1
+                for line in infile:
+                    if not line.startswith("#"):
+                        try:
+                            gene_id = re.search('gene_id \"([\(\)a-zA-Z_0-9-,\'|]+?)\";',line).group(1)
+                            gene_name = re.search('gene_name \"([\(\)a-zA-Z_0-9-,\'|]+?)\";',line).group(1)
+
+                            line = line.replace(f'gene_id \"{gene_id}\";',f'gene_id \"{gene_id}_peak_{peak_number}\";')
+                            line = line.replace(f'gene_name \"{gene_name}\";',f'gene_name \"{gene_name}_peak_{peak_number}\";')
+                            peak_number += 1
+                            outfile.write(line)
+                        except:
+                            sys.stderr.write(line)
+                    else:
+                        outfile.write(line)
+                outfile.close()
+            return True
+        else:
+            sys.stderr.write(f"\tOutput file {output_file_name} already exists!\n")
+            return False
+
+def getFileBaseName(file_name):
+    """ Returns the file basename without extension. """
+    return os.path.splitext(os.path.basename(file_name))[0]
+
+def mergeHittables(hittables,outfile_name="merged_hittables.txt"):
+    """ Merges pyReadCounters hittables. """
+
+    genes = defaultdict(set)
+    data  = dict()
+    feature = str()
+    columns = [0,1]
+    sumofdata = defaultdict(float)
+    mappedreadsdata = defaultdict()
+
+    if not os.path.exists(outfile_name):
+        for i in hittables:
+            data[i] = defaultdict(lambda: defaultdict(int))
+            mappedreadsdata[i] = defaultdict(float)
+            with open(i,"r") as infile:
+                mappedreads = 0
+                for line in infile:
+                    if line.startswith("##"):
+                        feature = line.strip().split()[1]
+                    elif line.startswith("# total number of paired"):
+                        mappedreads += int(line.strip().split("\t")[-1]) 
+                    elif line.startswith("# total number of single"):
+                        mappedreads += int(line.strip().split("\t")[-1]) 
+                    elif re.search("[A-Za-z0-9]",line[0] ):
+                        Fld = line.strip().split("\t")
+                        gene,hits = Fld[columns[0]],Fld[columns[1]]
+                        data[i][feature][gene] = float(hits)
+                        genes[feature].add(gene)
+                mappedreadsdata[i] = mappedreads             
+
+        outfile = open(outfile_name,"w")
+
+        outfile.write("# gene\t%s\n" % ("\t".join([getFileBaseName(i) for i in hittables])))
+        outfile.write("# total mapped reads:\t%s\n" % ("\t".join([str(mappedreadsdata[i]) for i in hittables])))
+        for feature in sorted(genes):
+            for i in hittables:
+                sumofdata[i] = sum([data[i][feature][j] for j in genes[feature]])
+            sumoffeaturehits = "\t".join([str(sumofdata[x]) for x in hittables])
+            outfile.write("\n## %s\t%s\n" % (feature,sumoffeaturehits))
+            for gene in sorted(list(genes[feature])):
+                hitstring = "\t".join([str(data[i][feature][gene]) for i in hittables])
+                outfile.write("%s\t%s\n" % (gene,hitstring))
+        return True
+    else:
+        sys.stderr.write(f"\tOutput file {outfile_name} already exists!\n")
+        return False
+
+def runDESeq(merged_hittable,conditions,no_cpus=1,output_dir="DESeq2_results"):
+    """ Runs the DESeq2 analyses on the samples. Returns the results in a text file. """
+
+    ### Creating the directory where the results will be stored:
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    ### Defining the GTF file:
+    basename = getFileBaseName(merged_hittable)
+    outfile_name = f"{output_dir}/{basename}_DESeq2_results.txt"
+
+    if not os.path.exists(outfile_name):
+        ### opening the merged hittable file:
+        data = pd.read_csv(merged_hittable,comment="#",sep="\t",header=None,index_col=None)
+        columns = ["gene"]
+        columns.extend(conditions)
+
+        data.columns = columns
+        data.set_index('gene',inplace=True)
+
+        ### Creating a DataFrame with column data:
+        colData = pd.DataFrame(data.columns, columns=['gene'])
+        colData['Conditions'] = conditions
+
+        ### Changing the index so that the first column of both 
+        ### countData and colData are the same:
+        colData = colData.set_index('gene')
+
+        ### Starting DESeq2
+        inference = DefaultInference(n_cpus=no_cpus)
+
+        dds = DeseqDataSet(
+            counts=data.T,
+            metadata=colData,
+            design_factors="Conditions",
+            refit_cooks=True,
+            inference=inference,
+        )
+
+        dds.deseq2()
+        stat_res = DeseqStats(dds, inference=inference)
+
+        ### Getting the final results:
+        stat_res.summary()
+        final_results = stat_res.results_df
+
+        ### Storing the final results:
+        final_results.to_csv(outfile_name,sep="\t")
+        return True
+    else:
+        sys.stderr.write(f"\tOutput file {outfile_name} already exists!\n")
+        return False
+
+def addFoldChangeToGTF(deseq_results,merged_peaks,output_dir="./"):
+    """ Adds the log2-fold changes calculated be DESeq2 to the peak gtf file. """
+    
+    ### Setting the output file names:
+    peak_outfile_name = f"{output_dir}/{getFileBaseName(merged_peaks)}_with_padj.gtf"
+
+    ### If the output file already exist, then don't overwrite:
+    if not os.path.exists(peak_outfile_name):
+        ### Creating the output file:
+        outfile = open(peak_outfile_name,"w")
+        ### loading the input files: 
+        deseq_data = pd.read_csv(deseq_results,comment="#",sep="\t",index_col=None,header=0)
+        
+        ### Opening the peak data:
+        with open(merged_peaks,"r") as peak_file:
+            for line in peak_file:
+                if not line.startswith("#"):
+                    gene_name = re.search('gene_name \"([\(\)a-zA-Z_0-9-,\'|]+?)\";',line).group(1)
+                    if gene_name in deseq_data["gene"].values:
+                        log2fold_change = deseq_data.loc[deseq_data["gene"] == gene_name,"log2FoldChange"].values[0]
+                        p_value = deseq_data.loc[deseq_data["gene"] == gene_name,"padj"].values[0]
+                        line = f"{line.strip()} log2foldchange \"{log2fold_change}\"; padj \"{p_value}\";\n"                   
+                    else:
+                        line = f"{line.strip()} log2foldchange \"unknown\"; padj \"unknown\";\n" 
+                outfile.write(line)
+        outfile.close()
+        return True
+    else:
+        sys.stderr.write(f"\tOutput file {peak_outfile_name} already exist!\n")
+        return False
+
+def getSignificantPeaks(deseq_results,merged_peaks,fdr_threshold=0.05,output_dir="DESeq2_results"):
+    """ Extracts the significantly DE peaks from the merged peak GTF file """
+
+    ### Setting the output file names:
+    deseq_outfile_name = f"{output_dir}/{getFileBaseName(deseq_results)}_FDR_{str(fdr_threshold)}.txt"
+    peak_outfile_name = f"{output_dir}/{getFileBaseName(merged_peaks)}_FDR_{str(fdr_threshold)}.gtf"
+
+    ### If the output files already exist, then don't overwrite:
+    if not os.path.exists(peak_outfile_name):
+        ### loading the input files: 
+        deseq_data = pd.read_csv(deseq_results,comment="#",sep="\t",index_col=None,header=0)
+
+        ### Filter the DESeq2 results:
+        deseq_data = deseq_data.loc[deseq_data['padj'] <= fdr_threshold]
+        deseq_data.to_csv(deseq_outfile_name,sep="\t",index=None)
+        
+        ### DE genes:
+        de_genes = list(deseq_data[deseq_data.columns[0]])
+        
+        ### Opening the peak data:
+        peak_data = pd.read_csv(merged_peaks,index_col=None,header=None,comment="#",sep="\t")
+        peak_data.columns = ['chrom','source','feature','start','end','score','strand','frame','annotations']
+        
+        ### Making a seperate gene_name colum:
+        peak_data['gene_name'] = peak_data['annotations'].str.extract(r'gene_name \"(.*?)\"', expand=False)
+
+        ### Filter rows based on the list of gene names
+        filtered_peak_data = peak_data[peak_data['gene_name'].isin(de_genes)]
+        filtered_peak_data = filtered_peak_data.drop(columns=['gene_name'])
+        filtered_peak_data.to_csv(peak_outfile_name,sep="\t",header=False,index=False,quoting=csv.QUOTE_NONE)
+
+        return True
+    else:
+        sys.stderr.write(f"\tOutput files {peak_outfile_name} and {deseq_outfile_name} already exist!\n")
+        return False
+
+
+def main(): 
+    parser = argparse.ArgumentParser(usage="usage: %(prog)s [options]", description="A tool for identifying differential RNA-binding sites in CLIP/CRAC datasets")
+    
+    files = parser.add_argument_group("File input options")
+    files.add_argument("--samples", dest="samples", nargs="*", metavar="clip_samples.bam", 
+                       help="Paths to the bam files containing the replicate clip samples you want to compare", default=None)
+    files.add_argument("--controls", dest="controls", nargs="*", metavar="control_clip_samples.bam", 
+                       help="Paths to bam files containing replicate control clip samples.", default=None)
+    files.add_argument("-c", "--chromfile", dest="chromfile", type=str,
+                       help="Location of the chromosome info file. This file should have two columns: \
+                        first column is the names of the chromosomes, second column is length of the chromosomes.", default=None)
+    files.add_argument("--gtf", dest="gtf_annotation", type=str, metavar="yeast.gtf", 
+                       help="Path to GTF anotation file for your organism containing gene location information.", default=None)
+    files.add_argument("-j","--jobname",dest="jobname",type=str,metavar="WT_vs_mutant",
+                       help="provide a name for the job. Default = WT_vs_mutant")
+    #files.add_argument("--log", dest="log", help="To print all the command lines used during the run to the 'command_lines.txt' file",
+    #                   action="store_true",default=False)
+
+    peaks = parser.add_argument_group("Peak calling settings")
+    peaks.add_argument("-m", "--minfdr", dest="minfdr", type=float, metavar="0.05", 
+                       help="To set a minimal FDR threshold for filtering interval data. Default is 0.05", default=0.05)
+    peaks.add_argument("--padj", dest="padj", metavar="0.05", type=float,
+                       help="DESeq2 threshold for calling a DE peak. Default is 0.05", default=0.05)
+    peaks.add_argument("--min", dest="min", metavar="5", 
+                       help="to set a minimal read coverages for a region. Regions with coverage less than minimum will be ignoredve an FDR of zero", type=int, default=1)
+    peaks.add_argument("--blocks", dest="blocks", help="Add this flag if you want to consider reads with identical mapping coordinates once, regardless of sequence",
+                       action="store_true",default=False)
+    peaks.add_argument("--iterations", dest="iterations", metavar="100", type=int, 
+                       help="to set the number of iterations for randomization of read coordinates. Default=100", default=100)
+    peaks.add_argument("-r","--rep",dest="reproducibility",metavar="90", type=float, 
+                       help="To set in what percentage of the replicates the peak should be detected. Default=100", default=100.0)
+    peaks.add_argument("--filter",dest="filter_peak_height", metavar="mean", type=str,
+                       help="To filter the peaks in gtf files by a specific threshold. \
+                       Options are mean, median or mean plus one standard devation (mean_plus_std) peak heights. Default is no filtering.",default="None",choices=["mean","median","mean_plus_std","None"])
+    peaks.add_argument("--min_peak_width",dest="min_peak_width",type=int,metavar="20"
+                       ,help="To set the minimum width of a called peak. Default = 20",default=20)
+        
+    log = parser.add_argument_group("Logging options")
+    log.add_argument("-v", "--verbose", action="store_true", help="to print status messages to a log file", default=False)		
+    
+    cpu = parser.add_argument_group("Number of CPUs needed for the analyses")
+    cpu.add_argument("--cpu", dest="cpu", type=int, metavar="12", help="The number of processors you want to use for the analyses. Default = 1", default=1)	 
+    
+    args = parser.parse_args()
+
+    ### Setting key parameters;
+    
+    data_type = "reads"
+    
+    if args.blocks:
+        data_type = "cDNAs"
+        
+
+    ### Running the code:
+
+    # Making the directory where the results files are stored:
+    storage_dir = f"{args.jobname}"
+    if not os.path.exists(storage_dir):
+        os.makedirs(storage_dir)
+
+    # Getting read counts for all the bam files:
+    if args.verbose:
+        sys.stdout.write("### Getting gene counts from sample bam files....\n")
+
+    all_bam_files = list()
+    all_bam_files.extend(args.samples)
+    all_bam_files.extend(args.controls)
+    
+    countReadsBam(all_bam_files,
+                  args.gtf_annotation,
+                  no_cpus=args.cpu,
+                  output_dir=f"{storage_dir}/bam_read_counts"
+                  )
+
+    # Getting all the peak_files:
+    if args.verbose:
+        sys.stdout.write("### Finding peaks in the sample files....\n")
+
+    file_basenames = [getFileBaseName(i) for i in all_bam_files]
+    
+    all_read_counters_files = [f"{storage_dir}/bam_read_counts/{i}_count_output_{data_type}.gtf" for i in file_basenames]
+
+        
+    getPeaks(all_read_counters_files,
+             args.gtf_annotation,
+             args.chromfile,
+             no_cpus=args.cpu,
+             min_peak_height=args.min,
+             min_fdr=args.minfdr,
+             output_dir=f"{storage_dir}/peak_gtf_files"
+            )
+    
+    # Filtering the peaks by peak height:
+    if args.verbose:
+        sys.stdout.write(f"### Filtering the peaks by {args.filter_peak_height} values of peak heights....\n")
+
+    read_counters_file_basenames = [getFileBaseName(i) for i in all_read_counters_files]
+    peak_gtf_files = [f"{storage_dir}/peak_gtf_files/{i}_FDR_{str(args.minfdr)}_min_peak_height_{str(args.min)}.gtf" \
+                      for i in read_counters_file_basenames]
+    
+    filterPeaks(peak_gtf_files,
+                by=args.filter_peak_height,
+                output_dir=f"{storage_dir}/filtered_peak_files"
+                )
+
+    # Setting minimum peak widths:
+    if args.verbose:
+        sys.stdout.write(f"### Adjusting peak widths to a minimum of {args.min_peak_width}....\n")
+
+    file_basenames = [getFileBaseName(i) for i in peak_gtf_files]
+    filtered_peak_files = [f"{storage_dir}/filtered_peak_files/{i}_filtered_by_{args.filter_peak_height}_threshold.gtf" \
+                           for i in file_basenames]
+    
+    adjustPeakWidths(filtered_peak_files,
+                     args.chromfile,
+                     min_width=args.min_peak_width,
+                     no_cpus=args.cpu,
+                     output_dir=f"{storage_dir}/filtered_peak_files"
+                     )
+
+    # Merging the peak intervals for the sample files:
+    if args.verbose:
+        sys.stdout.write("### Merging peak intervals...\n")
+
+    file_basenames = [getFileBaseName(i) for i in filtered_peak_files]
+    filtered_peak_files = [f"{storage_dir}/filtered_peak_files/{i}_min_width_{args.min_peak_width}.gtf" for i in file_basenames]
+    reproducibility = args.reproducibility/100.0
+    merged_peak_output_file_name = f"{storage_dir}/filtered_peak_files/{args.jobname}_merged_peaks.gtf"
+
+    mergeGTFintervals(filtered_peak_files,
+                      reproducibility,
+                      merged_peak_output_file_name,
+                      )
+
+    # Numbering the peaks:
+    if args.verbose:
+        sys.stdout.write("### Numbering the peaks....\n")
+
+    numberPeaks([merged_peak_output_file_name],
+                output_dir=f"{storage_dir}/filtered_peak_files"
+                )
+
+    # Performing pyReadCounters analysis on the bam files using the new GTF file containing the numbered peaks:
+    if args.verbose:
+        sys.stdout.write("### Counting peak coverage for each sample and control file....\n")
+    
+    annotation_file = f"{os.path.splitext(merged_peak_output_file_name)[0]}_numbered.gtf"
+
+    # Making sure the input file actually exists!:
+    if os.path.exists(annotation_file):
+        
+        all_bam_files = list()
+        all_bam_files.extend(args.samples)
+        all_bam_files.extend(args.controls)
+
+        countReadsGTF(all_bam_files,
+                    gtf_annotation_file=annotation_file,
+                    no_cpus=args.cpu,
+                    output_dir=f"{storage_dir}/peak_hittables"
+                    )
+    else:
+        sys.stderr.write(f"The file {os.path.basename(annotation_file)} already exists!\n")    
+    
+    # Merging the hittables:
+    if args.verbose:
+        sys.stdout.write("Merging the peak read coverage hit tables.\n")
+
+    sample_file_base_names = [getFileBaseName(i) for i in args.samples]
+    control_file_base_names = [getFileBaseName(i) for i in args.controls]
+
+    sample_file_hittables = [f"{storage_dir}/peak_hittables/{i}_hittable_{data_type}.txt" for i in sample_file_base_names]
+    control_file_hittables = [f"{storage_dir}/peak_hittables/{i}_hittable_{data_type}.txt" for i in control_file_base_names]
+
+    tables_to_merge = list()
+    tables_to_merge.extend(sample_file_hittables)
+    tables_to_merge.extend(control_file_hittables)
+    hittable_name = f"{storage_dir}/peak_hittables/{args.jobname}_merged_hittables.txt"
+
+    if not os.path.exists(hittable_name):
+        mergeHittables(tables_to_merge,hittable_name)
+    else:
+        sys.stderr.write(f"\tOutput file {os.path.basename(hittable_name)} already exists!\n")
+
+    # Running the DESeq2 analyses:
+    # Setting the testing conditions:
+    if args.verbose:
+        sys.stdout.write("### Running the DESeq2 analyses....\n")
+
+    conditions = list()
+    conditions.extend(len(args.samples)*["WT"])
+    conditions.extend(len(args.controls)*["control"])
+
+    # Order of Conditions: The order in which conditions are specified affects the reference level in DESeq2. 
+    # In our case, "WT" samples are listed first in the conditions list and then "Control samples"
+    # DESeq2 will treat "WT" as the reference level by default (assuming no other specifications are made to alter this). 
+    # This means:
+    # POSITIVE log2FC: Indicates higher expression in "control" relative to "WT".
+    # NEGATIVE log2FC: Indicates higher expression in "WT" relative to "control".
+
+    runDESeq(hittable_name,
+             conditions,
+             no_cpus=args.cpu,
+             output_dir=f"{storage_dir}/DESeq2_results"
+             )
+
+    # Adding log2-fold changes to the peak GTF file:
+    deseq_table_name = f"{storage_dir}/DESeq2_results/{getFileBaseName(hittable_name)}_DESeq2_results.txt"
+
+    addFoldChangeToGTF(deseq_table_name,
+                       annotation_file,
+                       output_dir=f"{storage_dir}/DESeq2_results"
+                       )
+
+    # Extracting the significant peaks
+    annotation_file_with_padj = f"{storage_dir}/DESeq2_results/{getFileBaseName(annotation_file)}_with_padj.gtf"
+    
+    if args.verbose:
+        sys.stdout.write("#### Extracting significant peaks....\n")
+
+    getSignificantPeaks(deseq_table_name,
+                        annotation_file_with_padj,
+                        fdr_threshold=args.padj,
+                        output_dir=f"{storage_dir}/DESeq2_results"
+                        )
+
+if __name__ == "__main__":
+    main()

dbpeaks-0.0.3.dist-info/METADATA

@@ -0,0 +1,175 @@
+Metadata-Version: 2.4
+Name: DBPeaks
+Version: 0.0.3
+Summary: A tool for identifying differentially bound peaks in CLIP/CRAC data
+Author-email: Sander Granneman <Sander.Granneman@ed.ac.uk>
+License-Expression: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pybedtools
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: pydeseq2==0.4.9
+Requires-Dist: pyCRAC==1.5.2
+Dynamic: license-file
+
+# DBPeaks: Differential RNA-Binding Site Analysis Tool
+
+## Contents
+
+- [Introduction](#introduction)
+
+- [Repo Contents](#repo-contents)
+
+- [Features](#features)
+
+- [System Requirements](#system-requirements)
+
+- [Installation Guide](#installation-guide)
+
+- [License](./LICENSE)
+
+- [Citation](#citation)
+
+- [Contact](#contact)
+
+## Inroduction
+
+DBPeaks is a Python-based command-line tool designed for the identification and analysis of differential RNA-binding sites in CLIP/CRAC datasets. It integrates various bioinformatics tools and methods to process sequencing data, identify peaks, and perform statistical analyses to detect significant differences in RNA-binding across conditions. It does so by first analysing the peaks in each individual file and it then looks whether peaks are found in the same regions. These peaks need to have overlapping genome mapping coordinates. All overlapping peaks will then be merged into a single peak interval and for each interval the program will then calculate the total number of reads covering that genomic interval. DESeq2 will then be used to determine if the read counts for that interval is statistically significantly different between sample and control files.
+
+It requires CLIP/CRAC data BAM files as input as well as GTF and genome files for the model organism.
+Make sure your GTF annotation file does not have any silly formatting mistakes, otherwise the program will not run.
+Example genome files for yeast are available in this repository.
+
+NOTE! DBPeaks was SPECIFICALLY designed to analyse CLIP/CRAC datasets from two different conditions or by comparing data from WT vs mutant RBPs. It was NOT designed to compare RBP CLIP datasets to control datasets that have substantially lower read counts (i.e. data from untagged strains or no UV cross-linking controls). Should you be stubborn and still decide to use DBPeaks for this purpose, you will get rubbish results! 
+
+It is really important that all bam files have good number of reads and that there is not a huge difference in read depth between the files. This will make DESeq2 much happier and will therefore improve the results.
+
+We have tried many different tools that do similar things. However, we were either not able to get them running on our servers or they were not able to detect clearly differentially bound (DB) peaks in our data. We have not benchmarked DBPeaks to existing tools so we do not yet know how well it performs compared to most popular peak calling methods. All I can say is that on OUR data where we removed an RBP binding site in the genome it performs better than existing tools such as MACS3 and Peakachu. DBPeaks was able to detect loss of binding in that single genomic location. The other tools we tested could not. DBPeaks is, however, slower than most existing tools. This is because it relies on pyCalculateFDRs from the pyCRAC package to call peaks. This script looks for peaks in each individual gene anotated in the genome and takes read coverage of the gene into consideration for this. So this part is rather slow if you have many features annotated in your genome file. 
+
+DBPeaks uses multiple CPUs to process the data and has the added advantage that it can also use replicates.
+
+## Repo Contents
+- [DBPeaks](./DBPeaks.py)
+- [License](./LICENSE)
+
+## Features
+
+Comprehensive Analysis Pipeline: From reading BAM files to statistical analysis with DESeq2.
+Parallel Processing: Utilizes multiple CPUs to speed up the analysis.
+Flexible Input Options: Supports various configurations and customizations through command-line options.
+Integrated Peak Calling and Filtering: Includes functionality for peak detection, filtering based on reproducibility, and adjustment of peak widths.
+Statistical Analysis: Incorporates DESeq2 for rigorous differential analysis.
+
+## Installation Guide
+
+### Prerequisites
+
+Python 3.6 or higher
+Dependencies: pybedtools, numpy, pandas, pydeseq2, pyCRAC, and others as listed in requirements.txt.
+Steps
+
+Clone the repository:
+
+```
+git clone https://git.ecdf.ed.ac.uk/sgrannem/dbpeaks.git
+cd dbpeaks
+```
+
+### Install required Python packages:
+
+```
+pip install -r requirements.txt
+```
+
+### Install DBPeaks:
+
+```
+cd dbpeaks
+pip install -e . --user
+```
+
+### Running DBPeaks
+
+DBPeaks is run from the command line. Here is a basic example to get you started:
+
+python dbpeaks.py --samples path/to/sample1.bam path/to/sample2.bam --controls path/to/control1.bam path/to/control2.bam --gtf path/to/annotation.gtf --chromfile path/to/chrominfo.txt --jobname ExampleAnalysis
+
+### Command-Line Options
+
+--samples: Specify paths to the BAM files for the sample group.
+--controls: Specify paths to the BAM files for the control group.
+--gtf: Path to the GTF annotation file.
+--chromfile: Location of the chromosome info file. This file should have two columns: first column is the names of the chromosomes, second column is length of the chromosomes.
+--jobname: A name for the job to organize output files.
+
+### Additional options for peak calling, filtering, and statistical thresholds can be viewed using the help option:
+
+```
+DBpeaks.py --help
+```
+
+### Peak calling settings:
+  -m 0.05, --minfdr 0.05  To set a minimal FDR threshold for filtering interval data. Default is 0.05
+
+This is a setting that is used when running pyCalculateFDRs. If you end up getting a lot of peaks in your data,
+it is recommended to change this threshold, let's say to 0.01 as this will reduce the number of significantly enriched peaks
+in your data.
+                        
+  --padj 0.05           DESeq2 threshold for calling a peak DB. Default is 0.05
+
+If you hardly get any DB peaks, then it may be worth slighly adjusting this threshold.
+However, in this scenario, it may also be the case that your samples just have too much variability. 
+It may then be wise to do a PCA analysis on your data to see if replicates are indeed grouped together.
+
+  --min 5               to set a minimal read coverages for a region. Regions with coverage less than minimum will be ignored
+
+  --blocks              Add this flag if you want to consider reads with identical mapping coordinates once, regardless of sequence.
+
+NOTE! This is a HUGELY important flag! Setting --blocks will remove any 'towers' in your data and collapse them into
+one single interval. This can completely change the shape and height of the peak and the peak may no longer be detected.
+However, if you suspect that your library is of low complexity and you see many of these blocks or towers in your genome browser, then I would recommend adding this flag as I have seen that this can improve the reliability of the final DESeq2 analyses.
+
+  --iterations 100      to set the number of iterations for randomization of read coordinates. Default=100
+                        
+This is important for the peak calling analysis by the pyCalculateFDR.py script.
+
+
+  -r 90, --rep 90       To set in what percentage of the replicates the peak should be detected. Default=100
+
+Let's say you have three sample and three control bam files and you set -r to 50, then peaks that are, for example present in the smaple files but absent in the control files will also be considered. If you, in this scenario, set -r to 100, then the tool will expect to find overlapping peaks at any given position for ALL samples! So you may miss peaks that were, for example, only present in your sample but not in the control!
+
+  --filter mean         To filter the peaks in gtf files by a specific threshold. Options are mean, median or mean plus one standard devation 
+                        (mean_plus_std) peak heights. Default is no filtering.
+
+I would always recommend starting with no filtering. If you get too many DB peaks, then I would start with --filter mean and then --filter median.
+
+  --min_peak_width 20   To set the minimum width of a called peak. Default = 20
+
+
+## Contributing to further improving DBPeaks
+
+Contributions to DBPeaks are welcome! Please fork the repository and submit pull requests with your enhancements.
+We will also be including some test data on the repository soon!
+
+## License
+
+This project is licensed under the Apache License - see the LICENSE file for details.
+
+
+## Citation
+
+DBPeaks was developed to analyse CRAC data for a manuscript that we are about to submit. This will be updated once the paper has been accepted or put on a preprint server.
+
+## Contact
+
+For support or to report issues, please contact Sander Granneman at Sander.Granneman@ed.ac.uk, University of Edinburgh.

dbpeaks-0.0.3.dist-info/RECORD

@@ -0,0 +1,7 @@
+DBPeaks.py,sha256=H7ZSGxxK4hvEbpN52jXz0aojXENwF1AYY3wlQfj57UM,34794
+dbpeaks-0.0.3.dist-info/licenses/LICENSE,sha256=DU9_yiwF7Kz7teRaufuoFy-WJ8abkKbkzkn8e2wVIvw,11338
+dbpeaks-0.0.3.dist-info/METADATA,sha256=Udp6wfLHzKEbCBZsWuyfpD83UWl677y1sWlWU6d9H9c,9356
+dbpeaks-0.0.3.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+dbpeaks-0.0.3.dist-info/entry_points.txt,sha256=Aa_zwEkr9vFVgLr7YffiVUGsi3asuy3pyfzd9KIwjY4,41
+dbpeaks-0.0.3.dist-info/top_level.txt,sha256=x9WZWRV0ZCfB8TEjokW0A5nJGNf9XoGC_T3u1c7TC3E,8
+dbpeaks-0.0.3.dist-info/RECORD,,

dbpeaks-0.0.3.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

dbpeaks-0.0.3.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+dbpeaks = DBPeaks:main

dbpeaks-0.0.3.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2021 sgrannem
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

dbpeaks-0.0.3.dist-info/top_level.txt

@@ -0,0 +1 @@
+DBPeaks