MoleditPy 2.2.6__py3-none-any.whl → 2.3.0__py3-none-any.whl

moleditpy/modules/constants.py

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

moleditpy/modules/main_window_main_init.py

@@ -1878,39 +1878,63 @@ class MainWindowMainInit(object):
             no_plugin_action.setEnabled(False)
             plugin_menu.addAction(no_plugin_action)
         else:
-            # Sort plugins: directories first (to create menus), then alphabetical by name
-            plugins.sort(key=lambda x: (x.get('rel_folder', ''), x['name']))
+            # Sort plugins: 
+            # 1. Categories (A-Z)
+            # 2. Within Category: Items (A-Z)
+            # 3. Root items (A-Z)
+            
+            # Group plugins by category
+            categorized_plugins = {}
+            root_plugins = []
             
-            # Dictionary to keep track of created submenus: path -> QMenu
-            menus = { "": plugin_menu }
-
             for p in plugins:
-                # Only add legacy plugins (with 'run' function) to the generic Plugins menu.
                 if hasattr(p['module'], 'run'):
-                    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
+                    category = p.get('category', p.get('rel_folder', '')).strip()
+                    if category:
+                        if category not in categorized_plugins:
+                            categorized_plugins[category] = []
+                        categorized_plugins[category].append(p)
+                    else:
+                        root_plugins.append(p)
+            
+            # Sort categories
+            sorted_categories = sorted(categorized_plugins.keys())
+            
+            # Build menu: Categories first
+            for cat in sorted_categories:
+                # Create/Get Category Menu (Nested support)
+                parts = cat.split(os.sep)
+                parent_menu = plugin_menu
+                
+                # Traverse/Create nested menus
+                for part in parts:
+                    found_sub = False
+                    for act in parent_menu.actions():
+                        if act.menu() and act.text().replace('&', '') == part:
+                            parent_menu = act.menu()
+                            found_sub = True
+                            break
+                    if not found_sub:
+                        parent_menu = parent_menu.addMenu(part)
+
+                # Add items to the leaf category menu (Sorted A-Z)
+                cat_items = sorted(categorized_plugins[cat], key=lambda x: x['name'])
+                for p in cat_items:
                     action = QAction(p['name'], self)
-                    action.triggered.connect(lambda checked, mod=p['module']: self.plugin_manager.run_plugin(mod, self)) 
+                    action.triggered.connect(lambda checked, mod=p['module']: self.plugin_manager.run_plugin(mod, self))
                     parent_menu.addAction(action)
 
+            # Add separator if needed  <-- REMOVED per user request
+            # if sorted_categories and root_plugins:
+            #      plugin_menu.addSeparator()
+
+            # Build menu: Root items last (Sorted A-Z)
+            root_plugins.sort(key=lambda x: x['name'])
+            for p in root_plugins:
+                action = QAction(p['name'], self)
+                action.triggered.connect(lambda checked, mod=p['module']: self.plugin_manager.run_plugin(mod, self))
+                plugin_menu.addAction(action)
+
         # 4. Integrate Export Actions into Export Button and Menu
         # 4. Integrate Export Actions into Export Button AND Main File->Export Menu
         if self.plugin_manager.export_actions:

moleditpy/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/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-2.2.6.dist-info → moleditpy-2.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MoleditPy
-Version: 2.2.6
+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

{moleditpy-2.2.6.dist-info → moleditpy-2.3.0.dist-info}/RECORD

@@ -12,7 +12,7 @@ moleditpy/modules/bond_item.py,sha256=eVkEeKvM4igYI67DYxpey3FllqDyt_iWDo4VPYMhaP
 moleditpy/modules/bond_length_dialog.py,sha256=6bFPGssnqlgINuqpxLv-OhjMH3_hspnaH8QtorAyu2M,14782
 moleditpy/modules/calculation_worker.py,sha256=KiGQY7i-QCQofEoE0r65KoQgpEGFcbhmxWv6egfkUdc,42324
 moleditpy/modules/color_settings_dialog.py,sha256=Ow44BhCOLo0AFb6klO001k6B4drOgKX9DeNBQhZLp5o,15474
-moleditpy/modules/constants.py,sha256=_LJDuqJFfR_t_84zzl3p5dhK7C2LB-ZyFuBE4K0dUE4,4702
+moleditpy/modules/constants.py,sha256=J9rIFaD6tWxdMBzGcaYWovarEJy72gXD784k9WVahr8,4702
 moleditpy/modules/constrained_optimization_dialog.py,sha256=REsk4ePsqNmAGPMTS_jckeM7jexrU3krwun8sKqKUCs,30062
 moleditpy/modules/custom_interactor_style.py,sha256=LDNODMJoNHGe1AUSrvqv6PdeJm-hpPmSpWINppnJLt0,38942
 moleditpy/modules/custom_qt_interactor.py,sha256=vCZsDfRO-FtphD5cTP7Ps-5rpHZMIGloaoe6EaKzrsw,4139
@@ -25,7 +25,7 @@ moleditpy/modules/main_window_dialog_manager.py,sha256=QR96LqHAPSOShXbc9cK-Ffq8a
 moleditpy/modules/main_window_edit_3d.py,sha256=CUArB5wcsgq1C7LygAEC6URlbnn4RhRYDa5n-Y-etWI,19731
 moleditpy/modules/main_window_edit_actions.py,sha256=yEc0Nw-VpN0P4e4neUu7pDuUHPGEcu6eFmwWFrSBIQ8,64815
 moleditpy/modules/main_window_export.py,sha256=dSVfylsybDDboDuXU9Inotf6YkrKJwgBTqGYSfq1lRE,38241
-moleditpy/modules/main_window_main_init.py,sha256=Shxs8_vVa7PhfhVZdHYtPniItLHKJ3i9wcamcVofvso,91172
+moleditpy/modules/main_window_main_init.py,sha256=BChZuyXgWfOTFqAM1OUukFgtL5KLusW4t29GnfCN1QE,92018
 moleditpy/modules/main_window_molecular_parsers.py,sha256=KR6vzuqc3nutOcorpYr0QOyX3MFBcxTwDhZX96VgJ9Q,48291
 moleditpy/modules/main_window_project_io.py,sha256=TWwtuKDuvgcvPZ9IGmW8r1EJJOrgxrIJRnxe_f4C1oM,17149
 moleditpy/modules/main_window_string_importers.py,sha256=v47wOd4RtjKYcF-aLP-mogGGdYTpTEo3dDyAu79_5MM,10782
@@ -39,8 +39,8 @@ moleditpy/modules/move_group_dialog.py,sha256=Fyuy3Uq1KsFsk9qR96r_FxPbAM_-zSfW2d
 moleditpy/modules/periodic_table_dialog.py,sha256=ItEZUts1XCietz9paY-spvbzxh6SXak3GnikwqkHZCw,4006
 moleditpy/modules/planarize_dialog.py,sha256=eaqI1MpF35e-VUMpJATt-EtGG5FhcSUlbAenUaFGabY,8593
 moleditpy/modules/plugin_interface.py,sha256=srzPZ3a_aRTx28NAvWNKRVUDYQNfQOTcjzx-5YW2Pb4,8164
-moleditpy/modules/plugin_manager.py,sha256=cxbqIE7Rb_KeBd-cG1vF2ySY2qNx8IJVRXjVPyQMFDc,13457
-moleditpy/modules/plugin_manager_window.py,sha256=UeoPQWTxmckoFIQAuv9jVBzok_9gEKEm9c7JsKRX0P4,10135
+moleditpy/modules/plugin_manager.py,sha256=nb106AfUAnAVyp4LYFmLhKzFY4taeteH8gY5SNf1h1I,20037
+moleditpy/modules/plugin_manager_window.py,sha256=b4kEv0DaWHZG76ZaFTOxn6CVtA62_0MpPYYr10ehCtA,12544
 moleditpy/modules/settings_dialog.py,sha256=Nr7yE8UmYRi3VObWvRlrnv0DnjSjmYXbvqryZ02O12k,65348
 moleditpy/modules/template_preview_item.py,sha256=djdq3tz73d_fJGOvai3E-V9Hk9q9ZW7skx7BV59mooA,6556
 moleditpy/modules/template_preview_view.py,sha256=4OCHZDO51BvJpKdfrBWJ4_4WfLfFSKxsVIyf7I-Kj2E,3350
@@ -51,9 +51,9 @@ moleditpy/modules/assets/file_icon.ico,sha256=yyVj084A7HuMNbV073cE_Ag3Ne405qgOP3
 moleditpy/modules/assets/icon.icns,sha256=wD5R6-Vw7K662tVKhu2E1ImN0oUuyAP4youesEQsn9c,139863
 moleditpy/modules/assets/icon.ico,sha256=RfgFcx7-dHY_2STdsOQCQziY5SNhDr3gPnjO6jzEDPI,147975
 moleditpy/modules/assets/icon.png,sha256=kCFN1WacYIdy0GN6SFEbNA00ef39pCczBnFdkkBI8Bs,147110
-moleditpy-2.2.6.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-moleditpy-2.2.6.dist-info/METADATA,sha256=vHsKbmtTEC9mSX2KC3VMASZqxNyvRpQCblso_8fBiN8,60629
-moleditpy-2.2.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-moleditpy-2.2.6.dist-info/entry_points.txt,sha256=yH1h9JjALhok1foXT3-hYrC4ufoZt8b7oiBcsdnGNNM,54
-moleditpy-2.2.6.dist-info/top_level.txt,sha256=ARICrS4ihlPXqywlKl6o-oJa3Qz3gZRWu_VZsQ3_c44,10
-moleditpy-2.2.6.dist-info/RECORD,,
+moleditpy-2.3.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+moleditpy-2.3.0.dist-info/METADATA,sha256=KMJCk7r-QqD1yc1YHvb-EoQ65q5Xgfa9gvuO0sSmzEw,60629
+moleditpy-2.3.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+moleditpy-2.3.0.dist-info/entry_points.txt,sha256=yH1h9JjALhok1foXT3-hYrC4ufoZt8b7oiBcsdnGNNM,54
+moleditpy-2.3.0.dist-info/top_level.txt,sha256=ARICrS4ihlPXqywlKl6o-oJa3Qz3gZRWu_VZsQ3_c44,10
+moleditpy-2.3.0.dist-info/RECORD,,