As you have seen in previous chapters, metaclasses allow you to intercept and customize class creation in Python. One of the most powerful patterns is **validation**: using the metaclass to enforce certain rules or requirements on classes at the time they are defined. This could include checking for required attributes, ensuring naming conventions, or validating the presence of specific methods. By leveraging the `__new__` or `__init__` methods of a metaclass, you can examine the class’s namespace and raise an error if requirements are not met. This pattern helps catch mistakes early and ensures that all classes using the metaclass follow the same contract.


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

class TestTask(unittest.TestCase):
    def test_valid_class_no_error(self):
        import user_code
        importlib.reload(user_code)
        # If ValidClass is defined and callable, test passes
        valid_cls = getattr(user_code, 'ValidClass', None)
        _dynamic_test(
            self,
            valid_cls is not None and callable(getattr(valid_cls(), 'describe', None)),
            "ValidClass defines a callable 'describe' method and passes metaclass validation.",
            "ValidClass did not pass metaclass validation or 'describe' method is missing.",
        )

    def test_valid_class_describe_output(self):
        import user_code
        importlib.reload(user_code)
        valid_cls = getattr(user_code, 'ValidClass', None)
        _dynamic_test(
            self,
            valid_cls is not None,
            "ValidClass exists.",
            "ValidClass does not exist.",
        )
        result = valid_cls().describe()
        _dynamic_test(
            self,
            result == "I am valid",
            "ValidClass.describe() returns correct string.",
            f"Expected 'I am valid', got '{result}'.",
        )

    def test_invalid_class_raises_typeerror(self):
        # Reload user_code and capture stdout
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            importlib.reload(user_code)
        output = f.getvalue()
        # Look for TypeError message in output
        _dynamic_test(
            self,
            "must define a callable 'describe' method" in output,
            "TypeError raised with correct message for missing 'describe' method.",
            f"TypeError message not found in output: {output}",
        )

    def test_error_message_contains_class_name(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            importlib.reload(user_code)
        output = f.getvalue()
        _dynamic_test(
            self,
            "InvalidClass" in output and "must define a callable 'describe' method" in output,
            "TypeError message includes class name and requirement.",
            f"Expected class name and requirement in error message. Output: {output}",
        )

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: Required Method Enforcement

Solution