orca-webui 0.1.0__py3-none-any.whl

orca_webui/__init__.py

@@ -0,0 +1,9 @@
+"""orca-webui: a Gradio web UI for simple ORCA computational-chemistry calculations.
+
+Public entry point is :func:`orca_webui.app.main` (exposed as the ``orca-webui``
+console command). Submodules are imported lazily by that entry point so that
+lightweight consumers (e.g. importing :mod:`orca_webui.utils` for its parsing/spectrum
+helpers) do not pull in the full Gradio/FastAPI UI stack.
+"""
+
+__version__ = "0.1.0"

orca_webui/app.py

@@ -0,0 +1,104 @@
+"""Application entry point.
+
+Builds the FastAPI host, mounts the ``/static`` file server and the Gradio Blocks UI
+(the three tabs: conformer generation, calculation, result), and serves everything on
+the first free port at/after 7860.
+
+Runtime directories (``data/`` and ``static/``) are created in the **current working
+directory** so an installed copy of the package never writes into its own install
+location; ``styles.css`` ships inside the package and is read from there. Transient
+artifacts left in ``static/`` (and stray ``*.log`` files) by a previous run are cleaned
+up on startup.
+"""
+import socket
+from pathlib import Path
+
+import gradio as gr
+import uvicorn
+from fastapi import FastAPI
+from fastapi.staticfiles import StaticFiles
+
+from .working_directory import working_directory_blocks
+from .conformer_generation import conformer_generation_tab_content
+from .calculation import calculation_tab_content
+from .result import result_tab_content
+
+# styles.css is packaged data, resolved relative to this module (read-only).
+_STYLES_PATH = Path(__file__).parent / "styles.css"
+
+# Glob patterns for transient files removed from the run directory on startup.
+_TRANSIENT_PATTERNS = (
+    "*.log",
+    "static/*.html",
+    "static/**/*.html",
+    "static/**/*.cube",
+    "static/**/*.xyz",
+)
+
+
+def _cleanup_transient_files(run_dir: Path) -> None:
+    """Delete transient artifacts left in ``run_dir`` by a previous session."""
+    for pattern in _TRANSIENT_PATTERNS:
+        for filepath in run_dir.glob(pattern):
+            try:
+                filepath.unlink()
+            except OSError:
+                pass  # best-effort cleanup; ignore files we cannot remove
+
+
+def find_available_port(start_port: int = 7860) -> int:
+    """Return the first TCP port at/after ``start_port`` that can be bound on localhost."""
+    port = start_port
+    while True:
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            try:
+                s.bind(('localhost', port))
+                return port  # Available port found
+            except OSError:
+                port += 1  # Try next port
+
+
+def build_app(run_dir: Path | None = None) -> FastAPI:
+    """Build the FastAPI app with the Gradio UI mounted.
+
+    ``run_dir`` (default: current working directory) is where the ``data/`` and
+    ``static/`` directories are created and served from.
+    """
+    run_dir = Path.cwd() if run_dir is None else run_dir
+    _cleanup_transient_files(run_dir)
+
+    app = FastAPI()
+
+    # Working directories live under ./data; transient viewer files under ./static.
+    (run_dir / "data").mkdir(parents=True, exist_ok=True)
+    static_dir = run_dir / "static"
+    static_dir.mkdir(parents=True, exist_ok=True)
+
+    # mount FastAPI StaticFiles server
+    app.mount("/static", StaticFiles(directory=static_dir), name="static")
+
+    with gr.Blocks(css_paths=_STYLES_PATH) as blocks:
+        with gr.Row():
+            working_directory_path_state, working_directory_file_list_state = working_directory_blocks()
+            with gr.Column(scale=2):
+                with gr.Row(min_height=40):
+                    status_markdown = gr.Markdown()
+                with gr.Row():
+                    with gr.Tabs():
+                        conformer_generation_tab_content(working_directory_path_state, working_directory_file_list_state, status_markdown)
+                        calculation_tab_content(working_directory_path_state, working_directory_file_list_state, status_markdown)
+                        result_tab_content(working_directory_path_state, working_directory_file_list_state, status_markdown)
+
+    # mount Gradio app to FastAPI app
+    return gr.mount_gradio_app(app, blocks, path="/")
+
+
+def main() -> None:
+    """Console-script entry point: build the app and serve it on the first free port."""
+    app = build_app()
+    port = find_available_port()
+    uvicorn.run(app, host="127.0.0.1", port=port, access_log=False)
+
+
+if __name__ == "__main__":
+    main()

orca_webui/calculation.py

@@ -0,0 +1,277 @@
+"""Calculation tab: turn a structure file into an ORCA input file and run ORCA.
+
+The upper section builds an ``.inp`` file for the chosen calculation type (single
+point, optimization, frequency, TD-DFT, NMR) and method/basis/solvation settings;
+the lower section invokes the external ``orca`` binary on a selected ``.inp`` and
+captures its stdout to a ``.log``.
+"""
+import os
+import time
+import multiprocessing
+import psutil
+import subprocess
+import math
+import gradio as gr
+import pandas as pd
+from rdkit import Chem
+from rdkit.Chem import AllChem
+import cclib
+from .utils import *
+
+# Physical RAM in whole GB, used as the upper bound / default of the memory slider.
+max_memory = math.floor(psutil.virtual_memory().total / (1024 ** 3))
+
+def on_working_directory_file_list_change(working_directory_file_list, input_file_name):
+    """Repopulate the input-structure and input-file dropdowns from the file list.
+
+    Keeps the currently-typed input file name selected if a matching ``.inp`` exists,
+    otherwise falls back to the first available input file. Returns updates for the
+    structure dropdown and the input-file dropdown.
+    """
+    structure_file_names = [f for f in working_directory_file_list if f.endswith('.xyz') or f.endswith('.pdb') or f.endswith('.mol') or f.endswith('.mol2') or f.endswith('.log')]
+    input_file_names = [f for f in working_directory_file_list if f.endswith('.inp')]
+    if input_file_name + ".inp" in input_file_names:
+        input_file_name_value = input_file_name + ".inp"
+    else:
+        input_file_name_value = input_file_names[0] if len(input_file_names) > 0 else None
+    
+    return gr.update(choices=structure_file_names, value=structure_file_names[0] if len(structure_file_names) > 0 else None, interactive=True), \
+           gr.update(choices=input_file_names, value=input_file_name_value, interactive=True)
+   
+def on_change_calculation_type(calculation_type):
+    """React to the calculation-type radio changing.
+
+    Suggests a default input file name, restricts the available method types (NMR
+    excludes semi-empirical/CC), swaps the functional list for TD-DFT, and toggles
+    visibility of the TD-DFT sliders and the NMR spin-spin-coupling checkbox.
+    """
+    if calculation_type == "Single-Point":
+        file_name = "single_point"
+    elif calculation_type == "Geometry Optimization":
+        file_name = "geometry_optimization"
+    elif calculation_type == "Frequency":
+        file_name = "frequency"
+    elif calculation_type == "Time-Dependent Density Functional Theory":
+        file_name = "tddft"
+    else: # calculation_type == "NMR Spectrum"
+        file_name = "nmr_spectrum"
+    
+    if calculation_type == "NMR Spectrum":
+        method_types = ["HF", "DFT", "MP2"]
+    else:
+        method_types = ["HF", "DFT", "Semi-empirical", "MP2", "CCSD", "CCSD(T)"]
+
+    if calculation_type == "Time-Dependent Density Functional Theory":
+        functional_dropdown = gr.Dropdown(label="Functional", value="PBE", choices=["CAM-B3LYP", "PBE", "PBE0", "revPBE", "B97-3C", "wB97X", "wB97X-D3"], allow_custom_value=True)
+    else:
+        functional_dropdown = gr.Dropdown(label="Functional", value="B3LYP", choices=["BLYP", "B3LYP", "CAM-B3LYP", "B3PW91", "PBE", "PBE0", "revPBE", "B97-3C", "M06L", "M062X", "wB97X", "wB97X-D3"], allow_custom_value=True)
+    
+    show_tddft = calculation_type == "Time-Dependent Density Functional Theory"
+
+    show_spin_spin_couplings = (calculation_type == "NMR Spectrum")
+
+    return file_name, gr.update(choices=method_types, value="DFT"), functional_dropdown, gr.update(visible=show_tddft), gr.update(visible=show_tddft), gr.update(visible=show_tddft), gr.update(visible=show_spin_spin_couplings)
+
+def on_mm_checkbox_change(mm_checkbox: gr.Checkbox):
+    """Show/hide the force-field and max-iterations controls with the MM checkbox."""
+    return gr.update(visible=mm_checkbox), gr.update(visible=mm_checkbox)
+
+def on_solvation_checkbox_change(solvation_checkbox: gr.Checkbox):
+    """Show/hide the solvation-model and solvent controls with the solvation checkbox."""
+    return gr.update(visible=solvation_checkbox), gr.update(visible=solvation_checkbox)
+
+def on_method_type_change(method_type):
+    """Toggle method-name/functional/basis controls to match the chosen method type.
+
+    Semi-empirical shows a method-name dropdown (AM1/PM3) and hides the basis set;
+    DFT shows the functional; everything else shows only the basis set.
+    """
+    show_method_name = (method_type=="Semi-empirical")
+    show_functional = method_type=="DFT"
+    show_basis_set = not (method_type=="Semi-empirical")
+
+    if method_type == "Semi-empirical":
+        method_names = ["AM1", "PM3"]
+        default_method_name = "AM1"
+    else:
+        method_names = [""]
+        default_method_name = ""
+
+    return gr.update(choices=method_names, value=default_method_name, visible=show_method_name), gr.update(visible=show_functional), gr.update(visible=show_basis_set)
+
+def on_generate_input_file(working_directory_path, input_structure_file_dropdown, calculation_type,
+                           use_mm, force_field, max_iters,
+                           use_solvation, solvation_model, solvent,
+                           method_type, method_name, functional, basis_set_textbox, n_states, maxdim, root, spin_spin_coupling, charge, multiplicity,
+                           n_cores, memory, input_file_name):
+    """Generate an ORCA ``.inp`` file for the selected structure and settings.
+
+    Loads the structure (optionally pre-optimizing it with MMFF/UFF molecular
+    mechanics), then dispatches to the matching ``write_*_orca_input`` helper based on
+    ``calculation_type``. Returns ``(status_html, file_list)``; errors are reported in
+    the status span rather than raised.
+    """
+    if input_structure_file_dropdown is None or input_structure_file_dropdown == "":
+        gr.Warning("Please select an input structure")
+        return "", get_files_in_working_directory(working_directory_path)
+    
+    try:
+        # Get the molecule object 
+        file_path = os.path.join(working_directory_path, input_structure_file_dropdown)
+        if input_structure_file_dropdown.endswith('.pdb'):
+            mol = Chem.MolFromPDBFile(file_path, sanitize=False, removeHs=False)
+        elif input_structure_file_dropdown.endswith('.mol'):    
+            mol = Chem.MolFromMolFile(file_path, sanitize=False, removeHs=False)
+        elif input_structure_file_dropdown.endswith('.mol2'): 
+            mol = Chem.MolFromMol2File(file_path, sanitize=False, removeHs=False)
+        elif input_structure_file_dropdown.endswith('.xyz'):    
+            mol = add_bonds(mol_from_xyz_file(file_path))
+        else: # file_name.endswith('.log')
+            mol = add_bonds(mol_from_orca_file(file_path))
+
+        Chem.SanitizeMol(mol)
+        if mol.GetNumConformers()==0:
+            AllChem.EmbedMolecule(mol)
+
+        # Optimize geometry with molecular mechanics
+        if use_mm:
+            if force_field=="MMFF":
+                AllChem.MMFFOptimizeMolecule(mol, maxIters=max_iters)
+            else: # force_field=="UFF"
+                AllChem.UFFOptimizeMolecule(mol, maxIters=max_iters)
+
+        # Generate input file
+        input_file_path = os.path.join(working_directory_path, input_file_name)
+        if calculation_type == "Single-Point":
+            write_sp_orca_input(mol, input_file_path, method_type, method_name, functional=functional, basis=basis_set_textbox,
+                                charge=charge, multiplicity=multiplicity,
+                                solvation=use_solvation, solvation_model=solvation_model, solvent=solvent, n_proc=n_cores, memory=memory)
+        elif calculation_type == "Geometry Optimization":
+            write_opt_orca_input(mol, input_file_path, method_type, method_name, functional=functional, basis=basis_set_textbox,
+                                 charge=charge, multiplicity=multiplicity,
+                                 solvation=use_solvation, solvation_model=solvation_model, solvent=solvent, n_proc=n_cores, memory=memory)
+        elif calculation_type == "Frequency":
+            write_opt_freq_orca_input(mol, input_file_path, method_type, method_name, functional=functional, basis=basis_set_textbox,
+                                      charge=charge, multiplicity=multiplicity,
+                                      solvation=use_solvation, solvation_model=solvation_model, solvent=solvent, n_proc=n_cores, memory=memory)
+        elif calculation_type == "Time-Dependent Density Functional Theory":
+            write_tddft_orca_input(mol, input_file_path, method_type, method_name, functional=functional, basis=basis_set_textbox,
+                                     n_states=n_states, maxdim=maxdim, root=root, charge=charge, multiplicity=multiplicity,
+                                     solvation=use_solvation, solvation_model=solvation_model, solvent=solvent, n_proc=n_cores, memory=memory)
+        else: # calculation_type == "NMR Spectrum"
+            write_nmr_orca_input(mol, input_file_path, method_type, functional=functional, basis=basis_set_textbox,
+                                 spin_spin_coupling=spin_spin_coupling, charge=charge, multiplicity=multiplicity,
+                                 solvation=use_solvation, solvation_model=solvation_model, solvent=solvent, n_proc=n_cores, memory=memory)
+
+        status = "Input file generated."
+        return f"<span style='color:green;'>{status}</span>", get_files_in_working_directory(working_directory_path)
+    except Exception as exc:
+        status = exc
+        return f"<span style='color:red;'>{status}</span>", get_files_in_working_directory(working_directory_path)
+
+def on_run_calculation(working_directory_path, input_file_name):
+    """Run the external ``orca`` binary on ``input_file_name`` (a ``.inp`` in the wd).
+
+    stdout is captured to a same-named ``.log``. Returns ``(status_html, file_list)``
+    with the elapsed time on success; a non-zero ORCA exit (or a missing binary) is
+    reported in the status span rather than raised.
+    """
+    if input_file_name is None or input_file_name=="":
+        gr.Warning("Please choose an input file.")
+        return "", get_files_in_working_directory(working_directory_path)
+
+    try:
+        input_file_path = os.path.join(working_directory_path, input_file_name)
+        output_file_path = os.path.join(working_directory_path, os.path.splitext(input_file_name)[0] + ".log")
+
+        # Run calculation with ORCA
+        cmd = ["orca", input_file_path]
+        start = time.time()
+        print(f"Running command: {' '.join(cmd)} > {output_file_path}")
+        with open(output_file_path, 'w') as outfile:
+            subprocess.run(cmd, stdout=outfile, check=True)
+        end = time.time()
+        duration = end - start
+
+        status = f"Calculation finished ({round(duration, 3)} s)."
+        return f"<span style='color:green;'>{status}</span>", get_files_in_working_directory(working_directory_path)
+    except Exception as exc:
+        status = f"Error running calculation: {exc}"
+        return f"<span style='color:red;'>{status}</span>", get_files_in_working_directory(working_directory_path)
+
+def calculation_tab_content(working_directory_path_state, working_directory_file_list_state, status_markdown):
+    """Build the "Calculation" tab (settings, input generation, run) and wire events.
+
+    Takes the shared path/file-list states and status line; returns the tab component.
+    """
+    with gr.Tab("Calculation") as calculation_tab:
+        with gr.Accordion("Settings", open=False):
+            with gr.Row():
+                n_cores_slider = gr.Slider(label="Number of cores", value=1, minimum=1, maximum=1, step=1, interactive=False)
+                memory_slider = gr.Slider(label="Memory (GB)", value=max_memory, minimum=1, maximum=max_memory, step=1)
+        with gr.Accordion("Generate Input File"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    input_structure_file_dropdown = gr.Dropdown(label="Input structure", choices=[""], value="", interactive=False)
+                with gr.Column(scale=4):
+                    calculation_type_radio = gr.Radio(label="Type of calculation", value="Single-Point", choices=["Single-Point", "Geometry Optimization", "Frequency", "Time-Dependent Density Functional Theory", "NMR Spectrum"])
+            with gr.Row():
+                with gr.Column(scale=1):
+                    with gr.Row():
+                        mm_checkbox = gr.Checkbox(label="Optimize geometry with molecular mechanics", value=False)
+                    with gr.Row():
+                        with gr.Column(scale=1):
+                            force_field_dropdown = gr.Dropdown(label="Force field", value="MMFF", choices=["MMFF", "UFF"], visible=False)
+                        with gr.Column(scale=1):
+                            max_iters_slider = gr.Slider(label="Max iterations", value=200, minimum=0, maximum=1000, step=1, visible=False)
+                    with gr.Row():
+                        solvation_checkbox = gr.Checkbox(label="Solvation", value=False)
+                    with gr.Row():
+                        with gr.Column(scale=1):
+                            solvation_dropdown = gr.Dropdown(label="Solvation model", value="cpcm", choices=[("SMD", "smd"), ("CPCM", "cpcm")], visible=False)
+                        with gr.Column(scale=1):
+                            solvent_dropdown = gr.Dropdown(label="Solvent", value="water", choices=["water", ("DMSO", "dmso"),  "nitromethane", "acetonitrile", "methanol", "ethanol", "acetone", "dichloromethane",
+                                                                                                    "dichloroethane", ("THF", "thf"), "aniline", "chlorobenzene", "chloroform", ("diethyl ether", "diethylether"),
+                                                                                                    "toluene", "benzene", ("CCl4", "ccl4"), "cyclohexane", "heptane"], allow_custom_value=True, visible=False)
+                with gr.Column(scale=1):
+                    with gr.Row():
+                        method_type_dropdown = gr.Dropdown(label="Type of method", value="DFT", choices=["HF", "DFT", "Semi-empirical", "MP2", "CCSD", "CCSD(T)"])
+                        method_name_dropdown = gr.Dropdown(label="Method", choices=[], visible=False)
+                    with gr.Row():
+                        functional_dropdown = gr.Dropdown(label="Functional", value="B3LYP", choices=["BLYP", "B3LYP", "CAM-B3LYP", "B3PW91", "PBE", "PBE0", "revPBE", "B97-3C", "M06L", "M062X", "wB97X", "wB97X-D3"], allow_custom_value=True)
+                        basis_set_dropdown = gr.Dropdown(label="Basis set", value="3-21G", choices=["STO-3G", "3-21G", "6-31G", "6-31G(d,p)", "6-31+G(d,p)", "6-31++G(d,p)",
+                                                                                                    "6-311G", "6-311G(d,p)", "cc-pVDZ", "cc-pVTZ", "cc-pVQZ", "aug-cc-pVDZ", "aug-cc-pVTZ", "aug-cc-pVQZ",
+                                                                                                    "LanL2DZ", "SDD"], allow_custom_value=True)
+                    with gr.Row():
+                        n_states_slider = gr.Slider(label="Number of excited states", value=10, minimum=5, maximum=100, step=1, visible=False)
+                        maxdim_slider = gr.Slider(label="Dimension of expansion space", value=5, minimum=1, maximum=10, step=1, visible=False)
+                        root_slider = gr.Slider(label="Root state", value=0, minimum=0, maximum=99, step=1, visible=False)
+                        spin_spin_coupling_checkbox = gr.Checkbox(label="Compute spin-spin couplings", value=False, visible=False)
+                    with gr.Row():
+                        charge_slider = gr.Slider(label="Charge", value=0, minimum=-2, maximum=2, step=1)
+                        multiplicity_dropdown = gr.Dropdown(label="Multiplicity", value=1, choices=[("Singlet", 1), ("Doublet", 2),
+                                                                                                    ("Triplet", 3), ("Quartet", 4),
+                                                                                                    ("Quintet", 5), ("Sextet ", 6)])
+                with gr.Column(scale=1):
+                    input_file_name_textbox = gr.Textbox(label="File name", value="single_point")
+                    generate_input_file_button = gr.Button(value="Generate input file")
+        with gr.Accordion("Run calculation"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    input_file_name_dropdown = gr.Dropdown(label="Input file", choices=[""], value="", interactive=False)
+                with gr.Column(scale=2):
+                    run_button = gr.Button("Run")                
+
+        working_directory_file_list_state.change(on_working_directory_file_list_change, [working_directory_file_list_state, input_file_name_textbox], [input_structure_file_dropdown, input_file_name_dropdown])
+        calculation_type_radio.change(on_change_calculation_type, calculation_type_radio, [input_file_name_textbox, method_type_dropdown, functional_dropdown, n_states_slider, maxdim_slider, root_slider, spin_spin_coupling_checkbox])        
+        mm_checkbox.change(on_mm_checkbox_change, mm_checkbox, [force_field_dropdown, max_iters_slider])
+        solvation_checkbox.change(on_solvation_checkbox_change, solvation_checkbox, [solvation_dropdown, solvent_dropdown])
+        method_type_dropdown.change(on_method_type_change, method_type_dropdown, [method_name_dropdown, functional_dropdown, basis_set_dropdown])
+        generate_input_file_button.click(on_generate_input_file, [working_directory_path_state, input_structure_file_dropdown, calculation_type_radio,
+                                                                  mm_checkbox, force_field_dropdown, max_iters_slider, solvation_checkbox, solvation_dropdown, solvent_dropdown,
+                                                                  method_type_dropdown, method_name_dropdown, functional_dropdown, basis_set_dropdown, n_states_slider, maxdim_slider, root_slider, spin_spin_coupling_checkbox, charge_slider, multiplicity_dropdown,
+                                                                  n_cores_slider, memory_slider, input_file_name_textbox],
+                                                                 [status_markdown, working_directory_file_list_state])
+        run_button.click(on_run_calculation, [working_directory_path_state, input_file_name_dropdown], [status_markdown, working_directory_file_list_state])
+        
+    return calculation_tab

orca_webui/conformer_generation.py

@@ -0,0 +1,96 @@
+"""Conformer-generation tab: draw/enter a molecule and embed 3D conformers.
+
+A SMILES string (typed, or produced by the 2D editor) is embedded into ``num_confs``
+RDKit conformers, each written to the working directory as an XYZ/PDB/MOL structure
+file for later ORCA calculations.
+"""
+import os
+from rdkit import Chem
+from rdkit.Chem import AllChem
+import gradio as gr
+from gradio_molecule2d import molecule2d
+from .utils import get_files_in_working_directory, conformer_to_xyz_file
+
+def on_draw_molecule(molecule_editor: str) -> str:
+    """Canonicalize the SMILES coming from the 2D editor (empty string if invalid)."""
+    mol = Chem.MolFromSmiles(molecule_editor)
+    if mol is None:
+        return ""
+
+    return Chem.MolToSmiles(mol, canonical=True)
+
+def on_generate_conformers(working_directory_path: str, input_smiles: str, charge: int,
+                           multiplicity: int, num_confs: int, file_name: str,
+                           file_type: str, progress=gr.Progress()):
+    """Embed conformers of ``input_smiles`` and write one structure file each.
+
+    Returns ``(status_html, file_list)`` where ``status_html`` is a colored status
+    span and ``file_list`` is the refreshed working-directory listing (fed back into
+    the shared file-list state). Errors (invalid SMILES, no embeddable conformer, or
+    any RDKit failure) are reported in the status span rather than raised.
+    """
+    try:
+        # Generate conformers
+        mol = Chem.MolFromSmiles(input_smiles)
+        if mol is None:
+            status = 'Error generating conformers: invalid SMILES.'
+            return f"<span style='color:red;'>{status}</span>", get_files_in_working_directory(working_directory_path)
+        mol = Chem.AddHs(mol)
+        # EmbedMultipleConfs may return FEWER conformers than requested (or none for
+        # a molecule it cannot embed), so iterate the ids it actually created.
+        conf_ids = list(AllChem.EmbedMultipleConfs(mol, numConfs=num_confs))
+        if len(conf_ids) == 0:
+            status = 'Error generating conformers: RDKit could not embed any conformer for this molecule.'
+            return f"<span style='color:red;'>{status}</span>", get_files_in_working_directory(working_directory_path)
+
+        for i, conf_id in enumerate(progress.tqdm(conf_ids, total=len(conf_ids), desc="Generating")):
+            # Create a unique file name for each conformer
+            conf_file_path = os.path.join(working_directory_path, f'{file_name}_{i + 1}')
+            # Write conformers geometry to file
+            if file_type == 'xyz':
+                conf_file_path += '.xyz'
+                conformer_to_xyz_file(mol, conf_id, conf_file_path, charge, multiplicity)
+            elif file_type == 'pdb':
+                conf_file_path += '.pdb'
+                Chem.MolToPDBFile(mol, conf_file_path, confId=conf_id)
+            else: # file_type_dropdown == 'mol'
+                conf_file_path += '.mol'
+                Chem.MolToMolFile(mol, conf_file_path, confId=conf_id)
+
+        status = 'Conformers generated.'
+        return f"<span style='color:green;'>{status}</span>", get_files_in_working_directory(working_directory_path)
+    except Exception as exc:
+        status = f'Error generating conformers: {exc}'
+        return f"<span style='color:red;'>{status}</span>", get_files_in_working_directory(working_directory_path)
+
+def show_selected_file(selected_file):
+    gr.Warning(selected_file)
+    return selected_file
+
+def conformer_generation_tab_content(working_directory_path_state, working_directory_file_list_state, status_markdown):
+    """Build the "Conformer generation" tab and wire its events.
+
+    ``working_directory_path_state`` / ``working_directory_file_list_state`` are the
+    shared ``gr.State`` objects from the working-directory column; ``status_markdown``
+    is the shared status line. Returns the tab component.
+    """
+    with gr.Tab("Conformer generation") as conformer_generation_tab:
+        with gr.Row():
+            with gr.Column(scale=2):
+                with gr.Accordion("Molecular Structure"):
+                    molecule_editor = molecule2d(label="Molecule")
+            with gr.Column(scale=1):
+                with gr.Accordion("Generate Conformers"):
+                    input_smiles_texbox = gr.Textbox(label="SMILES")
+                    charge_slider = gr.Slider(label="Charge", value=0, minimum=-2, maximum=2, step=1)
+                    multiplicity_dropdown = gr.Dropdown(label="Multiplicity", value=1, choices=[("Singlet", 1), ("Doublet", 2), ("Triplet", 3), ("Quartet", 4), ("Quintet", 5), ("Sextet", 6)])
+                    num_confs_slider = gr.Slider(label="Number of conformers", value=1, minimum=1, maximum=100, step=1)
+                    file_name_textbox = gr.Textbox(label="File name", value="conformer")
+                    file_type_dropdown = gr.Dropdown(label="File type", value="xyz", choices=["xyz", "pdb", "mol"])
+                    generate_button = gr.Button(value="Generate")
+                    status_markdown = gr.Markdown()
+
+    molecule_editor.change(on_draw_molecule, molecule_editor, input_smiles_texbox)
+    generate_button.click(on_generate_conformers, [working_directory_path_state, input_smiles_texbox, charge_slider, multiplicity_dropdown, num_confs_slider, file_name_textbox, file_type_dropdown], [status_markdown, working_directory_file_list_state])
+        
+    return conformer_generation_tab