MoleditPy-linux 4.2.0__tar.gz → 4.2.2__tar.gz

{moleditpy_linux-4.2.0 → moleditpy_linux-4.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MoleditPy-linux
-Version: 4.2.0
+Version: 4.2.2
 Summary: A cross-platform, simple, and intuitive molecular structure editor built in Python. It allows 2D molecular drawing and 3D structure visualization. It supports exporting structure files for input to DFT calculation software.
 Author-email: HiroYokoyama <titech.yoko.hiro@gmail.com>
 License:                     GNU GENERAL PUBLIC LICENSE

{moleditpy_linux-4.2.0 → moleditpy_linux-4.2.2}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "MoleditPy-linux"
 
-version = "4.2.0"
+version = "4.2.2"
 
 license = {file = "LICENSE"}
 

{moleditpy_linux-4.2.0 → moleditpy_linux-4.2.2}/src/MoleditPy_linux.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MoleditPy-linux
-Version: 4.2.0
+Version: 4.2.2
 Summary: A cross-platform, simple, and intuitive molecular structure editor built in Python. It allows 2D molecular drawing and 3D structure visualization. It supports exporting structure files for input to DFT calculation software.
 Author-email: HiroYokoyama <titech.yoko.hiro@gmail.com>
 License:                     GNU GENERAL PUBLIC LICENSE

{moleditpy_linux-4.2.0 → moleditpy_linux-4.2.2}/src/moleditpy_linux/plugins/plugin_manager.py

@@ -485,12 +485,18 @@ class PluginManager:
         self, plugin_name: str, method_name: str, callback: Callable
     ) -> None:
         """Register a named 3D optimization method provided by a plugin."""
-        # Key by upper-case method name for consistency
-        self.optimization_methods[method_name.upper()] = {
+        method_key = method_name.upper()
+        self.optimization_methods[method_key] = {
             "plugin": plugin_name,
             "callback": callback,
             "label": method_name,
         }
+        if hasattr(self.main_window, "init_manager") and hasattr(
+            self.main_window.init_manager, "add_optimization_method"
+        ):
+            self.main_window.init_manager.add_optimization_method(
+                method_name, method_key
+            )
 
     def register_file_opener(
         self, plugin_name: str, extension: str, callback: Callable, priority: int = 0

{moleditpy_linux-4.2.0 → moleditpy_linux-4.2.2}/src/moleditpy_linux/ui/compute_logic.py

@@ -45,6 +45,9 @@ class ComputeManager:
         self.halt_ids: Set[int] = set()
         self.next_conversion_id: int = 1
         self.active_worker_ids: Set[int] = set()
+        # worker_id -> (method_key, plugin_entry) for a plugin optimizer to run
+        # as a post-step once conversion's built-in pre-optimization completes.
+        self._pending_plugin_opt: Dict[int, Tuple[str, Dict[str, Any]]] = {}
 
     def reset_active_threads(self) -> None:
         """Reset active calculation threads list."""
@@ -178,20 +181,10 @@ class ComputeManager:
             return
 
         menu = QMenu(self.host)
-        opt_list = [
-            ("MMFF94s (RDKit)", "MMFF_RDKIT"),
-            ("MMFF94 (RDKit)", "MMFF94_RDKIT"),
-            ("UFF (RDKit)", "UFF_RDKIT"),
-            ("MMFF94s (Open Babel)", "MMFF94s_OBABEL"),
-            ("MMFF94 (Open Babel)", "MMFF94_OBABEL"),
-            ("UFF (Open Babel)", "UFF_OBABEL"),
-            ("GAFF (Open Babel)", "GAFF_OBABEL"),
-            ("Ghemical (Open Babel)", "GHEMICAL_OBABEL"),
-        ]
-        for label, key in opt_list:
+        for key, source_action in self.host.init_manager.opt3d_actions.items():
+            label = source_action.text().replace("&", "")
             a = QAction(label, self.host)
-            if key in self.host.init_manager.opt3d_actions:
-                a.setEnabled(self.host.init_manager.opt3d_actions[key].isEnabled())
+            a.setEnabled(source_action.isEnabled())
             a.triggered.connect(
                 lambda checked=False, k=key: self._trigger_optimize_with_temp_method(k)
             )
@@ -249,6 +242,25 @@ class ComputeManager:
         self.next_conversion_id = run_id + 1
         self.active_worker_ids.add(run_id)
 
+        # The worker only runs built-in force fields. If the selected method is a
+        # plugin optimizer, pre-optimize with MMFF (RDKit) in the worker (which
+        # auto-falls-back to UFF if MMFF setup fails), then run the plugin
+        # callback as a post-step in on_calculation_finished.
+        effective_method = (
+            optimization_method
+            or self.host.init_manager.optimization_method
+            or "MMFF_RDKIT"
+        ).upper()
+        _reg = getattr(
+            getattr(self.host, "plugin_manager", None), "optimization_methods", None
+        )
+        plugin_entry = _reg.get(effective_method) if isinstance(_reg, dict) else None
+        if plugin_entry:
+            self._pending_plugin_opt[run_id] = (effective_method, plugin_entry)
+            worker_method = "MMFF_RDKIT"
+        else:
+            worker_method = effective_method
+
         # UI Updates
         self.host.init_manager.convert_button.setText("Halt conversion")  # type: ignore[union-attr]
         self._safe_disconnect(self.host.init_manager.convert_button.clicked)  # type: ignore[union-attr]
@@ -277,8 +289,7 @@ class ComputeManager:
         options = {
             "conversion_mode": conversion_mode
             or self.host.init_manager.settings.get("3d_conversion_mode", "fallback"),
-            "optimization_method": optimization_method
-            or self.host.init_manager.optimization_method,
+            "optimization_method": worker_method,
             "optimize_intermolecular_interaction_rdkit": self.host.init_manager.settings.get(
                 "optimize_intermolecular_interaction_rdkit", True
             ),
@@ -295,6 +306,7 @@ class ComputeManager:
         if wids_to_halt:
             self.halt_ids.update(wids_to_halt)
         self.active_worker_ids.clear()
+        self._pending_plugin_opt.clear()
 
         self._restore_button_ui()
         self.host.init_manager.cleanup_button.setEnabled(True)  # type: ignore[union-attr]
@@ -539,6 +551,16 @@ class ComputeManager:
         self.host.view_3d_manager.update_atom_id_menu_text()
         self.host.view_3d_manager.update_atom_id_menu_state()
 
+        # If the selected method was a plugin optimizer, the worker only did the
+        # built-in pre-optimization; run the plugin callback now on the result.
+        pending = (
+            self._pending_plugin_opt.pop(worker_id, None)
+            if worker_id is not None
+            else None
+        )
+        if pending and mol:
+            self._run_plugin_optimization(*pending)
+
     def on_calculation_error(self, message: Union[str, Tuple[int, str]]) -> None:
         """Handle an error or halt signal from the background optimization worker."""
         # Accept either a string or (worker_id, message) tuple from the worker signal
@@ -557,8 +579,10 @@ class ComputeManager:
                     self.host.statusBar().showMessage(  # type: ignore[union-attr]
                         f"Ignored stale worker error: {msg} (ID = {worker_id})"
                     )
+                self._pending_plugin_opt.pop(worker_id, None)
                 return  # stale worker, ignore
             self.active_worker_ids.discard(worker_id)
+            self._pending_plugin_opt.pop(worker_id, None)
         else:
             msg = str(message)
 

{moleditpy_linux-4.2.0 → moleditpy_linux-4.2.2}/src/moleditpy_linux/ui/main_window_init.py

@@ -1648,7 +1648,7 @@ class MainInitManager:
             self.conv_actions[saved_conv].setChecked(True)
         self.settings["3d_conversion_mode"] = saved_conv
 
-        optimization_menu = settings_menu.addMenu("3D Optimization Settings")
+        self.optimization_menu = settings_menu.addMenu("3D Optimization Settings")
         opt_methods = [
             ("MMFF94s (RDKit)", "MMFF_RDKIT"),
             ("MMFF94 (RDKit)", "MMFF94_RDKIT"),
@@ -1660,8 +1660,8 @@ class MainInitManager:
             ("Ghemical (Open Babel)", "GHEMICAL_OBABEL"),
         ]
         self.opt3d_method_labels = {key.upper(): label for (label, key) in opt_methods}
-        opt_group = QActionGroup(self.host)
-        opt_group.setExclusive(True)
+        self.opt_group = QActionGroup(self.host)
+        self.opt_group.setExclusive(True)
         self.opt3d_actions = {}
         for label, key in opt_methods:
             action = QAction(label, self.host)
@@ -1672,11 +1672,11 @@ class MainInitManager:
                 lambda checked,
                 m=key: self.host.compute_manager.set_optimization_method(m)
             )
-            optimization_menu.addAction(action)
-            opt_group.addAction(action)
+            self.optimization_menu.addAction(action)
+            self.opt_group.addAction(action)
             self.opt3d_actions[key] = action
 
-        optimization_menu.addSeparator()
+        self.opt3d_separator = self.optimization_menu.addSeparator()
         self.host.intermolecular_rdkit_action = QAction(
             "Consider Intermolecular Interaction for RDKit", self.host
         )
@@ -1687,7 +1687,7 @@ class MainInitManager:
         self.host.intermolecular_rdkit_action.triggered.connect(
             self.host.compute_manager.toggle_intermolecular_interaction_rdkit
         )
-        optimization_menu.addAction(self.host.intermolecular_rdkit_action)
+        self.optimization_menu.addAction(self.host.intermolecular_rdkit_action)
 
         saved_opt = (self.settings.get("optimization_method") or "MMFF_RDKIT").upper()
         if (
@@ -1705,6 +1705,31 @@ class MainInitManager:
         reset_settings_action.triggered.connect(self.reset_all_settings_menu)
         settings_menu.addAction(reset_settings_action)
 
+    def add_optimization_method(self, label: str, key: str) -> None:
+        """Dynamically add an optimization method to the menu."""
+        key_upper = key.upper()
+        if key_upper in self.opt3d_actions:
+            return
+
+        self.opt3d_method_labels[key_upper] = label
+        action = QAction(label, self.host)
+        action.setCheckable(True)
+        action.triggered.connect(
+            lambda checked,
+            m=key_upper: self.host.compute_manager.set_optimization_method(m)
+        )
+
+        self.optimization_menu.insertAction(self.opt3d_separator, action)
+        self.opt_group.addAction(action)
+        self.opt3d_actions[key_upper] = action
+
+        # Plugins register after menu-init, so restore the saved default here
+        # if it names this method (menu-init fell back to MMFF_RDKIT).
+        saved_opt = (self.settings.get("optimization_method") or "").upper()
+        if key_upper == saved_opt:
+            action.setChecked(True)
+            self.optimization_method = key_upper
+
     def _init_help_menu(self, menu_bar: Any) -> None:
         """Initialize the Help menu."""
         help_menu = menu_bar.addMenu("&Help")

{moleditpy_linux-4.2.0 → moleditpy_linux-4.2.2}/src/moleditpy_linux/ui/plugin_menu_manager.py

@@ -81,6 +81,7 @@ class PluginMenuManager:
         self.integrate_plugin_export_actions()
         self.integrate_plugin_file_openers()
         self.integrate_plugin_analysis_tools()
+        self.integrate_plugin_optimization_methods()
 
     def rebuild_plugin_menus(self) -> None:
         """Fully rebuild all plugin-managed UI after an install/uninstall.
@@ -120,6 +121,7 @@ class PluginMenuManager:
             (self.integrate_plugin_file_openers, "file openers"),
             (self.integrate_plugin_analysis_tools, "analysis tools"),
             (self.update_style_menu_with_plugins, "style menu"),
+            (self.integrate_plugin_optimization_methods, "optimization methods"),
         ]:
             try:
                 method()
@@ -366,6 +368,32 @@ class PluginMenuManager:
                 a.setData(PLUGIN_ACTION_TAG)
                 menu.addAction(a)
 
+    def integrate_plugin_optimization_methods(self) -> None:
+        """Inject plugin optimization methods into the 3D Optimization Settings menu.
+
+        Idempotent: previously-added plugin methods are purged first, so a menu
+        rebuild (install/uninstall/reload) re-adds only the currently registered
+        ones. Without this, _clean_menu removes the menu action while
+        opt3d_actions still holds it, and add_optimization_method's dedupe guard
+        would then skip re-adding a still-installed method.
+        """
+        im = self._im
+        methods = getattr(im.host.plugin_manager, "optimization_methods", None)
+        if not isinstance(methods, dict):
+            return
+
+        for key, action in list(im.opt3d_actions.items()):
+            if action.data() == "plugin_managed":
+                im.opt_group.removeAction(action)
+                im.optimization_menu.removeAction(action)
+                del im.opt3d_actions[key]
+                im.opt3d_method_labels.pop(key, None)
+
+        for key, entry in methods.items():
+            im.add_optimization_method(entry["label"], key)
+            if key in im.opt3d_actions:
+                im.opt3d_actions[key].setData("plugin_managed")
+
     def integrate_plugin_file_openers(self) -> None:
         """Inject plugin file-opener entries into the File > Import menu."""
         if not self._im.host.plugin_manager.file_openers: