Throughout this section, you have explored how metaclasses can be used to both log the process of class creation and enforce validation rules on class definitions. By customizing the `__new__` or `__init__` methods of a metaclass, you can intercept class creation, print useful information such as the class name, and check that certain constraints—like attribute naming conventions—are satisfied before the class is finalized. This dual capability makes metaclasses a powerful tool for building robust, self-validating code frameworks.


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

class TestLoggingUppercaseMeta(unittest.TestCase):
    def test_prints_class_name(self):
        f = io.StringIO()
        importlib.reload(user_code)
        with redirect_stdout(f):
            class TestClass(metaclass=user_code.LoggingUppercaseMeta):
                ATTRIBUTE_ONE = 1
        output = f.getvalue().strip()
        expected = "Creating class: TestClass"
        _dynamic_test(
            self,
            expected in output,
            f"Output includes line: {expected}",
            f"Expected output: '{expected}' not found in: '{output}'",
        )

    def test_raises_value_error_for_non_uppercase(self):
        try:
            class InvalidClass(metaclass=user_code.LoggingUppercaseMeta):
                attribute_one = 1
                ATTRIBUTE_TWO = 2
        except ValueError as e:
            _dynamic_test(
                self,
                "not uppercase" in str(e),
                "ValueError raised for non-uppercase attribute with correct message",
                f"ValueError message does not contain 'not uppercase': {e}",
            )
        else:
            _dynamic_test(
                self,
                False,
                "Should not reach here.",
                "ValueError was not raised for class with non-uppercase attribute.",
            )

    def test_allows_all_uppercase(self):
        try:
            class AllUppercase(metaclass=user_code.LoggingUppercaseMeta):
                ATTRIBUTE_X = 1
                CONSTANT_Y = 2
        except Exception as e:
            _dynamic_test(
                self,
                False,
                "All-uppercase attributes should not raise an exception.",
                f"Exception was raised for all-uppercase attributes: {e}",
            )
        else:
            _dynamic_test(
                self,
                True,
                "All-uppercase attributes do not raise exception.",
                "Should not reach here.",
            )

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 - Custom Metaclasses in Action

Solution