pkcm 0.0.1__tar.gz

pkcm-0.0.1/MANIFEST.in

@@ -0,0 +1,2 @@
+include pkcm_rust_lib/Cargo.toml
+recursive-include pkcm_rust_lib *.rs

pkcm-0.0.1/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: pkcm
+Version: 0.0.1
+Requires-Dist: pyhmmer
+Requires-Dist: numpy
+Requires-Dist: networkx
+Requires-Dist: biopython
+Requires-Dist: pymeiji
+Dynamic: requires-dist

pkcm-0.0.1/README.md

@@ -0,0 +1,31 @@
+We suggest the creation of a python environment:
+```
+    python3 -m env pkcm_env
+    source pkcm_env/bin/activate
+```
+
+## Installation
+
+The dependencies and package can be installed with:
+```
+    pip install -r requirements.txt
+    pip install .
+```
+To run the code, one also need to install the pkcm rust library:
+```
+    cd pkcm_rust_lib/
+    maturin develop
+```
+## Example
+Building the model:
+```
+    pkcmbuild pkcm_models/toy_model.pkcm seed_alignments/toy_model.stk_keep 
+```
+Computing a tree decomposition for it
+```
+    pkcmtd pkcm_models/toy_model.pkcm.helix
+```
+Aligning sequences to it:
+```
+   pkcmalign pkcm_models/toy_model.pkcm pkcm_models/toy_model.pkcm.helix pkcm_models/toy_model.pkcm.helix.td unaligned_full_fasta/toy_model.fa test seed_alignments/toy_model.stk_keep 
+```

pkcm-0.0.1/binaries/pkcmalign

@@ -0,0 +1,396 @@
+#!/usr/bin/python3
+import warnings
+import numpy as np
+import subprocess
+import argparse
+from pkcm_rust_lib import rust_align_wrapper, QdbError, HmmQdbError
+from pkcm.utils import get_sscons, constrained_helix_mapping_dict, extract_helix_state_graph, evaluate_alignment, best_possible_score_helix, read_pkcm_file, get_infernal_solution 
+from Bio import SeqIO
+from Bio.Seq import Seq
+from Bio.SeqRecord import SeqRecord
+import sys
+import time
+
+parser = argparse.ArgumentParser(description="align a set of sequences in a fasta file to a pseudoknotted covariance model.")
+
+parser.add_argument('pkcm_file', type=str, help='.pkcm file to align to')
+parser.add_argument('td_file', type=str, help='.td file, nice tree decomposition of the graph of variables.')
+parser.add_argument('fasta_file', type=str, help='.fasta of sequences to align')
+parser.add_argument('output_file', type=str, help='output file')
+parser.add_argument('seed_alignment', type=str, help='.seed seed alignment used to build the pkcm')
+parser.add_argument('--beta', type=float, default=0.00001, help='parameter for Query-Dependent Banding, between 0 and 1.\
+                    Higher is faster, but more approximate.')
+parser.add_argument('--tau', type=float, default=0.001, help='parameter for Query-Dependent Banding, between 0 and 1.\
+                    Higher is faster, but more approximate.')
+parser.add_argument('--exact', action='store_true', help="Deactivates any heuristic")
+parser.add_argument('--noqdb', action='store_true', help="Deactivates QDB")
+parser.add_argument('--nohmm', action='store_true', help="Deactivates HMM")
+parser.add_argument('--dense', action='store_true', help="Uses a denser contiguous array instead of a hashmap.\
+                                                          Faster, but may use more memory.")
+parser.add_argument('-N', type=int, default=sys.maxsize, dest='limit_num_sequences')
+
+args = parser.parse_args()
+
+outfile = open(args.output_file,'w', buffering=1)
+
+# Getting the ss_cons and rf lines to include
+# them in the output.
+for line in open(args.seed_alignment).readlines():
+    if line.startswith('#=GC SS_cons'):
+        ss_cons = line.split(' ')[-1].rstrip('\n')
+    if line.startswith('#=GC RF'):
+        rf_line = line.split(' ')[-1].rstrip('\n')
+
+# Re-figuring out the mapping between the 
+# bounds of the helices and the 
+# half helices <-> variables
+partner = {}
+half_helices = []
+helices = []
+for line in open(args.pkcm_file).readlines():
+    if line.startswith("## END HELIX ARRANGEMENT DESCRIPTION"):
+        break
+    if line.startswith("Helix"):
+        name = line.split(' ')[0]
+        i = int(line.split(' ')[-4])-1
+        j = int(line.split(' ')[-3])-1
+        k = int(line.split(' ')[-2])-1
+        l = int(line.split(' ')[-1].rstrip('\n'))-1
+
+        half_helices.append((i,j))
+        half_helices.append((k,l))
+        helices.append((name,(i,j),(k,l)))
+
+        partner[(k,l)] = (i,j)
+
+half_helices = sorted(half_helices, key=lambda x : x[0])
+
+cnt1 = 1
+cnt2 = 2
+
+import copy
+
+pos = {}
+
+for k in range(len(half_helices)):
+
+    i,j = half_helices[k]
+    pos[(i,j)] = (copy.copy(cnt1), copy.copy(cnt2))
+
+    cnt1 += 1
+    cnt2 += 1
+
+# end of figuring out mapping
+
+
+cons_column_writes = [] # list of dicts: column -> symbol. should be exactly one symbol for every column
+insert_writes = []      # list of dicts: column -> the insert written between column and column+1
+num_inserts = {}        # column: length of longest insert between column and column+1
+ids = []
+
+num_cons_cols = 0
+for k, c in enumerate(list(rf_line)):
+    if c != '.':
+        num_cons_cols += 1
+
+## retrieve HMM model
+#print("READING HMM")
+#start_reading = False
+#for line in open(args.pkcm_file).readlines():
+#    if line.startswith("## FULL HMM"):
+#        start_reading = True
+#        continue
+#    if start_reading:
+#        if line.startswith("transition probabilities"):
+#            transition_probabilities_hmm = parse_transition_probas_hmm(line)
+#        if line.startswith("match_emissions probabilities"):
+#            match_emissions_probabilities_hmm = parse_transition_probas_hmm(line)
+#        if line.startswith("insert_emissions probabilities"):
+#            insert_emissions_probabilities_hmm = parse_transition_probas_hmm(line)
+
+
+# map id -> seq
+id2seq = {}
+
+# loop over input sequences
+cnt = 0
+times = []
+is_too_long_for_beta = []
+for record in SeqIO.parse(args.fasta_file, "fasta"):
+    if cnt >= args.limit_num_sequences:
+        break
+    cnt += 1
+
+    ids.append(record.id)
+    id2seq[record.id] = str(record.seq)
+
+    print("aligning",record.id)
+    outfile.write(" ".join(["aligning", record.id,'\n']))
+    t0 = time.time()
+    try:
+        opt, mapping, state_lists = rust_align_wrapper(args.pkcm_file, 
+                                                   args.td_file, 
+                                                   str(record.seq),
+                                                   args.beta,
+                                                   args.tau,
+                                                   args.exact,
+                                                   args.dense,
+                                                   args.noqdb,
+                                                   args.nohmm)
+    except QdbError as e:
+        print(str(e))
+        is_too_long_for_beta.append(record.id)
+        continue
+
+    except HmmQdbError as e:
+        print(str(e))
+        is_too_long_for_beta.append(record.id)
+        continue
+
+    times.append(time.time()-t0)
+
+    # corrected score using NULL random model
+    score = opt+2*len(str(record.seq))
+
+    print("computation time ",time.time()-t0)
+    print("id, opt, score", record.id, opt, score)
+    print("mapping ", mapping)
+    outfile.write(f"id {record.id} score {score} computation_time {time.time()-t0}\n")
+
+    # null3 proba
+    nA = float(record.seq.count('A'))
+    nU = float(record.seq.count('U'))
+    nG = float(record.seq.count('G'))
+    nC = float(record.seq.count('C'))
+    nTotal = nA+nU+nG+nC
+
+    null3_log_prob = 0.0
+    for c in ['A','U','G','C']:
+        n = float(record.seq.count(c))
+        if n > 0:
+            null3_log_prob += n*np.log2((n/nTotal))
+
+    seq_list = list(str(record.seq))
+
+    # converting to dict
+    map_dict = {}
+    for key,val in mapping:
+        map_dict[key] = val
+
+    cons_column_write = {}
+    insert_write = {}
+    for col_index in range(num_cons_cols+2):
+        insert_write[col_index] = [""]
+
+    for helix_index in range(len(helices)):
+
+        i,j = helices[helix_index][1]
+        k,l = helices[helix_index][2]
+
+        pos_i,pos_j = pos[(i,j)]
+        pos_k,pos_l = pos[(k,l)]
+
+        start_L,end_L = map_dict[pos_i]+1, map_dict[pos_j]
+        start_R,end_R = map_dict[pos_k]+1, map_dict[pos_l]
+
+        var_L = start_L-1
+        var_R = end_R-1
+
+        # shifting
+        i += 1
+        l += 1
+
+        #print("starting indices",i,l)
+        #print("map_dict", map_dict)
+        #print(state_lists[helix_index])
+        #print("left seq", "".join(seq_list[start_L-1:end_L]),"right seq","".join(seq_list[start_R-1:end_R]))
+
+        def left_insert_pos(state, num_cons_cols):
+            if state.startswith("ROOT"):
+                return 0
+            try:
+                i = int(state.split('_')[1])
+                if state.startswith("BEGR"):
+                    return i-1
+            except:
+                assert(state.split('_')[1]=='-')
+                i = 0
+            return i
+
+        def right_insert_pos(state, num_cons_cols):
+            if state.startswith("ROOT"):
+                return num_cons_cols
+            try:
+                i = int(state.split('_')[2])-1
+            except:
+                assert(state.split('_')[2]=='-')
+                i = num_cons_cols
+            return i
+
+        for state in state_lists[helix_index]:
+        # in what follows: i and l track the cons positions
+        # var_L and var_R track the sequence positions
+            if state.endswith("IL"):
+                insert_write[left_insert_pos(state, num_cons_cols)].append(seq_list[var_L])
+                var_L += 1
+                continue
+
+            if state.endswith("IR"):
+                insert_write[right_insert_pos(state, num_cons_cols)] = [seq_list[var_R]] + insert_write[right_insert_pos(state, num_cons_cols)]
+                var_R -= 1
+                continue
+
+            if state.startswith("MATP"):
+                if state.endswith("MP"):
+                    cons_column_write[i] = seq_list[var_L] 
+                    cons_column_write[l] = seq_list[var_R]
+
+                    var_L += 1
+                    var_R -= 1
+
+                if state.endswith("ML"):
+                    cons_column_write[i] = seq_list[var_L] 
+                    cons_column_write[l] = "-"
+
+                    # no var_R decrement
+                    var_L += 1
+
+                if state.endswith("MR"):
+                    cons_column_write[i] = "-" 
+                    cons_column_write[l] =  seq_list[var_R]
+
+                    var_R -= 1
+
+                if state.endswith("D"):
+                    cons_column_write[i] = "-" 
+                    cons_column_write[l] = "-"
+                    
+                # for matp node: in any case we write both left/right
+                # consensus columns
+                i += 1
+                l -= 1
+
+            if state.startswith("MATL"):
+                if state.endswith("ML"):
+                    cons_column_write[i] = seq_list[var_L] 
+                    var_L += 1
+
+                if state.endswith("D"):
+                    cons_column_write[i] = "-" 
+
+                i += 1
+
+            if state.startswith("MATR"):
+                if state.endswith("MR"):
+                    cons_column_write[l] = seq_list[var_R] 
+                    var_R -= 1
+
+                if state.endswith("D"):
+                    cons_column_write[l] = "-" 
+
+                l -= 1
+                
+    cons_column_writes.append(cons_column_write)
+    insert_writes.append(insert_write)
+
+for k in range(num_cons_cols+2):
+    max_ins = 0
+    for insert_write in insert_writes:
+        max_ins = max(max_ins,len(insert_write[k])-1) # -1 because there is ""
+
+    num_inserts[k] = max_ins
+
+
+max_id_len = 0
+for identifier in ids+['ss_cons','rf_line']:
+    max_id_len = max(len(identifier)+1, max_id_len)
+
+def pad_with_spaces(s, L):
+    while len(s) < L:
+        s += ' '
+    return s
+
+# TODO: right-inserts should be padded on the left, not
+# the right
+def pad_with_gaps(s, L):
+    while len(s) < L:
+        s += '-'
+    return s
+
+def pad_with_dots(s, L):
+    while len(s) < L:
+        s += '.'
+    return s
+
+def print_aligned_seq(identifier, num_cons_cols, insert_write, cons_column_write, num_inserts, max_id_len):
+
+#    print("cons   write", sorted(cons_column_write.items(),key = lambda x : x[0]))
+#    print("insert write", insert_write)
+
+    # also storing the seq for validation purposes
+    seq = ""
+
+    print(pad_with_spaces(identifier, max_id_len),end='')
+    outfile.write(pad_with_spaces(identifier, max_id_len))
+    for col_index in range(num_cons_cols+2):
+        if col_index > 0 and col_index <= num_cons_cols:
+            print(cons_column_write[col_index], end='')
+            outfile.write(cons_column_write[col_index])
+            seq += cons_column_write[col_index]
+
+        print(pad_with_gaps(''.join(insert_write[col_index]), num_inserts[col_index]),end='')
+        outfile.write(pad_with_gaps(''.join(insert_write[col_index]), num_inserts[col_index]))
+        seq += ''.join(insert_write[col_index])
+
+    print("")
+    outfile.write('\n')
+    return seq
+
+def print_aligned_cons(identifier, num_cons_cols, insert_write, cons_column_write, num_inserts, max_id_len):
+    print(pad_with_spaces(identifier, max_id_len),end='')
+    outfile.write(pad_with_spaces(identifier, max_id_len))
+    for col_index in range(num_cons_cols+2):
+        if col_index > 0 and col_index <= num_cons_cols:
+            print(cons_column_write[col_index], end='')
+            outfile.write(cons_column_write[col_index])
+
+        print(pad_with_dots(''.join(insert_write[col_index]), num_inserts[col_index]),end='')
+        outfile.write(pad_with_dots(''.join(insert_write[col_index]), num_inserts[col_index]))
+
+    print("")
+    outfile.write('\n')
+
+# making objects with good format for ss_cons and gc_rf
+ss_cons_col_write = {}
+ss_cons_insert_write = {}
+rf_line_col_write = {}
+rf_line_insert_write = {}
+curr_insert = ""
+tracker = 0
+
+for col_index in range(num_cons_cols+2):
+    ss_cons_insert_write[col_index] = ""
+    rf_line_insert_write[col_index] = ""
+
+col_index = 0
+for k,c in enumerate(list(rf_line)):
+    if c!='.':
+        ss_cons_col_write[col_index+1] = ss_cons[k]
+        rf_line_col_write[col_index+1] = rf_line[k]
+        col_index += 1
+    
+print("average single-sequence alignment time ", np.mean(times),"seconds")
+outfile.write(" ".join(["average single-sequence alignment time ", str(np.mean(times)),"seconds\n"]))
+
+# final print
+print_aligned_cons("ss_cons", num_cons_cols, ss_cons_insert_write, ss_cons_col_write, num_inserts, max_id_len)
+print_aligned_cons("rf_line", num_cons_cols, rf_line_insert_write, rf_line_col_write, num_inserts, max_id_len)
+
+ids = [identifier for identifier in ids if identifier not in is_too_long_for_beta]
+
+for num,identifier in enumerate(ids):
+    reconstructed_seq = print_aligned_seq(identifier, num_cons_cols, insert_writes[num], cons_column_writes[num], num_inserts, max_id_len)
+    reconstructed_seq = reconstructed_seq.replace('-','')
+    #print("for id", identifier, "reconstructed seq is ", reconstructed_seq)
+    #print("            whereas seq is ", id2seq[identifier])
+    assert(reconstructed_seq==id2seq[identifier])

pkcm-0.0.1/binaries/pkcmbuild

@@ -0,0 +1,181 @@
+#!/usr/bin/python3
+from pkcm.utils import Node, Helix, adhoc_helix_decomposition, get_sscons, preambule_stk_file, alignment_lines_stk_file, filter_alignment, homemade_cmbuild, read_pkcm_lines_infernal_format, equalise_whitespace
+import subprocess
+import tempfile
+import sys
+import argparse
+
+# parser configuration
+parser = argparse.ArgumentParser(description='Builds a pseudoknotted covariance model (.pkcm file) from a multiple sequence alignment. Also outputs a .helix file specifying how the consensus structure was decomposed into helices.')
+
+# main arguments
+parser.add_argument('output_pkcm_filename', type=str, help='name of the file in which to write the pseudoknotted covariance model.')
+parser.add_argument('inputfile_msa_name', type=str, help='name of the input multiple sequence alignment')
+
+# optional arguments
+parser.add_argument('--dump-helix-alignments', 
+                    type=str, 
+                    help="optionally, directory in which to dump alignment files of each helix.", 
+                    dest='dump_helix_alignments',
+                    metavar='DIR',
+                    required=False)
+
+parser.add_argument('--ignore-pk',
+                    help="Ignore the pk helices (those with Aa,Bb,Cc...)",
+                    dest='ignore_pk',
+                    action='store_true',
+                    required=False)
+
+parser.add_argument('--use-infernal-format',
+                    help="If present, use infernal (cmbuild) for each helix. Instead of simple Laplace smoothing and ``home-made'' format.",
+                    dest='use_infernal',
+                    action='store_true',
+                    required=False)
+
+# parsing args
+args = parser.parse_args()
+
+msa_filename = args.inputfile_msa_name
+cm_outname = args.output_pkcm_filename
+try:
+    helix_msa_dir = args.dump_helix_alignments
+except AttributeError:
+    helix_msa_dir = None
+
+
+# getting ss_cons
+ss_cons, rf_line = get_sscons(open(msa_filename).readlines(), ignore_pk=args.ignore_pk)
+rf_line = rf_line.replace('.','')
+N = len(ss_cons)
+
+# helix decomposition
+helix_list = adhoc_helix_decomposition(ss_cons)
+
+pkcm_file = open(cm_outname,'w')
+
+if args.use_infernal:
+    print('#USING_CMBUILD_BACKEND=true',file=pkcm_file)
+    ss_cons_spacer = '<<<.>>>'
+    gc_rf_spacer = '..GAC..'
+else:
+    print('#USING_CMBUILD_BACKEND=false',file=pkcm_file)
+    ss_cons_spacer = '||'
+    gc_rf_spacer = '||'
+
+# storing helix decomposition description
+print("## BEGIN HELIX ARRANGEMENT DESCRIPTION ##", file=pkcm_file)
+for helix in helix_list:
+    print(helix.name, helix.parenthesis_system, helix.print_boundaries(), file=pkcm_file)
+    for node in helix.nodes:
+        print(node.type, node.left_end, node.right_end,file=pkcm_file)
+    print('-'*10,file=pkcm_file)
+print("## END HELIX ARRANGEMENT DESCRIPTION ##", file=pkcm_file)
+
+preambule = preambule_stk_file(open(msa_filename).readlines())
+alignment_lines = alignment_lines_stk_file(open(msa_filename).readlines(),ignore_pk=args.ignore_pk)
+
+all_lines = []
+
+cm_lines_per_helix = {}
+
+if not args.use_infernal:
+    print("## BEGIN PKCM ##", file=pkcm_file)
+
+for helix in helix_list:
+
+    # isolating the part of the alignment concerning the helix
+    alignment_file = tempfile.NamedTemporaryFile()
+    filter_alignment(preambule, alignment_lines, helix, alignment_file,ss_cons_spacer=ss_cons_spacer,gc_rf_spacer=gc_rf_spacer) 
+    alignment_file.seek(0)
+    if helix_msa_dir is not None:
+        helix_msa_file = open(helix_msa_dir+msa_filename.split('.')[0].split('/')[-1]+'_'+helix.name+'.seed','w')
+        for line in alignment_file.readlines():
+            helix_msa_file.write(line.decode('utf-8'))
+        alignment_file.seek(0)
+
+    if args.use_infernal:
+        # file to store the resulting covariance model for that helix
+        helix_cm_file = tempfile.NamedTemporaryFile()
+
+        print("input given to cmbuild:")
+        for line in alignment_file.readlines():
+            print(line)
+        alignment_file.seek(0)
+
+        # infernal run
+        cmd_args = ['cmbuild','--iins','--iflank','--hand','-F',helix_cm_file.name,alignment_file.name]
+        subprocess.run(cmd_args, check=True)
+
+        # dumping into overall pkcm file
+        helix_cm_file.seek(0)
+        cm_lines_per_helix[helix.name] = list(helix_cm_file.readlines())
+
+        all_lines.append('## CM FILE for '+helix.name)
+        for line in cm_lines_per_helix[helix.name]:
+            print(line)
+            all_lines.append(line.decode("utf-8"))
+
+    else:
+        print('-----------',file=pkcm_file)
+        print(helix.name, helix.parenthesis_system, helix.print_boundaries(), file=pkcm_file)
+
+        transition_edge_list, emission_list = homemade_cmbuild(alignment_file, helix)
+
+        for state1, state2, weight in transition_edge_list:
+            print('transition',state1,'->',state2,weight,file=pkcm_file)
+
+        for state, nucl, weight in emission_list:
+            print('emission',state,'->', nucl, weight, file=pkcm_file)
+
+if not args.use_infernal:
+    print("## END PKCM ##", file=pkcm_file)
+
+if args.use_infernal:
+    transition_probabilities, emission_probabilities = read_pkcm_lines_infernal_format(all_lines, helix_list)
+    print("## BEGIN PKCM ##", file=pkcm_file)
+    for helix in helix_list:
+        print('-----------',file=pkcm_file)
+        print(helix.name, helix.parenthesis_system, helix.print_boundaries(), file=pkcm_file)
+        for key, value in transition_probabilities[helix.name].items():
+            print('transition',key,value,file=pkcm_file)
+        for state, value in emission_probabilities[helix.name].items():
+            for nucl, weight in value.items():
+                print('emission',state,'->',nucl,weight,file=pkcm_file)
+    print("## END PKCM ##", file=pkcm_file)
+    print("## BEGIN INDIVIDUAL CM FILES", file=pkcm_file)
+    for helix in helix_list:
+        for line in cm_lines_per_helix[helix.name]:
+            print(line.decode("utf-8"),end='',file=pkcm_file)
+    print("## END INDIVIDUAL CM FILES", file=pkcm_file)
+else:
+    print("## END PKCM ##", file=pkcm_file)
+
+rf_line, ss_cons = equalise_whitespace(rf_line, '#=GC SS_cons '+ss_cons)
+
+import pyhmmer
+from pyhmmer import easel, plan7
+
+alphabet = easel.Alphabet.rna()
+
+with easel.MSAFile(args.inputfile_msa_name, digital=False) as msa_file:
+    msa = next(msa_file)
+
+digital_msa = msa.digitize(alphabet)
+
+builder = plan7.Builder(alphabet)
+background = plan7.Background(alphabet)
+
+hmm, profile, optimized_profile = builder.build_msa(
+    digital_msa, background
+)
+
+print("## FULL HMM ", file=pkcm_file)
+print("transition probabilities", hmm.transition_probabilities, file=pkcm_file)
+print("match_emission probabilities", hmm.match_emissions, file=pkcm_file)
+print("insert_emission probabilities", hmm.insert_emissions, file=pkcm_file)
+print("## END FULL HMM", file=pkcm_file)
+
+
+pkcm_file.write('### CONSENSUS INFO'+'\n')
+pkcm_file.write(ss_cons+'\n')
+pkcm_file.write(rf_line+'\n')

pkcm-0.0.1/binaries/pkcmemit

@@ -0,0 +1,68 @@
+#!/usr/bin/python3
+import random
+from pkcm.utils import read_helices_in_file, read_pkcm_file
+import tempfile
+import argparse
+import subprocess
+
+parser = argparse.ArgumentParser(description="Emits sequences from a pseudoknotted covariance model.")
+
+parser.add_argument('pkcm_file', type=str, help='.pkcm file to emit from')
+parser.add_argument('-N', type=int, help="number of samples to get. (default=10)", default=10)
+
+args = parser.parse_args()
+N = args.N
+
+helices = read_helices_in_file(args.pkcm_file)
+
+transition_probabilities, in_ngbh, emission_probabilities, start_state = read_pkcm_file(open(args.pkcm_file).readlines())
+
+
+def sample(list_of_outcomes):
+    weight_list = [2**w for _,w in list_of_outcomes]
+    cumulative_weight = 0
+    cumulative_weights = []
+    for k, p in enumerate(weight_list):
+        cumulative_weight += p
+        cumulative_weights.append(cumulative_weight)
+
+    r = random.random()
+
+    for k, cw in enumerate(cumulative_weights):
+        if r-cw < 0:
+            return list_of_outcomes[k][0]
+
+    return list_of_outcomes[-1][0] # sometimes we can have
+                                   # cumulative weights
+                                   # not exactly summing to 1
+                                   # because of precision errors
+
+for _ in range(N):
+    sequences = []
+    for helix in helices:
+        try:
+            state = start_state[helix.name]
+        except KeyError:
+            no_in = [s for s in transition_probabilities[helix.name].keys() if s not in in_ngbh[helix.name].keys()]
+            state = random.choice(no_in)
+        left_seq = ""
+        right_seq = ""
+        while True:
+            if state in emission_probabilities[helix.name].keys():
+                outcome = sample(emission_probabilities[helix.name][state])
+                if state.endswith('L'):
+                    left_seq += outcome
+                if state.endswith('R'):
+                    right_seq = outcome + right_seq
+                if state.endswith('P'):
+                    left_seq += outcome[0]
+                    right_seq = outcome[0] + right_seq
+            if state in transition_probabilities[helix.name].keys():
+                state = sample(transition_probabilities[helix.name][state])
+            else:
+                break
+        sequences.append((helix.outer_left, left_seq))
+        sequences.append((helix.inner_left, right_seq))
+
+    print(''.join([s[1] for s in  sorted(sequences, key=lambda x : x[0])]))
+