MoleditPy-linux 2.2.5__py3-none-any.whl → 2.3.0__py3-none-any.whl

moleditpy_linux/modules/move_group_dialog.py

@@ -42,7 +42,6 @@ class MoveGroupDialog(Dialog3DPickingMixin, QDialog):
     def init_ui(self):
         self.setWindowTitle("Move Group")
         self.setModal(False)
-        self.setWindowFlags(Qt.WindowType.Window | Qt.WindowType.WindowStaysOnTopHint)
         self.resize(300,400)  # ウィンドウサイズを設定
         layout = QVBoxLayout(self)
         
@@ -195,9 +194,12 @@ class MoveGroupDialog(Dialog3DPickingMixin, QDialog):
                         if 0 <= closest_atom_idx < self.mol.GetNumAtoms():
                             atom = self.mol.GetAtomWithIdx(int(closest_atom_idx))
                             if atom:
-                                atomic_num = atom.GetAtomicNum()
-                                pt = Chem.GetPeriodicTable()
-                                vdw_radius = pt.GetRvdw(atomic_num)
+                                try:
+                                    atomic_num = atom.GetAtomicNum()
+                                    vdw_radius = pt.GetRvdw(atomic_num)
+                                    if vdw_radius < 0.1: vdw_radius = 1.5
+                                except Exception:
+                                    vdw_radius = 1.5
                                 click_threshold = vdw_radius * 1.5
                                 
                                 if distances[closest_atom_idx] < click_threshold:
@@ -349,7 +351,7 @@ class MoveGroupDialog(Dialog3DPickingMixin, QDialog):
                 return False
         
         # その他のイベントは親クラスに渡す
-        return False
+        return super().eventFilter(obj, event)
     
     def on_atom_picked(self, atom_idx):
         """原子がピックされたときに、その原子が属する連結成分全体を選択（複数グループ対応）"""

moleditpy_linux/modules/planarize_dialog.py

@@ -46,7 +46,6 @@ class PlanarizeDialog(Dialog3DPickingMixin, QDialog):
     def init_ui(self):
         self.setWindowTitle("Planarize")
         self.setModal(False)
-        self.setWindowFlags(Qt.WindowType.Window | Qt.WindowType.WindowStaysOnTopHint)
         layout = QVBoxLayout(self)
 
         instruction_label = QLabel("Click atoms in the 3D view to select them for planarization (minimum 3 required).")

moleditpy_linux/modules/plugin_manager.py

@@ -18,6 +18,7 @@ Manages discovery, loading, and execution of external plugins.
 import os
 import sys
 import shutil
+import zipfile
 import importlib.util
 import traceback
 import ast
@@ -71,34 +72,110 @@ class PluginManager:
         QDesktopServices.openUrl(QUrl.fromLocalFile(self.plugin_dir))
 
     def install_plugin(self, file_path):
-        """Copies a plugin file to the plugin directory."""
+        """Copies a plugin file to the plugin directory. Supports .py and .zip."""
         self.ensure_plugin_dir()
         try:
+            # Handle trailing slash and normalize path
+            file_path = os.path.normpath(file_path)
             filename = os.path.basename(file_path)
-            dest_path = os.path.join(self.plugin_dir, filename)
-            shutil.copy2(file_path, dest_path)
+            
+            if os.path.isdir(file_path):
+                # Copy entire directory
+                dest_path = os.path.join(self.plugin_dir, filename)
+                if os.path.exists(dest_path):
+                     # Option 1: Overwrite (remove then copy) - safer for clean install
+                     if os.path.isdir(dest_path):
+                         shutil.rmtree(dest_path)
+                     else:
+                         os.remove(dest_path)
+                
+                # Copy directory, ignoring cache files
+                shutil.copytree(file_path, dest_path, ignore=shutil.ignore_patterns('__pycache__', '*.pyc', '.git'))
+                msg = f"Installed package {filename}"
+            elif filename.lower().endswith('.zip'):
+                # Extract ZIP contents
+                with zipfile.ZipFile(file_path, 'r') as zf:
+                    # Smart Extraction: Check if ZIP has a single top-level folder
+                    # Fix for paths with backslashes on Windows if zip was created on Windows
+                    roots = set()
+                    for name in zf.namelist():
+                        # Normalize path separators to forward slash for consistent check
+                        name = name.replace('\\', '/')
+                        parts = name.split('/')
+                        if parts[0]:
+                            roots.add(parts[0])
+                    
+                    is_nested = (len(roots) == 1)
+                    
+                    if is_nested:
+                        # Case A: ZIP contains a single folder (e.g. MyPlugin/init.py)
+                        top_folder = list(roots)[0]
+                        
+                        # Guard: If the single item is __init__.py, we MUST create a wrapper folder
+                        # otherwise we pollute the plugin_dir root.
+                        if top_folder == "__init__.py":
+                            is_nested = False
+                    
+                    if is_nested:
+                        # Case A (Confirmed): Extract directly
+                        dest_path = os.path.join(self.plugin_dir, top_folder)
+                        
+                        # Clean Install: Remove existing folder to prevent stale files
+                        if os.path.exists(dest_path):
+                             if os.path.isdir(dest_path):
+                                 shutil.rmtree(dest_path)
+                             else:
+                                 os.remove(dest_path)
+                        
+                        zf.extractall(self.plugin_dir)
+                        msg = f"Installed package {top_folder} (from ZIP)"
+                    else:
+                        # Case B: ZIP is flat (e.g. file1.py, file2.py or just __init__.py)
+                        # Extract into a new folder named after the ZIP file
+                        folder_name = os.path.splitext(filename)[0]
+                        dest_path = os.path.join(self.plugin_dir, folder_name)
+                        
+                        if os.path.exists(dest_path):
+                            if os.path.isdir(dest_path):
+                                shutil.rmtree(dest_path)
+                            else:
+                                os.remove(dest_path)
+                        
+                        os.makedirs(dest_path)
+                        zf.extractall(dest_path)
+                        msg = f"Installed package {folder_name} (from Flat ZIP)"
+            else:
+                # Standard file copy
+                dest_path = os.path.join(self.plugin_dir, filename)
+                if os.path.exists(dest_path):
+                    if os.path.isdir(dest_path):
+                        import shutil
+                        shutil.rmtree(dest_path)
+                shutil.copy2(file_path, dest_path)
+                msg = f"Installed {filename}"
+
             # Reload plugins after install
             if self.main_window:
                 self.discover_plugins(self.main_window)
-            return True, f"Installed {filename}"
+            return True, msg
         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).
+        Hybrid discovery:
+        - Folders with '__init__.py' -> Treated as single package plugin.
+        - Folders without '__init__.py' -> Treated as category folders (scan for .py inside).
         """
         if parent:
             self.main_window = parent
             
         self.ensure_plugin_dir()
         self.plugins = []
+        # Clear registries
         self.menu_actions = []
         self.toolbar_actions = []
         self.drop_handlers = []
-        
-        # Clear extended registries
         self.export_actions = [] 
         self.optimization_methods = {}
         self.file_openers = {}
@@ -111,81 +188,122 @@ class PluginManager:
             return []
 
         for root, dirs, files in os.walk(self.plugin_dir):
-            # Modify dirs in-place to skip hidden directories and __pycache__
+            # Exclude hidden directories
             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 = ""
+            # [Check] Is current dir a package (plugin body)?
+            if "__init__.py" in files:
+                # === Case 1: Package Plugin (Folder is the plugin) ===
+                
+                # Stop recursion into this folder
+                dirs[:] = []
+                
+                entry_point = os.path.join(root, "__init__.py")
+                # Category is relative path to parent folder
+                rel_path = os.path.relpath(os.path.dirname(root), self.plugin_dir)
+                category = rel_path if rel_path != "." else ""
+                
+                # Module name is the folder name
+                module_name = os.path.basename(root)
+                
+                self._load_single_plugin(entry_point, module_name, category)
+                
+            else:
+                # === Case 2: Category Folder (Load individual .py files) ===
+                
+                # Category is relative path to current folder
+                rel_path = os.path.relpath(root, self.plugin_dir)
+                category = rel_path if rel_path != "." else ""
+
+                for filename in files:
+                    if filename.endswith(".py") and not filename.startswith("__"):
+                        entry_point = os.path.join(root, filename)
+                        module_name = os.path.splitext(filename)[0]
                         
+                        self._load_single_plugin(entry_point, module_name, category)
+        
+        return self.plugins
+
+    def _load_single_plugin(self, filepath, module_name, category):
+        """Common loading logic for both single-file and package plugins."""
+        try:
+            # Ensure unique module name by including category path
+            # e.g. Analysis.Docking
+            unique_module_name = f"{category.replace(os.sep, '.')}.{module_name}" if category else module_name
+            unique_module_name = unique_module_name.strip(".")
+
+            spec = importlib.util.spec_from_file_location(unique_module_name, filepath)
+            if spec and spec.loader:
+                module = importlib.util.module_from_spec(spec)
+                sys.modules[spec.name] = module
+                
+                # Inject category info
+                module.PLUGIN_CATEGORY = category 
+                
+                spec.loader.exec_module(module)
+
+                # --- Metadata Extraction ---
+                # Metadata
+                # Priority: PLUGIN_XXX > __xxx__ > Fallback
+                plugin_name = getattr(module, 'PLUGIN_NAME', module_name)
+                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__', ''))
+                plugin_category = getattr(module, 'PLUGIN_CATEGORY', category)
+                
+                # Additional cleanup for docstring (strip whitespace)
+                if plugin_desc is None: plugin_desc = ""
+                plugin_desc = str(plugin_desc).strip()
+                
+                 # Handle version tuple
+                if isinstance(plugin_version, tuple):
+                    plugin_version = ".".join(map(str, plugin_version))
+                    
+                # 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 initialization
+                if has_init:
+                    context = PluginContext(self, plugin_name)
+                    # Pass category to context if needed, currently not storing it in context directly but could be useful
                     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
-                            })
-                            
+                        module.initialize(context)
                     except Exception as e:
-                        print(f"Failed to load plugin {filename}: {e}")
+                        status = f"Error (Init): {e}"
+                        print(f"Plugin {plugin_name} initialize error: {e}")
                         traceback.print_exc()
-        
-        return self.plugins
+                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,
+                    'category': plugin_category, # Store category
+                    'status': status,
+                    'filepath': filepath,
+                    'has_run': has_run
+                })
+                
+        except Exception as e:
+            print(f"Failed to load plugin {module_name}: {e}")
+            traceback.print_exc()
 
     def run_plugin(self, module, main_window):
         """Executes the plugin's run method (Legacy manual trigger)."""
@@ -266,29 +384,50 @@ class PluginManager:
                  tree = ast.parse(f.read())
              
              for node in tree.body:
+                 targets = []
                  if isinstance(node, ast.Assign):
-                     for target in node.targets:
-                         if isinstance(target, ast.Name):
-                             # Helper to extract value
-                             val = None
+                     targets = node.targets
+                 elif isinstance(node, ast.AnnAssign):
+                     targets = [node.target]
+                 
+                 for target in targets:
+                     if isinstance(target, ast.Name):
+                         # Helper to extract value
+                         val = None
+                         if node.value: # AnnAssign might presumably not have value? (though usually does for module globals)
                              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
+                             elif isinstance(node.value, ast.Tuple):
+                                 # Handle version tuples e.g. (1, 0, 0)
+                                 try:
+                                     # Extract simple constants from tuple
+                                     elts = []
+                                     for elt in node.value.elts:
+                                         if isinstance(elt, ast.Constant):
+                                             elts.append(elt.value)
+                                         elif hasattr(ast, 'Num') and isinstance(elt, ast.Num):
+                                             elts.append(elt.n)
+                                     val = ".".join(map(str, elts))
+                                 except:
+                                     pass
+                         
+                         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 == 'PLUGIN_CATEGORY':
+                                 info['category'] = 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):

moleditpy_linux/modules/plugin_manager_window.py

@@ -18,6 +18,7 @@ from PyQt6.QtWidgets import (
 )
 from PyQt6.QtCore import Qt, QMimeData, QUrl
 from PyQt6.QtGui import QDragEnterEvent, QDropEvent, QDesktopServices
+import shutil
 
 class PluginManagerWindow(QDialog):
     def __init__(self, plugin_manager, parent=None):
@@ -33,8 +34,7 @@ class PluginManagerWindow(QDialog):
     def init_ui(self):
         layout = QVBoxLayout(self)
         
-        # Header / Instruction
-        lbl_info = QLabel("Drag & Drop .py files here to install plugins.")
+        lbl_info = QLabel("Drag & Drop .py or .zip files here to install plugins.")
         lbl_info.setStyleSheet("color: gray; font-style: italic;")
         layout.addWidget(lbl_info)
 
@@ -152,16 +152,31 @@ class PluginManagerWindow(QDialog):
             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}")
+                # Check if it is a package plugin (based on __init__.py)
+                is_package = os.path.basename(filepath) == "__init__.py"
+                target_path = os.path.dirname(filepath) if is_package else filepath
+                
+                msg = f"Are you sure you want to remove '{plugin.get('name', 'Unknown')}'?"
+                if is_package:
+                    msg += f"\n\nThis will delete the entire folder:\n{target_path}"
+                else:
+                    msg += f"\n\nFile: {filepath}"
+                    
+                msg += "\nThis cannot be undone."
+
+                reply = QMessageBox.question(self, "Remove Plugin", msg, 
+                                             QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No)
+                if reply == QMessageBox.StandardButton.Yes:
+                    try:
+                        if is_package:
+                             shutil.rmtree(target_path)
+                        else:
+                             os.remove(target_path)
+                        
+                        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 plugin: {e}")
             else:
                QMessageBox.warning(self, "Error", f"Plugin file not found:\n{filepath}")
 
@@ -189,9 +204,47 @@ class PluginManagerWindow(QDialog):
         errors = []
         for url in event.mimeData().urls():
             file_path = url.toLocalFile()
-            if os.path.isfile(file_path) and file_path.endswith('.py'):
+            
+            is_valid = False
+            is_zip = False
+            is_folder = False
+            
+            if os.path.isfile(file_path):
+                # Special handling: If user drops __init__.py, assume they want to install the package (folder)
+                if os.path.basename(file_path) == "__init__.py":
+                    file_path = os.path.dirname(file_path)
+                    is_valid = True
+                    is_folder = True
+                elif file_path.endswith('.py'):
+                    is_valid = True
+                elif file_path.endswith('.zip'):
+                    is_valid = True
+                    is_zip = True
+            
+            if os.path.isdir(file_path):
+                # Check for __init__.py to confirm it's a plugin package? 
+                # Or just assume any folder is fair game (could be category folder too?)
+                # We'll allow any folder and let manager handle it.
+                is_valid = True
+                is_folder = True
+
+            if is_valid:
                 # Extract info and confirm
-                info = self.plugin_manager.get_plugin_info_safe(file_path)
+                info = {'name': os.path.basename(file_path), 'version': 'Unknown', 'author': 'Unknown', 'description': ''}
+                
+                if is_folder:
+                     info['description'] = "Folder Plugin / Category"
+                     # Try to parse __init__.py if it exists
+                     init_path = os.path.join(file_path, "__init__.py")
+                     if os.path.exists(init_path):
+                         info = self.plugin_manager.get_plugin_info_safe(init_path)
+                         info['description'] += f" (Package: {info['name']})"
+                         
+                elif is_zip:
+                     info['description'] = "ZIP Package Plugin"
+                elif file_path.endswith('.py'):
+                     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"

moleditpy_linux/modules/translation_dialog.py

@@ -31,7 +31,6 @@ class TranslationDialog(Dialog3DPickingMixin, QDialog):
     def init_ui(self):
         self.setWindowTitle("Translation")
         self.setModal(False)  # モードレスにしてクリックを阻害しない
-        self.setWindowFlags(Qt.WindowType.Window | Qt.WindowType.WindowStaysOnTopHint)  # 常に前面表示
         layout = QVBoxLayout(self)
         
         # Instructions

{moleditpy_linux-2.2.5.dist-info → moleditpy_linux-2.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MoleditPy-linux
-Version: 2.2.5
+Version: 2.3.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
@@ -689,7 +689,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
-Requires-Python: <3.14,>=3.9
+Requires-Python: <3.15,>=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy