<jupyter_start><jupyter_text>Design of optimised PgRNA  GC Content<jupyter_code># Checking all the criteria for gRNA design
# GC content > 30% and <70%

# Defining a function
# GC content (or Guanine-Cytosine content)
def gc_content(genome):
    g_content = genome.count("G")
    c_content = genome.count("C")
    a_content = genome.count("A")
    t_content = genome.count("T")
    return 100*((g_content+c_content)/(a_content+c_content+g_content+t_content))<jupyter_output><empty_output><jupyter_text>CFD Scoring part<jupyter_code># df_mismatch = pd.read_csv("Mismatch_Scores.csv")
# df_mismatch_scores = df_mismatch.set_index('Pair')
# df_mismatch_scores
with open('mismatch_score.pkl', "rb") as f:
    lines = [line.rstrip(b"\r\n") for line in f.readlines()]
    mm_scores = pickle.loads(b"\n".join(lines))<jupyter_output><empty_output><jupyter_text>Reading the PAM scores from the pickle file<jupyter_code>with open('pam_scores.pkl', "rb") as f:
    lines = [line.rstrip(b"\r\n") for line in f.readlines()]
    pam_scores = pickle.loads(b"\n".join(lines))
print(pam_scores)
#Reverse complements a given string
def revcom(s):
    basecomp = {'A': 'T', 'C': 'G', 'G': 'C', 'T': 'A','U':'A'}
    letters = list(s[::-1])
    letters = [basecomp[base] for base in letters]
    return ''.join(letters)
#Calculates CFD score
def calc_cfd(wt,sg,pam):
    #mm_scores,pam_scores = get_mm_pam_scores()
    score = 1
    sg = sg.replace('T','U')
    wt = wt.replace('T','U')
    #print ("sg:", sg)
    #print ("DNA", wt)
    s_list = list(sg)
    #print("s_list",s_list)
    wt_list = list(wt)
    #print("wt_list",wt_list)
    for i,sl in enumerate(s_list):
        if wt_list[i] == sl:
            score*=1
        else:
            key = 'r'+wt_list[i]+':d'+revcom(sl)+','+str(i+1)
            #print(key)
            score*= mm_scores[key]
    score*=pam_scores[pam]
    return (score)<jupyter_output><empty_output><jupyter_text>Final Function to calculate the cfd score of Cas9 given two input sequence, polyvalent gRNA (20mer +PAM) and Spacer gDNA (20mer +PAM)<jupyter_code># a is the Spacer gDNA/RNA and b is the pgDNA
def Cal_Mismatch_Score(a,b):
    #wt = a[:-3] 
    wt = a
    off = b
    #sg = off[:-3]
    sg = b
    #pam = off[-2:] # Assuming pam as NGG
    pam = 'GG'
    score = calc_cfd(wt,sg,pam)
    return (score)
Cal_Mismatch_Score('GGGAAAAAAAAAAAAAAAAAA','AAAAAAAAAAAAAAAAAAAAA')
Cal_Mismatch_Score('CAGTACAGTAGTGGAAGTGG','CAGTACAGTGGTGGAAGTGG')
Cal_Mismatch_Score('CAGTACAGTAGTGGAAGTGG','CAGTACAGTAGTGGAAGTGG')
len('ATTAGCAGAACTACACACCA')<jupyter_output><empty_output><jupyter_text>Design of optimised PgRNA based on target activity at A and B greater than minimum of both columns Spacer A and B<jupyter_code>## Design of optimised PgRNA Based on target activity at target A and B both > 0.75
l = len(df_pairs)
crRNA_list = []
Guide_score = []
Guide_scoreA = []
Guide_scoreB = []
for i in range(l):
    s1 = df_pairs["Guide A"][i]
    t1 = s1# storing as t1 because we are changing the s1 for the design of pgRNAs
    s2 = df_pairs["Guide B"][i]
    t2 = s2# storing as t2 because we are changing the s2 for the design of pgRNAs
    s1_score = df_pairs["Guide A Score"][i]
    s2_score = df_pairs["Guide B Score"][i]

    mismatch = dif(s1, s2)
    MMn = len(mismatch)
    #print(MMn)
    Com_MMn = ((4**MMn))
    BaseSwap_list = []
    for n in range(Com_MMn):
        #print(n)
        BaseSwap = Dec2base4(n);
        #print(BaseSwap);
        #print(type(BaseSwap))
        BaseSwap_list.append(BaseSwap)
        
    for val in BaseSwap_list:
        if(len(val) < MMn):
            zero_padding = MMn - len(val)
            listofzeros = [0]*zero_padding
            for n in listofzeros:
                val.insert(0, n)
            #print(val)
    #print("For Mismatch", MMn,"The list of replacer", BaseSwap_list)
    
    
    for pair in BaseSwap_list:
        l = len(pair)
        for j in range(l):
            if (pair[j] == 0):
                pair[j] = "A"
            elif (pair[j] == 1):
                pair[j] = "C"
            elif (pair[j] == 2):
                pair[j] = "G"
            elif (pair[j] == 3):
                pair[j] = "T"
        #print(pair)
        
    crRNA_list_1 = []
    for replacer in BaseSwap_list:
        i = 0
        for val in mismatch:
            #print(replacer[i])
            list1 = list(s1)
            list1[val] = replacer[i]
            i = i+1
            s1 = ''.join(list1)

        #print(s1)
        crRNA_list_1.append(s1)
        
        
    ## Checking the GC content of crRNA in CrRNA_list
    
    crRNA_list_1_corrected1 = []
    for i in range(len(crRNA_list_1)):
        gc_value = gc_content(crRNA_list_1[i])
        #print(gc_value)
        if (gc_value >30) and (gc_value < 70 ):
            #print(gc_value)
            crRNA_list_1_corrected1.append(crRNA_list_1[i])
            #print(crRNA_list_1_corrected1)
            
            
    crRNA_list_1_corrected2 = []        
    # Criteria 2
    # To avoid repeats (≥4 consecutive ‘rU’ or ≥5 consecutive ‘rG’, ‘rC’, or ‘rA)
    l1 = len(crRNA_list_1_corrected1)
    for i in range(l1):
        U_repeat = crRNA_list_1_corrected1[i].find('UUUU')
        G_repeat = crRNA_list_1_corrected1[i].find('GGGGG')
        C_repeat = crRNA_list_1_corrected1[i].find('CCCCC')
        A_repeat = crRNA_list_1_corrected1[i].find('AAAAA')
        if (U_repeat==-1) and (G_repeat==-1) and (C_repeat==-1) and (A_repeat==-1):
            crRNA_list_1_corrected2.append(crRNA_list_1_corrected1[i])
    #print(crRNA_list_1_corrected2)
            
    #Checking the cfd cores
    Activity1 = min(df_pairs['Guide A Score'])  
    Activity2 = min(df_pairs['Guide B Score']) 
    crRNA_list_1_corrected3 = []
    Activity_guide = []
    Activity_guideA = []
    Activity_guideB = []
    for i in range(len(crRNA_list_1_corrected2)):
        mismatch_scoreA = Cal_Mismatch_Score(t1, crRNA_list_1_corrected2[i])
        #print(mismatch_scoreA)
        Activity_scoreA  = s1_score* mismatch_scoreA
        mismatch_scoreB = Cal_Mismatch_Score(t2, crRNA_list_1_corrected2[i])
        #print(mismatch_scoreA)
        Activity_scoreB  = s2_score* mismatch_scoreB
        
        Activity_guide_avg = (Activity_scoreA+Activity_scoreB)/2 # Taking the average of activity of Guide at target A and B
        
        if ( Activity_scoreA > Activity1) and (Activity_scoreB > Activity2):
            #print(mismatch_scoreA)
            #print(mismatch_scoreA)
            crRNA_list_1_corrected3.append(crRNA_list_1_corrected2[i])
            Activity_guide.append(Activity_guide_avg)
            Activity_guideA.append(Activity_scoreA)
            Activity_guideB.append(Activity_scoreB)
    #print(crRNA_list_1_corrected3)
            
    ## Appending to final design RNA list
    d2 = {'Guide A' : t1, 'Guide B' : t2, 'Mismatch' : MMn , 'pgRNA List' :crRNA_list_1_corrected3 }
    crRNA_list.append(d2)
    ## Appending the guide scores
    Guide_score.append(Activity_guide)
    Guide_scoreA.append(Activity_guideA)
    Guide_scoreB.append(Activity_guideB)
    
    
df_crRNA = pd.DataFrame(crRNA_list)
df_crRNA
x = 0
for i in range(len(df_crRNA)):
    #print(len(df_crRNA['pgRNA List'][i]))
    x = x + len(df_crRNA['pgRNA List'][i])
print(x)
# Use list comprehension to convert the nested lists and get a full list of pgRNAs Activity Score
Guide_score_list = [ item for elem in Guide_score for item in elem]
len(Guide_score_list)
# Use list comprehension to convert the nested lists and get a full list of pgRNAs Activity Score at Target A
Guide_scoreA_list = [ item for elem in Guide_scoreA for item in elem]
len(Guide_scoreA_list)
# Use list comprehension to convert the nested lists and get a full list of pgRNAs Activity Score at Target A
Guide_scoreB_list = [ item for elem in Guide_scoreB for item in elem]
len(Guide_scoreB_list)
#df_pairs["Guide A"] == df_crRNA["Guide A"]
df_crRNA1 = df_crRNA
df_crRNA1['GuideA Position'] = df_pairs['GuideA Position']
df_crRNA1['Guide A Score'] = df_pairs['Guide A Score']
df_crRNA1['GuideB Position'] = df_pairs['GuideB Position']
df_crRNA1['Guide B Score'] = df_pairs['Guide B Score']
df_crRNA1 = df_crRNA1.rename(columns={"Guide A": "GuideA", "Guide B": "GuideB", "GuideA Position": "GuideAPosition", "GuideB Position": "GuideBPosition", "Guide A Score": "GuideAScore", "Guide B Score": "GuideBScore", "pgRNA List": "pgRNA"})
df_crRNA1
df1 = df_crRNA1[['GuideA', 'pgRNA']].copy()
GuideAs = []
pgRNAs = []
for _, row in df1.iterrows():
    GuideA = row.GuideA
    
    for val in row.pgRNA:
        GuideAs.append(GuideA)
        pgRNAs.append(val)
df2 = pd.DataFrame({"GuideA": GuideAs,
    "pgRNA": pgRNAs
})
df2
df1 = df_crRNA1[['GuideB', 'pgRNA']].copy()
GuideBs = []
pgRNAs = []
for _, row in df1.iterrows():
    GuideB = row.GuideB
    
    for val in row.pgRNA:
        GuideBs.append(GuideB)
        pgRNAs.append(val)
df2 = pd.DataFrame({"GuideB": GuideBs,
    "pgRNA": pgRNAs
})
df2
df1 = df_crRNA1[['GuideAPosition', 'pgRNA']].copy()
GuideAPositions = []
pgRNAs = []
for _, row in df1.iterrows():
    GuideAPosition = row.GuideAPosition
    
    for val in row.pgRNA:
        GuideAPositions.append(GuideAPosition)
        pgRNAs.append(val)
df2 = pd.DataFrame({"GuideAPosition": GuideAPositions,
    "pgRNA": pgRNAs
})
df2
df1 = df_crRNA1[['GuideBPosition', 'pgRNA']].copy()
GuideBPositions = []
pgRNAs = []
for _, row in df1.iterrows():
    GuideBPosition = row.GuideBPosition
    
    for val in row.pgRNA:
        GuideBPositions.append(GuideBPosition)
        pgRNAs.append(val)
df2 = pd.DataFrame({"GuideBPosition": GuideBPositions,
    "pgRNA": pgRNAs
})
df2
df1 = df_crRNA1[['GuideAScore', 'pgRNA']].copy()
GuideAScores = []
pgRNAs = []
for _, row in df1.iterrows():
    GuideAScore = row.GuideAScore
    
    for val in row.pgRNA:
        GuideAScores.append(GuideAScore)
        pgRNAs.append(val)
df2 = pd.DataFrame({"GuideAScore": GuideAScores,
    "pgRNA": pgRNAs
})
df2
df1 = df_crRNA1[['GuideBScore', 'pgRNA']].copy()
GuideBScores = []
pgRNAs = []
for _, row in df1.iterrows():
    GuideBScore = row.GuideBScore
    
    for val in row.pgRNA:
        GuideBScores.append(GuideBScore)
        pgRNAs.append(val)
df_crRNA_expanded = pd.DataFrame({"GuideA": GuideAs, "GuideB": GuideBs,
    "pgRNA": pgRNAs
})
df_crRNA_expanded
df_crRNA_expanded["GuideScore"] = Guide_score_list
df_crRNA_expanded["GuideScore_At_TargetA"] = Guide_scoreA_list
df_crRNA_expanded["GuideScore_At_TargetB"] = Guide_scoreB_list
df_crRNA_expanded["GuideAScore"] = GuideAScores
df_crRNA_expanded["GuideBScore"] = GuideBScores
df_crRNA_expanded["GuideAPosition"] = GuideAPositions
df_crRNA_expanded["GuideBPosition"] = GuideBPositions

# deleting df_crRNA1 dataframe
del df_crRNA1
df_crRNA1 = df_crRNA_expanded
### Adding a column for the GC content
GC_content_list = df_crRNA1["pgRNA"].apply(gc_content)
df_crRNA1["GC_content%"] = GC_content_list
df_crRNA1<jupyter_output><empty_output><jupyter_text>Doing Multiple sequences call in RNAfold<jupyter_code># Initializing list  
list1 = df_crRNA1['pgRNA'].values.tolist()
  
len(list1)
# Criteria 3
# Min Free energy of pgRNA > -5
list3 = []
for val in list1:
    crRNA_combined = val
    list3.append(crRNA_combined)
# Converting the list3 to a text file
with open('crRNA_combined.txt', 'w') as f:
    for item in list3:
        f.write("%s\n" % item)
# Converting the text file to a fasta file

fileInput = open("crRNA_combined.txt", "r")
fileOutput = open("out_crRNA_combined.fsa", "w")
#Seq count
count = 1 ;

#Loop through each line in the input file
print("Converting to FASTA...")
for strLine in fileInput:

    #Strip the endline character from each input line
    strLine = strLine.rstrip("\n")

    #Output the header
    fileOutput.write(">" + str(count) + "\n")
    fileOutput.write(strLine + "\n")

    count = count + 1
print ("Done.")

#Close the input and output file
fileInput.close()
fileOutput.close()
### Function to calculate the Minimum Free energy 
def cal_Min_Eng(x):
    s = x.split("\n")[0]
    s_negative = s.find("-")
    numeric_filter = filter(str.isdigit, s)
    numeric_string = "".join(numeric_filter)
    l = list(numeric_string)
    length_l = len(l)
    l.insert(length_l-2, ".")
    Mng = ''.join(l)
    Mng = float(Mng)
    if (s_negative == -1):
        Mng = Mng
    else:
        Mng = -Mng
        
    return Mng
### Function to calculate the Secondary Structure Using RNAFold Software
def cal_Structure(s):
    s1 = s.split(" ")
    Structure = s1[0]
    return Structure
command1 = "RNAfold < out_crRNA_combined.fsa >> energyoutput.txt"
subprocess.call(command1, shell=True) 
command2 = "del *_ss.ps"
subprocess.call(command2, shell=True) 
f=open("energyoutput.txt", "r")
contents =f.readlines()
l = len(contents)
sequence_count = []
energy_count = []
for i in range(l):
    For_Query = contents[i].find(">")
    #print(For_Query)
    if (For_Query == 0):
        sequence_count.append(contents[i+1])
        energy_count.append(contents[i+2])
        
f.close()
energy_list = []
Structure_list = []
for val in energy_count:
    energy = cal_Min_Eng(val)
    energy_list.append(energy)
    Structure = cal_Structure(val)
    Structure_list.append(Structure)
df_crRNA1["Free Energy"] = energy_list
df_crRNA1["Secondary Structure"] = Structure_list
df_crRNA2 = df_crRNA1.loc[(df_crRNA1['Free Energy']) > -5]
len( df_crRNA2)
df_crRNA2 = df_crRNA2.reset_index(drop=True)
df_crRNA2
df_crRNA2.to_csv (r'df_crRNA_withEnergy_filtered.csv', index = False, header=True)
list_filtered = df_crRNA2['pgRNA'].values.tolist()
  
len(list_filtered)
reverse_complement_rna_list = []
for val in list_filtered:
    # Taking the reverse complement of pg-DNA sequence
    s = revcom(val)
    s = s.replace('T', 'U')
    reverse_complement_rna_list.append(s)
    
    
len(reverse_complement_rna_list)
# Converting the reverse_complement_rna_list into a text file
with open('pgRNA_filtered.txt', 'w') as f:
    for item in reverse_complement_rna_list:
        f.write("%s\n" % item)
# Converting the text file to a fasta file

fileInput = open("pgRNA_filtered.txt", "r")
fileOutput = open("out_pgRNA_filtered.fsa", "w")
#Seq count
count = 1 ;

#Loop through each line in the input file
print("Converting to FASTA...")
for strLine in fileInput:

    #Strip the endline character from each input line
    strLine = strLine.rstrip("\n")

    #Output the header
    fileOutput.write(">" + str(count) + "\n")
    fileOutput.write(strLine + "\n")

    count = count + 1
print ("Done.")

#Close the input and output file
fileInput.close()
fileOutput.close()<jupyter_output>Converting to FASTA...
Done.<jupyter_text>Blast search<jupyter_code>command = 'blastn -query out_pgRNA_filtered.fsa -task blastn-short -db C:/Users/18064/Documents/Blast/db/Human_NCBI_DNAdb -outfmt "7 qacc sacc qstart qend sstart send" -out pgRNA_NCBI_blast.out'
subprocess.call(command, shell=True)
f=open('pgRNA_NCBI_blast.out', "r")
contents =f.readlines()
query_list =[]
hits_list = []
for x in contents:
    For_Query = x.find("Query")
    if (For_Query != -1):
        query_list.append(x)
        #print("For Sequence",x)
    hits_count = x.find("hits found")
    if (hits_count != -1):
        hits_list.append(x)
        #print(x)

# Making a list of query sequence
new_query_list =[]
for val in query_list:
    x = val.split("\n")[0].split("#")[1].split(":")[1].split(" ")[1]
    x = int(x)
    new_query_list.append(x)

# Making a list of blast hits in human genome for the query sequences
new_hit_list =[]
for val in hits_list:
    x = val.split("\n")[0].split(" ")[1]
    x = int(x)
    new_hit_list.append(x)

blast_hits = pd.DataFrame({'GuideNumber': new_query_list,'Hits': new_hit_list})
blast_hits.head()
len(blast_hits)
df_crRNA2["HumanBlastHits"] = new_hit_list
df_crRNA2.to_csv (r'df_crRNA_withhits.csv', index = False, header=True)
f=open("pgRNA_NCBI_blast.out", "r")
contents =f.readlines()
Blast_list = []
for i in range(len(contents)):
    target = contents[i].find("#")
    if (target == -1):
        Blast_list.append(i)
seq_list = []
accession_list = []
qstart_list = []
qend_list = []
sstart_list = []
send_list = []
for val in Blast_list:
    line = contents[val]
    seq = line.split('\t')[0]
    accession = line.split('\t')[1]
    qstart = line.split('\t')[2]
    qend = line.split('\t')[3]
    sstart = line.split('\t')[4]
    send = line.split('\t')[5].split('\n')[0]
    seq_list.append(seq)
    accession_list.append(accession)
    qstart_list.append(qstart)
    qend_list.append(qend)
    sstart_list.append(sstart)
    send_list.append(send)
    
d = {'Sequence':seq_list,'Accession':accession_list,'qstart':qstart_list,'qend':qend_list,'sstart':sstart_list,'send':send_list}
df_blast = pd.DataFrame(d)
df_blast.head()
# This is for Cas9
range_list = []
seq_4_range_list = []
l = len(sstart_list)
for i in range(l):
    if (sstart_list[i] > send_list[i]): # When hit top strand
        #print('strand = minus')

        range_blast = accession_list[i] + '  '+ str(int(sstart_list[i])+int(qstart_list[i])-1-23) + '-' + str(int(sstart_list[i])-1 + int(qend_list[i])) + '  '+ 'minus'
    else: # When hit Bottom strand
        range_blast = accession_list[i] + '  '+ str(int(sstart_list[i])+ 1 - int(qstart_list[i])) + '-' + str(int(sstart_list[i])-int(qstart_list[i])+1+23) + '  '+ 'plus'
    range_list.append(range_blast)
    seq_4_range_list.append(seq_list[i])
range_list
len(range_list)
#seq_4_range_list
# Converting the list to a text file
with open('range_NCBIBlasthits.txt', 'w') as f:
    for item in range_list:
        f.write("%s\n" % item)
command1 = 'blastdbcmd -db C:/Users/18064/Documents/Blast/db/Human_NCBI_DNAdb -entry_batch range_NCBIBlasthits.txt -outfmt "%s" -out NCBI_Human_DNA_Range.txt'
subprocess.call(command1, shell=True)
## Reading the NCBI_Human_RNA_Range.txt file
f_rangeDNA=open("NCBI_Human_DNA_Range.txt", "r")
contents_rangeDNA =f_rangeDNA.readlines()
Human_rangeDNA_list = []
for val in contents_rangeDNA:
    val1 = (val.split('\n')[0])[0:23]
    Human_rangeDNA_list.append(val1)   
len(Human_rangeDNA_list)
len(Human_rangeDNA_list[1])# Checking if there are 23 nucleotide in human DNA range
seq_blast_cfd = []
GuideScore_blast = []
for val in seq_4_range_list:
    i = (int(val) - 1)
    #print(i)
    seq_blast = revcom(df_crRNA2.iloc[i].loc['pgRNA'])
    guide_score = df_crRNA2.iloc[i].loc['GuideScore']
    seq_blast_cfd.append(seq_blast)
    GuideScore_blast.append(guide_score)
Blast_cfd_df = pd.DataFrame({'GuideNumber': seq_4_range_list,'SequenceComplementGuide': seq_blast_cfd,'HumanDNA_range': Human_rangeDNA_list,'GuideActivity': GuideScore_blast})
Blast_cfd_df.head()<jupyter_output><empty_output><jupyter_text>Modified Function for CFD Mismatch score in Human Range, Now we have to consider the PAM effect<jupyter_code># a is the Spacer gDNA/RNA and b is the pgDNA
def Cal_Mismatch_Score_blastcmd(a,b):
    wt = a[:-3] 
    off = b
    sg = off[:-3]
    pam = off[-2:] 
    score = calc_cfd(wt,sg,pam)
    return (score)
## Calculating the cfd score for the Human transcriptome region corresponding to blast hits
x = len(Human_rangeDNA_list)
cfd_humanBlast_list = []
Activity_humanBlast_list = []
for i in range(x):
    #print(i)
    try:
        #cfd_humanBlast = Cal_Mismatch_Score(Blast_cfd_df["SequenceComplementGuide"][i], Blast_cfd_df["HumanDNA_range"][i])
        cfd_humanBlast = Cal_Mismatch_Score_blastcmd(Blast_cfd_df["HumanDNA_range"][i], Blast_cfd_df["SequenceComplementGuide"][i])
        Activity_humansite = cfd_humanBlast*Blast_cfd_df["GuideActivity"][i]
    except IndexError:
        cfd_humanBlast = 'null'
        Activity_humansite = "null"
    cfd_humanBlast_list.append(cfd_humanBlast)
    Activity_humanBlast_list.append(Activity_humansite)
Cal_Mismatch_Score_blastcmd('ACACTTCCACCACTGTACTTTCT','CCACTTCCACCACTGTACTG')
Blast_cfd_df["CFD_Score"] = cfd_humanBlast_list
Blast_cfd_df["ActivityScore"] = Activity_humanBlast_list
Blast_cfd_df.head()
Blast_cfd_df["Guide"] = Blast_cfd_df["SequenceComplementGuide"].apply(revcom)
Blast_cfd_df.head()
Blast_cfd_df.to_csv (r'BlastHumanRnaHits_Activity.csv', index = False, header=True)<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.13058351098111148, 'fraction_numerical': 0.013236825145010163, 'mean_word_length': 3.826992103374013, 'pattern_counts': {'":': 21, '<': 36, '<?xml version=': 0, '>': 45, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 2, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '8', 'dir': 'jupyter-structured-clean-dedup', 'id': '216030', 'license': 'BSD-3-Clause', 'n_tokens_mistral': 8045, 'n_tokens_neox': 7466, 'n_words': 1577, 'path': 'cas9pgrna/pg_RNA_Cas9.ipynb', 'repo_name': 'ejosephslab/pgrna', 'size': '20171'}