RILseq-analysis 1.0.0__py3-none-any.whl

RILseq_analysis_package/annotations_graphs.py

@@ -0,0 +1,185 @@
+import pandas as pd
+import os
+import seaborn as sns
+import matplotlib.pyplot as plt
+from RILseq_analysis_package.utils import get_annotation, get_RNA_types, load_config
+import argparse
+
+
+
+def get_gene_annotation(gene, genes, tRNAs, sRNAs, oRNAs):
+    if gene in tRNAs:
+        return "tRNA"
+    if gene in sRNAs:
+        return "sRNA"
+    if gene in oRNAs:
+        return "oRNA"
+    if "3UTR" in gene:
+        return "3UTR"
+    if "5UTR" in gene:
+        return "5UTR"
+    if "AS" in gene:
+        return "AS"
+    if "IGR" in gene:
+        return "IGR"
+    if "IGT" in gene:
+        return "IGT"
+    if gene in genes:
+        return "CDS"
+    return "unknown"
+
+
+def get_RNAs_types(rna_types_excel):
+    sRNAs = set(get_RNA_types("sRNA", rna_types_excel))
+    tRNAs = set(get_RNA_types("tRNA", rna_types_excel))
+    oRNAs = set(get_RNA_types("oRNA", rna_types_excel))
+    return sRNAs, tRNAs, oRNAs
+
+
+def RNA1_RNA2_annotations(chr_dic, base_path, experiments, rna_types_excel, annotation_path, chimeras_or_fragments, chrom=None):
+    """
+    Creates heatmaps of the chimeras annotations, with and without the annotations numbers.
+    :param chimeras_or_fragments: if "chimeras" create the heatmaps according to the amount of chimeras. Else, according
+    to the amount of fragments.
+    :param chrom: if None, create the heatmaps base on the chimeras between the two chromosomes. Else, create the heatmaps
+     base on the chimeras of the given chromosome.
+    """
+    genes = get_annotation(annotation_path, chromosome=chrom, separate_id_name=True)["name"].values.tolist()
+    sRNAs, tRNAs, oRNAs = get_RNAs_types(rna_types_excel)
+    if chrom:
+        dir_ = chr_dic[chrom] + "_annotation"
+    else:
+        dir_ = "_".join(chr_dic.values()) + "_annotation"
+    output_path = os.path.join(base_path, dir_)
+    if not os.path.exists(output_path):
+        os.makedirs(output_path)
+    for experiment in experiments:
+        df = pd.read_excel(os.path.join(base_path, "RILseq_unified_results.xlsx"), sheet_name=experiment)
+        if chrom is not None:
+            df = df[(df["RNA1 chromosome"] == chrom) & (df["RNA2 chromosome"] == chrom)]
+        else:
+            chr1, chr2 = chr_dic.keys()
+            df = df[((df["RNA1 chromosome"] == chr1) & (df["RNA2 chromosome"] == chr2)) |
+                    ((df["RNA1 chromosome"] == chr2) & (df["RNA2 chromosome"] == chr1))]
+        df["RNA1_annotation"] = df["RNA1 name"].apply(get_gene_annotation, genes=genes, tRNAs=tRNAs, sRNAs=sRNAs, oRNAs=oRNAs)
+        df["RNA2_annotation"] = df["RNA2 name"].apply(get_gene_annotation, genes=genes, tRNAs=tRNAs, sRNAs=sRNAs, oRNAs=oRNAs)
+        options = ["3UTR", "5UTR", "CDS", "AS", "IGR", "sRNA", "tRNA", "IGT"] #"oRNA"
+
+        if chimeras_or_fragments == "chimeras":
+            df["i"] = df.index
+            df = df[["RNA1_annotation", "RNA2_annotation", "i"]]
+            small_df = df.groupby(["RNA1_annotation", "RNA2_annotation"]).count()
+            small_df_pairs = small_df.index
+            amount = small_df["i"].values
+        else:
+            df = df[["RNA1_annotation", "RNA2_annotation", "interactions"]]
+            small_df = df.groupby(["RNA1_annotation", "RNA2_annotation"]).sum()
+            small_df_pairs = small_df.index
+            amount = small_df["interactions"].values
+        dic = {}
+        for i in range(len(amount)):
+            dic[small_df_pairs[i]] = amount[i]
+        results = pd.DataFrame(0, index=options, columns=options)
+        for option1 in options:
+            for option2 in options:
+                if (option1, option2) in small_df_pairs:
+                    results.loc[option2, option1] = dic[(option1, option2)]
+        for annot in [True, False]:
+            plt.figure()
+            sns.heatmap(results, annot=annot, cmap='Blues', fmt=".6g", annot_kws={"size": 8})
+            plt.xlabel("RNA1")
+            plt.ylabel("RNA2")
+            with_annot = "with_annot" if annot else "without_annot"
+            plt.savefig(os.path.join(output_path, f"{experiment}_{chimeras_or_fragments}_{with_annot}.png"))
+
+
+def get_RNAs_type_fractions(df, options, chimeras_or_fragments):
+    """
+    :param df: chimeras data-frame
+    :param options: the annotations
+    :param chimeras_or_fragments: if "chimeras" calculate the fraction according to the amount of chimeras. Else, according
+    to the amount of fragments.
+    :return: a list of the fraction of each annotation
+    """
+    if df.empty:
+        return [0] * len(options)
+    amount_dic = {i:0 for i in options}
+    for RNA in "12":
+        small_df = df[[f"RNA{RNA}_annotation", "interactions"]]
+        small_df = small_df.groupby([f"RNA{RNA}_annotation"])
+        if chimeras_or_fragments == "chimeras":
+            small_df = small_df.count()
+        elif chimeras_or_fragments == "fragments":
+            small_df = small_df.sum()
+        indexes = small_df.index
+        for index in indexes:
+            amount_dic[index] += small_df["interactions"][index]
+    amount_list = [amount_dic[i] for i in options]
+    amount_sum = sum(amount_list)
+    return [i/amount_sum for i in amount_list]
+
+
+def chimeras_annotations(chr_dic, experiments, base_path, annotation_path, rna_types_excel, chimeras_or_fragments):
+    """
+    Creates a bar plot of the annotation fraction for within and between chromosomes for each time point.
+    :param chimeras_or_fragments: if "chimeras" create the bar plot according to the amount of chimeras. Else, according
+    to the amount of fragments.
+    """
+    genes = get_annotation(annotation_path, separate_id_name=True)["name"].values.tolist()
+    sRNAs, tRNAs, oRNAs = get_RNAs_types(rna_types_excel)
+    options = ["3UTR", "sRNA", "CDS", "5UTR", "IGR", "AS", "tRNA", "oRNA", "IGT"]
+    final_dic = {}
+    chr1, chr2 = chr_dic.keys()
+    chr1_name = chr_dic[chr1]
+    chr2_name = chr_dic[chr2]
+    for experiment in experiments:
+        df = pd.read_excel(os.path.join(base_path, "RILseq_unified_results.xlsx"), sheet_name=experiment)
+        df["RNA1_annotation"] = df["RNA1 name"].apply(get_gene_annotation, genes=genes, tRNAs=tRNAs, sRNAs=sRNAs, oRNAs=oRNAs)
+        df["RNA2_annotation"] = df["RNA2 name"].apply(get_gene_annotation, genes=genes, tRNAs=tRNAs, sRNAs=sRNAs, oRNAs=oRNAs)
+        chr1_df = df[(df["RNA1 chromosome"] == chr1) & (df["RNA2 chromosome"] == chr1)]
+        chr2_df = df[(df["RNA1 chromosome"] == chr2) & (df["RNA2 chromosome"] == chr2)]
+        chr1_chr2 = df[((df["RNA1 chromosome"] == chr1) & (df["RNA2 chromosome"] == chr2)) |
+                           ((df["RNA1 chromosome"] == chr2) & (df["RNA2 chromosome"] == chr1))]
+        if chimeras_or_fragments == "chimeras":
+            chr1_amount = chr1_df.shape[0]
+            chr1_chr2_amount = chr1_chr2.shape[0]
+            chr2_amount = chr2_df.shape[0]
+        else:
+            chr1_amount = chr1_df["interactions"].sum()
+            chr1_chr2_amount = chr1_chr2["interactions"].sum()
+            chr2_amount = chr2_df["interactions"].sum()
+        final_dic[f"{chr1_name}-{chr1_name} {experiment} ({chr1_amount})"] = get_RNAs_type_fractions(chr1_df, options, chimeras_or_fragments)
+        final_dic[f"{chr1_name}-{chr2_name} {experiment} ({chr1_chr2_amount})"] = get_RNAs_type_fractions(chr1_chr2, options, chimeras_or_fragments)
+        final_dic[f"{chr2_name}-{chr2_name} {experiment} ({chr2_amount})"] = get_RNAs_type_fractions(chr2_df, options, chimeras_or_fragments)
+    df = pd.DataFrame.from_dict(final_dic, orient="index", columns=options)
+    df = df[df.columns[(df != 0).any()]]
+    fig = plt.figure()
+    h = df.plot(kind="bar", linewidth=0, stacked=True, grid=False, cmap="tab20c")
+    plt.subplots_adjust(bottom=0.35, right=0.7)
+    plt.xticks(rotation=-45, ha='left')
+    handles, labels = h.get_legend_handles_labels()
+    plt.legend(handles[::-1], labels[::-1], loc=(1.1, 0))
+    plt.tight_layout()
+    plt.savefig(os.path.join(base_path, f"{chimeras_or_fragments}_annotation_fractions.png"))
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Create annotation heatmaps and annotation fraction plots for RIL-seq chimeras and fragments.")
+
+    parser.add_argument("config", help="Path to the YAML configuration file.")
+
+    args = parser.parse_args()
+    config = load_config(args.config)
+
+    for type_ in ("fragments", "chimeras"):
+        for chrom in config["chr_dic"].keys():
+            RNA1_RNA2_annotations(config["chr_dic"], config["base_path"], config["experiments"], config["rna_types_excel"], config["annotation_path"], type_, chrom)
+        RNA1_RNA2_annotations(config["chr_dic"], config["base_path"], config["experiments"], config["rna_types_excel"], config["annotation_path"], type_)
+
+        chimeras_annotations(config["chr_dic"], config["experiments"], config["base_path"], config["annotation_path"], config["rna_types_excel"], type_)
+
+
+
+
+
+

RILseq_analysis_package/chimeras_venn_diagram.py

@@ -0,0 +1,81 @@
+import argparse
+import os
+import pandas as pd
+from matplotlib_venn import venn2
+import matplotlib.pyplot as plt
+from RILseq_analysis_package.utils import load_config
+
+
+def get_chimeras_pairs(RILseq_path, experiment, chromosomes=None):
+    """
+    Reads the RILSeq results and returns a set of the chimeras pairs. Doesn't take into account which RNA is first and
+    which is second in the chimera.
+    """
+    df = pd.read_excel(os.path.join(RILseq_path, "RILseq_unified_results.xlsx"), sheet_name=experiment)
+    if chromosomes:
+        df = df[(df["RNA1 chromosome"].isin(chromosomes)) & (df["RNA2 chromosome"].isin(chromosomes))]
+    chimeras_pairs = df[["RNA1 name", "RNA2 name"]].values
+    chimeras_set = set()
+    for pair in chimeras_pairs:
+        rna1, rna2 = pair
+        if rna1 > rna2:
+            chimeras_set.add((rna1, rna2))
+        else:
+            chimeras_set.add((rna2, rna1))
+    return chimeras_set
+
+
+def get_all_conditions(conditions):
+    all_conditions = []
+    for conditions_tuple in conditions:
+        all_conditions.append(conditions_tuple[0])
+        all_conditions.append(conditions_tuple[1])
+    return all_conditions
+
+
+def plot(chr_lst, conditions_to_compare, output_path, RILseq_path):
+    experiments_chimeras = {}
+    for condition in get_all_conditions(conditions_to_compare):
+        if chr_lst:
+            chimeras_pairs = get_chimeras_pairs(RILseq_path, condition, chromosomes=chr_lst)
+        else:
+            chimeras_pairs = get_chimeras_pairs(RILseq_path, condition)
+        experiments_chimeras.update({condition: chimeras_pairs})
+
+    for conditions in conditions_to_compare:
+        plt.figure()
+        venn2([experiments_chimeras[conditions[0]], experiments_chimeras[conditions[1]]],
+              set_labels=(conditions[0], conditions[1]),
+              set_colors=("SkyBlue", "Salmon"))
+        plt.savefig(os.path.join(output_path, f"{conditions[0]}_and_{conditions[1]}_venn.jpg"))
+        with open(os.path.join(output_path, f"{conditions[0]}_and_{conditions[1]}_chimeras_pairs.txt"), "w") as f:
+            pairs = experiments_chimeras[conditions[0]] & experiments_chimeras[conditions[1]]
+            for i in pairs:
+                f.write(i[0] + "," + i[1] + "\n")
+
+
+def main():
+    parser = argparse.ArgumentParser("Generate Venn diagrams of chimeras pairs between two conditions. RNA1/RNA2 positions are ignored.")
+
+    parser.add_argument("config", help="Path to the YAML configuration file.")
+    parser.add_argument("conditions_pairs", help="Pairs of experiments to compare, with the two conditions separated by '-'. "
+     "Multiple pairs can be separated by commas. "
+     "Example: exp1-exp2,exp3-exp4 creates two Venn diagrams: one comparing exp1 and exp2, and the other comparing exp3 and exp4.")
+    parser.add_argument("--chr", help="Comma-separated list of chromosomes to include. If not provided, chimeras from all chromosomes are included.")
+
+    args = parser.parse_args()
+
+    base_path = load_config(args.config)["base_path"]
+    venn_path = os.path.join(base_path, "venn_diagrams")
+    if not os.path.exists(venn_path):
+        os.makedirs(venn_path)
+
+    pairs = args.conditions_pairs.split(",")
+    pairs = [i.split("-") for i in pairs]
+
+    if args.chr is not None:
+        chr_list = args.chr.split(",")
+    else:
+        chr_list = None
+    plot(chr_list, pairs, venn_path, base_path)
+

RILseq_analysis_package/circos_plot.py

@@ -0,0 +1,164 @@
+import os
+import pandas as pd
+from RILseq_analysis_package.utils import get_annotation
+
+
+def convert_to_kb_mb(range_lst):
+    if range_lst[-1] > 10 ** 6:
+        return [str("%.0f" % (i / 10 ** 6)) + " MB" for i in range_lst]
+    else:
+        return [str("%.0f" % (i / 1000)) + " KB" for i in range_lst]
+
+
+def get_scale_lists(chr_sizes, chr_dic, factor, kb_mb):
+    """
+    Returns lists for the scale marks of the circos plot, the multiplication factor needed for the shorter chromosome, and its name.
+    """
+    # chr_sizes = {}
+    # with open(CHR_SIZES_PATH, "r") as f:
+    #     lines = f.readlines()
+    #     max_len = 0
+    #     min_len = 10**9
+    #     min_chr = ""
+    #     for line in lines:
+    #         chrom, chr_len = line.split()
+    #         chr_sizes[chrom] = chr_len
+    #         if int(chr_len) > max_len:
+    #             max_len = int(chr_len)
+    #         if int(chr_len) < min_len:
+    #             min_len = int(chr_len)
+    #             min_chr = chrom
+    max_chr = max(chr_sizes, key=chr_sizes.get)
+    min_chr = min(chr_sizes, key=chr_sizes.get)
+
+    max_len = chr_sizes[max_chr]
+    min_len = chr_sizes[min_chr]
+
+    multiply_factor = round(max_len/min_len)
+
+    ranges = {}
+    for chrom in chr_sizes.keys():
+        ranges[chrom] = list(range(0, int(chr_sizes[chrom]), 10 ** (len(str(chr_sizes[chrom])) - factor)))
+
+    chromosome = []
+    for i in ranges.keys():
+        chromosome += [chr_dic[i]] * len(ranges[i])
+
+    chrom_start = []
+    for i in ranges.keys():
+        if i == min_chr:
+            chrom_start += [i * multiply_factor for i in ranges[i]]
+        else:
+            chrom_start += ranges[i]
+
+    name = []
+    if kb_mb:
+        for chrom in chr_sizes.keys():
+            name += convert_to_kb_mb(ranges[chrom])
+    else:
+        for i in ranges.keys():
+            name += [str(k) for k in ranges[i]]
+
+    return chromosome, chrom_start, name, multiply_factor, min_chr
+
+
+def add_color(chimeras_df, chr1, chr2):
+    """
+    Add a column of colors to the chimeras. Set different colors to chimeras from different genomes and to chimeras between genomes.
+    """
+    chimeras_df["PlotColor"] = None
+    chimeras_df.loc[(chimeras_df["RNA1 chromosome"] == chr1) & (chimeras_df["RNA2 chromosome"] == chr1), "PlotColor"] = "gray48"
+    chimeras_df.loc[(chimeras_df["RNA1 chromosome"] == chr1) & (chimeras_df["RNA2 chromosome"] == chr2), "PlotColor"] = "blue"
+    chimeras_df.loc[(chimeras_df["RNA1 chromosome"] == chr2) & (chimeras_df["RNA2 chromosome"] == chr1), "PlotColor"] = "blue"
+    chimeras_df.loc[(chimeras_df["RNA1 chromosome"] == chr2) & (chimeras_df["RNA2 chromosome"] == chr2), "PlotColor"] = "red"
+    return chimeras_df
+
+
+def two_genomes_circos_plot_half_circle(circos_path, base_path, chr_sizes, chr_dic, present_chr=None, gene_list=None, experiments=None):
+    """
+    Generates files required for creating circos plot of two genomes, each represented by half a circle.
+     Use the output files for circos_plot.R script.
+    :param gene_list: list of genes. If it's not None the circos plot will contain only the chimeras of the genes in the list.
+    """
+    chromosome, chrom_start, gene, multiply_factor, chr_to_multiply = get_scale_lists(chr_sizes, chr_dic, 2, kb_mb=False)
+    scale_df = pd.DataFrame({"Chromosome":chromosome, "chromStart":chrom_start, "chromEnd":[i+1 for i in chrom_start],
+                             "Gene":gene})
+
+    scale_df.to_csv(os.path.join(circos_path, "two_genomes_scale_half_circles.csv"), index=False)
+
+    chromosome, chrom_start, gene, _, _ = get_scale_lists(chr_sizes, chr_dic, 1, kb_mb=True)
+
+    scale_df = pd.DataFrame({"Chromosome":chromosome, "chromStart":chrom_start, "chromEnd":[i+1 for i in chrom_start],
+                             "Gene":gene})
+    scale_df.to_csv(os.path.join(circos_path, "two_genomes_scale_numbers_half_circles.csv"), index=False)
+
+    RILseq_excel = pd.ExcelFile(os.path.join(base_path, "RILseq_unified_results.xlsx"))
+
+    if experiments is None:
+        experiments = RILseq_excel.sheet_names
+    for experiment in experiments:
+        chimeras_df = RILseq_excel.parse(experiment)
+        if gene_list is not None:
+            chimeras_df = chimeras_df[(chimeras_df["RNA1 name"].isin(gene_list)) | (chimeras_df["RNA2 name"].isin(gene_list))]
+        if present_chr:
+            chimeras_df = chimeras_df[(chimeras_df["RNA1 chromosome"] == present_chr) & (chimeras_df["RNA2 chromosome"] == present_chr)]
+
+        for i in ("1", "2"):
+            for j in [f"Start of RNA{i} first read", f"Start of RNA{i} last read"]:
+                # chimeras_df[j][chimeras_df[f"RNA{i} chromosome"] == chr_to_multiply] *= multiply_factor
+                chimeras_df.loc[chimeras_df[f"RNA{i} chromosome"] == chr_to_multiply,j] *= multiply_factor
+        chr1, chr2 = chr_sizes.keys()
+        chimeras_df = add_color(chimeras_df, chr1, chr2)
+
+        for genome, genome_name in chr_dic.items():
+            chimeras_df.loc[chimeras_df["RNA1 chromosome"] == genome, "RNA1 chromosome"] = genome_name
+            chimeras_df.loc[chimeras_df["RNA2 chromosome"] == genome, "RNA2 chromosome"] = genome_name
+
+        file_name = f"{experiment}_two_genomes_chimeras_half_circles"
+        if gene_list is not None:
+            genes = "_".join(gene_list)
+            file_name += genes
+        chimeras_df.to_csv(os.path.join(circos_path, f"{file_name}.csv"),
+                           columns=["RNA1 chromosome", "Start of RNA1 first read", "Start of RNA1 last read", "RNA2 chromosome", "Start of RNA2 last read", "Start of RNA2 first read", "PlotColor"],
+                           header=["Chromosome", "chromStart", "chromEnd", "Chromosome.1", "chromStart.1", "chromEnd.1", "PlotColor"], index=False)
+
+
+def two_genomes_circos_plot_real_proportions(circos_path, base_path, chr_sizes, chr_dic, mark_step1, mark_step2, present_chr=None, gene_list=None):
+    """
+    Generates files required for creating circos plot of two genomes. Use the output files for circos_plot.R script.
+    """
+    chr1, chr2 = chr_sizes.keys()
+    chrI_range = list(range(0, chr_sizes[chr1], mark_step1))
+    chrII_range = list(range(0, chr_sizes[chr2], mark_step2))
+    scale_df = pd.DataFrame({"Chromosome":[chr_dic[chr1]]*len(chrI_range) + [chr_dic[chr2]]*len(chrII_range),
+                             "chromStart":chrI_range + chrII_range,
+                             "chromEnd":[i+1 for i in chrI_range] +[i+1 for i in chrII_range],
+                             "Gene":convert_to_kb_mb(chrI_range+chrII_range)})
+    scale_df.to_csv(os.path.join(circos_path, "two_genomes_scale_real_proportions.csv"), index=False)
+
+    RILseq_excel = pd.ExcelFile(os.path.join(base_path, "RILseq_unified_results.xlsx"))
+    for experiment in RILseq_excel.sheet_names:
+        chimeras_df = RILseq_excel.parse(experiment)
+
+        if gene_list is not None:
+            chimeras_df = chimeras_df[(chimeras_df["RNA1 name"].isin(gene_list)) | (chimeras_df["RNA2 name"].isin(gene_list))]
+        if present_chr:
+            chimeras_df = chimeras_df[(chimeras_df["RNA1 chromosome"] == present_chr) & (chimeras_df["RNA2 chromosome"] == present_chr)]
+
+        chimeras_df = add_color(chimeras_df, chr1, chr2)
+
+        for genome, genome_name in chr_dic.items():
+            chimeras_df.loc[chimeras_df["RNA1 chromosome"] == genome, "RNA1 chromosome"] = genome_name
+            chimeras_df.loc[chimeras_df["RNA2 chromosome"] == genome, "RNA2 chromosome"] = genome_name
+
+        file_name = f"{experiment}_two_genomes_chimeras_real_proportions"
+        if gene_list is not None:
+            genes = "_".join(gene_list)
+            file_name += genes
+        chimeras_df.to_csv(os.path.join(circos_path, f"{file_name}.csv"),
+                           columns=["RNA1 chromosome", "Start of RNA1 first read", "Start of RNA1 last read", "RNA2 chromosome", "Start of RNA2 last read", "Start of RNA2 first read", "PlotColor"],
+                           header=["Chromosome", "chromStart", "chromEnd", "Chromosome.1", "chromStart.1", "chromEnd.1", "PlotColor"], index=False)
+
+
+
+

RILseq_analysis_package/cli/add_number_of_libraries_cli.py

@@ -0,0 +1,15 @@
+import argparse
+from RILseq_analysis_package.generate_and_edit_RILseq_xslx import add_number_of_libraries
+from RILseq_analysis_package.utils import load_config
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Record for each chimera the number of libraries in which it appears, "
+                                                 "and rename columns in the S-chimeras workbook.")
+
+    parser.add_argument("config", help="Path to the YAML configuration file.")
+
+    args = parser.parse_args()
+    config = load_config(args.config)
+    add_number_of_libraries(config["base_path"], config["experiments"], config["replicates"], config["chr_dic"])
+

RILseq_analysis_package/cli/circos_plot_cli.py

@@ -0,0 +1,48 @@
+import argparse
+from RILseq_analysis_package import circos_plot
+from RILseq_analysis_package.utils import load_config
+import os
+
+def main():
+    parser = argparse.ArgumentParser(description="Create a Circos plot showing RIL-seq chimeric interactions between two chromosomes.")
+
+    parser.add_argument("plot_type", choices=["two_genomes_half_circle", "two_genomes_real_proportions"], help="Type of circos plot to generate.")
+    parser.add_argument("config", help="Path to the YAML configuration file.")
+    parser.add_argument("--mark_step1", default=200000, type=int, help="Distance between scale marks on the first chromosome (default: 200000).")
+    parser.add_argument("--mark_step2", default=48500, type=int, help="Distance between scale marks on the second chromosome (default: 48500).")
+    parser.add_argument("--genes", default=None,
+                        help="Plot only chimeras involving the specified genes. Separate gene names with underscores.")
+    parser.add_argument("--present_chr", default=None, help="Plot only chimeras involving the specified chromosome.")
+    parser.add_argument("--out_path", default=None,
+                        help="Output directory for the Circos plot. If not provided, a 'circos_plots' directory is created under base_path.")
+    parser.add_argument("--experiments", default=None,
+                        help="Comma-separated list of experiment names to plot. "
+                             "Experiment names must match sheet names in RILseq_unified_results.xlsx.")
+    args = parser.parse_args()
+    config = load_config(args.config)
+
+    base_path = config["base_path"]
+    if args.out_path is None:
+        circos_path = os.path.join(base_path, "circos_plots")
+    else:
+        circos_path = args.out_path
+
+    if not os.path.exists(circos_path):
+        os.makedirs(circos_path)
+
+    if args.genes is not None:
+        genes_list = args.genes.split("_")
+    else:
+        genes_list = None
+
+    if args.experiments is not None:
+        experiments = args.experiments.split(",")
+    else:
+        experiments = None
+
+    if args.plot_type == "two_genomes_half_circle":
+        circos_plot.two_genomes_circos_plot_half_circle(circos_path, base_path, config["chr_len"], config["chr_dic"], args.present_chr, genes_list, experiments)
+    elif args.plot_type == "two_genomes_real_proportions":
+        circos_plot.two_genomes_circos_plot_real_proportions(circos_path, base_path, config["chr_len"], config["chr_dic"], args.mark_step1, args.mark_step2, args.present_chr, genes_list)
+
+

RILseq_analysis_package/cli/merge_results_cli.py

@@ -0,0 +1,20 @@
+import argparse
+from RILseq_analysis_package.generate_and_edit_RILseq_xslx import merge_RILseq_results
+from RILseq_analysis_package.utils import load_config
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Merge RIL-seq results from multiple experiments into a unified Excel file.")
+
+    parser.add_argument("config", help="Path to the YAML configuration file.")
+    parser.add_argument("file_names",
+                        help="path to file contains two columns. One is the name of the sig_interactions file names and "
+                             "the other is the corresponding experiment names as appear in the yaml file. The two columns "
+                             "are separated by a Tab.")
+    parser.add_argument("--no-annotations", dest="annotations", action="store_false", default=True,
+                        help="Do not add RNA annotations to the merged results.")
+
+    args = parser.parse_args()
+    config = load_config(args.config)
+    merge_RILseq_results(config["base_path"], config["annotation_path"], config["rna_types_excel"], args.file_names, args.annotations)
+

RILseq_analysis_package/extract_genes_by_chr.py

@@ -0,0 +1,32 @@
+import pandas as pd
+from RILseq_analysis_package.utils import get_annotation, load_config
+import argparse
+
+
+def filter_chr_genes(annotation_path, old_file_path, new_file, chromosome, sep="\t", names_col="Unnamed: 0", identifier="name"):
+    if identifier in ("name", "id"):
+        annotations_df = get_annotation(annotation_path, chromosome=chromosome, separate_id_name=True)
+        chr_genes = annotations_df[identifier].values.tolist()
+    else:
+        annotations_df = get_annotation(annotation_path, chromosome=chromosome, identifier=identifier)
+        chr_genes = annotations_df["identifier"].values.tolist()
+
+    old_file_df = pd.read_csv(old_file_path, sep=sep)
+
+    new_df = old_file_df[old_file_df[names_col].isin(chr_genes)]
+    new_df.to_csv(new_file, index=False, sep=sep)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Filter a file and keep only genes belonging to a specified chromosome.")
+    parser.add_argument("input", help="Path to the input file.")
+    parser.add_argument("output", help="Path to the output file.")
+    parser.add_argument("chr", help="Chromosome to keep, according to the chromosome names in the annotation file.")
+    parser.add_argument("config", help="Path to the YAML configuration file.")
+    parser.add_argument("--sep", default="\t", help="Column separator used in the input and output files (default: tab).")
+    parser.add_argument("--names_col", default="Unnamed: 0", help="Name of the column containing gene names (default: there is no column name).")
+    parser.add_argument("--identifier", default="name", help="Type of gene identifier to use from the annotation file (default: name).")
+
+    args = parser.parse_args()
+
+    filter_chr_genes(load_config(args.config)["annotation_path"], args.input, args.output, args.chr, args.sep, args.names_col, args.identifier)

RILseq_analysis_package/generate_and_edit_RILseq_xslx.py

@@ -0,0 +1,118 @@
+import os
+import pandas as pd
+from RILseq_analysis_package.utils import get_annotation, get_RNA_types
+
+
+def find_genomic_annotation(gene, sRNAs_list, tRNAs_list, all_genes_list):
+    if gene in sRNAs_list:
+        return "sRNA"
+    if gene in tRNAs_list:
+        return "tRNA"
+    if "3UTR" in gene:
+        return "3UTR"
+    if "5UTR" in gene:
+        return "5UTR"
+    if "AS" in gene:
+        return "AS"
+    if "IGR" in gene:
+        return "IGR"
+    if "IGT" in gene:
+        return "IGT"
+    if gene in all_genes_list:
+        return "CDS"
+    return "unknown"
+
+
+def create_names_dic(file_names):
+    dic = {}
+    with open(file_names) as f:
+        line = f.readline()
+        while line:
+            line = line.split("\t")
+            dic[line[0]] = line[1].strip()
+            line = f.readline()
+    return dic
+
+
+def merge_RILseq_results(base_path, annotation_path, rna_types_excel, file_names, add_genomic_annotation=True):
+    names_dic = create_names_dic(file_names)
+    write_unified = False
+    write_single = False
+    with pd.ExcelWriter(os.path.join(base_path, 'RILseq_unified_results.xlsx')) as unified, pd.ExcelWriter(os.path.join(base_path, 'RILseq_single_results.xlsx')) as single:
+        for file in os.listdir(base_path):
+            if file.endswith("sig_interactions.txt"):
+                df = pd.read_csv(os.path.join(base_path, file), sep="\t")
+                if not df.empty:
+                    if add_genomic_annotation:
+                        sRNAs_list = get_RNA_types("sRNA", rna_types_excel)
+                        tRNAs_list = get_RNA_types("tRNA", rna_types_excel)
+                        genes_names = get_annotation(annotation_path, separate_id_name=True)["name"].values.tolist()
+                        df["Genomic annotation of RNA1"] = df["RNA1 name"].apply(find_genomic_annotation, sRNAs_list=sRNAs_list, tRNAs_list=tRNAs_list, all_genes_list=genes_names)
+                        df["Genomic annotation of RNA2"] = df["RNA2 name"].apply(find_genomic_annotation, sRNAs_list=sRNAs_list, tRNAs_list=tRNAs_list, all_genes_list=genes_names)
+                    sheet_name = names_dic[file]
+                    if file.startswith("unified"):
+                        df.to_excel(unified, sheet_name=sheet_name, index=False)
+                        write_unified = True
+                    else:
+                        df.to_excel(single, sheet_name=sheet_name, index=False)
+                        write_single = True
+        if not write_unified:
+            pd.DataFrame().to_excel(unified, sheet_name="Empty", index=False)
+        if not write_single:
+            pd.DataFrame().to_excel(single, sheet_name="Empty", index=False)
+
+
+def find_number_of_libraries_helper(name1, name2, start1, end1, start2, end2, chr1, chr2, strand1, strand2, df):
+    cur1 = df[(df["RNA1 name"] == name1) & (df["RNA2 name"] == name2) & (df["RNA1 strand"] == strand1) & (df["RNA2 strand"] == strand2) & (df["RNA1 chromosome"] == chr1) & (df["RNA2 chromosome"] == chr2)]
+    cur1 = cur1[~((cur1["Start of RNA1 first read"] > end1) | (cur1["Start of RNA1 last read"] < start1))]
+    cur1 = cur1[~((cur1["Start of RNA2 last read"] > end2) | (cur1["Start of RNA2 first read"] < start2))]
+    return cur1.shape[0]
+
+
+def find_number_of_libraries(unify_chimera, singles):
+    name1, name2, start1, end1, start2, end2, chr1, chr2, strand1, strand2 = unify_chimera[["RNA1 name", "RNA2 name", "Start of RNA1 first read", "Start of RNA1 last read", "Start of RNA2 last read", "Start of RNA2 first read", "RNA1 chromosome", "RNA2 chromosome", "RNA1 strand", "RNA2 strand"]]
+
+    counter = 0
+    for single in singles:
+        single = single.astype({"Start of RNA1 first read":int, "Start of RNA2 first read":int, "Start of RNA1 last read":int, "Start of RNA2 last read":int})
+        amount1 = find_number_of_libraries_helper(name1, name2, start1, end1, start2, end2, chr1, chr2, strand1, strand2, single)
+        amount2 = find_number_of_libraries_helper(name2, name1, start2, end2, start1, end1, chr2, chr1, strand2, strand1, single)
+        if amount1 + amount2 != 0:
+            counter += 1
+
+    if counter == 0:
+        return "U"
+    return counter
+
+
+def add_number_of_libraries(base_path, experiments, replicates, chr_dic):
+    # new = pd.ExcelWriter(os.path.join(base_path, 'RILseq_unified_results_with_number_of_libraries.xlsx'))
+    single_results_excel = pd.ExcelFile(os.path.join(base_path, "RILseq_single_results.xlsx"))
+    with pd.ExcelWriter(os.path.join(base_path, 'RILseq_unified_results_with_number_of_libraries.xlsx')) as new:
+        for experiment in experiments:
+            singles = []
+            for i in replicates:
+                replicate_name = f"{experiment + i}_S_chimeras"
+                if replicate_name in single_results_excel.sheet_names:
+                    single1 = single_results_excel.parse(replicate_name)
+                    singles.append(single1)
+
+            unify_df = pd.read_excel(os.path.join(base_path, "RILseq_unified_results.xlsx"), sheet_name=experiment)
+
+            unify_df["# of libraries"] = unify_df.apply(find_number_of_libraries, singles=singles, axis=1)
+            unify_df = unify_df[["RNA1 name", "RNA2 name", "interactions", "# of libraries", "Normalized Odds Ratio (NOR)", "odds ratio", "Fisher's exact test p-value", "Genomic annotation of RNA1", "Genomic annotation of RNA2", "RNA1 description", "RNA2 description", "RNA1 chromosome", "Start of RNA1 first read", "Start of RNA1 last read", "RNA1 strand", "RNA2 chromosome", "Start of RNA2 last read", "Start of RNA2 first read", "RNA2 strand", "other interactions of RNA1", "other interactions of RNA2", "total other interactions", "total RNA reads1", "total RNA reads2", "lib norm IP RNA1", "lib norm IP RNA2", "lib norm total RNA1", "lib norm total RNA2", "IP/total ratio1", "IP/total ratio2", "RNA1 EcoCyc ID", "RNA2 EcoCyc ID"]]
+            unify_df.rename(columns={"interactions":"# of chimeric fragments", "Normalized Odds Ratio (NOR)":"Normalized Odds Ratio", "odds ratio":"Odds Ratio",
+                             "Start of RNA1 first read":"RNA1 from", "Start of RNA1 last read":"RNA1 to", "Start of RNA2 last read":"RNA2 from",
+                             "Start of RNA2 first read":"RNA2 to", "other interactions of RNA1":"other fragments of RNA1", "other interactions of RNA2":"other fragments of RNA2",
+                             "total other interactions":"Total other fragments", "total RNA reads1":"RNA1 in total RNA (# of reads)",
+                             "total RNA reads2":"RNA2 in total RNA (# of reads)"}, inplace=True)
+            unify_df["RNA1 chromosome"] = unify_df["RNA1 chromosome"].apply(lambda x: chr_dic[x])
+            unify_df["RNA2 chromosome"] = unify_df["RNA2 chromosome"].apply(lambda x: chr_dic[x])
+            unify_df.to_excel(new, sheet_name=experiment, index=False)
+
+    # new.save()
+
+
+# if __name__ == '__main__':
+#     merge_RILseq_results(rf"{BASE_PATH}\RILSeq\results", add_genomic_annotation=True)
+#     add_number_of_libraries(rf"{BASE_PATH}\RILSeq\results", get_experiments())

RILseq_analysis_package/sRNAs_percent.py

@@ -0,0 +1,144 @@
+from RILseq_analysis_package.utils import *
+import argparse
+import pandas as pd
+import numpy as np
+import matplotlib.pylab as plt
+import matplotlib
+import os
+
+
+def find_highest_sRNAs(df, sRNAs_amount):
+    """
+    Returns a list of the sRNAs with the highest percentages.
+    :param df: a data frame of the percentages of each sRNA in each condition.
+    """
+    max_values = df.max().sort_values(ascending=False)
+    return max_values.head(sRNAs_amount).index.tolist()
+
+
+def get_counts_table(sRNAs, path, experiments, replicates):
+    """
+    Returns a data frame of the number of reads of each sRNA for each condition. The number is the sum of the read
+    numbers at the different replicates.
+    :param sRNAs: a list of sRNAs names.
+    :param experiment: RILseq or RNAseq
+    """
+    df = pd.read_csv(path, sep="\t")
+    names_dic = {i:i.replace("_cutadapt_bwa", "") for i in df.columns}
+    names_dic["Unnamed: 0"] = "gene"
+    df = df.rename(columns=names_dic)
+
+    df = df[df["gene"].isin(sRNAs)]
+    df.index = df["gene"].values
+    relevant_cols = []
+    for condition in experiments:
+        df[condition] = df[[condition + i for i in replicates]].sum(axis=1)
+        relevant_cols.append(condition)
+
+    return df[relevant_cols]
+
+
+def convert_to_percent(df):
+    row_sum = df.sum(axis=1)
+    return df.div(row_sum/100, axis=0)
+
+
+def rename(rna):
+    lst = list(rna)
+    lst[0] = rna[0].upper()
+    return "".join(lst)
+
+
+def get_colors(genes_list, genes_colors_dic):
+    colors = plt.cm.tab20c.colors + plt.cm.tab20b.colors
+    res = []
+    for gene in genes_list:
+        if gene in genes_colors_dic.keys():
+            res.append(genes_colors_dic[gene])
+        else:
+            color = colors[len(genes_colors_dic)]
+            res.append(color)
+            genes_colors_dic[gene] = color
+    return res, genes_colors_dic
+
+
+def chimeras_bar_plot(sRNAs_amount, sRNAs, experiments, replicates, base_path, only_between_chr_chimeras, rna_seq_counts):
+    """
+    Creates bar plots of the percentages of the sRNAs for each condition according to the number of chimers, chimeric fragments,
+    RNAseq reads and RILSeq reads. The 15 sRNAs with the highest percentages are colored, the other are gray.
+    :param sRNAs: a list of the sRNAs names
+    :param only_between_chr_chimeras: if True, create the plot according to the between-chromosome chimeras.
+    """
+    experiments = [i for i in experiments if "wt" not in i]
+    df_chimeras_amount = pd.DataFrame(np.zeros((len(experiments), len(sRNAs))), columns=sRNAs, index=experiments)
+    df_fragments_amount = pd.DataFrame(np.zeros((len(experiments), len(sRNAs))), columns=sRNAs, index=experiments)
+    df_reads_amount_RILseq = pd.DataFrame(np.zeros((len(experiments), len(sRNAs))), columns=sRNAs, index=experiments)
+    counts_table_RILseq = get_counts_table(sRNAs, os.path.join(base_path, "all_counts_table.txt"), experiments, replicates)
+    if rna_seq_counts is not None:
+        df_reads_amount_RNAseq = pd.DataFrame(np.zeros((len(experiments), len(sRNAs))), columns=sRNAs, index=experiments)
+        counts_table_RNAseq = get_counts_table(sRNAs, rna_seq_counts, experiments, replicates)
+    for experiment in experiments:
+        chimeras_df = pd.read_excel(os.path.join(base_path, r"RILseq_unified_results.xlsx"), sheet_name=experiment)
+        if only_between_chr_chimeras:
+            chimeras_df = chimeras_df[chimeras_df["RNA1 chromosome"] != chimeras_df["RNA2 chromosome"]]
+            # chromosomes = list(chr_dic.keys())
+            # chimeras_df = chimeras_df[((chimeras_df["RNA1 chromosome"] == chromosomes[0]) & (chimeras_df["RNA2 chromosome"] == chromosomes[1])) |
+            #                           ((chimeras_df["RNA1 chromosome"] == chromosomes[1]) & (chimeras_df["RNA2 chromosome"] == chromosomes[0]))]
+        for rna in sRNAs:
+            srna_chimeras = chimeras_df[(chimeras_df["RNA1 name"] == rna) | (chimeras_df["RNA2 name"] == rna)]
+            df_chimeras_amount.at[experiment, rna] = srna_chimeras.shape[0]
+            df_fragments_amount.at[experiment, rna] = srna_chimeras["interactions"].sum()
+            df_reads_amount_RILseq.at[experiment, rna] = counts_table_RILseq[experiment][rna]
+            if rna_seq_counts is not None:
+                df_reads_amount_RNAseq.at[experiment, rna] = counts_table_RNAseq[experiment][rna]
+    dic = {"chimeras":df_chimeras_amount, "fragments":df_fragments_amount, "RILseq_reads":df_reads_amount_RILseq}
+    if rna_seq_counts is not None:
+        dic["RNAseq_reads"] = df_reads_amount_RNAseq
+    genes_colors_dic = {"other sRNAs":"gray"}
+    for name, df in dic.items():
+        df = convert_to_percent(df)
+        fig = plt.figure()
+        relevant_sRNAs = find_highest_sRNAs(df, sRNAs_amount)
+        other_sRNAs = [i for i in sRNAs if i not in relevant_sRNAs]
+        df["other sRNAs"] = df[other_sRNAs].sum(axis=1)
+        # df = df.rename(index=experiments_dic)
+        colors, genes_colors_dic = get_colors(relevant_sRNAs + ["other sRNAs"], genes_colors_dic)
+        # if only_between_chr_chimeras and EXPERIMENT == "lambda":
+        #     if name in ("chimeras", "fragments"):
+        #         df = df.loc[["infected 30", "infected 60"]]
+        ax = df[relevant_sRNAs + ["other sRNAs"]].plot.bar(stacked=True, color=colors)
+        handles, labels = ax.get_legend_handles_labels()
+        labels = [rename(i) for i in labels]
+        plt.legend(handles[::-1], labels[::-1], loc='center left', bbox_to_anchor=(1, 0.5))
+        plt.xticks(rotation=0)
+        ax.get_yaxis().set_major_formatter(matplotlib.ticker.FuncFormatter(lambda x, p: format(int(x))))
+        plt.ylabel(f"{name} %")
+        fig_name = f"sRNAs_{name}_percent"
+        if only_between_chr_chimeras:
+            fig_name = f"{fig_name}_only_between_chr_chimeras"
+        plt.savefig(os.path.join(base_path, f"{fig_name}.png"), bbox_inches='tight')
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Create stacked bar plots showing the percentage of sRNAs "
+                "among RIL-seq chimeras, fragments and reads.")
+    parser.add_argument("config", help="Path to the YAML configuration file.")
+    parser.add_argument("sRNAs_number", type=int,
+                        help="Number of the most abundant sRNAs to show individually in the plots. "
+                             "All remaining sRNAs are grouped as 'other sRNAs'.")
+    parser.add_argument("--RNAseq_counts", default=None,
+                        help="Path to an RNA-seq counts table. If provided, an additional graph showing sRNA percentages "
+                             "based on the RNA-seq results will be generated.")
+
+    args = parser.parse_args()
+    config = load_config(args.config)
+    sRNAs = get_RNA_types("sRNA", config["rna_types_excel"])
+    all_genes = get_annotation(config["annotation_path"], separate_id_name=True)["name"].values.tolist()
+    sRNAs = [i for i in sRNAs if i in all_genes]
+    chimeras_bar_plot(args.sRNAs_number, sRNAs, config["experiments"], config["replicates"], config["base_path"], True, args.RNAseq_counts)
+    chimeras_bar_plot(args.sRNAs_number, sRNAs, config["experiments"], config["replicates"], config["base_path"], False, args.RNAseq_counts)
+
+
+
+
+

RILseq_analysis_package/utils.py

@@ -0,0 +1,84 @@
+import pandas as pd
+import yaml
+# from RILseq_analysis_package.defaults import *
+
+
+def load_config(path):
+    with open(path, "r") as f:
+        return yaml.safe_load(f)
+
+
+def get_gene_identifier(gene_id, identifier):
+    """
+    For the given gene_id, returns the value of the given identifier.
+    """
+    split_id = gene_id.split(";")
+    if identifier in gene_id:
+        for i in split_id:
+            if identifier in i:
+                if i.startswith(" "):
+                    return i.split(" ")[2].replace("\"", "")
+                return i.split(" ")[1].replace("\"", "")
+    id_ = split_id[0].split(" ")
+    return id_[1].replace("\"", "")
+
+
+def get_annotation(annotation_path, chromosome=None, separate_id_name=False, identifier=None):
+    """
+    Returns a df of the annotations according to ANNOTATION_FILE.
+    separate_id_name: if True add a column of name, the id column will contain only the id. Use when there are two
+                      identifiers - id and name.
+    identifier: add a column "identifier" which contains the values of the give identifier. Use when there are other
+                identifier (not id and name).
+    """
+    cols_names = ["chr", "EcoCyc", "exon", "start", "end", ".1", "strand", ".2", "id"]
+    df = pd.read_csv(annotation_path, sep="\t", names=cols_names)
+    if chromosome:
+        if type(chromosome) is str:
+            df = df[df["chr"] == chromosome]
+        if type(chromosome) is list:
+            df = df[df["chr"].isin(chromosome)]
+    if separate_id_name:
+        df["name"] = df["id"].apply(lambda x: x.split()[3].replace(";", "").replace("\"", ""))
+        df["id"] = df["id"].apply(lambda x: x.split()[1].replace(";", "").replace("\"", ""))
+    if identifier:
+        df["identifier"] = df["id"].apply(get_gene_identifier, args=(identifier,))
+    return df
+
+
+def get_only_id(gene):
+    return gene.split()[1].replace(";", "").replace("\"", "")
+
+
+def get_only_name(gene):
+    return gene.split()[3].replace(";", "").replace("\"", "")
+
+
+def get_RNA_types(RNA_type, rna_types_excel):
+    RNAs = pd.read_excel(rna_types_excel, sheet_name=RNA_type)
+    RNAs = RNAs["Name"].values.tolist()
+    return RNAs
+
+
+def remove_UTR(df):
+    df["RNA1 name"] = df["RNA1 name"].apply(lambda x: x.split(".EST3UTR")[0].split(".EST5UTR")[0].split(".5UTR")[0].split(".3UTR")[0])
+    df["RNA2 name"] = df["RNA2 name"].apply(lambda x: x.split(".EST3UTR")[0].split(".EST5UTR")[0].split(".5UTR")[0].split(".3UTR")[0])
+    return df
+
+
+def get_gene_chr(gene, annotation_df):
+    return annotation_df["chr"][annotation_df["name"] == gene]
+
+
+def get_E_coli_lambda_experiments(with_wt):
+    res = []
+    for time in ("30", "60"):
+        for experiment in ("Hfq_", "Hfq_lambda_", "wt_lambda_", "wt"):
+            if not with_wt and "wt" in experiment:
+                continue
+            if "wt" in experiment:
+                if time == "60":
+                    continue
+            res.append(experiment + time)
+    return res
+

rilseq_analysis-1.0.0.dist-info/METADATA

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: RILseq_analysis
+Version: 1.0.0
+Requires-Dist: pandas
+Requires-Dist: seaborn
+Requires-Dist: matplotlib
+Requires-Dist: matplotlib-venn
+Requires-Dist: numpy
+Requires-Dist: openpyxl
+Requires-Dist: pyyaml

rilseq_analysis-1.0.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+RILseq_analysis_package/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+RILseq_analysis_package/annotations_graphs.py,sha256=uO48iyR_hqwm-xkam3wt23ZiSHxT3NabukMi8_jUwOQ,8998
+RILseq_analysis_package/chimeras_venn_diagram.py,sha256=KTwIyVsb0Dzak7sMBgn3f58Z1ZJLDW1ysp5Qmh2bLxk,3452
+RILseq_analysis_package/circos_plot.py,sha256=qjfg20us7H5fim50pn4uKGfIPweEvyDQea-I7XknOWA,8220
+RILseq_analysis_package/extract_genes_by_chr.py,sha256=_GOopsdw1xq-NL6UUHryBG5IXrxsIUvh9gShU8Q4IDE,1869
+RILseq_analysis_package/generate_and_edit_RILseq_xslx.py,sha256=EYwfwf0WtU9RrWHdDvj2sd_cNoR3fdn694PniNK6Nwk,7189
+RILseq_analysis_package/sRNAs_percent.py,sha256=I6trQXA-rdgC7k9PMNli3JtOgUQtJkJuuXOmXrYDits,7337
+RILseq_analysis_package/utils.py,sha256=j5Qw1OQgzCqjfiTFzLQ0rp49NNm9XxNfwX1jsXWkKnA,3053
+RILseq_analysis_package/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+RILseq_analysis_package/cli/add_number_of_libraries_cli.py,sha256=nTzdTF1J8Kov3zH7Pdo6phdOjNqc6_gENpkYSPF8V94,673
+RILseq_analysis_package/cli/circos_plot_cli.py,sha256=6678Zzqug4zcgbc7s9WSt-cgPFpWbo13DfvAIVBolPw,2581
+RILseq_analysis_package/cli/merge_results_cli.py,sha256=NxnccfPT7oKj_Z2iR25yxpgdwaHpJ8hwmB7R_zHfyf8,1126
+rilseq_analysis-1.0.0.dist-info/METADATA,sha256=Tq9YOQEl9u-j0aBAiWVDpqiqqIMwIuK7ZU2tzqaWk4o,228
+rilseq_analysis-1.0.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+rilseq_analysis-1.0.0.dist-info/entry_points.txt,sha256=PjXflPsVqyAJ7xhp8typhQhLuXfzrAvwh52VsUXkemA,485
+rilseq_analysis-1.0.0.dist-info/top_level.txt,sha256=jYZHXO5yozHSW56muTG8TMzeRX8A_X-pGmsoicCWuuE,24
+rilseq_analysis-1.0.0.dist-info/RECORD,,

rilseq_analysis-1.0.0.dist-info/WHEEL

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

rilseq_analysis-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,8 @@
+[console_scripts]
+annotations-graphs = RILseq_analysis_package.annotations_graphs:main
+chimeras-venn = RILseq_analysis_package.chimeras_venn_diagram:main
+circos-plot = RILseq_analysis_package.cli.circos_plot_cli:main
+filter-genes = RILseq_analysis_package.extract_genes_by_chr:main
+libraries-num = RILseq_analysis_package.cli.add_number_of_libraries_cli:main
+merge-results = RILseq_analysis_package.cli.merge_results_cli:main
+sRNAs-percent = RILseq_analysis_package.sRNAs_percent:main

rilseq_analysis-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+RILseq_analysis_package