Plugin Registry System

class Registry:
    """Central plugin registry for all Plover extensions."""
    
    PLUGIN_TYPES = (
        'command', 'dictionary', 'extension', 'gui', 
        'gui.qt.machine_option', 'gui.qt.tool', 'machine', 
        'macro', 'meta', 'system'
    )
    
    def register_plugin(self, plugin_type: str, name: str, obj) -> None:
        """
        Register a plugin with the registry.
        
        Args:
            plugin_type: Type of plugin from PLUGIN_TYPES
            name: Unique name for the plugin
            obj: Plugin class or object to register
            
        Registers plugin for discovery by other components.
        """
    
    def get_plugin(self, plugin_type: str, plugin_name: str) -> Plugin:
        """
        Get specific plugin by type and name.
        
        Args:
            plugin_type: Type of plugin to retrieve
            plugin_name: Name of specific plugin
            
        Returns:
            Plugin wrapper object with metadata
            
        Raises:
            KeyError: If plugin not found
        """
    
    def list_plugins(self, plugin_type: str) -> list:
        """
        List all plugins of specified type.
        
        Args:
            plugin_type: Type of plugins to list
            
        Returns:
            List of Plugin objects of specified type
            
        Useful for enumerating available options like machines or dictionaries.
        """
    
    def list_distributions(self) -> list:
        """
        List all plugin distributions.
        
        Returns:
            List of distribution objects containing plugins
            
        Shows all installed packages that provide plugins.
        """
    
    def update(self) -> None:
        """
        Update registry from entry points.
        
        Scans installed packages for new plugins and updates
        the registry with any discoveries.
        """

registry: Registry
"""
Global registry instance used throughout Plover.

All components access plugins through this shared instance.
"""

class Plugin:
    """Wrapper for individual plugin with metadata."""
    
    def __init__(self, plugin_type: str, name: str, obj):
        """
        Initialize plugin wrapper.
        
        Args:
            plugin_type: Type classification of plugin
            name: Unique identifier for plugin
            obj: Actual plugin class or object
        """
    
    plugin_type: str
    """Type classification from Registry.PLUGIN_TYPES"""
    
    name: str
    """Unique plugin identifier"""
    
    obj: object
    """Actual plugin class or implementation object"""
    
    __doc__: str
    """Plugin documentation string"""

from plover.registry import registry

# Update registry from installed packages
registry.update()

# List available machines
machines = registry.list_plugins('machine')
for machine in machines:
    print(f"Machine: {machine.name}")

# Get specific machine plugin
gemini_plugin = registry.get_plugin('machine', 'Gemini PR')
gemini_machine = gemini_plugin.obj

# List all GUI tools
tools = registry.list_plugins('gui.qt.tool')
for tool in tools:
    print(f"Tool: {tool.name} - {tool.__doc__}")

# Register custom plugin
class CustomExtension:
    def __init__(self, engine):
        self.engine = engine
    
    def start(self):
        pass
    
    def stop(self):
        pass

registry.register_plugin('extension', 'my_extension', CustomExtension)

# List dictionary formats
dict_formats = registry.list_plugins('dictionary')
for fmt in dict_formats:
    print(f"Dictionary format: {fmt.name}")

# Get meta command
attach_meta = registry.get_plugin('meta', 'attach')
attach_command = attach_meta.obj

# setup.py
entry_points={
    'plover.machine': [
        'My Machine = my_package.machine:MyMachine',
    ],
    'plover.extension': [
        'My Extension = my_package.extension:MyExtension',
    ],
    'plover.dictionary': [
        'My Format = my_package.dictionary:MyDictionary',
    ],
}

from typing import List, Dict, Any, Callable, Type, Union

PluginType = str
PluginName = str
PluginObject = Union[Type, Callable, object]

PluginTypesList = tuple[str, ...]
PluginsList = List[Plugin]
DistributionsList = List[Any]