pyfurnace 0.0.1__py3-none-any.whl

pyfurnace/__init__.py

@@ -0,0 +1,5 @@
+from .design import *
+
+__all__ = ["motifs", "strand", "origami", "symbols"]
+__version__ = "0.0.1"
+

pyfurnace/__main__.py

@@ -0,0 +1,33 @@
+import os
+import sys
+import pathlib
+import subprocess
+
+def main():
+    config_options = {'theme.base': 'light',
+                      'theme.font': "monospace",
+                      'theme.primaryColor': "#00856A",
+                      'server.enableStaticServing': True,
+                      'logger.level': 'error',
+                      'global.showWarningOnDirectExecution': False,
+                      'client.toolbarMode': "minimal",
+                    }
+    config_str = ' '.join([f'--{key} "{value}"' 
+                                    for key, value in config_options.items()])
+    
+    app_path = str(pathlib.Path(__file__).parent.resolve()/'app'/'streamlit_app.py')
+
+    ### COPY THE PYTHON PATH AND ADD RNAfold
+    python_path = sys.executable # Get path to the current Python interpreter
+    python_dir = os.path.dirname(python_path)
+
+    # Prepend it to PATH, to make sure the correct Python is used
+    env = os.environ.copy()
+    env["PATH"] = python_dir + os.pathsep + os.environ["PATH"]
+
+    subprocess.run(f'streamlit run "{app_path}" {config_str}', 
+                   shell=True, 
+                   env=env)
+
+if __name__ == "__main__":
+    main()

pyfurnace/app/pages/0_Home.py

@@ -0,0 +1,37 @@
+import streamlit as st
+from utils import load_logo
+
+if __name__ == '__main__':
+    load_logo() 
+
+    st.write("# Hello and Welcome to pyFuRNAce!")
+
+    st.write('Design and generate RNA nanostructures in few simple steps.')
+
+    st.page_link("pages/1_Design.py", 
+                 label=":orange[Design:]", 
+                 icon=":material/draw:")
+
+    st.markdown("- Design your RNA nanostructure and download it as "
+                "textfile/python script.")
+
+    st.page_link("pages/2_Generate.py", 
+                 label=":orange[Generate:]", 
+                 icon=":material/network_node:")
+
+    st.markdown("- Generate the RNA sequence that matches the desired dot-bracket" 
+                " notation for the nanostructure.")
+
+    st.page_link("pages/3_Convert.py", 
+                 label=":orange[Template:]", 
+                 icon=":material/genetics:")
+
+    st.markdown("- Prepare the DNA template for you RNA Origami, search subsequences "
+                "and search for dimers.")
+
+    st.page_link("pages/4_Prepare.py", 
+                 label=":orange[Prepare:]", 
+                 icon=":material/sync_alt:")
+
+    st.markdown("- Design primers for your DNA template or prepare the Origami for "
+                "OxDNA simulation.")

pyfurnace/app/pages/1_Design.py

@@ -0,0 +1,77 @@
+import streamlit as st
+import matplotlib.pyplot as plt
+
+### My modules
+from utils import check_import_pyfurnace, load_logo, save_origami
+check_import_pyfurnace()
+import utils.design_functions as des_func
+from utils.st_fixed_container import sticky_container
+
+
+if __name__ == "__main__":
+    load_logo()
+    ### initiate the session state
+    des_func.initiate_session_state()
+    st.header('Design', 
+              help='Design your RNA nanostructure and '
+                    'download it as textfile/python script.')
+
+    ### make the general options for the RNA origami
+    des_func.origami_general_options(st.session_state.origami, 
+                                     expanded=False)
+
+    cols = st.columns([1.3, 1.3] + [1] * 2 + [2, 1.3], 
+                      vertical_alignment='center') 
+    with cols[0]:    
+        with st.popover("Make a simple origami",
+                        use_container_width=False,
+                        help='Start by creating a simple origami rather than '
+                            'starting from scratch'):
+            des_func.simple_origami()
+
+    with cols[2]:
+        st.write('OxView 3D colormap:')
+
+    with cols[3]:
+        cmap = st.selectbox('OxView 3D colormap:', 
+                            ['Reds', None] + plt.colormaps(),
+                            key='colormap',
+                            label_visibility='collapsed', 
+                            help='Change the color of the OxView visualization.')
+        st.session_state.oxview_colormap = cmap
+    with cols[5]:
+        grad = st.toggle('Color gradient path', 
+                          key='grad', 
+                          help='Toggle the gradient color scheme for the nucleotides')
+        st.session_state.gradient = grad
+
+
+    def motif_menu_expander():
+        with st.expander("**Add motifs to the origami:**", expanded=True):
+            des_func.make_motif_menu(st.session_state.origami)
+
+    if st.session_state.motif_menu_sticky:
+        with sticky_container(mode="top", border=False):
+            motif_menu_expander()
+            view_opt = des_func.origami_select_display()
+    else:
+        motif_menu_expander()
+        view_opt = des_func.origami_select_display()
+
+    ### select the render mode
+    if not st.session_state.origami:
+        st.success('The origami is empty, add a motif!')
+        st.stop()
+    else:
+        des_func.origami_build_view(view_opt)
+
+    ### display the dot-bracket notation and sequence constraints 
+    # and link to the Generate page
+
+    des_func.display_structure_sequence()
+
+    ### Download the RNA origami structure
+    save_origami()
+
+    
+    

pyfurnace/app/pages/2_Generate.py

@@ -0,0 +1,378 @@
+from functools import partial
+import streamlit as st
+from colour import Color
+import os
+import warnings
+
+### My modules
+from utils import (check_import_pyfurnace, 
+                   load_logo, 
+                   save_origami, 
+                   copy_to_clipboard)
+check_import_pyfurnace()
+from pyfurnace.generate import generate_road, fold_p
+
+def format_text(text):
+    return "```\n" + text + "\n```"
+
+def forna_options(lenght):
+    ### checkboxes for the options
+    col1, col2, col3 = st.columns(3, vertical_alignment='bottom')
+    with col1:
+        st.session_state.zoomable = st.checkbox("Zoomable", 
+                                                value=True, 
+                help = """Enable zooming in and out the structure""")
+    with col2:
+        st.session_state.animation = st.checkbox("Interact", 
+                                                 value=False, 
+                help = """Enable interaction with the structure""")
+    with col3:
+        st.session_state.node_label = st.checkbox("Label", 
+                                                  value=True, 
+                help = """Show the nucleotide label""")
+    
+    ### second row of options
+    col1, col2, col3 = st.columns(3, vertical_alignment='center')
+    with col1:
+        ### color scheme options
+        scheme_options = ["sequence", 
+                          "structure", 
+                          "positions", 
+                          "color range", 
+                          "custom"]
+        st.session_state.color_scheme = st.selectbox("Color scheme", 
+                                                     scheme_options, 
+                                                     index=1)
+
+    with col2:
+        st.session_state.height = st.slider("Frame height", 
+                                            min_value=10, 
+                                            max_value=800, 
+                                            value=300, 
+                help = """Set the height of the frame""")
+
+    with col3:
+        st.session_state.label_interval = st.slider("Label every", 
+                                                    min_value=0, 
+                                                    max_value=max(lenght, 10), 
+                                                    value=min(lenght, 10), 
+                help = """Show the nucleotide number every n nucleotides""")
+
+    st.session_state.color_text = ''
+    st.session_state.colors = {}
+
+    ### color scheme based on the sequence
+    if st.session_state.color_scheme == "color range":
+        st.session_state.color_scheme = "custom"
+
+        with col2: # start color
+            first = st.color_picker("Start color", "#ff0000")
+
+        with col3: # end color
+            last = st.color_picker("End color", "#00ff00")
+
+        # create the colors range
+        first = Color(first)
+        last = Color(last)
+
+        color_range = [first] + list(first.range_to(last, lenght))
+
+        # save the colors in the session state and create the colors string
+        for i, c in enumerate(color_range):
+            st.session_state.colors[i] = c.hex
+            st.session_state.color_text += str(i) + ":" + c.hex + " "
+
+    ### custom colors for each nucleotide
+    elif st.session_state.color_scheme == "custom":
+
+        with col2: # select nucleotide index
+            index = st.number_input("Select nucleotide index", 1, lenght, 1)
+
+        with col3: # select color
+            color = st.color_picker("Select a color", "#ffffff")
+
+        # save the color in the session state
+        st.session_state.colors[index] = color
+
+        # create the colors string
+        for i, c in st.session_state.colors.items():
+            st.session_state.color_text += str(i) + ":" + c + " "
+
+    ### display the custom colors
+    else:
+        st.session_state.color_text = None
+
+def generate_sequence():
+    if not structure:
+        st.error('No structure input given')
+        return
+    
+    if not sequence_constraint:
+        st.error('No sequence constraint input given')
+        return
+        
+    # Initialize the UI elements
+    progress_bar = st.empty()
+    output_status = st.empty()
+    
+    # Initialize the progress bar
+    progress_bar.progress(0, "Initializing...")
+
+    def callback_forna(structure, sequence, step, stage_name, n_stage):
+        # Update the progress bar
+        progress_bar.progress(n_stage, text = stage_name)
+        output_status.markdown(format_text(f"Structure:\n{structure}"
+                                            f"\nSequence:\n{sequence}"
+                                            f"\nSpool:\n{step}"))
+
+    ori_txt = '\n\n'.join(st.session_state.code)
+    opti_sequence, zip_out = generate_road(structure, 
+                                           sequence_constraint, 
+                                           pseudoknot_info, 
+                                           name=filename,
+                                           callback=callback_forna,
+                                           zip_directory=True,
+                                           origami_code=ori_txt,
+                                           )
+    
+    st.session_state.rna_origami_seq = opti_sequence
+    st.session_state.rna_origami_folds = fold_p(opti_sequence)
+    # if there was already a zip file, remove it
+    if 'zip_path' in st.session_state:
+        if os.path.exists(st.session_state.zip_path):
+            os.remove(st.session_state.zip_path)
+    # save the new zip file
+    st.session_state.zip_path = zip_out
+
+    # Clear the progress bar
+    progress_bar.progress(1.0, text = f"Generation Completed")
+    output_status.empty()
+
+    if ('origami' in st.session_state 
+            and st.session_state.origami
+            and len(st.session_state.origami.sequence) == len(st.session_state.rna_origami_seq)):
+        # try:
+        st.session_state.origami.sequence = st.session_state.rna_origami_seq
+        if 'code' in st.session_state:
+            code_text = 'origami.sequence = "' + st.session_state.rna_origami_seq + '"'
+            st.session_state.code.append(code_text)
+        st.success("Sequence loaded to the origami design!")
+        # except Exception as e:
+        #     st.error(f"Error while loading the sequence into the origami design: {e}")
+
+
+if __name__ == "__main__":
+    # somehow st components cause `Thread 'MainThread': missing ScriptRunContext!` 
+    # warning when using multiprocessing
+    from st_forna_component import forna_component
+
+    load_logo()
+
+    ### ignore warnings
+    warnings.filterwarnings("ignore")
+
+    ### initialize the session state
+
+    ### Forna options
+    if 'zoomable' not in st.session_state:
+        st.session_state.zoomable = True
+    if 'animation' not in st.session_state:
+        st.session_state.animation = False
+    if 'editable' not in st.session_state:
+        st.session_state.editable = False
+    if 'labels' not in st.session_state:
+        st.session_state.node_label = True
+    if 'height' not in st.session_state:
+        st.session_state.height = 300
+    if 'label_interval' not in st.session_state:
+        st.session_state.label_interval = 10
+    if 'color_scheme' not in st.session_state:
+        st.session_state.color_scheme = "structure"
+    if 'color_text' not in st.session_state:
+        st.session_state.color_text = ''
+
+    ### RNA origami options
+    if 'generate_structure' not in st.session_state:
+        st.session_state.generate_structure = ""
+    if 'generate_sequence' not in st.session_state:
+        st.session_state.generate_sequence = ""
+    if 'generate_pseudoknots' not in st.session_state:
+        st.session_state.generate_pseudoknots = ""
+    if 'rna_origami_seq' not in st.session_state:
+        st.session_state.rna_origami_seq = ""
+    if 'rna_origami_folds' not in st.session_state:
+        st.session_state.rna_origami_folds = ()
+    
+    st.header('Generate', help='Generate the RNA sequence that matches the desired dot-bracket notation (and sequence constraints) for the nanostructure.')
+    structure = st.text_input("RNA strucutre (dot-bracket notation)", value=st.session_state.generate_structure)
+    sequence_constraint = st.text_input("Sequence constraints", value=st.session_state.generate_sequence)
+    pseudoknot_info = st.text_input("Pseudoknot constraints (semicolon-separated)", value=st.session_state.generate_pseudoknots)
+    
+    if not sequence_constraint:
+        sequence_constraint = "N" * len(structure.replace("&", ""))
+
+    # check if the dot-bracket notation contains multiple strands   
+    if "&" in structure:
+        st.warning("Experimental: the dot-bracket notation contains multiple strands")
+
+    with st.columns([1.3, 3])[0]:
+        with st.popover("RNA display options", use_container_width=True):
+            forna_options(len(structure))
+
+    partial_forna = partial(forna_component,
+                           height = st.session_state.height,
+                           animation = st.session_state.animation,
+                           zoomable = st.session_state.zoomable,
+                           label_interval = st.session_state.label_interval,
+                           node_label = st.session_state.node_label,
+                           editable = st.session_state.editable,
+                           color_scheme = st.session_state.color_scheme,
+                           colors = st.session_state.color_text)
+    
+
+    # # Initialize the FORNA link for the target structure
+    if structure:
+    #     st.markdown("#### Target Structure")
+    #     st.markdown(format_text(structure))
+        edited = partial_forna(structure = structure, 
+                                sequence = sequence_constraint,
+                                key='target_forna')
+
+    if sequence_constraint and sequence_constraint[0] != 'G':
+        col1, col2, col3 = st.columns(3, vertical_alignment='bottom')
+        with col1:
+            st.warning("The RNA sequence doens't start with G.")
+        with col2:
+            new_start = st.text_input("Start the sequence with", value='GGGA',
+                                      help='The transcription of the RNA sequence often '
+                                      'often requires at least one G at the start of the sequence.')
+        with col3:
+            if st.button('Apply the sequence start'):
+
+                seq_list = list(sequence_constraint)
+                # pair_map = pf.dot_bracket_to_pair_map(structure) # unnecessary
+
+                for i in range(len(new_start)):
+                    seq_list[i] = new_start[i]
+                    ### NOT NECESSARY
+                    # paired = pair_map[i]
+                    # if paired is not None:
+                    #     paired_nucl = new_start[i].translate(pf.nucl_to_pair)
+                    #     seq_list[paired] = paired_nucl
+
+                st.session_state.generate_sequence = "".join(seq_list)
+                st.rerun()
+    
+    col1, col2 = st.columns(2, vertical_alignment='bottom')
+    with col1:
+        filename =  st.text_input('Name of RNA origami', value='Origami')
+    with col2: 
+        generate = False
+        if st.button("Generate RNA sequence"):
+            generate = True
+    if generate:
+        generate_sequence()
+
+
+    if not st.session_state.rna_origami_seq:
+        st.stop()
+        
+    st.divider()
+    sequence = st.session_state.rna_origami_seq
+    folds = st.session_state.rna_origami_folds
+
+    diversity = round(folds[6], 1)
+    if diversity < 30:
+        diversity_text = f":green[low {diversity}]"
+    elif diversity < 50:
+        diversity_text = f":orange[medium {diversity}]"
+    else:
+        diversity_text = f":red[high {diversity}]"
+
+    cols = st.columns(4, vertical_alignment='bottom')
+    st.markdown("### Last Optimized sequence "
+                f"(ensemble diversity: {diversity_text})", 
+                help='The ensemble diversity is the average distance between the '
+                'structures in the ensemble (the set of all the possible structures '
+                'that can be formed by the sequence). A lower value means that the '
+                'structures are more similar to each other (and therefore more '
+                'similar to the Minimum Free Energy structure). A higher value '
+                'means that the structures are more diverse and there are less '
+                'chances to obtain the minimum free energy structure. '
+                )
+    
+
+    col1, col2 = st.columns(2)
+    with col1:
+        with st.columns(3)[1]:
+            st.markdown("#### MFE Structure", 
+                        help='The Minimum Free Energy (MFE) structure is the structure with '
+                        'the lowest free energy. It is the most stable structure that can be '
+                        'formed by the sequence. '
+                        )
+            
+        subcol1, subcol2 = st.columns(2)
+        with subcol1:
+            st.markdown(f'Energy: {round(folds[1], 2)} Kcal/mol')
+        with subcol2:
+            st.markdown(f'Frequency in the ensemble: {round(folds[2] * 100, 4)} %',
+                        help = 'The MFE frequency in the ensemble is the probability of '
+                        'obtaining the MFE structure among all the possible structures '
+                        'that can be formed by the sequence.'
+                        )
+        partial_forna(structure = folds[0],
+                        sequence = sequence,
+                        key='struct_mfe')
+    with col2:
+        with st.columns(3)[1]:
+            st.markdown("#### Centroid",
+                        help='The centroid structure is the structure that is the most similar to '
+                        'the average structure of the ensemble. It is the closest structure to '
+                        'represent the average of all the possible structures that can be '
+                        'formed by the sequence. '
+                        )
+        subcol1, subcol2 = st.columns(2)
+        with subcol1:
+            st.markdown(f'Energy: {round(folds[4], 2)} Kcal/mol')
+        with subcol2:
+            st.markdown(f'Frequency in the ensemble: {round(folds[5] * 100, 4)} %',
+                        help = 'The centroid frequency in the ensemble is the probability of '
+                        'obtaining the centroid structure among all the possible structures '
+                        'that can be formed by the sequence.'
+                        )
+        partial_forna(structure = folds[3],
+                        sequence = sequence,
+                        key='struct_centroid')
+        
+    st.divider()
+
+    st.markdown(format_text(st.session_state.rna_origami_seq))
+    col1, col2, col3, col4 = st.columns(4)
+    with col1:
+        st.page_link("pages/3_Convert.py", 
+                        label=":orange[Convert the RNA to the DNA template]", 
+                        icon=":material/genetics:")
+    with col2:
+        copy_to_clipboard(folds[0], 'Structure')
+    with col3:
+        copy_to_clipboard(sequence, 'Sequence')
+    with col4:
+        with open(st.session_state.zip_path, "rb") as fp:
+            st.download_button("Download Optimization Files",
+                                data=fp,
+                                file_name = f"{filename}.zip",
+                                mime = "application/zip",
+                                on_click='ignore',
+                                )
+
+    if ('origami' in st.session_state 
+            and st.session_state.origami
+            and str(st.session_state.origami.sequence) == st.session_state.rna_origami_seq):
+
+        st.session_state.prepare_ind = 1
+        st.page_link("pages/4_Prepare.py",
+                        label=":orange[Prepare MD simulations]", 
+                        icon=":material/sync_alt:")
+
+        save_origami(filename)
+