Upload 13 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+data/baa.gif filter=lfs diff=lfs merge=lfs -text

.streamlit/config.toml

@@ -0,0 +1,3 @@
+[theme]
+base="light"
+primaryColor="#b99de4"

app.py

@@ -0,0 +1,10 @@
+# importing Liberaries
+
+import streamlit as st
+
+
+chemstudio24_page = st.Page("chemstudio24.py", title="CHEMSTUDIO24", default=True)
+your_molecule_playground_page = st.Page('your_molecule.py', title = "Your Molecule Playground", icon=":material/splitscreen_left:")
+multi_pages = st.navigation([chemstudio24_page, your_molecule_playground_page])
+multi_pages.run()
+

chemstudio24.py

@@ -0,0 +1,380 @@
+# importing Liberaries
+
+import streamlit as st
+from streamlit_ketcher import st_ketcher
+from rdkit import Chem
+from rdkit.Chem import Draw, AllChem, rdDetermineBonds, Descriptors
+
+from PIL import Image
+import py3Dmol
+from stmol import showmol
+from stmol import speck_plot
+from io import StringIO
+import sys
+import base64
+import subprocess
+import time
+import datamol as dm
+import medchem as mc
+import streamlit_shadcn_ui as ui
+from molvs import standardize_smiles
+from molvs import Standardizer
+import pandas as pd
+import streamlit_shadcn_ui as ui
+
+
+try:
+    # from openbabel import OBMol, OBConversion
+    import openbabel
+except ModuleNotFoundError as e:
+    subprocess.Popen([f'{sys.executable} -m pip install --global-option=build_ext --global-option="-I/usr/include/openbabel3" --global-option="-L/usr/lib/openbabel" openbabel==2.4.1'], shell=True)
+    subprocess.Popen([f'{sys.executable} -m pip install --global-option=build_ext --global-option="-I/home/appuser/include/openbabel3" --global-option="-L/home/appuser/lib/openbabel" openbabel==2.4.1'], shell=True)
+    subprocess.Popen([f'{sys.executable} -m pip install --global-option=build_ext --global-option="-I/home/appuser/usr/include/openbabel3" --global-option="-L/home/appuser/usr/lib/openbabel" openbabel==2.4.1'], shell=True)
+    # wait for subprocess to install package before running your actual code below
+    #print('openbabel python not importing')
+    time.sleep(90)
+    
+from openbabel import pybel
+
+#from chemicalconverters import NamesConverter
+
+
+st.set_page_config(page_title="CHEMSTUDIO24", page_icon="data/favicon.png", layout="centered")
+st.logo("data/banner24.png")
+
+
+
+tab_titles = ['Home', 'Drawing Arena', 'Rendering and Visualization', 'Representation and Format Conversion', 'Descriptors and Rules',]
+tab1, tab2, tab3, tab4, tab5,= st.tabs(tab_titles)
+
+
+
+#st.sidebar.link_button("Contact me", "mailto:mohamedelsoudy404@gmail.com")
+Titlelogo = Image.open('data/banner24.png')
+#st.sidebar.image(Titlelogo)
+Titlelogo = Image.open('data/banner24.png')
+
+
+with tab1:
+
+    # banner and header
+    st.image(Titlelogo)
+
+    st.link_button("**:gray[@IN SILICO] :violet[CHEMISTRY]**", "https://www.insilicochemistry.io")
+    st.link_button(":rainbow[@mohamed elsoudy]", "mailto:mohamedelsoudy404@gmail.com")
+    # st.markdown('#') #insert space
+
+    # show gif
+    file_ = open("data/baa.gif", "rb")
+    contents = file_.read()
+    data_url = base64.b64encode(contents).decode("utf-8")
+    file_.close()
+
+    st.markdown(
+        f'<center><img src="data:image/gif;base64,{data_url}" class="centerImage" alt="cat gif"></center>',
+        unsafe_allow_html=True,
+    )
+
+    st.divider()
+
+
+    def support():
+        link = "https://www.paypal.com/paypalme/insilicochemistry"
+        file_ = open("data/support.png", "rb")
+        contents = file_.read()
+        data_url = base64.b64encode(contents).decode("utf-8")
+        file_.close()
+        st.markdown(
+            f'<center><a href="{link}"><img src="data:image/png;base64,{data_url}" class="centerImage" alt="cat gif"></center>',
+            unsafe_allow_html=True, )
+
+
+    def support_button():
+        url = "https://www.paypal.com/paypalme/insilicochemistry"
+
+        st.markdown(f'''
+        <a href={url}><button style="background-color:#a870dd;">Support us</button></a>
+        ''',
+                    unsafe_allow_html=True)
+
+    col1, col2, col3, col4, col5 = st.columns(5)
+
+    with col1:
+        pass
+    with col2:
+        pass
+    with col4:
+        pass
+    with col5:
+        pass
+    with col3:
+
+        st.link_button("**:white[Support us]**", "https://www.paypal.com/paypalme/insilicochemistry", type="primary")
+
+
+with tab2:
+    # KETCHER
+
+    st.subheader("Drawing Arena")
+    molecule = st.text_input("Enter SMILES or Draw your Molecule :art:", "C1=C[SH]=CCO1")
+    smiles = st_ketcher(molecule, height=800)
+    stan_smiles = standardize_smiles(smiles)
+
+    #converter = NamesConverter(model_name="knowledgator/SMILES2IUPAC-canonical-base")
+    #st.code(converter.smiles_to_iupac(stan_smiles), "html")
+    st.code(stan_smiles, "html")
+
+    mol = Chem.MolFromSmiles(smiles)
+    s = Standardizer()
+    smol = s.standardize(mol)
+
+
+# RENDERING
+
+def render_2d(mol):
+    mol = Chem.MolFromSmiles(mol)
+    s = Standardizer()
+    smol = s.standardize(mol)
+    image = Draw.MolToImage(mol, size = (400, 400))
+    return image
+
+
+def render_3d(smi):
+    mol = Chem.MolFromSmiles(smi)
+
+    if Hydrogen:
+        mol = Chem.AddHs(mol)
+    else:
+        pass
+
+    AllChem.EmbedMolecule(mol)
+    mblock = Chem.MolToMolBlock(mol)
+
+    xyzview = py3Dmol.view( width=400, height=400)
+    xyzview.addModel(mblock, 'mol')
+
+
+    xyzview.setStyle(stylemd, viewer=(0,0))
+    xyzview.setBackgroundColor(bcolor)
+    if box:
+        xyzview.addBox({'center': {'x': 0,'y': 0,'z': 0},
+                    # 'dimensions': {'w': 1, 'h': 1, 'd': 1}, # scalars
+                    'dimensions': {'w': {'x': 8, 'y': 8, 'z': 0}, #[1, 1, 0], #np.array([1,1,0]),
+                                   'h': {'x': 8, 'y': -8, 'z': 0}, # [1, -1, 0], #np.array([1,-1,0]),
+                                   'd': {'x': 0, 'y': 0, 'z': 8}, # [0, 0, 1], #np.array([0,0,1]),
+                                   },
+                    'color': '#C791FB',
+                    'alpha': 0.5,
+                    })
+    else:
+        pass
+    xyzview.rotate(23, {'x': 1, 'y': 1, 'z': 1})
+    xyzview.zoomTo()
+
+    if spin:
+        xyzview.spin(True)
+    else:
+        xyzview.spin(False)
+    xyzview.setViewStyle({"style": "outline", "color": "#CA86FF", "width": 0.05})
+    #xyzview.addLabel(stan_smiles, {'position': {'x': -6.89, 'y': 0.75, 'z': 0.35},
+    #                              'backgroundColor': '#515151', 'backgroundOpacity': 0.5,'fontSize':18,'fontColor':'#F9F7F7 ',
+    #                              'fontOpacity':1,'borderThickness':0.0,'inFront':'true','showBackground':'true'})
+
+    showmol(xyzview,height=400,width=400)
+
+blk2 = render_2d(smiles)
+
+
+with tab3:
+    #st.code(converter.smiles_to_iupac(stan_smiles)[0], "html")
+    st.code(stan_smiles, "html")
+    col1, col2= st.columns((4,4))
+    with col1:
+        col1.subheader("2D STRUCTURE")
+        st.image(blk2)
+    with col2:
+        col2.subheader("3D STRUCTURE")
+
+        st.markdown("Select your Model!")
+        styles3d = {"Line Model": {"line": {}},
+                    "Cross Model": {"cross":{}},
+                    "Stick Model": {"stick": {}, "sphere": {"scale": 0}},
+                    "Ball and Stick Model": {"stick": {}, "sphere": {"scale": 0.3}},
+                    "CPK Model": {"sphere": {}}
+                    }
+        list_style = ['Line', 'Cross', 'Stick', 'Ball and Stick', 'CPK']
+        value = ui.tabs(options=list_style, default_value='Line', key="kanaries")
+
+
+        def stylem(value):
+            if value == list_style[0]:
+                value2 = styles3d["Line Model"]
+            elif value ==  list_style[1]:
+                value2 = styles3d["Cross Model"]
+            elif value == list_style[2]:
+                value2 = styles3d["Stick Model"]
+            elif value == list_style[3]:
+                value2 = styles3d["Ball and Stick Model"]
+            elif value == list_style[4]:
+                value2 = styles3d["CPK Model"]
+            return value2
+
+
+        stylemd = stylem(value)
+
+        Hydrogen = st.toggle('Add Hydrogens', value=False, key=1)
+
+        spin = st.toggle('Animate', value=False, key=2)
+        box = st.toggle('Show Box', value=False, key=3)
+        bcolor = st.color_picker('Pick Background Color', '#323232', key=4)
+        render_3d(smiles)
+
+with tab4:
+    st.subheader("**:gray[Representation and Format] :gray[Conversion]**")
+
+    datamol_mol = dm.to_mol(smiles)
+    #st.markdown(datamol_mol)
+
+
+    def to_smarts(datamol_mol):
+        smarts = dm.smiles_as_smarts(datamol_mol)
+        st.code(smarts, "html")
+
+
+    def to__inchi(datamol_mol):
+        inchi = dm.to_inchi(datamol_mol)
+        st.code(inchi, "html")
+
+
+    def to__inchikey(datamol_mol):
+        inchikey = dm.to_inchikey(datamol_mol)
+        st.code(inchikey, "html")
+
+
+    def to_xyz(smiles, unsafe_allow_html=True):
+        mol = Chem.MolFromSmiles(smiles)
+        mol_h = Chem.AddHs(mol)
+        AllChem.EmbedMolecule(mol_h)
+        xyz = Chem.MolToXYZBlock(mol_h)
+        mol2 = Chem.MolFromXYZBlock(xyz)
+        rdDetermineBonds.DetermineBonds(mol2)
+        xyz = Chem.MolToXYZBlock(mol2)
+        st.code(xyz,"html")
+        st.download_button(label="Download .xyz File", data=xyz,
+                        file_name=f'{stan_smiles}' + "." + "xyz", mime='text/csv', )
+
+    
+    def to_rdkit3d(smiles):
+        mol = Chem.MolFromSmiles(smiles)
+        mol_h = Chem.AddHs(mol)
+        AllChem.EmbedMolecule(mol_h)
+        xyz = Chem.MolToXYZBlock(mol_h)
+        mol2 = Chem.MolFromXYZBlock(xyz)
+        rdDetermineBonds.DetermineBonds(mol2)
+        xyz = Chem.MolToXYZBlock(mol2)
+        input_geom_str = xyz
+        mol2 = pybel.readstring("xyz", input_geom_str)
+        # mol.make3D()
+        output_geom_str = mol2.write("mol")
+        st.code(output_geom_str,"html")
+        st.download_button(label="Download .mol File", data=output_geom_str,
+                           file_name=f'{stan_smiles}' + "." + "mol", mime='text/csv', )
+        
+    def to_sdf(smiles):
+        mol = Chem.MolFromSmiles(smiles)
+        mol_h = Chem.AddHs(mol)
+        AllChem.EmbedMolecule(mol_h)
+        xyz = Chem.MolToXYZBlock(mol_h)
+        mol2 = Chem.MolFromXYZBlock(xyz)
+        rdDetermineBonds.DetermineBonds(mol2)
+        xyz = Chem.MolToXYZBlock(mol2)
+        input_geom_str = xyz
+        mol2 = pybel.readstring("xyz", input_geom_str)
+        # mol.make3D()
+        output_geom_str = mol2.write("sdf")
+        st.code(output_geom_str,"html")
+        st.download_button(label="Download .sdf File", data=output_geom_str,
+                           file_name=f'{stan_smiles}' + "." + "sdf", mime='text/csv', )
+
+    def to_cif(smiles):
+        mol = Chem.MolFromSmiles(smiles)
+        mol_h = Chem.AddHs(mol)
+        AllChem.EmbedMolecule(mol_h)
+        xyz = Chem.MolToXYZBlock(mol_h)
+        mol2 = Chem.MolFromXYZBlock(xyz)
+        rdDetermineBonds.DetermineBonds(mol2)
+        xyz = Chem.MolToXYZBlock(mol2)
+        input_geom_str = xyz
+        mol2 = pybel.readstring("xyz", input_geom_str)
+        # mol.make3D()
+        output_geom_str = mol2.write("cif")
+        st.code(output_geom_str,"html")
+        st.download_button(label="Download .cif File", data=output_geom_str,
+                           file_name=f'{stan_smiles}' + "." + "cif", mime='text/csv', )
+
+
+    def to_pdb(smiles):
+        mol = Chem.MolFromSmiles(smiles)
+        mol_h = Chem.AddHs(mol)
+        AllChem.EmbedMolecule(mol_h)
+        xyz = Chem.MolToXYZBlock(mol_h)
+        mol2 = Chem.MolFromXYZBlock(xyz)
+        rdDetermineBonds.DetermineBonds(mol2)
+        xyz = Chem.MolToXYZBlock(mol2)
+        input_geom_str = xyz
+        mol2 = pybel.readstring("xyz", input_geom_str)
+        # mol.make3D()
+        output_geom_str = mol2.write("pdb")
+        st.code(output_geom_str,"html")
+        st.download_button(label="Download .pdb File", data=output_geom_str,
+                           file_name=f'{stan_smiles}' + "." + "pdb", mime='text/csv', )
+
+    
+    SMILES_OUT = st.selectbox("Select Output!",["SMARTS", "InChI", "InChIKey", "mol", "sdf", "xyz", "cif", "pdb"])
+
+    if SMILES_OUT == "SMARTS":
+        to_smarts(datamol_mol)
+    elif SMILES_OUT == "InChI":
+        to__inchi(datamol_mol)
+    elif SMILES_OUT == "InChIKey":
+        to__inchikey(datamol_mol)
+    elif SMILES_OUT == "xyz":
+        to_xyz(smiles, unsafe_allow_html=True)
+    elif SMILES_OUT == "mol":
+        to_rdkit3d(smiles)
+    elif SMILES_OUT == "sdf":
+        to_sdf(smiles)    
+    elif SMILES_OUT == "cif":  
+        to_cif(smiles)
+    elif SMILES_OUT == "pdb":
+        to_pdb(smiles)
+    
+
+
+with tab5:
+
+    my_dict = {'SMILES': stan_smiles,
+               'Molecular Weight': Descriptors.MolWt(smol),
+               'Number of H Acceptors': Descriptors.NumHAcceptors(smol),
+               'Number of H Donors': Descriptors.NumHDonors(smol),
+               'Octanol/Water Partition Coefficient LogP': Descriptors.MolLogP(smol),
+               "Topological Polar Surface Area (TPSA)": Descriptors.TPSA(smol),
+               "Lipinski's Rule of 5": mc.rules.basic_rules.rule_of_five(datamol_mol),
+               "Pfizer Rule 3/75": mc.rules.basic_rules.rule_of_pfizer_3_75(datamol_mol)
+               }
+
+
+    new = pd.DataFrame.from_dict([my_dict],)
+    new = new.rename(index={0: 'Descriptors and Rules'})
+    NEWT = new.T
+    st.dataframe(NEWT)
+    NEWT = NEWT.to_csv(index=True).encode('utf-8')
+    st.download_button(
+        "Download data!",
+        NEWT,
+        f"{stan_smiles}"+" Descriptors_Rules"+".csv",
+        "text/csv",
+        key='download-csv'
+    )
+
+

environment_backup.yml

@@ -0,0 +1,10 @@
+name: streamlit-conda-minimal
+channels:
+  - conda-forge
+  - anaconda
+dependencies:
+  - streamlit
+  - openbabel
+  - py3Dmol
+  - ipython
+  - ase

packages.txt

@@ -0,0 +1,2 @@
+openbabel
+libopenbabel-dev

requirements.txt

@@ -0,0 +1,20 @@
+datamol==0.12.2
+ipyspeck==0.6.1
+matplotlib==3.7.1
+medchem==2.0.3
+MolVS==0.1.1
+numpy==1.24.3
+pandas==1.5.3
+Pillow==9.4.0
+py3Dmol==2.0.4
+pyperclip==1.8.2
+rdkit==2023.9.1
+st_speckmol==0.0.6
+stmol==0.0.9
+streamlit
+streamlit_ketcher==0.0.1
+streamlit_scrollable_textbox==0.0.3
+streamlit_shadcn_ui==0.1.18
+ipython_genutils==0.1.0
+openbabel-wheel
+ipython

your_molecule.py

@@ -0,0 +1,180 @@
+import streamlit as st
+from streamlit_ketcher import st_ketcher
+from rdkit import Chem
+from rdkit.Chem import Draw, AllChem, rdDetermineBonds, Descriptors
+
+import py3Dmol
+from stmol import showmol
+from io import StringIO
+import sys
+import subprocess
+import time
+import streamlit_shadcn_ui as ui
+import streamlit_shadcn_ui as ui
+
+
+try:
+    # from openbabel import OBMol, OBConversion
+    import openbabel
+except ModuleNotFoundError as e:
+    subprocess.Popen([f'{sys.executable} -m pip install --global-option=build_ext --global-option="-I/usr/include/openbabel3" --global-option="-L/usr/lib/openbabel" openbabel==2.4.1'], shell=True)
+    subprocess.Popen([f'{sys.executable} -m pip install --global-option=build_ext --global-option="-I/home/appuser/include/openbabel3" --global-option="-L/home/appuser/lib/openbabel" openbabel==2.4.1'], shell=True)
+    subprocess.Popen([f'{sys.executable} -m pip install --global-option=build_ext --global-option="-I/home/appuser/usr/include/openbabel3" --global-option="-L/home/appuser/usr/lib/openbabel" openbabel==2.4.1'], shell=True)
+    # wait for subprocess to install package before running your actual code below
+    #print('openbabel python not importing')
+    time.sleep(90)
+    
+from openbabel import pybel
+
+
+st.set_page_config(page_title="CHEMSTUDIO24", page_icon="data/favicon.png", layout="centered")
+st.logo("data/banner24.png")
+
+st.write("# **:gray[Your] :rainbow[Molecule] :gray[playground]**")
+st.markdown((":gray[Visualize and Convert your] :rainbow[Molecule]"))
+
+supported_input_formats =  ['xyz', 'cif', 'pdb','mol', 'mol2','sdf', 'tmol', 'poscar','cub','cube','mcif','mmcif', 'pwscf','smi']
+supported_output_formats = ['cif', 'tmol', 'xyz', 'sdf','pdb','smiles', 'cube','mcif','mmcif','mdl','mol','mol2','smi',]
+    
+data = '''12
+
+C      1.525098    0.401299   -0.169919
+C      1.267282   -0.890923   -0.090842
+S     -0.375869   -1.429467   -0.350672
+C     -1.364069   -0.186583   -0.232712
+C     -0.787332    1.146673    0.059053
+O      0.519018    1.327928   -0.452149
+H      2.534310    0.743140   -0.012656
+H      2.085372   -1.592058    0.136539
+H     -0.704143   -2.346960    0.640753
+H     -2.462024   -0.305561   -0.365090
+H     -0.753918    1.233523    1.179450
+H     -1.483725    1.898990   -0.341753
+'''
+    
+#   st.components.v1.iframe("https://pubchem.ncbi.nlm.nih.gov/periodic-table/#view=table&embed=true", width=800, height=800, scrolling=True)
+col1, col2 = st.columns(2)
+col1.write('## Input Molecule')
+input_format = col1.selectbox('Firstly, select the input file format',
+        supported_input_formats, )
+
+input_text_area = col1.empty()
+uploaded_file = col1.file_uploader("or Choose a file from your local data")
+if uploaded_file is not None:
+        # To read file as bytes:
+    bytes_data = uploaded_file.getvalue()
+        
+    #uploaded_file_name = uploaded_file.name.split(".")
+    #input_up_format = uploaded_file_name[-1]
+        
+    
+        # To convert to a string based IO:
+    stringio = StringIO(uploaded_file.getvalue().decode("utf-8"))
+    
+            # To read file as string:
+    string_data = stringio.read()
+    placeholder_xyz_str = string_data
+    input_geom_str = input_text_area.text_area(label='Enter the contents of the source file here', value = placeholder_xyz_str, placeholder = 'Put your text here', height=400)
+
+elif uploaded_file is None:
+        
+    input_geom_str = input_text_area.text_area(label='Secondly, paste the file contents here', value = data, placeholder = 'Paste the contents of your file here', height=400, key = 'input_text_area')
+    # # Get rid of empty lines
+    # input_geom_str = os.linesep.join([s for s in input_geom_str.splitlines() if s])
+    
+mol = pybel.readstring(input_format, input_geom_str)
+        # mol.make3D()
+    
+        
+    
+    ## OUTPUT ##
+col2.write('## Output')
+output_format = col2.selectbox('Select the output file format',
+        supported_output_formats)
+output_geom_str = mol.write(output_format)
+col2.text_area(label='Converted file structure', value=output_geom_str, height=400)
+col2.download_button(
+         label="Download the output",
+         data=output_geom_str,
+         file_name='your_new_output.'+output_format,
+         mime='text/csv',)
+
+st.divider()
+
+st.subheader("Visualization Scene")
+col3, col4 = st.columns(2)
+
+
+def vis_your_molecule():
+    newviewer = py3Dmol.view(width=400, height=400)
+    structure_for_visualization = ''
+    try:
+        mol = pybel.readstring(input_format, input_geom_str)
+                # mol.make3D()
+    
+        structure_for_visualization = mol.write('xyz')
+    except Exception as e:
+        print('There was a problem with the conversion', e)
+    
+    newviewer.addModel(structure_for_visualization, 'xyz')
+    newviewer.setBackgroundColor(bcolor2)
+        
+    newviewer.setStyle(stylemd2)
+    newviewer.setViewStyle({"style": "outline", "color": "#CA86FF", "width": 0.05})
+        
+    if spin2:
+        newviewer.spin(True)
+    else:
+        newviewer.spin(False)   
+    
+    if box2:
+        newviewer.addBox({'center': {'x': 0,'y': 0,'z': 0},
+                    # 'dimensions': {'w': 1, 'h': 1, 'd': 1}, # scalars
+                    'dimensions': {'w': {'x': 8, 'y': 8, 'z': 0}, #[1, 1, 0], #np.array([1,1,0]),
+                                   'h': {'x': 8, 'y': -8, 'z': 0}, # [1, -1, 0], #np.array([1,-1,0]),
+                                   'd': {'x': 0, 'y': 0, 'z': 8}, # [0, 0, 1], #np.array([0,0,1]),
+                                   },
+                    'color': '#C791FB',
+                    'alpha': 0.5,
+                    })
+    else:
+        pass
+    
+    showmol(newviewer,height=400,width=400)
+
+with col3:
+
+    st.markdown("Select your Model!")
+    styles3d2 = {"Line Model": {"line": {}},
+                "Cross Model": {"cross":{}},
+                "Stick Model": {"stick": {}, "sphere": {"scale": 0}},
+                "Ball and Stick Model": {"stick": {}, "sphere": {"scale": 0.3}},
+                "CPK Model": {"sphere": {}}
+                }
+    list_style2 = ['Line', 'Cross', 'Stick', 'Ball and Stick', 'CPK']
+    value2 = ui.tabs(options=list_style2, default_value='Line', key="flowers")
+    
+    spin2 = st.toggle('Animate', value=False, key=5)
+    box2 = st.toggle('Show Box', value=False, key=6)
+    bcolor2 = st.color_picker('Pick Background Color', '#323232', key=7)
+
+def stylem2(value2):
+    if value2 == list_style2[0]:
+        value4 = styles3d2["Line Model"]
+    elif value2 ==  list_style2[1]:
+        value4 = styles3d2["Cross Model"]
+    elif value2 == list_style2[2]:
+        value4 = styles3d2["Stick Model"]
+    elif value2 == list_style2[3]:
+        value4 = styles3d2["Ball and Stick Model"]
+    elif value2 == list_style2[4]:
+        value4 = styles3d2["CPK Model"]
+    return value4
+
+
+stylemd2 = stylem2(value2)
+
+
+
+with col4:
+    vis_your_molecule()