After exploring how metaclasses can enforce API requirements, you have seen how to guarantee that certain methods are present in classes, ensuring consistency and reliability in your codebase. This technique is especially valuable in large projects or frameworks where all subclasses must provide a specific interface for interoperability. By using a metaclass to check for the presence of required methods, you can catch errors at class creation time rather than at runtime, making your code safer and easier to maintain.

import unittest
import user_code
import ast
import re   
import unittest
import user_code

class TestTask(unittest.TestCase):
    def dynamic_test(self, condition, success_message, failure_message):
        if condition:
            self._testMethodName = success_message
            self.assertTrue(True, success_message)
        else:
            self._testMethodName = failure_message
            self.fail(failure_message)

    def test_missing_connect_raises(self):
        class_namespace = {}
        code = '''
class APIMethodEnforcer(type):
    def __init__(cls, name, bases, namespace):
        required_methods = ["connect", "disconnect"]
        for method in required_methods:
            if method not in namespace or not callable(namespace[method]):
                raise TypeError(f"Class '{name}' must define a '{method}' method.")
        super().__init__(name, bases, namespace)

class BadAPI(metaclass=APIMethodEnforcer):
    def disconnect(self):
        pass
'''
        try:
            exec(code, class_namespace)
            self.dynamic_test(False, '', "TypeError was not raised when 'connect' was missing.")
        except TypeError as e:
            msg = str(e)
            self.dynamic_test("connect" in msg and "BadAPI" in msg, "TypeError for missing 'connect' in BadAPI", "Error message does not mention 'connect' and 'BadAPI'")

    def test_missing_disconnect_raises(self):
        class_namespace = {}
        code = '''
class APIMethodEnforcer(type):
    def __init__(cls, name, bases, namespace):
        required_methods = ["connect", "disconnect"]
        for method in required_methods:
            if method not in namespace or not callable(namespace[method]):
                raise TypeError(f"Class '{name}' must define a '{method}' method.")
        super().__init__(name, bases, namespace)

class BadAPI(metaclass=APIMethodEnforcer):
    def connect(self):
        pass
'''
        try:
            exec(code, class_namespace)
            self.dynamic_test(False, '', "TypeError was not raised when 'disconnect' was missing.")
        except TypeError as e:
            msg = str(e)
            self.dynamic_test("disconnect" in msg and "BadAPI" in msg, "TypeError for missing 'disconnect' in BadAPI", "Error message does not mention 'disconnect' and 'BadAPI'")

    def test_both_methods_present_no_error(self):
        class_namespace = {}
        code = '''
class APIMethodEnforcer(type):
    def __init__(cls, name, bases, namespace):
        required_methods = ["connect", "disconnect"]
        for method in required_methods:
            if method not in namespace or not callable(namespace[method]):
                raise TypeError(f"Class '{name}' must define a '{method}' method.")
        super().__init__(name, bases, namespace)

class GoodAPI(metaclass=APIMethodEnforcer):
    def connect(self):
        pass
    def disconnect(self):
        pass
'''
        try:
            exec(code, class_namespace)
            self.dynamic_test(True, "No TypeError for GoodAPI", "")
        except TypeError as e:
            self.dynamic_test(False, '', f"Unexpected error: {e}")

    def test_method_not_callable_raises(self):
        class_namespace = {}
        code = '''
class APIMethodEnforcer(type):
    def __init__(cls, name, bases, namespace):
        required_methods = ["connect", "disconnect"]
        for method in required_methods:
            if method not in namespace or not callable(namespace[method]):
                raise TypeError(f"Class '{name}' must define a '{method}' method.")
        super().__init__(name, bases, namespace)

class BadAPI(metaclass=APIMethodEnforcer):
    connect = 123
    def disconnect(self):
        pass
'''
        try:
            exec(code, class_namespace)
            self.dynamic_test(False, '', "TypeError was not raised when 'connect' was not callable.")
        except TypeError as e:
            msg = str(e)
            self.dynamic_test("connect" in msg and "BadAPI" in msg, "TypeError for non-callable 'connect' in BadAPI", "Error message does not mention 'connect' and 'BadAPI'")

if __name__ == "__main__":
    unittest.main()

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 API Methods

解答