You have explored how metaclasses can register plugins by collecting subclasses into a registry, as well as how to enforce that certain required methods are present in class definitions. These two patterns are often combined in real-world plugin systems: you want to both track all available plugin classes and guarantee that each plugin implements a required API, such as a `run` method. Now you will bring these ideas together by writing a metaclass that both registers plugins and enforces that every plugin defines a `run` method.


import unittest
import user_code
import ast
import re   
import unittest
import importlib
import sys
import io
from contextlib import redirect_stdout

class TestTask(unittest.TestCase):
    def test_good_plugin_registered(self):
        import user_code
        importlib.reload(user_code)
        registry = getattr(user_code.PluginMeta, 'registry', None)
        _dynamic_test(
            self,
            isinstance(registry, list) and 'GoodPlugin' in registry,
            "GoodPlugin is registered in PluginMeta.registry",
            f"GoodPlugin should be in registry, got: {registry}",
        )

    def test_base_plugin_not_registered(self):
        import user_code
        importlib.reload(user_code)
        registry = getattr(user_code.PluginMeta, 'registry', None)
        _dynamic_test(
            self,
            isinstance(registry, list) and 'BasePlugin' not in registry,
            "BasePlugin is not registered in PluginMeta.registry",
            f"BasePlugin should not be in registry, got: {registry}",
        )

    def test_typeerror_on_missing_run(self):
        code = ''
        with open('user_code.py', 'r') as f:
            code = f.read()
        class_def = '\\nclass BadPlugin(BasePlugin):\\n    pass\\n'
        code = code + '\\n' + class_def
        ns = {}
        raised = False
        try:
            exec(code, ns)
        except TypeError as e:
            raised = True
        _dynamic_test(
            self,
            raised,
            "TypeError raised if subclass does not define run method",
            "TypeError was not raised when subclass missing run method",
        )

    def test_typeerror_on_non_callable_run(self):
        code = ''
        with open('user_code.py', 'r') as f:
            code = f.read()
        class_def = '\\nclass NotCallablePlugin(BasePlugin):\\n    run = 42\\n'
        code = code + '\\n' + class_def
        ns = {}
        raised = False
        try:
            exec(code, ns)
        except TypeError as e:
            raised = True
        _dynamic_test(
            self,
            raised,
            "TypeError raised if subclass defines non-callable run",
            "TypeError was not raised when subclass run is not callable",
        )

    def test_multiple_good_plugins(self):
        code = ''
        with open('user_code.py', 'r') as f:
            code = f.read()
        class_defs = '''\\nclass PluginA(BasePlugin):\\n    def run(self):\\n        pass\\nclass PluginB(BasePlugin):\\n    def run(self):\\n        pass\\n'''
        code = code + '\\n' + class_defs
        ns = {}
        f = io.StringIO()
        with redirect_stdout(f):
            exec(code, ns)
        registry = ns['PluginMeta'].registry
        _dynamic_test(
            self,
            'PluginA' in registry and 'PluginB' in registry,
            "Multiple good plugins are registered",
            f"Expected PluginA and PluginB in registry, got: {registry}",
        )

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\s{2,}", " ", text)
    text = re.sub(r"\s*([,:?])\s*", r"\1 ", text)
    return text.strip()

def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    changed = False
    # Collect all assignment nodes to modify
    assign_nodes = [
        (i, node)
        for i, node in enumerate(tree.body)
        if isinstance(node, ast.Assign)
        and any(isinstance(target, ast.Name) and target.id == var_name for target in node.targets)
    ]

    # If nothing to change, return unmodified code
    if not assign_nodes:
        return code

    # Perform replacements for all matching assignments (from last to first to not break line offsets)
    for i, node in reversed(assign_nodes):
        start_line = node.lineno - 1
        line = lines[start_line]
        indent = ' ' * (len(line) - len(line.lstrip()))
        lines[start_line] = f"{indent}{var_name} = {value}"
        next_line = len(lines)
        for next_node in tree.body[i+1:]:
            if hasattr(next_node, 'lineno'):
                next_line = next_node.lineno - 1
                break
        if next_line > start_line + 1:
            lines[start_line+1:next_line] = []
        changed = True

    return '\\n'.join(lines) if changed else code

if __name__ == "__main__":
    unittest.main()


test_main.py

A beginner-friendly, hands-on course that unravels the mysteries of Python metaclasses. Learn what metaclasses are, how they work, and how to use them to create powerful, flexible, and maintainable code. Each section blends clear theory with practical, real-world tasks to ensure deep understanding.

Explore the foundational concepts of metaclasses, their relationship with classes and objects, and why they matter in Python.

Learn how to define your own metaclasses, customize class creation, and explore practical use cases.

Discover practical applications of metaclasses, including plugin systems, singletons, and API enforcement.

Challenge: Section Review - Real-World Metaclasses

解答