MoleditPy-linux 2.2.4__py3-none-any.whl

moleditpy_linux/modules/plugin_manager.py

@@ -0,0 +1,309 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+MoleditPy — A Python-based molecular editing software
+
+Author: Hiromichi Yokoyama
+License: GPL-3.0 license
+Repo: https://github.com/HiroYokoyama/python_molecular_editor
+DOI: 10.5281/zenodo.17268532
+"""
+
+"""
+plugin_manager.py
+Manages discovery, loading, and execution of external plugins.
+"""
+
+import os
+import sys
+import shutil
+import importlib.util
+import traceback
+import ast
+from PyQt6.QtGui import QDesktopServices
+from PyQt6.QtCore import QUrl
+from PyQt6.QtWidgets import QMessageBox
+
+try:
+    from .plugin_interface import PluginContext
+except ImportError:
+    # Fallback if running as script
+    from modules.plugin_interface import PluginContext
+
+class PluginManager:
+    def __init__(self, main_window=None):
+        self.plugin_dir = os.path.join(os.path.expanduser('~'), '.moleditpy', 'plugins')
+        self.plugins = [] # List of dicts
+        self.main_window = main_window
+        
+        # Registries for actions
+        self.menu_actions = [] # List of (plugin_name, path, callback, text, icon, shortcut)
+        self.toolbar_actions = [] 
+        self.drop_handlers = [] # List of (priority, plugin_name, callback)
+        
+        # Extended Registries (Added to prevent lazy initialization "monkey patching")
+        self.export_actions = [] 
+        self.optimization_methods = {}
+        self.file_openers = {}
+        self.analysis_tools = []
+        self.save_handlers = {}
+        self.load_handlers = {}
+        self.custom_3d_styles = {} # style_name -> {'plugin': name, 'callback': func}
+
+    def get_main_window(self):
+        return self.main_window
+
+    def set_main_window(self, mw):
+        self.main_window = mw
+
+    def ensure_plugin_dir(self):
+        """Creates the plugin directory if it 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 install_plugin(self, file_path):
+        """Copies a plugin file to the plugin directory."""
+        self.ensure_plugin_dir()
+        try:
+            filename = os.path.basename(file_path)
+            dest_path = os.path.join(self.plugin_dir, filename)
+            shutil.copy2(file_path, dest_path)
+            # Reload plugins after install
+            if self.main_window:
+                self.discover_plugins(self.main_window)
+            return True, f"Installed {filename}"
+        except Exception as e:
+            return False, str(e)
+
+    def discover_plugins(self, parent=None):
+        """
+        Recursively scans the plugin directory.
+        Supports both legacy autorun(parent) and new initialize(context).
+        """
+        if parent:
+            self.main_window = parent
+            
+        self.ensure_plugin_dir()
+        self.plugins = []
+        self.menu_actions = []
+        self.toolbar_actions = []
+        self.drop_handlers = []
+        
+        # Clear extended registries
+        self.export_actions = [] 
+        self.optimization_methods = {}
+        self.file_openers = {}
+        self.analysis_tools = []
+        self.save_handlers = {}
+        self.load_handlers = {}
+        self.custom_3d_styles = {}
+        
+        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)
+                    rel_folder = os.path.relpath(root, self.plugin_dir)
+                    if rel_folder == '.':
+                        rel_folder = ""
+                        
+                    try:
+                        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)
+
+                            # --- Metadata Extraction ---
+                            plugin_name = getattr(module, 'PLUGIN_NAME', filename[:-3])
+                            plugin_version = getattr(module, 'PLUGIN_VERSION', getattr(module, '__version__', 'Unknown'))
+                            plugin_author = getattr(module, 'PLUGIN_AUTHOR', getattr(module, '__author__', 'Unknown'))
+                            plugin_desc = getattr(module, 'PLUGIN_DESCRIPTION', getattr(module, '__doc__', ''))
+                            
+                            # Clean up docstring if used as description
+                            if plugin_desc:
+                                plugin_desc = plugin_desc.strip().split('\n')[0]
+
+                            # check for interface compliance
+                            has_run = hasattr(module, 'run') and callable(module.run)
+                            has_autorun = hasattr(module, 'autorun') and callable(module.autorun)
+                            has_init = hasattr(module, 'initialize') and callable(module.initialize)
+                            
+                            status = "Loaded"
+                            
+                            # Execute loading logic
+                            if has_init:
+                                context = PluginContext(self, plugin_name)
+                                try:
+                                    module.initialize(context)
+                                except Exception as e:
+                                    status = f"Error (Init): {e}"
+                                    print(f"Plugin {plugin_name} initialize error: {e}")
+                                    traceback.print_exc()
+                            elif has_autorun:
+                                try:
+                                    if self.main_window:
+                                        module.autorun(self.main_window)
+                                    else:
+                                        status = "Skipped (No MW)"
+                                except Exception as e:
+                                    status = f"Error (Autorun): {e}"
+                                    print(f"Plugin {plugin_name} autorun error: {e}")
+                                    traceback.print_exc()
+                            elif not has_run:
+                                status = "No Entry Point"
+
+                            self.plugins.append({
+                                'name': plugin_name,
+                                'version': plugin_version,
+                                'author': plugin_author,
+                                'description': plugin_desc,
+                                'module': module,
+                                'rel_folder': rel_folder,
+                                'status': status,
+                                'filepath': filepath,
+                                'has_run': has_run # for menu manual run
+                            })
+                            
+                    except Exception as e:
+                        print(f"Failed to load plugin {filename}: {e}")
+                        traceback.print_exc()
+        
+        return self.plugins
+
+    def run_plugin(self, module, main_window):
+        """Executes the plugin's run method (Legacy manual trigger)."""
+        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()
+
+    # --- Registration Callbacks ---
+    def register_menu_action(self, plugin_name, path, callback, text, icon, shortcut):
+        self.menu_actions.append({
+            'plugin': plugin_name, 'path': path, 'callback': callback,
+            'text': text, 'icon': icon, 'shortcut': shortcut
+        })
+    
+    def register_toolbar_action(self, plugin_name, callback, text, icon, tooltip):
+        self.toolbar_actions.append({
+            'plugin': plugin_name, 'callback': callback, 
+            'text': text, 'icon': icon, 'tooltip': tooltip
+        })
+
+
+        
+    def register_drop_handler(self, plugin_name, callback, priority):
+        self.drop_handlers.append({
+            'priority': priority, 'plugin': plugin_name, 'callback': callback
+        })
+        # Sort by priority desc
+        self.drop_handlers.sort(key=lambda x: x['priority'], reverse=True)
+
+    def register_export_action(self, plugin_name, label, callback):
+        self.export_actions.append({
+            'plugin': plugin_name, 'label': label, 'callback': callback
+        })
+
+    def register_optimization_method(self, plugin_name, method_name, callback):
+        # Key by upper-case method name for consistency
+        self.optimization_methods[method_name.upper()] = {
+            'plugin': plugin_name, 'callback': callback, 'label': method_name
+        }
+
+    def register_file_opener(self, plugin_name, extension, callback):
+        # Normalize extension to lowercase
+        ext = extension.lower()
+        if not ext.startswith('.'):
+            ext = '.' + ext
+        self.file_openers[ext] = {
+            'plugin': plugin_name, 'callback': callback
+        }
+
+    # Analysis Tools registration
+    def register_analysis_tool(self, plugin_name, label, callback):
+        self.analysis_tools.append({'plugin': plugin_name, 'label': label, 'callback': callback})
+
+    # State Persistence registration
+    def register_save_handler(self, plugin_name, callback):
+        self.save_handlers[plugin_name] = callback
+
+    def register_load_handler(self, plugin_name, callback):
+        self.load_handlers[plugin_name] = callback
+
+    def register_3d_style(self, plugin_name, style_name, callback):
+        self.custom_3d_styles[style_name] = {
+            'plugin': plugin_name, 'callback': callback
+        }
+
+    def get_plugin_info_safe(self, file_path):
+        """Extracts plugin metadata using AST parsing (safe, no execution)."""
+        info = {
+            'name': os.path.basename(file_path),
+            'version': 'Unknown',
+            'author': 'Unknown',
+            'description': ''
+        }
+        try:
+             with open(file_path, "r", encoding="utf-8") as f:
+                 tree = ast.parse(f.read())
+             
+             for node in tree.body:
+                 if isinstance(node, ast.Assign):
+                     for target in node.targets:
+                         if isinstance(target, ast.Name):
+                             # Helper to extract value
+                             val = None
+                             if isinstance(node.value, ast.Constant): # Py3.8+
+                                 val = node.value.value
+                             elif hasattr(ast, 'Str') and isinstance(node.value, ast.Str): # Py3.7 and below
+                                 val = node.value.s
+                             
+                             if val is not None:
+                                 if target.id == 'PLUGIN_NAME':
+                                     info['name'] = val
+                                 elif target.id == 'PLUGIN_VERSION':
+                                     info['version'] = val
+                                 elif target.id == 'PLUGIN_AUTHOR':
+                                     info['author'] = val
+                                 elif target.id == 'PLUGIN_DESCRIPTION':
+                                     info['description'] = val
+                                 elif target.id == '__version__' and info['version'] == 'Unknown':
+                                     info['version'] = val
+                                 elif target.id == '__author__' and info['author'] == 'Unknown':
+                                     info['author'] = val
+                 
+                 # Docstring extraction
+                 if isinstance(node, ast.Expr):
+                     val = None
+                     if isinstance(node.value, ast.Constant) and isinstance(node.value.value, str):
+                          val = node.value.value
+                     elif hasattr(ast, 'Str') and isinstance(node.value, ast.Str):
+                          val = node.value.s
+                          
+                     if val and not info['description']:
+                          info['description'] = val.strip().split('\n')[0]
+
+        except Exception as e:
+            print(f"Error parsing plugin info: {e}")
+        return info
+
+
+

moleditpy_linux/modules/plugin_manager_window.py

@@ -0,0 +1,221 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+MoleditPy — A Python-based molecular editing software
+
+Author: Hiromichi Yokoyama
+License: GPL-3.0 license
+Repo: https://github.com/HiroYokoyama/python_molecular_editor
+DOI: 10.5281/zenodo.17268532
+"""
+
+import os
+import sys
+from PyQt6.QtWidgets import (
+    QDialog, QVBoxLayout, QHBoxLayout, QPushButton, QTableWidget, 
+    QTableWidgetItem, QHeaderView, QLabel, QFileDialog, QMessageBox, QAbstractItemView
+)
+from PyQt6.QtCore import Qt, QMimeData, QUrl
+from PyQt6.QtGui import QDragEnterEvent, QDropEvent, QDesktopServices
+
+class PluginManagerWindow(QDialog):
+    def __init__(self, plugin_manager, parent=None):
+        super().__init__(parent)
+        self.plugin_manager = plugin_manager
+        self.setWindowTitle("Plugin Manager")
+        self.resize(800, 500)
+        self.setAcceptDrops(True) # Enable drag & drop for the whole window
+        
+        self.init_ui()
+        self.refresh_plugin_list()
+
+    def init_ui(self):
+        layout = QVBoxLayout(self)
+        
+        # Header / Instruction
+        lbl_info = QLabel("Drag & Drop .py files here to install plugins.")
+        lbl_info.setStyleSheet("color: gray; font-style: italic;")
+        layout.addWidget(lbl_info)
+
+        # Plugin Table
+        self.table = QTableWidget()
+        self.table.setColumnCount(6)
+        self.table.setHorizontalHeaderLabels(["Status", "Name", "Version", "Author", "Location", "Description"])
+        self.table.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeMode.Interactive)
+        self.table.horizontalHeader().setSectionResizeMode(4, QHeaderView.ResizeMode.Interactive) 
+        self.table.horizontalHeader().setSectionResizeMode(5, QHeaderView.ResizeMode.Stretch) # Description stretches
+        self.table.setColumnWidth(1, 200) # Make Name column wider
+        self.table.setSelectionBehavior(QAbstractItemView.SelectionBehavior.SelectRows)
+        self.table.setEditTriggers(QAbstractItemView.EditTrigger.NoEditTriggers)
+        self.table.itemSelectionChanged.connect(self.update_button_state)
+        self.table.itemDoubleClicked.connect(self.show_plugin_details)
+        layout.addWidget(self.table)
+
+        # Buttons
+        btn_layout = QHBoxLayout()
+        
+        btn_reload = QPushButton("Reload Plugins")
+        btn_reload.clicked.connect(self.on_reload)
+        btn_layout.addWidget(btn_reload)
+        
+        btn_folder = QPushButton("Open Plugin Folder")
+        btn_folder.clicked.connect(self.plugin_manager.open_plugin_folder)
+        btn_layout.addWidget(btn_folder)
+        
+        self.btn_remove = QPushButton("Remove Plugin")
+        self.btn_remove.clicked.connect(self.on_remove_plugin)
+        self.btn_remove.setEnabled(False)
+        btn_layout.addWidget(self.btn_remove)
+
+        btn_explore = QPushButton("Explore Plugins Online")
+        btn_explore.clicked.connect(lambda: QDesktopServices.openUrl(QUrl("https://hiroyokoyama.github.io/moleditpy-plugins/explorer/")))
+        btn_layout.addWidget(btn_explore)
+
+        btn_close = QPushButton("Close")
+        btn_close.clicked.connect(self.close)
+        btn_layout.addStretch()
+        btn_layout.addWidget(btn_close)
+        
+        layout.addLayout(btn_layout)
+
+    def refresh_plugin_list(self):
+        self.table.setRowCount(0)
+        plugins = self.plugin_manager.plugins
+        
+        self.table.setRowCount(len(plugins))
+        for row, p in enumerate(plugins):
+            status_item = QTableWidgetItem(str(p.get('status', 'Unknown')))
+            status_item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
+            self.table.setItem(row, 0, status_item)
+            self.table.setItem(row, 1, QTableWidgetItem(str(p.get('name', 'Unknown'))))
+            self.table.setItem(row, 2, QTableWidgetItem(str(p.get('version', ''))))
+            self.table.setItem(row, 3, QTableWidgetItem(str(p.get('author', ''))))
+            
+            # Location (Relative Path)
+            full_path = p.get('filepath', '')
+            rel_path = ""
+            if full_path:
+                try:
+                    rel_path = os.path.relpath(full_path, self.plugin_manager.plugin_dir)
+                except Exception:
+                    rel_path = os.path.basename(full_path)
+            self.table.setItem(row, 4, QTableWidgetItem(str(rel_path)))
+            
+            self.table.setItem(row, 5, QTableWidgetItem(str(p.get('description', ''))))
+            
+            # Simple color coding for status
+            status = str(p.get('status', ''))
+            color = None
+            if status.startswith("Error"):
+                color = Qt.GlobalColor.red
+            elif status == "Loaded":
+                color = Qt.GlobalColor.darkGreen
+            elif status == "No Entry Point":
+                color = Qt.GlobalColor.gray
+            
+            if color:
+                self.table.item(row, 0).setForeground(color)
+
+    def update_button_state(self):
+        has_selection = (self.table.currentRow() >= 0)
+        if hasattr(self, 'btn_remove'):
+            self.btn_remove.setEnabled(has_selection)
+
+    def on_reload(self, silent=False):
+        # Trigger reload in main manager
+        if self.plugin_manager.main_window:
+            self.plugin_manager.discover_plugins(self.plugin_manager.main_window)
+            self.refresh_plugin_list()
+            # Also update main window menu if possible, but that might require a callback or signal
+            # For now we assume discover_plugins re-runs autoruns which might duplicate stuff if not careful?
+            # Actually discover_plugins clears lists, so re-running is safe logic-wise, 
+            # but main_window need to rebuild its menu.
+            # We will handle UI rebuild in the main window code by observing or callback.
+            
+            # For immediate feedback:
+            if not silent:
+                QMessageBox.information(self, "Reloaded", "Plugins have been reloaded.")
+        else:
+            self.plugin_manager.discover_plugins()
+            self.refresh_plugin_list()
+
+    def on_remove_plugin(self):
+        row = self.table.currentRow()
+        if row < 0:
+            QMessageBox.warning(self, "Warning", "Please select a plugin to remove.")
+            return
+
+        # Assuming table row index matches plugins list index (confirmed in refresh_plugin_list)
+        if row < len(self.plugin_manager.plugins):
+            plugin = self.plugin_manager.plugins[row]
+            filepath = plugin.get('filepath')
+            
+            if filepath and os.path.exists(filepath):
+               reply = QMessageBox.question(self, "Remove Plugin", 
+                                            f"Are you sure you want to remove '{plugin.get('name', 'Unknown')}'?\n\nFile: {filepath}\nThis cannot be undone.", 
+                                            QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No)
+               if reply == QMessageBox.StandardButton.Yes:
+                   try:
+                       os.remove(filepath)
+                       self.on_reload(silent=True) # Reload list and plugins
+                       QMessageBox.information(self, "Success", f"Removed '{plugin.get('name', 'Unknown')}'.")
+                   except Exception as e:
+                       QMessageBox.critical(self, "Error", f"Failed to delete file: {e}")
+            else:
+               QMessageBox.warning(self, "Error", f"Plugin file not found:\n{filepath}")
+
+    def show_plugin_details(self, item):
+        row = item.row()
+        if row < len(self.plugin_manager.plugins):
+            p = self.plugin_manager.plugins[row]
+            msg = f"Name: {p.get('name', 'Unknown')}\n" \
+                  f"Version: {p.get('version', 'Unknown')}\n" \
+                  f"Author: {p.get('author', 'Unknown')}\n" \
+                  f"Status: {p.get('status', 'Unknown')}\n" \
+                  f"Location: {p.get('filepath', 'Unknown')}\n\n" \
+                  f"Description:\n{p.get('description', 'No description available.')}"
+            QMessageBox.information(self, "Plugin Details", msg)
+
+    # --- Drag & Drop Support ---
+    def dragEnterEvent(self, event: QDragEnterEvent):
+        if event.mimeData().hasUrls():
+            event.accept()
+        else:
+            event.ignore()
+
+    def dropEvent(self, event: QDropEvent):
+        files_installed = []
+        errors = []
+        for url in event.mimeData().urls():
+            file_path = url.toLocalFile()
+            if os.path.isfile(file_path) and file_path.endswith('.py'):
+                # Extract info and confirm
+                info = self.plugin_manager.get_plugin_info_safe(file_path)
+                msg = (f"Do you want to install this plugin?\n\n"
+                       f"Name: {info['name']}\n"
+                       f"Author: {info['author']}\n"
+                       f"Version: {info['version']}\n"
+                       f"Description: {info['description']}\n\n"
+                       f"File: {os.path.basename(file_path)}")
+                
+                reply = QMessageBox.question(self, "Install Plugin?", msg, 
+                                             QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No)
+                
+                if reply == QMessageBox.StandardButton.Yes:
+                    success, msg = self.plugin_manager.install_plugin(file_path)
+                    if success:
+                        files_installed.append(msg)
+                    else:
+                        errors.append(msg)
+        
+        if files_installed or errors:
+            self.refresh_plugin_list()
+            summary = ""
+            if files_installed:
+                summary += "Installed:\n" + "\n".join(files_installed) + "\n\n"
+            if errors:
+                summary += "Errors:\n" + "\n".join(errors)
+            
+            QMessageBox.information(self, "Plugin Installation", summary)
+