Upload 4 files

app.py

@@ -0,0 +1,56 @@
+import gradio as gr
+import os
+import pyBigWig
+from func_gradio import predict_func,make_plots
+
+inputs = [
+    gr.Dropdown([str(i) for i in range(1, 23)], label='Chromosome', default='1'),
+    gr.Dropdown(['Micro-C', 'Hi-C (ChIA-PET)']
+                , label='Chromatin contact map', info='One type of contact map is predicted for each time'),
+    gr.Number(label='Region of interest (500kb for Micro-C and 1Mb for Hi-C)', info='From'),
+    gr.Number(info='To', show_label=False),
+    gr.File(label='Processed ATAC-seq file (in .pickle format)'),
+
+]
+
+outputs = [
+    gr.Files(label='Download the results'),
+]
+
+app1 = gr.Interface(
+    fn=predict_func,
+    inputs=inputs,
+    outputs=outputs,
+    title='A computational tool to use ATAC-seq to impute epigenome, transcriptome, and high-resolution chromatin contact maps',
+    description='<a href="https://github.com/zzh24zzh/EPCOT_gradio" class="built-with svelte-1lyswbr" target="_blank" '
+                'style="font-size: 15px; font-color: black; font-weight:bold" rel="noreferrer">'
+                'View Documentation </a>',
+    # examples=[["11","Micro-C","10500000","11000000","./examples/atac_GM12878.pickle"],
+    #     ["11","Hi-C (ChIA-PET)","7750000","8750000","./examples/atac_GM12878.pickle"]]
+)
+
+
+with open(os.path.abspath('data/epigenomes.txt'), 'r') as f:
+    epis=f.read().splitlines()
+inputs1 = [
+    gr.File(label="Prediction file (in .npz format))"),
+    gr.Markdown(value='### Visualization options'),
+    gr.Dropdown(epis,label='Epigenome features',multiselect=True,max_choices=10,value=['CTCF','H3K4me3']),
+    gr.Radio(choices=['Signal p-values (archsinh)','Binding probability'], label='Type of epigenomic feature data'
+             , value='Signal p-values (archsinh)'),
+    gr.Slider(maximum=16,label='Range of values displayed on the plots',info="Choose between 0 and 16 (contact maps)",value=4),
+    gr.Slider(minimum=2,maximum=12,info="Choose between 2 and 12 (epigenomic feature signals)",value=4,show_label=False),
+    gr.Slider(minimum=2,maximum=12,info="Choose between 2 and 12 (CAGE-seq)",value=8,show_label=False),
+]
+outputs1 = gr.Plot(label='Plots')
+app2 = gr.Interface(
+    fn=make_plots,
+    inputs=inputs1,
+    outputs=outputs1,
+    live=True
+)
+
+demo = gr.TabbedInterface([app1, app2], ["Run model", "Visualize prediction results"],
+                          theme=gr.themes.Soft())
+
+demo.launch(debug=True)

func_gradio.py

@@ -0,0 +1,165 @@
+import gradio,psutil
+import numpy as np
+import torch,os,pickle,uuid
+from util import check_region,predict_microc,predict_cage,predict_epis,filetobrowser,predict_hic,predict_epb
+from scipy.sparse import load_npz
+import matplotlib.pyplot as plt
+from matplotlib.gridspec import GridSpec
+import matplotlib
+def predict_func(input_chrom,cop_type, region_start,region_end, atac_seq):
+    device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
+    print(device)
+    if input_chrom == '' or cop_type == '':
+        raise gradio.Error("The prediction options cannot be empty")
+    if atac_seq is None:
+        raise gradio.Error("Must provide an ATAC-seq file!")
+    if not os.path.exists('refSeq/hg38/chr%s.npz'%input_chrom):
+        raise gradio.Error("The reference genome must be downloaded!")
+
+    ref_genome = load_npz('refSeq/hg38/chr%s.npz'%input_chrom).toarray()
+    try:
+        with open(atac_seq.name,'rb') as f:
+            tmp_atac=pickle.load(f)
+        atac_seq = tmp_atac[int(input_chrom)].toarray()
+    except Exception:
+        raise gradio.Error('The ATAC-seq file cannot be read!')
+
+    if cop_type == 'Micro-C':
+        chrom, start, end = check_region(input_chrom, region_start,region_end, ref_genome,500000)
+    else:
+        chrom, start, end = check_region(input_chrom, region_start,region_end, ref_genome,1000000)
+
+
+
+    out_epi_binding = predict_epb(os.path.abspath('models/epi_bind.pt'), [start, end], ref_genome, atac_seq, device,
+                                  cop_type)
+    out_cage = predict_cage(os.path.abspath('models/cage.pt'), [start, end], ref_genome, atac_seq, device, cop_type)
+
+    out_epi = predict_epis(os.path.abspath('models/epi_track.pt'), [start, end], ref_genome, atac_seq, device, cop_type)
+
+    file_id = str(uuid.uuid4())
+
+    if not os.path.exists('results'):
+        os.mkdir('results')
+    else:
+        for f in os.listdir('results/'):
+            os.remove(os.path.join('results/', f))
+
+
+    if cop_type == 'Micro-C':
+        out_cop = predict_microc(os.path.abspath('models/microc.pt'), [start, end], ref_genome, atac_seq, device)
+        np.savez_compressed( 'results/prediction_%s.npz'%file_id,
+                             chrom= input_chrom,start =start+10000,end=end-10000,
+                             epi=out_epi,epb=out_epi_binding, cage=out_cage,cop=out_cop)
+        return ['results/prediction_%s.npz'%file_id,
+                filetobrowser(out_epi,out_cage,out_cop,input_chrom, start+10000,end-10000,file_id)]
+    else:
+        out_cop=predict_hic(os.path.abspath('models/hic.pt'), [start, end], ref_genome, atac_seq, device)
+        np.savez_compressed('results/prediction_%s.npz'%file_id,
+                            chrom=input_chrom, start=start + 20000, end=end - 20000,
+                            epi=out_epi,epb=out_epi_binding, cage=out_cage,cop=out_cop)
+
+        return ['results/prediction_%s.npz'%file_id,
+                filetobrowser(out_epi,out_cage,out_cop,input_chrom, start + 20000, end - 20000,file_id)]
+
+
+def make_plots(in_file,md,epis,epi_type, maxv1, maxv2,maxv3):
+    matplotlib.use("Agg")
+    # matplotlib.pyplot.switch_backend('Agg')
+    if in_file is None:
+        raise gradio.Error('Must upload a prediction file!')
+    try:
+        prediction = np.load(in_file.name)
+    except Exception:
+        raise gradio.Error('The prediction file cannot be read!')
+    maxv1,maxv2,maxv3=float(maxv1),float(maxv2),float(maxv3)
+    with open(os.path.abspath('data/epigenomes.txt'), 'r') as f:
+        epigenomes = f.read().splitlines()
+
+    bins = prediction['cop'].shape[-1]
+    if epis=='':
+        raise gradio.Error("No epigenomic feature is selected")
+    num_mod = len(epis) + 1
+    epi_idx=np.array([epigenomes.index(epi) for epi in epis])
+
+
+    # plt.rcParams['font.sans-serif'] = 'Arial'
+    # plt.rcParams['font.family'] = 'sans-serif'
+    plt.rcParams['font.size'] = 14
+
+    if bins==480:
+        fig = plt.figure(figsize=(9, num_mod + 4))
+        gs = GridSpec(num_mod+4, 9)
+        ax_map = [fig.add_subplot(gs[:4, :8])]
+        axc=fig.add_subplot(gs[:4, 8:])
+        axc.axis('off')
+        axs = [fig.add_subplot(gs[4+i, :8]) for i in range(num_mod)]
+    else:
+        fig = plt.figure(figsize=(9, num_mod+12))
+        gs = GridSpec(num_mod + 12, 9)
+        ax_map = [fig.add_subplot(gs[4*i:4*i+4, :8]) for i in range(4)]
+        axc = fig.add_subplot(gs[:8, 8:])
+        axc.axis('off')
+        axc1 = fig.add_subplot(gs[8:12, 8:])
+        axc1.axis('off')
+        axs = [fig.add_subplot(gs[12 + i, :8]) for i in range(num_mod)]
+
+    if bins == 480:
+        bin_coords = np.true_divide(np.arange(bins), np.sqrt(2))
+        x, y = np.meshgrid(bin_coords, bin_coords)
+        sin45 = np.sin(np.radians(45))
+        x, y = x * sin45 + y * sin45, x * sin45 - y * sin45
+        m=ax_map[0].pcolormesh(x, y, prediction['cop'], cmap='RdBu_r', vmin=0, vmax=maxv1)
+
+        cbar=fig.colorbar(m,ax=axc,aspect=20,fraction=1)
+    else:
+        bin_coords = np.true_divide(np.arange(bins), np.sqrt(2))
+        x, y = np.meshgrid(bin_coords, bin_coords)
+        sin45 = np.sin(np.radians(45))
+        x, y = x * sin45 + y * sin45, x * sin45 - y * sin45
+        m = [ax_map[i].pcolormesh(x, y, prediction['cop'][i], cmap='RdBu_r', vmin=0, vmax=maxv1) for i in range(3)]
+        cbar = fig.colorbar(m[0], ax=axc, aspect=30, fraction=1,shrink=0.85)
+        cbar.set_label('log2(x)+1')
+        cbar1 = fig.colorbar(m[2], ax=axc1, aspect=15, fraction=1,shrink=0.85)
+        types=['CTCF ChIA-PET','POLR2 ChIA-PET','Hi-C']
+        for i in range(3):
+            ax_map[i].text(2, bins//2.5, types[i],va='top',fontsize=18,color='r')
+
+
+    for i in range(len(ax_map)):
+        ax_map[i].set_yticks([])
+        ax_map[i].set_ylim(0, bins//2)
+        ax_map[i].spines['left'].set_visible(False)
+
+    for axm in axs+ax_map:
+        axm.set_xticks([])
+        axm.margins(x=0)
+        axm.spines['top'].set_visible(False)
+        axm.spines['right'].set_visible(False)
+        axm.spines['bottom'].set_visible(False)
+    for i in range(num_mod-1):
+        if epi_type=='Signal p-values (archsinh)':
+            axs[i].fill_between(np.arange(prediction['epi'].shape[0]), 0, prediction['epi'][:,epi_idx[i]])
+            axs[i].set_ylim(0, maxv2)
+            axs[i].text(2, maxv2, epis[i],va='top')
+        else:
+            axs[i].fill_between(np.arange(prediction['epb'].shape[0]), 0, prediction['epb'][:, epi_idx[i]])
+            axs[i].set_ylim(0, 1)
+            axs[i].text(2, 1, epis[i], va='top')
+
+    start=int(prediction['start'])
+    chrom=int(prediction['chrom'])
+    end= int(prediction['end'])
+    seq_inter=1000 if bins==480 else 5000
+    axs[-1].fill_between(np.arange(prediction['cage'].shape[0]), 0, prediction['cage'])
+    axs[-1].set_ylim(0, maxv3)
+    axs[-1].text(2, maxv3, 'CAGE',va='top')
+    axs[-1].set_xticks([i*prediction['cage'].shape[0]//4 for i in range(5)])
+    axs[-1].set_xticklabels([start+i*bins*seq_inter//4 for i in range(5)])
+
+    axs[-1].set_xlabel('chr%s:%s-%s'%(chrom,start,end))
+    plt.show()
+    return fig
+
+
+

requirements.txt

@@ -0,0 +1,11 @@
+numpy
+psutil
+pyBigWig==0.3.17
+scipy==1.9.1
+torch==1.10.1
+einops==0.3.2
+gradio==3.24.1
+gdown==4.7.1
+deepTools==3.5.1
+torchvision==0.11.2
+matplotlib==3.5.3

util.py

@@ -0,0 +1,318 @@
+import argparse
+import numpy as np
+import pyBigWig,os
+from zipfile import ZipFile
+import zipfile
+import shutil
+import torch
+from pretrain.model import build_epd_model
+from pretrain.track.model import build_track_model
+from cage.model import build_cage_model
+from cop.micro_model import build_microc_model
+from cop.hic_model import build_hic_model
+from einops import rearrange
+import gradio
+
+
+
+
+def parser_args():
+    """
+    Hyperparameters for the pre-training model
+    """
+    # add_help = False
+    parser = argparse.ArgumentParser(add_help = False)
+    parser.add_argument('--num_class', default=245, type=int,help='the number of epigenomic features to be predicted')
+    parser.add_argument('--seq_length', default=1600, type=int,help='the length of input sequences')
+    parser.add_argument('--nheads', default=4, type=int)
+    parser.add_argument('--hidden_dim', default=512, type=int)
+    parser.add_argument('--dim_feedforward', default=1024, type=int)
+    parser.add_argument('--enc_layers', default=1, type=int)
+    parser.add_argument('--dec_layers', default=2, type=int)
+    parser.add_argument('--dropout', default=0.2, type=float)
+    args, unknown = parser.parse_known_args()
+    return args,parser
+def get_args():
+    args,_ = parser_args()
+    return args,_
+
+def parser_args_epi(parent_parser):
+    """
+    Hyperparameters for the downstream model to predict 1kb-resolution CAGE-seq
+    """
+    parser=argparse.ArgumentParser(parents=[parent_parser],add_help = False)
+    parser.add_argument('--bins', type=int, default=500)
+    parser.add_argument('--crop', type=int, default=10)
+    parser.add_argument('--embed_dim', default=768, type=int)
+    parser.add_argument('--return_embed', default=False, action='store_true')
+    args, unknown = parser.parse_known_args()
+    return args
+
+def parser_args_cage(parent_parser):
+    """
+    Hyperparameters for the downstream model to predict 1kb-resolution CAGE-seq
+    """
+    parser=argparse.ArgumentParser(parents=[parent_parser],add_help = False)
+    parser.add_argument('--bins', type=int, default=500)
+    parser.add_argument('--crop', type=int, default=10)
+    parser.add_argument('--embed_dim', default=768, type=int)
+    parser.add_argument('--return_embed', default=True, action='store_false')
+    args, unknown = parser.parse_known_args()
+    return args
+
+def parser_args_hic(parent_parser):
+    """
+    Hyperparameters for the downstream model to predict 5kb-resolution Hi-C and ChIA-PET
+    """
+    parser=argparse.ArgumentParser(parents=[parent_parser],add_help = False)
+    parser.add_argument('--bins', type=int, default=200)
+    parser.add_argument('--crop', type=int, default=4)
+    parser.add_argument('--embed_dim', default=256, type=int)
+    args, unknown = parser.parse_known_args()
+    return args
+
+def parser_args_microc(parent_parser):
+    """
+    Hyperparameters for the downstream model to predict 1kb-resolution Micro-C
+    """
+    parser=argparse.ArgumentParser(parents=[parent_parser],add_help = False)
+    parser.add_argument('--bins', type=int, default=500)
+    parser.add_argument('--crop', type=int, default=10)
+    parser.add_argument('--embed_dim', default=768, type=int)
+    parser.add_argument('--return_embed', default=True, action='store_false')
+    args, unknown = parser.parse_known_args()
+    return args
+
+
+
+
+def check_region(chrom,start,end,ref_genome,region_len):
+    start,end=int(start),int(end)
+    if end-start != region_len:
+        if region_len==500000:
+            raise gradio.Error("Please enter a 500kb region!")
+        else:
+            raise gradio.Error("Please enter a 1Mb region!")
+    if start<300 or end > ref_genome.shape[1]-300:
+        raise gradio.Error("The start of input region should be greater than 300 and "
+                         "the end of the region should be less than %s!"%(ref_genome.shape[1]-300))
+    return int(chrom),start,end
+
+def generate_input(start,end,ref_genome,atac_seq):
+    # inputs=[]
+    pad_left=np.expand_dims(np.vstack((ref_genome[:,start-300:start],atac_seq[:,start-300:start])),0)
+    pad_right=np.expand_dims(np.vstack((ref_genome[:,end:end+300],atac_seq[:,end:end+300])),0)
+    center=np.vstack((ref_genome[:,start:end],atac_seq[:,start:end]))
+    center=rearrange(center,'n (b l)-> b n l',l=1000)
+    dmatrix = np.concatenate((pad_left, center[:, :, -300:]), axis=0)[:-1, :, :]
+    umatrix = np.concatenate((center[:, :, :300], pad_right), axis=0)[1:, :, :]
+    return np.concatenate((dmatrix, center, umatrix), axis=2)
+
+
+def search_tf(tf):
+    with open('data/epigenomes.txt', 'r') as f:
+        epigenomes = f.read().splitlines()
+    tf_idx= epigenomes.index(tf)
+    return tf_idx
+
+
+
+def predict_epb(
+        model_path,
+        region, ref_genome,atac_seq,
+        device,
+        cop_type
+):
+    args, parser = get_args()
+
+    pretrain_model = build_epd_model(args)
+    pretrain_model.load_state_dict(torch.load(model_path,map_location=torch.device(device)))
+    pretrain_model.eval()
+    pretrain_model.to(device)
+    start,end=region
+    inputs=generate_input(start,end,ref_genome,atac_seq)
+    inputs=torch.tensor(inputs).float().to(device)
+    with torch.no_grad():
+        pred_epi=torch.sigmoid(pretrain_model(inputs)).detach().cpu().numpy()
+    if cop_type == 'Micro-C':
+        return pred_epi[10:-10,:]
+    else:
+        return pred_epi[20:-20,:]
+
+
+def predict_epis(
+        model_path,
+        region, ref_genome,atac_seq,
+        device,
+        cop_type
+):
+    args, parser = get_args()
+    epi_args = parser_args_epi(parser)
+    pretrain_model = build_track_model(epi_args)
+    pretrain_model.load_state_dict(torch.load(model_path,map_location=torch.device(device)))
+    pretrain_model.eval()
+    pretrain_model.to(device)
+    inputs=[]
+    start,end=region
+    if cop_type == 'Micro-C':
+        inputs.append(generate_input(start,end,ref_genome,atac_seq))
+    else:
+        for loc in range(start+20000,end-20000,480000):
+            inputs.append(generate_input(loc-10000,loc+490000,ref_genome,atac_seq))
+    inputs=np.stack(inputs)
+    inputs=torch.tensor(inputs).float().to(device)
+    pred_epi=[]
+    with torch.no_grad():
+        for i in range(inputs.shape[0]):
+            pred_epi.append(pretrain_model(inputs[i:i+1]).detach().cpu().numpy())
+
+    out_epi = rearrange(np.vstack(pred_epi), 'i j k -> (i j) k')
+    return out_epi
+
+def predict_cage(
+        model_path,
+        region, ref_genome, atac_seq,
+        device,
+        cop_type
+):
+    args, parser = get_args()
+    cage_args = parser_args_cage(parser)
+    cage_model=build_cage_model(cage_args)
+    cage_model.load_state_dict(torch.load(model_path,map_location=torch.device(device)))
+    cage_model.eval()
+    cage_model.to(device)
+    inputs = []
+    start, end = region
+    if cop_type == 'Micro-C':
+        inputs.append(generate_input(start, end, ref_genome, atac_seq))
+    else:
+        for loc in range(start + 20000, end - 20000, 480000):
+            inputs.append(generate_input(loc - 10000, loc + 490000, ref_genome, atac_seq))
+    inputs = np.stack(inputs)
+    inputs = torch.tensor(inputs).float().to(device)
+    pred_cage = []
+    with torch.no_grad():
+        for i in range(inputs.shape[0]):
+            pred_cage.append(cage_model(inputs[i:i + 1]).detach().cpu().numpy().squeeze())
+    return np.concatenate(pred_cage)
+
+def arraytouptri(arrays,args):
+    effective_lens=args.bins-2*args.crop
+    triu_tup = np.triu_indices(effective_lens)
+    temp=np.zeros((effective_lens,effective_lens))
+    temp[triu_tup]=arrays
+    return temp
+def complete_mat(mat):
+    temp = mat.copy()
+    np.fill_diagonal(temp,0)
+    mat= mat+temp.T
+    return mat
+
+
+def predict_hic(
+        model_path,
+        region, ref_genome,atac_seq,
+        device
+):
+    args, parser = get_args()
+    hic_args = parser_args_hic(parser)
+    hic_model = build_hic_model(hic_args)
+    hic_model.load_state_dict(torch.load(model_path,map_location=torch.device(device)))
+    hic_model.eval()
+    hic_model.to(device)
+    start,end=region
+    inputs=np.stack([generate_input(start,end,ref_genome,atac_seq)])
+    inputs=torch.tensor(inputs).float().to(device)
+    with torch.no_grad():
+        temp=hic_model(inputs).detach().cpu().numpy().squeeze()
+    return np.stack([complete_mat(arraytouptri(temp[:,i], hic_args)) for i in range(temp.shape[-1])])
+
+
+def predict_microc(
+        model_path,
+        region, ref_genome,atac_seq,
+        device
+):
+    args, parser = get_args()
+    microc_args = parser_args_microc(parser)
+    microc_model = build_microc_model(microc_args)
+    microc_model.load_state_dict(torch.load(model_path,map_location=torch.device(device)))
+    microc_model.eval()
+    microc_model.to(device)
+    start,end=region
+    inputs=np.stack([generate_input(start,end,ref_genome,atac_seq)])
+    inputs=torch.tensor(inputs).float().to(device)
+    with torch.no_grad():
+        temp=microc_model(inputs).detach().cpu().numpy().squeeze()
+    return complete_mat(arraytouptri(temp, microc_args))
+
+
+def filetobrowser(out_epis,out_cages,out_cop,chrom,start,end,file_id):
+    with open('data/epigenomes.txt', 'r') as f:
+        epigenomes = f.read().splitlines()
+
+    files_to_zip = file_id
+    if os.path.exists(files_to_zip):
+        shutil.rmtree(files_to_zip)
+    os.mkdir(files_to_zip)
+
+    hdr=[]
+    with open('data/chrom_size_hg38.txt', 'r') as f:
+        for line in f:
+            tmp=line.strip().split('\t')
+            hdr.append((tmp[0],int(tmp[1])))
+
+
+    for i in range(out_epis.shape[1]):
+        bwfile = pyBigWig.open(os.path.join(files_to_zip,"%s.bigWig"%epigenomes[i]), 'w')
+        bwfile.addHeader(hdr)
+        bwfile.addEntries(['chr' + str(chrom)]*out_epis.shape[0],[loc for loc in range(start,end,1000)],
+                          ends=[loc+1000 for loc in range(start,end,1000)],values=out_epis[:,i].tolist())
+        bwfile.close()
+    bwfile = pyBigWig.open(os.path.join(files_to_zip,"cage.bigWig"),'w')
+    bwfile.addHeader(hdr)
+
+    bwfile.addEntries(['chr' + str(chrom)] * out_cages.shape[0], [loc for loc in range(start, end, 1000)],
+                      ends=[loc + 1000 for loc in range(start, end, 1000)], values=out_cages.tolist())
+    bwfile.close()
+    cop_lines=[]
+
+    interval=1000 if out_cop.shape[-1]==480 else 5000
+    if out_cop.shape[-1]==480:
+        for bin1 in range(out_cop.shape[-1]):
+            for bin2 in range(bin1,out_cop.shape[-1],1):
+                # tmp=['chr' + str(chrom),str(start+bin1*interval),str(start+(bin1+1)*interval),'chr' + str(chrom),
+                #                   str(start + bin2 * interval), str(start + (bin2 + 1) * interval),'.',str(np.around(out_cop[bin1,bin2],2)),'.','.'
+                #      ]
+                tmp = ['0', 'chr' + str(chrom), str(start + bin1 * interval), '0', '0', 'chr' + str(chrom),
+                       str(start + bin2 * interval), '1', str(np.around(out_cop[bin1, bin2], 2))]
+                cop_lines.append('\t'.join(tmp)+'\n')
+        with open(os.path.join(files_to_zip,"microc.bedpe"),'w') as f:
+            f.writelines(cop_lines)
+    else:
+        types=['CTCF_ChIA-PET','POLR2_ChIA-PET','Hi-C']
+        for i in range(len(types)):
+            for bin1 in range(out_cop.shape[-1]):
+                for bin2 in range(bin1, out_cop.shape[-1], 1):
+                    tmp=['0','chr' + str(chrom), str(start + bin1 * interval),'0','0','chr' +str(chrom),str(start + bin2 * interval),'1',str(np.around(out_cop[i,bin1, bin2], 2))]
+                    cop_lines.append('\t'.join(tmp) + '\n')
+            with open(os.path.join(files_to_zip,"%s.bedpe"%types[i]), 'w') as f:
+                f.writelines(cop_lines)
+
+    out_zipfile = ZipFile("results/formatted_%s.zip" % file_id, "w", zipfile.ZIP_DEFLATED)
+    for file_to_zip in os.listdir(files_to_zip):
+        file_to_zip_full_path = os.path.join(files_to_zip, file_to_zip)
+        out_zipfile.write(filename=file_to_zip_full_path, arcname=file_to_zip)
+
+    out_zipfile.close()
+    shutil.rmtree(files_to_zip)
+    return "results/formatted_%s.zip"%file_id
+
+
+
+
+
+
+
+
+