import unittest
import tracemalloc
import functools
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_snapshot_before_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, "snapshot_before"),
            "The `snapshot_before` variable is declared.",
            "Expected `snapshot_before` to be declared."
        )

    def test_snapshot_after_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, "snapshot_after"),
            "The `snapshot_after` variable is declared.",
            "Expected `snapshot_after` to be declared."
        )

    def test_top_stats_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, "top_stats"),
            "The `top_stats` variable is declared.",
            "Expected `top_stats` to be declared."
        )

    def test_top_stats_is_list(self):
        import user_code
        try:
            condition = isinstance(user_code.top_stats, list) and len(user_code.top_stats) > 0
            failure_message = f"Expected `top_stats` to be a non-empty list, but got `{type(user_code.top_stats)}`."
        except AttributeError:
            condition = False
            failure_message = "The `top_stats` variable is not declared."
        _dynamic_test(
            self,
            condition,
            "The `top_stats` is a non-empty list of snapshot statistics.",
            failure_message
        )

    def test_generate_report_fixed_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, "generate_report_fixed"),
            "The `generate_report_fixed` function is declared.",
            "Expected `generate_report_fixed` to be declared."
        )

    def test_lru_cache_used(self):
        with open("user_code.py", "r") as file:
            source = file.read()
        _dynamic_test(
            self,
            bool(re.search(r"lru_cache\s*\(\s*maxsize\s*=\s*256\s*\)", source)),
            "`@functools.lru_cache(maxsize=256)` is applied to `generate_report_fixed`.",
            "Expected `@functools.lru_cache(maxsize=256)` to be used."
        )

    def test_generate_report_fixed_returns_list(self):
        import user_code
        try:
            result = user_code.generate_report_fixed(1)
            condition = isinstance(result, list) and len(result) == 500
            failure_message = f"Expected `generate_report_fixed()` to return a list of 500 elements, but got `{type(result)}` with length `{len(result) if isinstance(result, list) else 'N/A'}`."
        except AttributeError:
            condition = False
            failure_message = "The `generate_report_fixed` function is not declared."
        _dynamic_test(
            self,
            condition,
            "`generate_report_fixed()` returns a list of `500` elements.",
            failure_message
        )

    def test_tracemalloc_start_used(self):
        with open("user_code.py", "r") as file:
            source = file.read()
        _dynamic_test(
            self,
            bool(re.search(r"tracemalloc\.start\s*\(\s*\)", source)),
            "`tracemalloc.start()` is called to begin tracing.",
            "Expected `tracemalloc.start()` to be called."
        )

    def test_compare_to_used(self):
        with open("user_code.py", "r") as file:
            source = file.read()
        _dynamic_test(
            self,
            bool(re.search(r"compare_to\s*\(", source)),
            "`compare_to()` is used to compare the two snapshots.",
            "Expected `snapshot_after.compare_to(snapshot_before, ...)` to be used."
        )


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: Profiling and Fixing a Leaky Pipeline

Ratkaisu