MoleditPy-linux 4.0.2__py3-none-any.whl → 4.1.1__py3-none-any.whl

moleditpy_linux/core/mol_geometry.py

@@ -13,7 +13,21 @@ DOI: 10.5281/zenodo.17268532
 from __future__ import annotations
 import math
 from collections import deque
-from typing import Any, Dict, Iterable, List, Optional, Set, Tuple, Union
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Dict,
+    Iterable,
+    List,
+    Optional,
+    Set,
+    Tuple,
+    Union,
+)
+
+if TYPE_CHECKING:
+    from rdkit import Chem
 
 import numpy as np
 
@@ -82,7 +96,7 @@ def calc_angle_deg(
 
 
 def get_connected_group(
-    mol: Any, start_atom: int, exclude: Optional[int] = None
+    mol: Chem.Mol, start_atom: int, exclude: Optional[int] = None
 ) -> Set[int]:
     """Return the set of atom indices reachable from *start_atom*
     without passing through *exclude*.
@@ -422,7 +436,9 @@ def is_problematic_valence(
 
 
 def inject_ez_stereo_to_mol_block(
-    mol_block: str, rdkit_mol: Any, bonds_data: Dict[Tuple[int, int], Any]
+    mol_block: str,
+    rdkit_mol: Chem.Mol,
+    bonds_data: Dict[Tuple[int, int], Dict[str, Any]],
 ) -> str:
     """Generate a modified MOL block with 'M CFG' lines for E/Z stereochemistry.
 
@@ -504,7 +520,7 @@ def identify_valence_problems(
     problem_atom_ids = []
 
     # Pre-calculate bond orders per atom
-    bond_orders: Dict[int, int] = {}
+    bond_orders: Dict[int, float] = {}
     for (id1, id2), bond in bonds_data.items():
         order = bond.get("order", 1)
         bond_orders[id1] = bond_orders.get(id1, 0) + order
@@ -521,7 +537,7 @@ def identify_valence_problems(
     return problem_atom_ids
 
 
-def optimize_2d_coords(mol: Any) -> Dict[int, Tuple[float, float]]:
+def optimize_2d_coords(mol: Chem.Mol) -> Dict[int, Tuple[float, float]]:
     """Generate 2D coordinates using RDKit and return a map of (x, y) tuples."""
     from rdkit.Chem import AllChem
 
@@ -572,7 +588,7 @@ def resolve_2d_overlaps(
     adjacency_list: Dict[int, List[int]],
     overlap_threshold: float = 0.5,
     move_distance: float = 20,
-    has_bond_check_func: Optional[Any] = None,
+    has_bond_check_func: Optional[Callable[[int, int], bool]] = None,
 ) -> List[Tuple[Set[int], Tuple[float, float]]]:
     """Detect and resolve overlapping atom groups in 2D.
 
@@ -601,13 +617,13 @@ def resolve_2d_overlaps(
     # Union-Find for overlap groups
     parent = {aid: aid for aid in atom_ids}
 
-    def find_set(aid: Any) -> Any:
+    def find_set(aid: int) -> int:
         if parent[aid] == aid:
             return aid
         parent[aid] = find_set(parent[aid])
         return parent[aid]
 
-    def unite_sets(aid1: Any, aid2: Any) -> None:
+    def unite_sets(aid1: int, aid2: int) -> None:
         root1 = find_set(aid1)
         root2 = find_set(aid2)
         if root1 != root2:

moleditpy_linux/main.py

@@ -11,10 +11,12 @@ DOI: 10.5281/zenodo.17268532
 """
 
 import ctypes
-import sys
-import argparse
+import json
 import logging
+import logging.handlers
 import os
+import sys
+import argparse
 from typing import Any
 
 from .utils.constants import VERSION
@@ -46,22 +48,55 @@ def _qt_message_handler(mode: QtMsgType, _context: Any, message: str) -> None:
     logging.log(_QT_LOG_LEVEL.get(mode, logging.WARNING), "Qt: %s", message)
 
 
+def _read_startup_log_settings() -> tuple[bool, bool]:
+    """Read log_to_file and log_level_debug from settings.json before Qt starts.
+
+    Returns (log_to_file, log_level_debug). Falls back to (False, False) on any error.
+    """
+    settings_path = os.path.join(os.path.expanduser("~"), ".moleditpy", "settings.json")
+    try:
+        with open(settings_path, encoding="utf-8") as f:
+            data = json.load(f)
+        return bool(data.get("log_to_file", False)), bool(
+            data.get("log_level_debug", False)
+        )
+    except (OSError, json.JSONDecodeError, ValueError):
+        return False, False
+
+
 def setup_logging() -> None:
     """Configure root logger and install a global unhandled-exception handler."""
+    log_to_file, log_level_debug = _read_startup_log_settings()
+    level = logging.DEBUG if log_level_debug else logging.INFO
+    fmt = "%(asctime)s [%(levelname)s] %(name)s (%(pathname)s:%(lineno)d): %(message)s"
+
     logging.basicConfig(
-        level=logging.INFO,
-        format="%(asctime)s [%(levelname)s] %(name)s (%(pathname)s:%(lineno)d): %(message)s",
+        level=level,
+        format=fmt,
         stream=sys.stdout,
         force=True,
     )
 
+    if log_to_file:
+        log_dir = os.path.join(os.path.expanduser("~"), ".moleditpy")
+        try:
+            os.makedirs(log_dir, exist_ok=True)
+            log_path = os.path.join(log_dir, "moleditpy_linux.log")
+            fh = logging.handlers.RotatingFileHandler(
+                log_path, maxBytes=1_048_576, backupCount=3, encoding="utf-8"
+            )
+            fh.setLevel(level)
+            fh.setFormatter(logging.Formatter(fmt))
+            logging.getLogger().addHandler(fh)
+            logging.info("File logging enabled: %s", log_path)
+        except OSError as e:
+            logging.warning("Could not open log file: %s", e)
+
     def handle_exception(exc_type: Any, exc_value: Any, exc_traceback: Any) -> None:
         """Log unhandled exceptions using the configured logging system."""
         if issubclass(exc_type, KeyboardInterrupt):
-            # Allow keyboard interrupt to exit normally
             sys.__excepthook__(exc_type, exc_value, exc_traceback)
             return
-
         logging.error(
             "Uncaught exception", exc_info=(exc_type, exc_value, exc_traceback)
         )

moleditpy_linux/plugins/plugin_interface.py

@@ -10,6 +10,7 @@ Repo: https://github.com/HiroYokoyama/python_molecular_editor
 DOI: 10.5281/zenodo.17268532
 """
 
+import logging
 from typing import Any, Callable, List, Optional, Union
 
 
@@ -173,10 +174,11 @@ class PluginContext:
         """Switch the application UI layout to 3D viewer mode (Public API)."""
         mw = self.get_main_window()
         if mw is not None and hasattr(mw, "ui_manager"):
-            if hasattr(mw.ui_manager, "enter_3d_viewer_mode"):
-                mw.ui_manager.enter_3d_viewer_mode()
-            elif hasattr(mw.ui_manager, "enter_3d_viewer_ui_mode"):
-                mw.ui_manager.enter_3d_viewer_ui_mode()
+            fn = getattr(mw.ui_manager, "enter_3d_viewer_mode", None) or getattr(
+                mw.ui_manager, "enter_3d_viewer_ui_mode", None
+            )
+            if fn:
+                fn()
 
     def enter_3d_mode(self) -> None:
         """Switch UI layout to 3D viewer mode. Alias for enter_3d_viewer_mode."""
@@ -240,16 +242,11 @@ class PluginContext:
         """Force the 3D window to redraw using the current molecule."""
         mw = self.get_main_window()
         if mw and hasattr(mw, "view_3d_manager"):
-            mol = getattr(mw.view_3d_manager, "current_mol", None)
+            mol = mw.view_3d_manager.current_mol
             if mol:
                 mw.view_3d_manager.draw_molecule_3d(mol)
-            else:
-                # Also redraw/clear plotter if no molecule
-                if (
-                    hasattr(mw.view_3d_manager, "plotter")
-                    and mw.view_3d_manager.plotter
-                ):
-                    mw.view_3d_manager.plotter.render()
+            elif mw.view_3d_manager.plotter:
+                mw.view_3d_manager.plotter.render()
 
     def reset_3d_camera(self) -> None:
         """Zoom in and re-center the 3D viewport to fit the current molecule."""
@@ -370,7 +367,7 @@ class PluginContext:
             default: Value to return if the setting is not found.
         """
         mw = self.get_main_window()
-        if mw and hasattr(mw, "init_manager") and hasattr(mw.init_manager, "settings"):
+        if mw and hasattr(mw, "init_manager"):
             namespaced = f"plugin.{self._plugin_name}.{key}"
             return mw.init_manager.settings.get(namespaced, default)
         return default
@@ -387,11 +384,10 @@ class PluginContext:
             value: Value to store (must be JSON-serializable).
         """
         mw = self.get_main_window()
-        if mw and hasattr(mw, "init_manager") and hasattr(mw.init_manager, "settings"):
+        if mw and hasattr(mw, "init_manager"):
             namespaced = f"plugin.{self._plugin_name}.{key}"
             mw.init_manager.settings[namespaced] = value
-            if hasattr(mw.init_manager, "settings_dirty"):
-                mw.init_manager.settings_dirty = True
+            mw.init_manager.settings_dirty = True
 
     def mark_project_modified(self) -> None:
         """Mark the current project as having unsaved changes and update the window title."""
@@ -399,8 +395,9 @@ class PluginContext:
         if mw and hasattr(mw, "state_manager"):
             try:
                 mw.state_manager.has_unsaved_changes = True
-                if hasattr(mw.state_manager, "update_window_title"):
-                    mw.state_manager.update_window_title()
+                fn = getattr(mw.state_manager, "update_window_title", None)
+                if fn:
+                    fn()
             except Exception:
                 pass
 
@@ -414,14 +411,16 @@ class PluginContext:
         if mw is None:
             return
         if hasattr(mw, "state_manager"):
-            if hasattr(mw.state_manager, "update_realtime_info"):
-                mw.state_manager.update_realtime_info()
-            if hasattr(mw.state_manager, "update_window_title"):
-                mw.state_manager.update_window_title()
-        if hasattr(mw, "edit_actions_manager") and hasattr(
-            mw.edit_actions_manager, "update_undo_redo_actions"
-        ):
-            mw.edit_actions_manager.update_undo_redo_actions()
+            fn = getattr(mw.state_manager, "update_realtime_info", None)
+            if fn:
+                fn()
+            fn = getattr(mw.state_manager, "update_window_title", None)
+            if fn:
+                fn()
+        if hasattr(mw, "edit_actions_manager"):
+            fn = getattr(mw.edit_actions_manager, "update_undo_redo_actions", None)
+            if fn:
+                fn()
 
     def fit_3d_view(self) -> None:
         """Zoom and re-center the 3D viewport to fit the current molecule."""
@@ -489,8 +488,10 @@ class PluginContext:
         mw = self.get_main_window()
         if mw and hasattr(mw, "init_manager"):
             scene = getattr(mw.init_manager, "scene", None)
-            if scene is not None and hasattr(scene, "update_all_items"):
-                scene.update_all_items()
+            if scene is not None:
+                fn = getattr(scene, "update_all_items", None)
+                if fn:
+                    fn()
 
     def load_from_smiles(self, smiles: str) -> None:
         """Add a molecule from a SMILES string to the 2D editor."""
@@ -518,6 +519,7 @@ class PluginContext:
 
             return "\n".join(xyz_lines)
         except Exception:
+            logging.debug("to_xyz_block failed", exc_info=True)
             return None
 
 
@@ -541,8 +543,8 @@ class Plugin3DController:
         v3d = self._get_v3d()
         if v3d:
             v3d.update_atom_color_override(atom_index, color_hex)
-            if hasattr(self._mw, "plotter") and self._mw.plotter:
-                self._mw.plotter.render()
+            if v3d.plotter:
+                v3d.plotter.render()
 
     def set_bond_color(self, bond_index: int, color_hex: str) -> None:
         """
@@ -555,8 +557,8 @@ class Plugin3DController:
         v3d = self._get_v3d()
         if v3d:
             v3d.update_bond_color_override(bond_index, color_hex)
-            if hasattr(self._mw, "plotter") and self._mw.plotter:
-                self._mw.plotter.render()
+            if v3d.plotter:
+                v3d.plotter.render()
 
     def set_bond_color_by_atoms(
         self, atom_idx1: int, atom_idx2: int, color_hex: str
@@ -569,7 +571,8 @@ class Plugin3DController:
             atom_idx2: Second RDKit atom index.
             color_hex: Hex string e.g., "#00FF00".
         """
-        mol = getattr(self._mw, "current_mol", None)
+        v3d = self._get_v3d()
+        mol = v3d.current_mol if v3d else None
         if not mol:
             return
 

moleditpy_linux/plugins/plugin_manager_window.py

@@ -213,7 +213,7 @@ class PluginManagerWindow(QDialog):
                             "Success",
                             f"Removed '{plugin.get('name', 'Unknown')}'.",
                         )
-                    except (AttributeError, RuntimeError, ValueError) as e:
+                    except OSError as e:
                         QMessageBox.critical(
                             self, "Error", f"Failed to delete plugin: {e}"
                         )

moleditpy_linux/ui/app_state.py

@@ -542,13 +542,9 @@ class StateManager:
         # 3D viewer mode
         is_3d_mode = json_data.get("is_3d_viewer_mode", False)
         # Restore last successful optimization method if present in file
-        try:
-            method = json_data.get("last_successful_optimization_method", None)
-            with contextlib.suppress(AttributeError, RuntimeError, TypeError):
-                self.host.set_last_successful_optimization_method(method)
-        except (AttributeError, RuntimeError, TypeError):
-            # Safe defensive fallback catching AttributeError, RuntimeError, TypeError
-            pass
+        method = json_data.get("last_successful_optimization_method", None)
+        with contextlib.suppress(AttributeError, RuntimeError, TypeError):
+            self.host.set_last_successful_optimization_method(method)
 
         # Plugin State Restoration (Phase 3)
         self._preserved_plugin_data = {}  # Reset preserved data on new load

moleditpy_linux/ui/atom_item.py

@@ -11,7 +11,7 @@ DOI: 10.5281/zenodo.17268532
 """
 
 from __future__ import annotations
-from typing import Any, List, Optional
+from typing import TYPE_CHECKING, Any, List, Optional
 
 from PyQt6.QtCore import QPointF, QRectF, Qt
 from PyQt6.QtGui import (
@@ -23,7 +23,12 @@ from PyQt6.QtGui import (
     QPainterPath,
     QPen,
 )
-from PyQt6.QtWidgets import QGraphicsItem, QWidget
+from PyQt6.QtWidgets import (
+    QGraphicsItem,
+    QGraphicsSceneHoverEvent,
+    QStyleOptionGraphicsItem,
+    QWidget,
+)
 
 from ..utils.constants import (
     ATOM_RADIUS,
@@ -34,6 +39,9 @@ from ..utils.constants import (
 )
 from ..utils.sip_isdeleted_safe import sip_isdeleted_safe
 
+if TYPE_CHECKING:
+    from .bond_item import BondItem
+
 
 class AtomItem(QGraphicsItem):
     """2D scene item representing a single atom in the molecule editor."""
@@ -46,7 +54,7 @@ class AtomItem(QGraphicsItem):
         self.symbol: str = symbol
         self.charge: int = charge
         self.radical: int = radical
-        self.bonds: List[Any] = []
+        self.bonds: List[BondItem] = []
         self.chiral_label: Optional[str] = None
 
         self.setPos(pos)
@@ -67,16 +75,24 @@ class AtomItem(QGraphicsItem):
         """Refresh font, color, and visibility based on current scene settings."""
         if sip_isdeleted_safe(self):
             return
-        # Allow updating font preference dynamically
         font_size = 20
         font_family = FONT_FAMILY
+        font_bold = True
+        font_italic = False
+        font_underline = False
 
         scene = self.scene()
         if scene is not None and hasattr(scene, "get_setting"):
             font_size = scene.get_setting("atom_font_size_2d", 20)
             font_family = scene.get_setting("atom_font_family_2d", FONT_FAMILY)
-
-        self.font = QFont(font_family, font_size, FONT_WEIGHT_BOLD)
+            font_bold = scene.get_setting("atom_font_bold_2d", True)
+            font_italic = scene.get_setting("atom_font_italic_2d", False)
+            font_underline = scene.get_setting("atom_font_underline_2d", False)
+
+        weight = QFont.Weight.Bold if font_bold else QFont.Weight.Normal
+        self.font = QFont(font_family, font_size, weight)
+        self.font.setItalic(font_italic)
+        self.font.setUnderline(font_underline)
         self.prepareGeometryChange()
 
         self.is_visible = not (
@@ -89,16 +105,23 @@ class AtomItem(QGraphicsItem):
 
     def boundingRect(self) -> QRectF:
         """Calculate the bounding rectangle for the atom item."""
-        # --- Calculate text position and size using logic matching paint() ---
-        # Get dynamic font size and family
         font_size = 20
         font_family = FONT_FAMILY
+        font_bold = True
+        font_italic = False
+        font_underline = False
         scene = self.scene()
         if scene is not None and hasattr(scene, "get_setting"):
             font_size = scene.get_setting("atom_font_size_2d", 20)
             font_family = scene.get_setting("atom_font_family_2d", FONT_FAMILY)
-
-        font = QFont(font_family, font_size, FONT_WEIGHT_BOLD)
+            font_bold = scene.get_setting("atom_font_bold_2d", True)
+            font_italic = scene.get_setting("atom_font_italic_2d", False)
+            font_underline = scene.get_setting("atom_font_underline_2d", False)
+
+        weight = QFont.Weight.Bold if font_bold else QFont.Weight.Normal
+        font = QFont(font_family, font_size, weight)
+        font.setItalic(font_italic)
+        font.setUnderline(font_underline)
         fm = QFontMetricsF(font)
 
         hydrogen_part = ""
@@ -207,13 +230,21 @@ class AtomItem(QGraphicsItem):
 
         font_size = 20
         font_family = FONT_FAMILY
+        font_bold = True
+        font_italic = False
+        font_underline = False
         scene = self.scene()
-        if scene is not None:
-            if hasattr(scene, "get_setting"):
-                font_size = scene.get_setting("atom_font_size_2d", 20)
-                font_family = scene.get_setting("atom_font_family_2d", FONT_FAMILY)
-
-        font = QFont(font_family, font_size, FONT_WEIGHT_BOLD)
+        if scene is not None and hasattr(scene, "get_setting"):
+            font_size = scene.get_setting("atom_font_size_2d", 20)
+            font_family = scene.get_setting("atom_font_family_2d", FONT_FAMILY)
+            font_bold = scene.get_setting("atom_font_bold_2d", True)
+            font_italic = scene.get_setting("atom_font_italic_2d", False)
+            font_underline = scene.get_setting("atom_font_underline_2d", False)
+
+        weight = QFont.Weight.Bold if font_bold else QFont.Weight.Normal
+        font = QFont(font_family, font_size, weight)
+        font.setItalic(font_italic)
+        font.setUnderline(font_underline)
         fm = QFontMetricsF(font)
 
         hydrogen_part = ""
@@ -292,7 +323,7 @@ class AtomItem(QGraphicsItem):
     def paint(
         self,
         painter: Optional[QPainter],
-        option: Any,
+        option: QStyleOptionGraphicsItem,
         widget: Optional[QWidget] = None,
     ) -> None:
         """Paint the atom symbol and its associated labels (charge, radical)."""
@@ -484,14 +515,14 @@ class AtomItem(QGraphicsItem):
                 self.update_style()
         return res
 
-    def hoverEnterEvent(self, event: Any) -> None:
+    def hoverEnterEvent(self, event: QGraphicsSceneHoverEvent) -> None:
         """Highlight the atom on mouse hover."""
         # Enable highlight on hover regardless of scene mode
         self.hovered = True
         self.update()
         super().hoverEnterEvent(event)
 
-    def hoverLeaveEvent(self, event: Any) -> None:
+    def hoverLeaveEvent(self, event: QGraphicsSceneHoverEvent) -> None:
         """Remove hover highlight when the mouse leaves."""
         if self.hovered:
             self.hovered = False

moleditpy_linux/ui/bond_item.py

@@ -13,7 +13,7 @@ DOI: 10.5281/zenodo.17268532
 from __future__ import annotations
 import math
 import logging
-from typing import Any, Optional, Tuple, Union
+from typing import TYPE_CHECKING, Optional, Tuple, Union
 
 from PyQt6.QtCore import QLineF, QPointF, QRectF, Qt
 from PyQt6.QtGui import (
@@ -27,7 +27,13 @@ from PyQt6.QtGui import (
     QPen,
     QPolygonF,
 )
-from PyQt6.QtWidgets import QGraphicsItem, QGraphicsScene, QWidget
+from PyQt6.QtWidgets import (
+    QGraphicsItem,
+    QGraphicsScene,
+    QGraphicsSceneHoverEvent,
+    QStyleOptionGraphicsItem,
+    QWidget,
+)
 
 from ..utils.constants import (
     DESIRED_BOND_PIXEL_WIDTH,
@@ -39,6 +45,9 @@ from ..utils.constants import (
     HOVER_PEN_WIDTH,
 )
 
+if TYPE_CHECKING:
+    from .atom_item import AtomItem
+
 
 class BondItem(QGraphicsItem):
     """Visual representation of a molecular bond in the 2D scene."""
@@ -138,14 +147,18 @@ class BondItem(QGraphicsItem):
         return min(0.9, 0.8 + 0.1 * openness)
 
     def __init__(
-        self, atom1_item: Any, atom2_item: Any, order: int = 1, stereo: int = 0
+        self,
+        atom1_item: AtomItem,
+        atom2_item: AtomItem,
+        order: int = 1,
+        stereo: int = 0,
     ) -> None:
         super().__init__()
         # Validate input parameters
         if atom1_item is None or atom2_item is None:
             raise ValueError("BondItem requires non-None atom items")
-        self.atom1: Any = atom1_item
-        self.atom2: Any = atom2_item
+        self.atom1: Optional[AtomItem] = atom1_item
+        self.atom2: Optional[AtomItem] = atom2_item
         self.order: int = order
         self.stereo: int = stereo
 
@@ -314,7 +327,7 @@ class BondItem(QGraphicsItem):
     def paint(
         self,
         painter: Optional[QPainter],
-        option: Any,
+        option: QStyleOptionGraphicsItem,
         widget: Optional[QWidget] = None,
     ) -> None:
         """Render the bond as single, double, triple, wedge, or dashed line."""
@@ -506,21 +519,12 @@ class BondItem(QGraphicsItem):
                         # --- Label Settings ---
                         font_size = 20
                         font_family = FONT_FAMILY
-                        try:
-                            if self.scene() and self.scene().views():
-                                win = self.scene().views()[0].window()
-                                if win and hasattr(win, "settings"):
-                                    font_size = win.settings.get(
-                                        "atom_font_size_2d", 20
-                                    )
-                                    font_family = win.settings.get(
-                                        "atom_font_family_2d", FONT_FAMILY
-                                    )
-                        except (AttributeError, RuntimeError, TypeError, ValueError):
-                            # Silent failure for non-critical 2D atom font setting
-                            # If we can't get custom settings, we just use defaults.
-                            # Safe defensive fallback catching AttributeError, RuntimeError, TypeError, ValueError
-                            pass
+                        _sc = self.scene()
+                        if _sc is not None and hasattr(_sc, "get_setting"):
+                            font_size = _sc.get_setting("atom_font_size_2d", 20)
+                            font_family = _sc.get_setting(
+                                "atom_font_family_2d", FONT_FAMILY
+                            )
 
                         font = QFont(font_family, font_size, FONT_WEIGHT_BOLD)
                         font.setItalic(True)
@@ -598,7 +602,7 @@ class BondItem(QGraphicsItem):
             logging.exception("Error updating bond position")
             # Continue without crashing
 
-    def hoverEnterEvent(self, event: Any) -> None:
+    def hoverEnterEvent(self, event: QGraphicsSceneHoverEvent) -> None:
         """Highlight the bond on mouse hover."""
         self.hovered = True
         self.update()
@@ -606,7 +610,7 @@ class BondItem(QGraphicsItem):
             self.scene().set_hovered_item(self)
         super().hoverEnterEvent(event)
 
-    def hoverLeaveEvent(self, event: Any) -> None:
+    def hoverLeaveEvent(self, event: QGraphicsSceneHoverEvent) -> None:
         """Remove hover highlight when the mouse leaves."""
         if self.hovered:
             self.hovered = False