MoleditPy-linux 2.0.0__tar.gz → 2.1.0__tar.gz

{moleditpy_linux-2.0.0 → moleditpy_linux-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MoleditPy-linux
-Version: 2.0.0
+Version: 2.1.0
 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-2.0.0 → moleditpy_linux-2.1.0}/pyproject.toml

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

{moleditpy_linux-2.0.0 → moleditpy_linux-2.1.0}/src/MoleditPy_linux.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MoleditPy-linux
-Version: 2.0.0
+Version: 2.1.0
 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-2.0.0 → moleditpy_linux-2.1.0}/src/moleditpy_linux/modules/constants.py

@@ -16,7 +16,7 @@ from PyQt6.QtGui import QFont, QColor
 from rdkit import Chem
 
 #Version
-VERSION = '2.0.0'
+VERSION = '2.1.0'
 
 ATOM_RADIUS = 18
 BOND_OFFSET = 3.5

{moleditpy_linux-2.0.0 → moleditpy_linux-2.1.0}/src/moleditpy_linux/modules/main_window_main_init.py

@@ -1214,6 +1214,8 @@ class MainWindowMainInit(object):
         reload_plugins_action = QAction("Reload Plugins", self)
         reload_plugins_action.triggered.connect(lambda: self.update_plugin_menu(plugin_menu))
         plugin_menu.addAction(reload_plugins_action)
+
+
         
         plugin_menu.addSeparator()
         
@@ -1723,19 +1725,53 @@ class MainWindowMainInit(object):
         reload_plugins_action = QAction("Reload Plugins", self)
         reload_plugins_action.triggered.connect(lambda: self.update_plugin_menu(plugin_menu))
         plugin_menu.addAction(reload_plugins_action)
+
+        explore_plugins_action = QAction("Explore Plugins", self)
+        explore_plugins_action.triggered.connect(
+            lambda: QDesktopServices.openUrl(QUrl("https://github.com/HiroYokoyama/moleditpy-plugins"))
+        )
+        plugin_menu.addAction(explore_plugins_action)
         
         plugin_menu.addSeparator()
         
         # Add dynamic plugin actions
         plugins = self.plugin_manager.discover_plugins(self)
+        
         if not plugins:
             no_plugin_action = QAction("(No plugins found)", self)
             no_plugin_action.setEnabled(False)
             plugin_menu.addAction(no_plugin_action)
         else:
+            # Sort plugins: directories first (to create menus), then alphabetical by name
+            # Actually simple sort by rel_folder, name is fine
+            plugins.sort(key=lambda x: (x.get('rel_folder', ''), x['name']))
+            
+            # Dictionary to keep track of created submenus: path -> QMenu
+            menus = { "": plugin_menu }
+
             for p in plugins:
-                # Use default param in lambda to capture the current p
+                rel_folder = p.get('rel_folder', "")
+                
+                # Get or create the parent menu for this plugin
+                parent_menu = menus.get("") # Start at root
+                
+                if rel_folder:
+                    # Split path and traverse/create submenus
+                    parts = rel_folder.split(os.sep)
+                    current_path = ""
+                    for part in parts:
+                        new_path = os.path.join(current_path, part) if current_path else part
+                        
+                        if new_path not in menus:
+                            # Create new submenu
+                            sub_menu = parent_menu.addMenu(part)
+                            menus[new_path] = sub_menu
+                        
+                        parent_menu = menus[new_path]
+                        current_path = new_path
+
+                # Add action to the resolved parent_menu
                 action = QAction(p['name'], self)
                 action.triggered.connect(lambda checked, mod=p['module']: self.plugin_manager.run_plugin(mod, self.mw if hasattr(self, 'mw') else self)) 
-                plugin_menu.addAction(action)
+                parent_menu.addAction(action)
 

moleditpy_linux-2.1.0/src/moleditpy_linux/modules/plugin_manager.py

@@ -0,0 +1,120 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+plugin_manager.py
+Manages discovery, loading, and execution of external plugins.
+"""
+
+import os
+import sys
+import importlib.util
+import traceback
+from PyQt6.QtGui import QDesktopServices
+from PyQt6.QtCore import QUrl
+from PyQt6.QtWidgets import QMessageBox
+
+class PluginManager:
+    def __init__(self):
+        self.plugin_dir = os.path.join(os.path.expanduser('~'), '.moleditpy', 'plugins')
+        self.plugins = [] # List of {"name": str, "module": module_obj}
+
+    def ensure_plugin_dir(self):
+        """Creates the plugin directory if it creates doesn't exist."""
+        if not os.path.exists(self.plugin_dir):
+            try:
+                os.makedirs(self.plugin_dir)
+            except OSError as e:
+                print(f"Error creating plugin directory: {e}")
+
+    def open_plugin_folder(self):
+        """Opens the plugin directory in the OS file explorer."""
+        self.ensure_plugin_dir()
+        QDesktopServices.openUrl(QUrl.fromLocalFile(self.plugin_dir))
+
+    def discover_plugins(self, parent=None):
+        """
+        Recursively scans the plugin directory for .py files and attempts to import them.
+        Ignores __pycache__ and other directories starting with "__".
+        Returns a list of valid loaded plugins.
+        """
+        self.ensure_plugin_dir()
+        self.plugins = []
+        
+        if not os.path.exists(self.plugin_dir):
+            return []
+
+        for root, dirs, files in os.walk(self.plugin_dir):
+            # Modify dirs in-place to skip hidden directories and __pycache__
+            dirs[:] = [d for d in dirs if not d.startswith('__') and d != '__pycache__']
+            
+            for filename in files:
+                if filename.endswith(".py") and not filename.startswith("__"):
+                    filepath = os.path.join(root, filename)
+                    
+                    # Calculate relative folder path for menu structure
+                    # equivalent to: rel_path = os.path.relpath(root, self.plugin_dir)
+                    # if root is plugin_dir, rel_path is '.'
+                    rel_folder = os.path.relpath(root, self.plugin_dir)
+                    if rel_folder == '.':
+                        rel_folder = ""
+                        
+                    try:
+                        # Unique module name based on file path to avoid conflicts
+                        # e.g. plugins.subdir.myplugin
+                        module_name = os.path.splitext(os.path.relpath(filepath, self.plugin_dir))[0].replace(os.sep, '.')
+                        
+                        spec = importlib.util.spec_from_file_location(module_name, filepath)
+                        if spec and spec.loader:
+                            module = importlib.util.module_from_spec(spec)
+                            sys.modules[spec.name] = module 
+                            spec.loader.exec_module(module)
+
+                            # Check for required attributes
+                            plugin_name = getattr(module, 'PLUGIN_NAME', filename[:-3])
+                            
+                            # Valid plugin if it has 'run' OR 'autorun'
+                            has_run = hasattr(module, 'run') and callable(module.run)
+                            has_autorun = hasattr(module, 'autorun') and callable(module.autorun)
+                             
+                            if has_run:
+                                self.plugins.append({
+                                    'name': plugin_name,
+                                    'module': module,
+                                    'rel_folder': rel_folder
+                                })
+                            
+                            if has_autorun:
+                                try:
+                                    if parent:
+                                        module.autorun(parent)
+                                    else:
+                                        print(f"Skipping autorun for {plugin_name}: parent not provided.")
+                                except Exception as e:
+                                    print(f"Error executing autorun for {filename}: {e}")
+                                    traceback.print_exc()
+
+                            if not has_run and not has_autorun:
+                                print(f"Plugin {filename} skipped: Missing 'run(main_window)' or 'autorun(main_window)' function.")
+
+                    except Exception as e:
+                        # Robust error handling
+                        msg = f"Failed to load plugin {filename}:\n{e}"
+                        print(msg)
+                        traceback.print_exc()
+                        if parent:
+                            # Use print/status bar instead of popups for non-critical failures during bulk load?
+                            # For now, keep it visible but maybe less intrusive if many fail?
+                            # sticking to original logic just in catch block
+                            pass 
+        
+        return self.plugins
+
+    def run_plugin(self, module, main_window):
+        """Executes the plugin's run method."""
+        try:
+            module.run(main_window)
+        except Exception as e:
+            QMessageBox.critical(main_window, "Plugin Error", f"Error running plugin '{getattr(module, 'PLUGIN_NAME', 'Unknown')}':\n{e}")
+            traceback.print_exc()
+

moleditpy_linux-2.0.0/src/moleditpy_linux/modules/plugin_manager.py

@@ -1,85 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""
-plugin_manager.py
-Manages discovery, loading, and execution of external plugins.
-"""
-
-import os
-import sys
-import importlib.util
-import traceback
-from PyQt6.QtGui import QDesktopServices
-from PyQt6.QtCore import QUrl
-from PyQt6.QtWidgets import QMessageBox
-
-class PluginManager:
-    def __init__(self):
-        self.plugin_dir = os.path.join(os.path.expanduser('~'), '.moleditpy', 'plugins')
-        self.plugins = [] # List of {"name": str, "module": module_obj}
-
-    def ensure_plugin_dir(self):
-        """Creates the plugin directory if it creates doesn't exist."""
-        if not os.path.exists(self.plugin_dir):
-            try:
-                os.makedirs(self.plugin_dir)
-            except OSError as e:
-                print(f"Error creating plugin directory: {e}")
-
-    def open_plugin_folder(self):
-        """Opens the plugin directory in the OS file explorer."""
-        self.ensure_plugin_dir()
-        QDesktopServices.openUrl(QUrl.fromLocalFile(self.plugin_dir))
-
-    def discover_plugins(self, parent=None):
-        """
-        Scans the plugin directory for .py files and attempts to import them.
-        Returns a list of valid loaded plugins.
-        """
-        self.ensure_plugin_dir()
-        self.plugins = []
-        
-        if not os.path.exists(self.plugin_dir):
-            return []
-
-        for filename in os.listdir(self.plugin_dir):
-            if filename.endswith(".py") and not filename.startswith("__"):
-                filepath = os.path.join(self.plugin_dir, filename)
-                try:
-                    # Dynamically import the module
-                    spec = importlib.util.spec_from_file_location(filename[:-3], filepath)
-                    if spec and spec.loader:
-                        module = importlib.util.module_from_spec(spec)
-                        sys.modules[spec.name] = module # helper for relative imports if needed
-                        spec.loader.exec_module(module)
-
-                        # Check for required attributes
-                        plugin_name = getattr(module, 'PLUGIN_NAME', filename[:-3])
-                        
-                        # Validate that it has a run function
-                        if hasattr(module, 'run') and callable(module.run):
-                            self.plugins.append({
-                                'name': plugin_name,
-                                'module': module
-                            })
-                        else:
-                            print(f"Plugin {filename} skipped: Missing 'run(main_window)' function.")
-                except Exception as e:
-                    # Robust error handling with user notification
-                    msg = f"Failed to load plugin {filename}:\n{e}"
-                    print(msg)
-                    traceback.print_exc()
-                    if parent:
-                        QMessageBox.warning(parent, "Plugin Load Error", msg)
-        
-        return self.plugins
-
-    def run_plugin(self, module, main_window):
-        """Executes the plugin's run method."""
-        try:
-            module.run(main_window)
-        except Exception as e:
-            QMessageBox.critical(main_window, "Plugin Error", f"Error running plugin '{getattr(module, 'PLUGIN_NAME', 'Unknown')}':\n{e}")
-            traceback.print_exc()
-