You have seen how metaclasses can be used to customize class creation and enforce rules. One of the most practical applications is the **registry pattern**, where a metaclass automatically tracks all classes that use it. This is especially useful for plugin systems, where you want each plugin class to register itself without extra boilerplate. By letting the metaclass handle registration, you ensure that every plugin is discoverable and can be managed centrally. You will now put this idea into practice by writing a metaclass that adds every class it creates to a global `PLUGIN_REGISTRY` dictionary, mapping class names to the class objects themselves.


import unittest
import user_code
import ast
import re   
import unittest
import importlib
import sys

class TestTask(unittest.TestCase):
    def test_registry_contains_pluginbase(self):
        import user_code
        importlib.reload(user_code)
        registry = getattr(user_code, 'PLUGIN_REGISTRY', None)
        PluginBase = getattr(user_code, 'PluginBase', None)
        _dynamic_test(
            self,
            isinstance(registry, dict) and 'PluginBase' in registry and registry['PluginBase'] is PluginBase,
            "PLUGIN_REGISTRY contains PluginBase mapped to the correct class object",
            f"PLUGIN_REGISTRY missing 'PluginBase' or incorrect mapping: {registry.get('PluginBase', None)}",
        )

    def test_registry_contains_myplugina(self):
        import user_code
        importlib.reload(user_code)
        registry = getattr(user_code, 'PLUGIN_REGISTRY', None)
        MyPluginA = getattr(user_code, 'MyPluginA', None)
        _dynamic_test(
            self,
            isinstance(registry, dict) and 'MyPluginA' in registry and registry['MyPluginA'] is MyPluginA,
            "PLUGIN_REGISTRY contains MyPluginA mapped to the correct class object",
            f"PLUGIN_REGISTRY missing 'MyPluginA' or incorrect mapping: {registry.get('MyPluginA', None)}",
        )

    def test_registry_contains_mypluginb(self):
        import user_code
        importlib.reload(user_code)
        registry = getattr(user_code, 'PLUGIN_REGISTRY', None)
        MyPluginB = getattr(user_code, 'MyPluginB', None)
        _dynamic_test(
            self,
            isinstance(registry, dict) and 'MyPluginB' in registry and registry['MyPluginB'] is MyPluginB,
            "PLUGIN_REGISTRY contains MyPluginB mapped to the correct class object",
            f"PLUGIN_REGISTRY missing 'MyPluginB' or incorrect mapping: {registry.get('MyPluginB', None)}",
        )

    def test_registry_keys_and_values(self):
        import user_code
        importlib.reload(user_code)
        registry = getattr(user_code, 'PLUGIN_REGISTRY', None)
        PluginBase = getattr(user_code, 'PluginBase', None)
        MyPluginA = getattr(user_code, 'MyPluginA', None)
        MyPluginB = getattr(user_code, 'MyPluginB', None)
        expected = {'PluginBase': PluginBase, 'MyPluginA': MyPluginA, 'MyPluginB': MyPluginB}
        _dynamic_test(
            self,
            isinstance(registry, dict) and all(k in registry and registry[k] is v for k, v in expected.items()),
            "PLUGIN_REGISTRY contains all required keys with correct class objects",
            f"PLUGIN_REGISTRY entries incorrect. Expected: {expected}. 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: Implementing a Plugin Registry

Solución