fix

app.py

@@ -148,7 +148,7 @@ if selected_model == 'Cas9':
         # Process predictions
         if predict_button and gene_symbol:
             with st.spinner('Predicting... Please wait'):
-                predictions, gene_sequence, exons  = cas9on.process_gene(gene_symbol, cas9on_path)
+                predictions, gene_sequence, exons = cas9on.process_gene(gene_symbol, cas9on_path)
                 sorted_predictions = sorted(predictions, key=lambda x: x[-1], reverse=True)[:10]
                 st.session_state['on_target_results'] = sorted_predictions
                 st.session_state['gene_sequence'] = gene_sequence  # Save gene sequence in session state

cas12.py

@@ -87,113 +87,126 @@ def fetch_ensembl_sequence(transcript_id):
         print(f"Error fetching sequence data from Ensembl: {response.text}")
         return None
 
-
-def find_crispr_targets(sequence, chr, start, strand, pam="TTTN", target_length=34):
+def find_crispr_targets(sequence, chr, start, strand, transcript_id, exon_id, pam="TTTN", target_length=34):
     targets = []
     len_sequence = len(sequence)
+    complement = {'A': 'T', 'T': 'A', 'C': 'G', 'G': 'C'}
+    dnatorna = {'A': 'A', 'T': 'U', 'C': 'C', 'G': 'G'}
+
+    if strand == -1:
+        sequence = ''.join([complement[base] for base in sequence])
 
     for i in range(len_sequence - target_length + 1):
         target_seq = sequence[i:i + target_length]
         if target_seq[4:7] == 'TTT':
             tar_start = start + i
             tar_end = start + i + target_length
-            gRNA = target_seq[8:28]
-            targets.append([target_seq, gRNA, chr, str(tar_start), str(tar_end), str(strand)])
+            gRNA = ''.join([dnatorna[base] for base in target_seq[8:28]])
+            targets.append([target_seq, gRNA, chr, str(tar_start), str(tar_end), str(strand), transcript_id, exon_id])
     return targets
 
-def format_prediction_output(targets, seq_deepCpf1):
+def format_prediction_output(targets, model_path):
+    # Loading weights for the model
+    Seq_deepCpf1 = Seq_DeepCpf1_model(input_shape=(34, 4))
+    Seq_deepCpf1.load_weights(model_path)
+
     formatted_data = []
     for target in targets:
         # Predict
-        encoded_seq = get_seqcode(target[0])  # 'target' seems to be the full sequence including PAM
-        prediction = seq_deepCpf1.predict(encoded_seq)
+        encoded_seq = get_seqcode(target[0])
+        prediction = float(list(Seq_deepCpf1.predict(encoded_seq)[0])[0])
+        if prediction > 100:
+            prediction = 100
+
         # Format output
-        gRNA = target[1]  # gRNA is presumably the guide RNA sequence
-        chr = target[2]  # Chromosome
-        start = target[3]  # Start position
-        end = target[4]  # End position
-        strand = target[5]  # Strand
-        target_seq = target[0]  # Full target sequence including PAM
-        formatted_data.append([chr, start, end, strand, target_seq, gRNA, prediction[0][0]])
+        gRNA = target[1]
+        chr = target[2]
+        start = target[3]
+        end = target[4]
+        strand = target[5]
+        transcript_id = target[6]
+        exon_id = target[7]
+        formatted_data.append([chr, start, end, strand, transcript_id, exon_id, target[0], gRNA, prediction])
+
     return formatted_data
 
 def process_gene(gene_symbol, model_path):
     transcripts = fetch_ensembl_transcripts(gene_symbol)
-    all_data = []
-    gene_sequence = ''  # Initialize an empty string for the gene sequence
-
-    # Load the model
-    seq_deepCpf1 = Seq_DeepCpf1_model(input_shape=(34, 4))
-    seq_deepCpf1.load_weights(model_path)
-
+    results = []
     if transcripts:
-        for transcript in transcripts:
-            transcript_id = transcript['id']
-            chr = transcript.get('seq_region_name', 'unknown')
-            start = transcript.get('start', 0)
-            strand = transcript.get('strand', 'unknown')
-            # Fetch the sequence here and concatenate if multiple transcripts
-            gene_sequence += fetch_ensembl_sequence(transcript_id) or ''
-
-            if gene_sequence:
-                targets = find_crispr_targets(gene_sequence, chr, start, strand)
-                if targets:
-                    formatted_data = format_prediction_output(targets, seq_deepCpf1)
-                    all_data.extend(formatted_data)
+        for i in range(len(transcripts)):
+            Exons = transcripts[i]['Exon']
+            transcript_id = transcripts[i]['id']
+            for j in range(len(Exons)):
+                exon_id = Exons[j]['id']
+                gene_sequence = fetch_ensembl_sequence(exon_id)
+                if gene_sequence:
+                    start = Exons[j]['start']
+                    strand = Exons[j]['strand']
+                    chr = Exons[j]['seq_region_name']
+                    targets = find_crispr_targets(gene_sequence, chr, start, strand, transcript_id, exon_id)
+                    if targets:
+                        formatted_data = format_prediction_output(targets,
+                                                                  '/content/drive/MyDrive/Colab Notebooks/DeepCpf1/Seq_deepCpf1_weights.h5')
+                        results.append(formatted_data)
+                        # for data in formatted_data:
+                        #    print(f"Chr: {data[0]}, Start: {data[1]}, End: {data[2]}, Strand: {data[3]}, target: {data[4]}, gRNA: {data[5]}, pred_Score: {data[6]}")
+                else:
+                    print("Failed to retrieve gene sequence.")
     else:
         print("Failed to retrieve transcripts.")
 
-    return all_data, gene_sequence
-
-
-def create_genbank_features(formatted_data):
-    features = []
-    for data in formatted_data:
-        try:
-            # Attempt to convert start and end positions to integers
-            start = int(data[1])
-            end = int(data[2])
-        except ValueError as e:
-            # Log the error and skip this iteration if conversion fails
-            print(f"Error converting start/end to int: {data[1]}, {data[2]} - {e}")
-            continue  # Skip this iteration
-
-        # Proceed as normal if conversion is successful
-        strand = 1 if data[3] == '+' else -1
-        location = FeatureLocation(start=start, end=end, strand=strand)
-        feature = SeqFeature(location=location, type="misc_feature", qualifiers={
-            'label': data[5],  # gRNA as label
-            'note': f"Prediction: {data[6]}"  # Prediction score in note
-        })
-        features.append(feature)
-    return features
-
-def generate_genbank_file_from_data(formatted_data, gene_sequence, gene_symbol, output_path):
-    features = create_genbank_features(formatted_data)
-    record = SeqRecord(Seq(gene_sequence), id=gene_symbol, name=gene_symbol,
-                       description='CRISPR Cas12 predicted targets', features=features)
-    record.annotations["molecule_type"] = "DNA"
-    SeqIO.write(record, output_path, "genbank")
-
-def create_csv_from_df(df, output_path):
-    df.to_csv(output_path, index=False)
-
-def generate_bed_file_from_data(formatted_data, output_path):
-    with open(output_path, 'w') as bed_file:
-        for data in formatted_data:
-            try:
-                # Ensure data has the expected number of elements
-                if len(data) < 7:
-                    raise ValueError("Incomplete data item")
-
-                chrom = data[0]
-                start = data[1]
-                end = data[2]
-                strand = '+' if data[3] == '+' else '-'
-                gRNA = data[5]
-                score = data[6]  # Ensure this index exists
-
-                bed_file.write(f"{chrom}\t{start}\t{end}\t{gRNA}\t{score}\t{strand}\n")
-            except ValueError as e:
-                print(f"Skipping an item due to error: {e}")
-                continue
+    return results, gene_sequence, Exons
+
+
+# def create_genbank_features(formatted_data):
+#     features = []
+#     for data in formatted_data:
+#         try:
+#             # Attempt to convert start and end positions to integers
+#             start = int(data[1])
+#             end = int(data[2])
+#         except ValueError as e:
+#             # Log the error and skip this iteration if conversion fails
+#             print(f"Error converting start/end to int: {data[1]}, {data[2]} - {e}")
+#             continue  # Skip this iteration
+#
+#         # Proceed as normal if conversion is successful
+#         strand = 1 if data[3] == '+' else -1
+#         location = FeatureLocation(start=start, end=end, strand=strand)
+#         feature = SeqFeature(location=location, type="misc_feature", qualifiers={
+#             'label': data[5],  # gRNA as label
+#             'note': f"Prediction: {data[6]}"  # Prediction score in note
+#         })
+#         features.append(feature)
+#     return features
+#
+# def generate_genbank_file_from_data(formatted_data, gene_sequence, gene_symbol, output_path):
+#     features = create_genbank_features(formatted_data)
+#     record = SeqRecord(Seq(gene_sequence), id=gene_symbol, name=gene_symbol,
+#                        description='CRISPR Cas12 predicted targets', features=features)
+#     record.annotations["molecule_type"] = "DNA"
+#     SeqIO.write(record, output_path, "genbank")
+#
+# def create_csv_from_df(df, output_path):
+#     df.to_csv(output_path, index=False)
+#
+# def generate_bed_file_from_data(formatted_data, output_path):
+#     with open(output_path, 'w') as bed_file:
+#         for data in formatted_data:
+#             try:
+#                 # Ensure data has the expected number of elements
+#                 if len(data) < 7:
+#                     raise ValueError("Incomplete data item")
+#
+#                 chrom = data[0]
+#                 start = data[1]
+#                 end = data[2]
+#                 strand = '+' if data[3] == '+' else '-'
+#                 gRNA = data[5]
+#                 score = data[6]  # Ensure this index exists
+#
+#                 bed_file.write(f"{chrom}\t{start}\t{end}\t{gRNA}\t{score}\t{strand}\n")
+#             except ValueError as e:
+#                 print(f"Skipping an item due to error: {e}")
+#                 continue

cas9on.py

@@ -115,31 +115,35 @@ def format_prediction_output(targets, model_path):
 def process_gene(gene_symbol, model_path):
     transcripts = fetch_ensembl_transcripts(gene_symbol)
     results = []
+    all_exons = []  # To accumulate all exons
+    all_gene_sequences = []  # To accumulate all gene sequences
+
     if transcripts:
-        for i in range(len(transcripts)):
-            Exons = transcripts[i]['Exon']
-            transcript_id = transcripts[i]['id']
-            for j in range(len(Exons)):
-                exon_id = Exons[j]['id']
+        for transcript in transcripts:
+            Exons = transcript['Exon']
+            all_exons.extend(Exons)  # Add all exons from this transcript to the list
+            transcript_id = transcript['id']
+
+            for exon in Exons:
+                exon_id = exon['id']
                 gene_sequence = fetch_ensembl_sequence(exon_id)
                 if gene_sequence:
-                    start = Exons[j]['start']
-                    strand = Exons[j]['strand']
-                    chr = Exons[j]['seq_region_name']
+                    all_gene_sequences.append(gene_sequence)  # Add this gene sequence to the list
+                    start = exon['start']
+                    strand = exon['strand']
+                    chr = exon['seq_region_name']
                     targets = find_crispr_targets(gene_sequence, chr, start, strand, transcript_id, exon_id)
-                    if not targets:
-                        print("No gRNA sites found in the gene sequence.")
-                    else:
+                    if targets:
                         # Predict on-target efficiency for each gRNA site
-                        formatted_data = format_prediction_output(targets,model_path)
-                        results.append(formatted_data)
-                    # for data in formatted_data:
-                    #    print(f"Chr: {data[0]}, Start: {data[1]}, End: {data[2]}, Strand: {data[3]}, gRNA: {data[4]}, pred_Score: {data[5]}")
+                        formatted_data = format_prediction_output(targets, model_path)
+                        results.extend(formatted_data)
                 else:
-                    print("Failed to retrieve gene sequence.")
+                    print(f"Failed to retrieve gene sequence for exon {exon_id}.")
     else:
         print("Failed to retrieve transcripts.")
-    return results, gene_sequence, Exons
+
+    # Return the sorted output, combined gene sequences, and all exons
+    return results, all_gene_sequences, all_exons
 
 
 # def create_genbank_features(formatted_data):