molbuilder 1.0.0__py3-none-any.whl

molbuilder/gui/dialogs.py

@@ -0,0 +1,117 @@
+"""Dialog windows: SMILES input, file open/save, export settings."""
+
+import tkinter as tk
+from tkinter import ttk, filedialog, messagebox
+
+
+class SmilesDialog:
+    """Dialog for entering a SMILES string."""
+
+    def __init__(self, parent):
+        self.result = None
+        self.dialog = tk.Toplevel(parent)
+        self.dialog.title("Enter SMILES")
+        self.dialog.geometry("400x150")
+        self.dialog.transient(parent)
+        self.dialog.grab_set()
+
+        ttk.Label(self.dialog, text="SMILES string:").pack(padx=10, pady=(10, 0), anchor="w")
+        self.entry = ttk.Entry(self.dialog, width=50)
+        self.entry.pack(padx=10, pady=5, fill="x")
+        self.entry.focus_set()
+        self.entry.bind("<Return>", lambda e: self._ok())
+
+        ttk.Label(self.dialog, text="Name (optional):").pack(padx=10, anchor="w")
+        self.name_entry = ttk.Entry(self.dialog, width=50)
+        self.name_entry.pack(padx=10, pady=5, fill="x")
+
+        bf = ttk.Frame(self.dialog)
+        bf.pack(pady=10)
+        ttk.Button(bf, text="OK", command=self._ok).pack(side="left", padx=5)
+        ttk.Button(bf, text="Cancel", command=self._cancel).pack(side="left", padx=5)
+
+        parent.wait_window(self.dialog)
+
+    def _ok(self):
+        smi = self.entry.get().strip()
+        name = self.name_entry.get().strip()
+        if smi:
+            self.result = (smi, name)
+        self.dialog.destroy()
+
+    def _cancel(self):
+        self.dialog.destroy()
+
+
+class FormulaDialog:
+    """Dialog for entering a molecular formula (for simple VSEPR molecules)."""
+
+    def __init__(self, parent):
+        self.result = None
+        self.dialog = tk.Toplevel(parent)
+        self.dialog.title("Enter Formula")
+        self.dialog.geometry("350x120")
+        self.dialog.transient(parent)
+        self.dialog.grab_set()
+
+        ttk.Label(self.dialog, text="Molecular formula (e.g. H2O, CH4):").pack(padx=10, pady=(10, 0), anchor="w")
+        self.entry = ttk.Entry(self.dialog, width=30)
+        self.entry.pack(padx=10, pady=5)
+        self.entry.focus_set()
+        self.entry.bind("<Return>", lambda e: self._ok())
+
+        ttk.Label(self.dialog, text="Charge:").pack(padx=10, anchor="w")
+        self.charge = ttk.Entry(self.dialog, width=5)
+        self.charge.insert(0, "0")
+        self.charge.pack(padx=10, pady=2, anchor="w")
+
+        bf = ttk.Frame(self.dialog)
+        bf.pack(pady=5)
+        ttk.Button(bf, text="OK", command=self._ok).pack(side="left", padx=5)
+        ttk.Button(bf, text="Cancel", command=self._cancel).pack(side="left", padx=5)
+
+        parent.wait_window(self.dialog)
+
+    def _ok(self):
+        formula = self.entry.get().strip()
+        try:
+            charge = int(self.charge.get().strip())
+        except ValueError:
+            charge = 0
+        if formula:
+            self.result = (formula, charge)
+        self.dialog.destroy()
+
+    def _cancel(self):
+        self.dialog.destroy()
+
+
+def file_open_dialog(parent, filetypes=None):
+    """Show file open dialog, return filepath or None."""
+    if filetypes is None:
+        filetypes = [
+            ("All supported", "*.xyz *.mol *.sdf *.pdb *.json *.smi"),
+            ("XYZ files", "*.xyz"),
+            ("MOL files", "*.mol"),
+            ("SDF files", "*.sdf"),
+            ("PDB files", "*.pdb"),
+            ("JSON files", "*.json"),
+            ("SMILES files", "*.smi"),
+            ("All files", "*.*"),
+        ]
+    return filedialog.askopenfilename(parent=parent, filetypes=filetypes)
+
+
+def file_save_dialog(parent, default_ext=".xyz", filetypes=None):
+    """Show file save dialog, return filepath or None."""
+    if filetypes is None:
+        filetypes = [
+            ("XYZ files", "*.xyz"),
+            ("MOL files", "*.mol"),
+            ("SDF files", "*.sdf"),
+            ("PDB files", "*.pdb"),
+            ("JSON files", "*.json"),
+            ("SMILES files", "*.smi"),
+        ]
+    return filedialog.asksaveasfilename(parent=parent, defaultextension=default_ext,
+                                        filetypes=filetypes)

molbuilder/gui/event_handler.py

@@ -0,0 +1,118 @@
+"""Event handler: atom placement, selection, coordinate computation."""
+
+from __future__ import annotations
+import numpy as np
+from molbuilder.molecule.graph import Molecule, Hybridization
+from molbuilder.core.bond_data import bond_length, SP3_ANGLE
+from molbuilder.core.geometry import normalize, available_tetrahedral_dirs
+
+
+class MolEventHandler:
+    """Manages molecule editing state and operations."""
+
+    def __init__(self):
+        self.mol = Molecule("untitled")
+        self.selected_atoms: list[int] = []  # selected atom indices
+        self.current_element = "C"
+        self.current_bond_order = 1
+
+    def add_atom_free(self, element: str = None) -> int:
+        """Add an atom at a computed position.
+
+        If no atoms exist, place at origin.
+        If atoms are selected, place bonded to the first selected atom.
+        Otherwise place bonded to the last atom.
+        """
+        sym = element or self.current_element
+
+        if len(self.mol.atoms) == 0:
+            idx = self.mol.add_atom(sym, [0.0, 0.0, 0.0], Hybridization.SP3)
+            return idx
+
+        # Determine attachment point
+        if self.selected_atoms:
+            parent = self.selected_atoms[0]
+        else:
+            parent = len(self.mol.atoms) - 1
+
+        idx = self.mol.add_atom_bonded(
+            sym, parent,
+            bond_order=self.current_bond_order,
+            hybridization=Hybridization.SP3,
+        )
+        return idx
+
+    def add_bond_between_selected(self) -> bool:
+        """Add a bond between two selected atoms."""
+        if len(self.selected_atoms) < 2:
+            return False
+        i, j = self.selected_atoms[0], self.selected_atoms[1]
+        existing = self.mol.get_bond(i, j)
+        if existing:
+            return False
+        self.mol.add_bond(i, j, order=self.current_bond_order)
+        return True
+
+    def delete_selected(self):
+        """Delete selected atoms (rebuild molecule without them)."""
+        if not self.selected_atoms:
+            return
+        keep = [i for i in range(len(self.mol.atoms)) if i not in self.selected_atoms]
+        if not keep:
+            self.mol = Molecule(self.mol.name)
+            self.selected_atoms.clear()
+            return
+
+        remap = {}
+        new_mol = Molecule(self.mol.name)
+        for new_i, old_i in enumerate(keep):
+            a = self.mol.atoms[old_i]
+            new_mol.add_atom(a.symbol, a.position.copy(), a.hybridization)
+            remap[old_i] = new_i
+
+        for bond in self.mol.bonds:
+            if bond.atom_i in remap and bond.atom_j in remap:
+                new_mol.add_bond(remap[bond.atom_i], remap[bond.atom_j],
+                                 bond.order, bond.rotatable)
+
+        self.mol = new_mol
+        self.selected_atoms.clear()
+
+    def add_hydrogens(self):
+        """Add missing hydrogens to all heavy atoms (simple valence fill)."""
+        from molbuilder.core.geometry import add_sp3_hydrogens
+
+        target_valence = {"C": 4, "N": 3, "O": 2, "S": 2, "P": 3, "B": 3}
+        for i, atom in enumerate(list(self.mol.atoms)):
+            if atom.symbol == "H":
+                continue
+            target = target_valence.get(atom.symbol)
+            if target is None:
+                continue
+            current = sum(b.order for b in self.mol.bonds
+                          if b.atom_i == i or b.atom_j == i)
+            needed = target - current
+            if needed > 0 and atom.symbol == "C":
+                add_sp3_hydrogens(self.mol, i, needed)
+            elif needed > 0:
+                # Generic hydrogen addition
+                from molbuilder.core.bond_data import bond_length as bl
+                pos = atom.position + np.array([0.0, 0.0, bl(atom.symbol, "H", 1)])
+                for _ in range(needed):
+                    h_idx = self.mol.add_atom_bonded("H", i, bond_order=1, rotatable=False)
+
+    def clear(self):
+        """Remove all atoms."""
+        self.mol = Molecule(self.mol.name)
+        self.selected_atoms.clear()
+
+    def toggle_selection(self, atom_idx: int):
+        """Toggle selection of an atom."""
+        if atom_idx in self.selected_atoms:
+            self.selected_atoms.remove(atom_idx)
+        else:
+            self.selected_atoms.append(atom_idx)
+
+    def clear_selection(self):
+        """Clear atom selection."""
+        self.selected_atoms.clear()

molbuilder/gui/sidebar.py

@@ -0,0 +1,105 @@
+"""Sidebar: molecule properties, analysis options."""
+
+import tkinter as tk
+from tkinter import ttk
+
+
+class MolSidebar(ttk.Frame):
+    """Side panel showing molecule properties and analysis controls."""
+
+    def __init__(self, parent, on_analyze=None):
+        super().__init__(parent, width=280)
+        self.pack_propagate(False)
+        self._on_analyze = on_analyze
+        self._build()
+
+    def _build(self):
+        # Info panel
+        info = ttk.LabelFrame(self, text="Molecule Info")
+        info.pack(fill="x", padx=5, pady=5)
+
+        self.name_var = tk.StringVar(value="(none)")
+        self.formula_var = tk.StringVar(value="")
+        self.atoms_var = tk.StringVar(value="0 atoms")
+        self.bonds_var = tk.StringVar(value="0 bonds")
+        self.mw_var = tk.StringVar(value="MW: --")
+
+        for var in [self.name_var, self.formula_var, self.atoms_var,
+                    self.bonds_var, self.mw_var]:
+            ttk.Label(info, textvariable=var).pack(anchor="w", padx=5)
+
+        # Analysis buttons
+        af = ttk.LabelFrame(self, text="Analysis")
+        af.pack(fill="x", padx=5, pady=5)
+        analyses = [
+            "Functional Groups",
+            "Bond Analysis",
+            "Stereochemistry",
+            "SMILES",
+            "Retrosynthesis",
+            "Process Engineering",
+        ]
+        for name in analyses:
+            b = ttk.Button(af, text=name,
+                           command=lambda n=name: self._analyze(n))
+            b.pack(fill="x", padx=5, pady=1)
+
+        # Export buttons
+        ef = ttk.LabelFrame(self, text="Export")
+        ef.pack(fill="x", padx=5, pady=5)
+        for fmt in ["XYZ", "MOL/SDF", "PDB", "JSON", "SMILES"]:
+            b = ttk.Button(ef, text=f"Save as {fmt}",
+                           command=lambda f=fmt: self._analyze(f"export_{f}"))
+            b.pack(fill="x", padx=5, pady=1)
+
+        # Results text area
+        rf = ttk.LabelFrame(self, text="Results")
+        rf.pack(fill="both", expand=True, padx=5, pady=5)
+        self.results_text = tk.Text(rf, wrap="word", bg="#111122",
+                                    fg="#ccddee", font=("Consolas", 9),
+                                    height=12)
+        scroll = ttk.Scrollbar(rf, orient="vertical",
+                               command=self.results_text.yview)
+        self.results_text.configure(yscrollcommand=scroll.set)
+        scroll.pack(side="right", fill="y")
+        self.results_text.pack(fill="both", expand=True)
+
+    def update_info(self, mol):
+        """Update displayed molecule info."""
+        if mol is None:
+            self.name_var.set("(none)")
+            self.formula_var.set("")
+            self.atoms_var.set("0 atoms")
+            self.bonds_var.set("0 bonds")
+            self.mw_var.set("MW: --")
+            return
+
+        self.name_var.set(mol.name or "(unnamed)")
+
+        # Compute formula
+        from collections import Counter
+        counts = Counter(a.symbol for a in mol.atoms)
+        formula = ""
+        for sym in ["C", "H", "N", "O", "S", "P"]:
+            if sym in counts:
+                formula += sym + (str(counts[sym]) if counts[sym] > 1 else "")
+                del counts[sym]
+        for sym in sorted(counts):
+            formula += sym + (str(counts[sym]) if counts[sym] > 1 else "")
+        self.formula_var.set(formula)
+
+        self.atoms_var.set(f"{len(mol.atoms)} atoms")
+        self.bonds_var.set(f"{len(mol.bonds)} bonds")
+
+        from molbuilder.core.elements import atomic_weight
+        mw = sum(atomic_weight(a.symbol) for a in mol.atoms)
+        self.mw_var.set(f"MW: {mw:.2f} g/mol")
+
+    def show_results(self, text: str):
+        """Display analysis results."""
+        self.results_text.delete("1.0", "end")
+        self.results_text.insert("1.0", text)
+
+    def _analyze(self, name):
+        if self._on_analyze:
+            self._on_analyze(name)

molbuilder/gui/toolbar.py

@@ -0,0 +1,71 @@
+"""Toolbar: element palette, bond tools, mode buttons."""
+
+import tkinter as tk
+from tkinter import ttk
+
+
+class MolToolbar(ttk.Frame):
+    """Toolbar with element selector, bond tools, and action buttons."""
+
+    COMMON_ELEMENTS = ["H", "C", "N", "O", "F", "P", "S", "Cl", "Br", "I"]
+    BOND_TYPES = [("Single", 1), ("Double", 2), ("Triple", 3)]
+
+    def __init__(self, parent, on_element_selected=None, on_bond_selected=None,
+                 on_action=None):
+        super().__init__(parent)
+        self._on_element = on_element_selected
+        self._on_bond = on_bond_selected
+        self._on_action = on_action
+        self.selected_element = tk.StringVar(value="C")
+        self.selected_bond = tk.IntVar(value=1)
+        self._build()
+
+    def _build(self):
+        # Element palette
+        ef = ttk.LabelFrame(self, text="Element")
+        ef.pack(side="left", padx=5, pady=2)
+        for sym in self.COMMON_ELEMENTS:
+            b = ttk.Radiobutton(ef, text=sym, value=sym,
+                                variable=self.selected_element,
+                                command=self._elem_changed)
+            b.pack(side="left", padx=1)
+
+        # Custom element entry
+        self._custom = ttk.Entry(ef, width=4)
+        self._custom.pack(side="left", padx=2)
+        self._custom.bind("<Return>", self._custom_elem)
+
+        # Bond type
+        bf = ttk.LabelFrame(self, text="Bond")
+        bf.pack(side="left", padx=5, pady=2)
+        for label, val in self.BOND_TYPES:
+            b = ttk.Radiobutton(bf, text=label, value=val,
+                                variable=self.selected_bond,
+                                command=self._bond_changed)
+            b.pack(side="left", padx=1)
+
+        # Action buttons
+        af = ttk.LabelFrame(self, text="Actions")
+        af.pack(side="left", padx=5, pady=2)
+        for label in ["Add Atom", "Add Bond", "Delete", "Add H", "Clear"]:
+            b = ttk.Button(af, text=label,
+                           command=lambda l=label: self._action(l))
+            b.pack(side="left", padx=2)
+
+    def _elem_changed(self):
+        if self._on_element:
+            self._on_element(self.selected_element.get())
+
+    def _custom_elem(self, event):
+        sym = self._custom.get().strip().capitalize()
+        if sym:
+            self.selected_element.set(sym)
+            self._elem_changed()
+
+    def _bond_changed(self):
+        if self._on_bond:
+            self._on_bond(self.selected_bond.get())
+
+    def _action(self, action):
+        if self._on_action:
+            self._on_action(action)

molbuilder/io/__init__.py

@@ -0,0 +1 @@
+"""File I/O: XYZ, JSON, MOL/SDF, PDB, SMILES."""

molbuilder/io/json_io.py

@@ -0,0 +1,146 @@
+"""JSON serialisation / deserialisation for Molecule objects.
+
+Schema::
+
+    {
+      "name": "ethanol",
+      "atoms": [
+        {"index": 0, "symbol": "C", "position": [0.0, 0.0, 0.0],
+         "hybridization": "SP3"},
+        ...
+      ],
+      "bonds": [
+        {"atom_i": 0, "atom_j": 1, "order": 1, "rotatable": true},
+        ...
+      ],
+      "properties": {
+        "formula": "C2H6O",
+        "atom_count": 9,
+        "bond_count": 8
+      }
+    }
+"""
+
+from __future__ import annotations
+
+import json
+from collections import Counter
+
+from molbuilder.molecule.graph import Molecule, Hybridization
+
+
+# ── Helpers ───────────────────────────────────────────────────────────
+
+# Map for serialising Hybridization to a string and back.
+_HYB_TO_STR = {
+    Hybridization.SP3: "SP3",
+    Hybridization.SP2: "SP2",
+    Hybridization.SP:  "SP",
+}
+_STR_TO_HYB = {v: k for k, v in _HYB_TO_STR.items()}
+
+
+def _molecular_formula(mol: Molecule) -> str:
+    """Return a Hill-system molecular formula (C first, H second, then
+    alphabetical)."""
+    counts: Counter[str] = Counter()
+    for atom in mol.atoms:
+        counts[atom.symbol] += 1
+
+    parts: list[str] = []
+    for sym in ("C", "H"):
+        if sym in counts:
+            n = counts.pop(sym)
+            parts.append(sym if n == 1 else f"{sym}{n}")
+    for sym in sorted(counts):
+        n = counts[sym]
+        parts.append(sym if n == 1 else f"{sym}{n}")
+    return "".join(parts)
+
+
+# ── Molecule -> dict -> JSON ──────────────────────────────────────────
+
+def _mol_to_dict(mol: Molecule) -> dict:
+    """Convert a Molecule to a JSON-serialisable dictionary."""
+    atoms = []
+    for atom in mol.atoms:
+        hyb_str = _HYB_TO_STR.get(atom.hybridization) if atom.hybridization else None
+        atoms.append({
+            "index": atom.index,
+            "symbol": atom.symbol,
+            "position": atom.position.tolist(),
+            "hybridization": hyb_str,
+        })
+
+    bonds = []
+    for bond in mol.bonds:
+        bonds.append({
+            "atom_i": bond.atom_i,
+            "atom_j": bond.atom_j,
+            "order": bond.order,
+            "rotatable": bond.rotatable,
+        })
+
+    return {
+        "name": mol.name,
+        "atoms": atoms,
+        "bonds": bonds,
+        "properties": {
+            "formula": _molecular_formula(mol),
+            "atom_count": len(mol.atoms),
+            "bond_count": len(mol.bonds),
+        },
+    }
+
+
+def _dict_to_mol(data: dict) -> Molecule:
+    """Reconstruct a Molecule from a JSON-derived dictionary."""
+    mol = Molecule(name=data.get("name", ""))
+
+    for atom_data in data["atoms"]:
+        hyb = None
+        hyb_str = atom_data.get("hybridization")
+        if hyb_str is not None:
+            hyb = _STR_TO_HYB.get(hyb_str)
+        mol.add_atom(
+            symbol=atom_data["symbol"],
+            position=atom_data["position"],
+            hybridization=hyb,
+        )
+
+    for bond_data in data["bonds"]:
+        mol.add_bond(
+            i=bond_data["atom_i"],
+            j=bond_data["atom_j"],
+            order=bond_data.get("order", 1),
+            rotatable=bond_data.get("rotatable", True),
+        )
+
+    return mol
+
+
+# ── String serialisation ─────────────────────────────────────────────
+
+def to_json_string(mol: Molecule, indent: int = 2) -> str:
+    """Serialise a Molecule to a JSON string."""
+    return json.dumps(_mol_to_dict(mol), indent=indent)
+
+
+def from_json_string(content: str) -> Molecule:
+    """Deserialise a Molecule from a JSON string."""
+    data = json.loads(content)
+    return _dict_to_mol(data)
+
+
+# ── File I/O ──────────────────────────────────────────────────────────
+
+def write_json(mol: Molecule, filepath: str) -> None:
+    """Write a Molecule to a JSON file."""
+    with open(filepath, "w") as f:
+        f.write(to_json_string(mol))
+
+def read_json(filepath: str) -> Molecule:
+    """Read a Molecule from a JSON file."""
+    with open(filepath, "r") as f:
+        content = f.read()
+    return from_json_string(content)