When you want to understand how Python classes and metaclasses relate, you can use the `__class__` attribute and the `type()` function. Every object in Python has a `__class__` attribute that points to its class. For classes themselves, `__class__` refers to the metaclass, which is usually `type` unless a custom metaclass is specified. The `type()` function, when called on an object, returns its class; when called on a class, it returns its metaclass. To explore the base classes of a class, you can use the `__bases__` attribute, which is a tuple of the class's immediate parent classes. By combining these tools, you can inspect class hierarchies and metaclass relationships for both user-defined and built-in types.


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

class TestInspectObjectHierarchy(unittest.TestCase):
    def test_user_defined_object_class(self):
        class MyBase: pass
        class MyClass(MyBase): pass
        x = MyClass()
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.inspect_object_hierarchy(x)
        output = f.getvalue().lower()
        expected = f"object's class: <class '{x.__class__.__module__}.{x.__class__.__qualname__}'>".lower()
        _dynamic_test(
            self,
            expected in output,
            f"Prints correct class for user-defined object: {expected}",
            f"Did not print correct class for user-defined object: expected {expected}, got {output}"
        )

    def test_user_defined_object_bases(self):
        class MyBase: pass
        class MyClass(MyBase): pass
        x = MyClass()
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.inspect_object_hierarchy(x)
        output = f.getvalue().lower()
        expected = f"class's base classes: {MyClass.__bases__}".lower()
        _dynamic_test(
            self,
            expected in output,
            f"Prints correct base classes for user-defined object: {expected}",
            f"Did not print correct base classes for user-defined object: expected {expected}, got {output}"
        )

    def test_user_defined_object_metaclass(self):
        class MyBase: pass
        class MyClass(MyBase): pass
        x = MyClass()
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.inspect_object_hierarchy(x)
        output = f.getvalue().lower()
        expected = f"class's metaclass: {type(MyClass)}".lower()
        _dynamic_test(
            self,
            expected in output,
            f"Prints correct metaclass for user-defined object: {expected}",
            f"Did not print correct metaclass for user-defined object: expected {expected}, got {output}"
        )

    def test_builtin_object_class(self):
        obj = 5
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.inspect_object_hierarchy(obj)
        output = f.getvalue().lower()
        expected = f"object's class: <class '{obj.__class__.__module__}.{obj.__class__.__qualname__}'>".lower()
        _dynamic_test(
            self,
            expected in output,
            f"Prints correct class for built-in object: {expected}",
            f"Did not print correct class for built-in object: expected {expected}, got {output}"
        )

    def test_builtin_object_bases_na(self):
        obj = 5
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.inspect_object_hierarchy(obj)
        output = f.getvalue().lower()
        expected = "class's base classes: n/a"
        _dynamic_test(
            self,
            expected in output,
            f"Prints N/A for base classes of built-in object.",
            f"Did not print N/A for base classes of built-in object: expected '{expected}', got {output}"
        )

    def test_builtin_object_metaclass(self):
        obj = 5
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.inspect_object_hierarchy(obj)
        output = f.getvalue().lower()
        expected = f"class's metaclass: {type(int)}".lower()
        _dynamic_test(
            self,
            expected in output,
            f"Prints correct metaclass for built-in object: {expected}",
            f"Did not print correct metaclass for built-in object: expected {expected}, 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: Inspecting Class Hierarchies

Lösning