You have seen that Python classes are themselves created by calling the `type` function. This powerful feature allows you to define classes dynamically at runtime, rather than using the standard `class` statement. When you call `type` with three arguments—the class name as a string, a tuple of base classes, and a dictionary of attributes—you receive a new class object, just as if you had defined it with `class`. This approach forms the foundation for understanding how **metaclasses** work under the hood.


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_student_class_exists(self):
        import user_code
        importlib.reload(user_code)
        Student = getattr(user_code, 'Student', None)
        _dynamic_test(
            self,
            Student is not None and isinstance(Student, type) and Student.__name__ == 'Student',
            "Student class is created using type and named 'Student'",
            f"Student class is missing or not created using type."
        )

    def test_student_class_attributes(self):
        import user_code
        importlib.reload(user_code)
        Student = getattr(user_code, 'Student', None)
        _dynamic_test(
            self,
            hasattr(Student, 'name') and hasattr(Student, 'age'),
            "Student class has 'name' and 'age' attributes",
            "Student class is missing 'name' or 'age' attributes."
        )

    def test_student_instance(self):
        import user_code
        importlib.reload(user_code)
        student_instance = getattr(user_code, 'student_instance', None)
        Student = getattr(user_code, 'Student', None)
        _dynamic_test(
            self,
            student_instance is not None and isinstance(student_instance, Student),
            "student_instance is an instance of Student",
            "student_instance is not an instance of Student or missing."
        )

    def test_student_instance_attributes(self):
        import user_code
        importlib.reload(user_code)
        student_instance = getattr(user_code, 'student_instance', None)
        _dynamic_test(
            self,
            hasattr(student_instance, 'name') and hasattr(student_instance, 'age'),
            "student_instance has 'name' and 'age' attributes",
            "student_instance is missing 'name' or 'age' attributes."
        )
        _dynamic_test(
            self,
            getattr(student_instance, 'name', None) == "Alice",
            "student_instance.name is correctly set to 'Alice'",
            f"student_instance.name is not set to 'Alice'."
        )
        _dynamic_test(
            self,
            getattr(student_instance, 'age', None) == 20,
            "student_instance.age is correctly set to 20",
            f"student_instance.age is not set to 20."
        )

    def test_print_output(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            importlib.reload(user_code)
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            "alice" in output,
            "Output includes 'Alice'",
            f"Expected output to include 'Alice', got: {output}"
        )
        _dynamic_test(
            self,
            "20" in output,
            "Output includes '20'",
            f"Expected output to include '20', got: {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: Simulate Class Creation

Рішення