As you continue exploring Python metaclasses, recall that the class attribute dictionary—`attrs` in the `__new__` or `__init__` method of a metaclass—contains all attributes defined directly in the class body. Manipulating or inspecting this dictionary enables you to enforce rules or transform class attributes as needed. For example, you can iterate through `attrs.items()` to examine attribute names and values before the class is actually created. This capability is central to many metaclass-driven customizations, such as validation, transformation, or automatic documentation.


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

class TestTask(unittest.TestCase):
    def test_good_example_does_not_raise(self):
        try:
            class Good(metaclass=sys.modules['user_code'].UppercaseAttributeMeta):
                FOO = 123
                BAR = 456
                __doc__ = "good"
                __init__ = lambda self: None
            _dynamic_test(self, True, "No error for valid uppercase and special attributes", "Unexpected error raised for valid attributes.")
        except Exception as e:
            _dynamic_test(self, False, "No error for valid uppercase and special attributes", f"Unexpected error raised for valid attributes: {e}")

    def test_bad_example_raises(self):
        try:
            class Bad(metaclass=sys.modules['user_code'].UppercaseAttributeMeta):
                foo = 1
                BAR = 2
        except ValueError as e:
            msg = str(e)
            cond = ("foo" in msg) and ("Bad" in msg)
            _dynamic_test(self, cond, "ValueError raised with correct message for non-uppercase attribute", f"ValueError message does not include attribute or class name: {msg}")
        else:
            _dynamic_test(self, False, "ValueError raised with correct message for non-uppercase attribute", "Did not raise ValueError for non-uppercase attribute.")

    def test_special_methods_allowed(self):
        try:
            class Special(metaclass=sys.modules['user_code'].UppercaseAttributeMeta):
                __init__ = lambda self: None
                __doc__ = "test"
            _dynamic_test(self, True, "Special methods allowed without error", "Special methods incorrectly rejected.")
        except Exception as e:
            _dynamic_test(self, False, "Special methods allowed without error", f"Special methods incorrectly rejected: {e}")

    def test_multiple_bad_attributes(self):
        try:
            class MultiBad(metaclass=sys.modules['user_code'].UppercaseAttributeMeta):
                foo = 1
                bar = 2
                BAZ = 3
        except ValueError as e:
            msg = str(e)
            cond = ("foo" in msg or "bar" in msg) and "MultiBad" in msg
            _dynamic_test(self, cond, "First non-uppercase attribute triggers ValueError with correct message", f"ValueError message does not include offending attribute or class name: {msg}")
        else:
            _dynamic_test(self, False, "First non-uppercase attribute triggers ValueError with correct message", "Did not raise ValueError for non-uppercase attribute.")

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: Enforcing Attribute Naming Conventions

Solution