import unittest
import array
import re

# Helper function to dynamically generate test names and assertions
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)


class TestUserCode(unittest.TestCase):

    def test_transaction_has_slots(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code.Transaction, "__slots__"),
            "The `Transaction` class defines `__slots__`.",
            "Expected `Transaction` to define `__slots__`."
        )

    def test_transaction_slots_correct(self):
        import user_code
        expected = {"transaction_id", "amount", "currency"}
        try:
            actual = set(user_code.Transaction.__slots__)
            condition = actual == expected
            failure_message = f"Expected `__slots__` to contain `{expected}`, but got `{actual}`."
        except AttributeError:
            condition = False
            failure_message = "The `Transaction` class does not define `__slots__`."
        _dynamic_test(
            self,
            condition,
            f"The `__slots__` contains the correct attributes: `{expected}`.",
            failure_message
        )

    def test_transaction_no_dict(self):
        import user_code
        transaction = user_code.Transaction(1, 100.0, "USD")
        _dynamic_test(
            self,
            not hasattr(transaction, "__dict__"),
            "The `Transaction` instance has no `__dict__` – `__slots__` is working correctly.",
            "Expected `Transaction` instance to have no `__dict__` when `__slots__` is defined."
        )

    def test_usd_amounts_is_array(self):
        import user_code
        _dynamic_test(
            self,
            isinstance(user_code.usd_amounts, array.array),
            "The `usd_amounts` variable is an `array.array` instance.",
            "Expected `usd_amounts` to be of type `array.array`."
        )

    def test_usd_amounts_type_code(self):
        import user_code
        try:
            condition = user_code.usd_amounts.typecode == "d"
            failure_message = f"Expected type code `'d'`, but got `'{user_code.usd_amounts.typecode}'`."
        except AttributeError:
            condition = False
            failure_message = "The `usd_amounts` variable is not declared."
        _dynamic_test(
            self,
            condition,
            "The `usd_amounts` array uses type code `'d'` (double).",
            failure_message
        )

    def test_usd_amounts_values(self):
        import user_code
        expected = array.array("d", [4500.0, 8900.0, 15000.0])
        try:
            condition = user_code.usd_amounts == expected
            failure_message = f"Expected `usd_amounts` to be `{list(expected)}`, but got `{list(user_code.usd_amounts)}`."
        except AttributeError:
            condition = False
            failure_message = "The `usd_amounts` variable is not declared."
        _dynamic_test(
            self,
            condition,
            f"The `usd_amounts` contains the correct values: `{list(expected)}`.",
            failure_message
        )

    def test_generator_used(self):
        with open("user_code.py", "r") as file:
            source = file.read()
        _dynamic_test(
            self,
            bool(re.search(r"Transaction\s*\(.*\)\s+for\s+", source)),
            "A generator expression is used to create `Transaction` objects.",
            "Expected a generator expression to be used for `transaction_stream`."
        )


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

test_main.py

Master the skills needed to understand Python's memory management internals and performance optimization techniques. This course is designed for intermediate and advanced Python developers who want to understand how Python handles memory, write memory-efficient code, detect and fix memory leaks, and optimize performance in real-world applications.

Explore the essentials of Python's memory management, including reference counting, garbage collection, and memory allocation strategies.

Get hands-on experience with practical techniques for writing memory-efficient Python code, including specialized data structures and tools for controlling object lifecycle.

Master the skills needed to profile memory usage and detect memory leaks in Python applications.

Explore the essentials of advanced memory and performance optimization patterns, including object interning, memory inspection tools, and the GIL's impact on memory access.

Challenge: Memory-Efficient Data Pipeline

Solution