stevedore

import os from setuptools import setup, find_packages from stevedore import extension # 1. Define a plugin interface (e.g., in myapp/plugins/base.py) # In a real scenario, this would be in a separate package. # For this quickstart, we'll simulate it. plugin_base_code = ''' import abc class FormatterBase(abc.ABC): @abc.abstractmethod def format(self, data): """Format the data and return a string.""" pass ''' # 2. Implement a concrete plugin (e.g., in myapp_simple_formatter/formatter.py) # In a real scenario, this would be in a separate package. plugin_impl_code = ''' from myapp.plugins.base import FormatterBase class SimpleFormatter(FormatterBase): def format(self, data): return f"Simple format: {data['value']}" ''' # Create dummy files for demonstration if not os.path.exists('myapp/plugins'): os.makedirs('myapp/plugins') with open('myapp/plugins/base.py', 'w') as f: f.write(plugin_base_code) if not os.path.exists('myapp_simple_formatter'): os.makedirs('myapp_simple_formatter') with open('myapp_simple_formatter/formatter.py', 'w') as f: f.write(plugin_impl_code) with open('myapp/__init__.py', 'w') as f: pass with open('myapp_simple_formatter/__init__.py', 'w') as f: pass # 3. Define entry points in setup.py (or pyproject.toml) # For a runnable quickstart, we'll use a dummy setup for the plugin # and then manually register it to simulate installation. # In a real project, myapp_simple_formatter would have its own setup.py # and be installed via pip install -e . # Simulate plugin registration by creating a pseudo-entry-point # This is for quickstart demonstration; usually setuptools handles this via installation. # This specific 'hack' for dynamic registration during runtime is not standard Stevedore usage, # but it makes the quickstart runnable without a full package installation process. # We'll use a hack to make the quickstart self-contained and runnable. # In a real scenario, 'myapp_simple_formatter' would be an installed package # with its entry point declared in its setup.py (or pyproject.toml). # To simulate: we directly add the module to sys.modules and define a mock entry_points function. import sys sys.path.insert(0, os.path.abspath('.')) # Temporarily import the base and plugin to make them available from myapp.plugins.base import FormatterBase from myapp_simple_formatter.formatter import SimpleFormatter # Mock the entry point discovery for demonstration def mock_entry_points(group=None): if group == 'myapp.formatters': class MockEntryPoint: def __init__(self, name, load_callable): self.name = name self._load_callable = load_callable def load(self): return self._load_callable return { 'simple': MockEntryPoint('simple', SimpleFormatter) } return {} # Replace the real entry_points discovery for this script's scope # This is a highly simplified mock for quickstart purposes and not how stevedore usually discovers plugins # In practice, entry points are discovered via 'importlib.metadata.entry_points()' after package installation. import stevedore.extension stevedore.extension.entry_points = mock_entry_points # 4. Use stevedore in your application to load plugins def main(): print("Loading formatters...") mgr = extension.ExtensionManager( namespace='myapp.formatters', invoke_on_load=True ) if not mgr.extensions: print("No formatters found. Ensure plugin packages are installed and define 'myapp.formatters' entry points.") return print(f"Found {len(mgr.extensions)} formatter(s).") for ext in mgr.extensions: print(f" - {ext.name}: {ext.obj.format({'value': 123})}") if __name__ == '__main__': main() # Clean up dummy files/dirs import shutil shutil.rmtree('myapp') shutil.rmtree('myapp_simple_formatter')