**Congratulations** on reaching this point in the course! In this capstone challenge, you will **manage perishable products** at a grocery store, determining discounts based on product expiration and stock levels. Your goal is to minimize waste while effectively maximizing sales through strategic discounting. 

Let's see how well you can translate business rules into Python code!

import unittest
import io
import re
from contextlib import redirect_stdout


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+", " ", text)
    text = text.strip()
    return text


def change_var(code, var_name, value):
    pattern = rf"{var_name}\s*=.*"
    repl = f"{var_name} = {value}"
    code_lines = code.splitlines()
    for i, line in enumerate(code_lines):
        if re.match(pattern, line.strip()):
            code_lines[i] = repl
    return "\\n".join(code_lines)


class TestEasierDiscountTask(unittest.TestCase):

    def run_code_with_vars(self, days_until_expiration, product_type):
        with open("user_code.py", "r", encoding="utf-8") as f:
            code = f.read()

        code = change_var(code, "days_until_expiration", str(days_until_expiration))
        code = change_var(code, "product_type", repr(product_type))

        buf = io.StringIO()
        with redirect_stdout(buf):
            exec(code, {})
        return normalize_text(buf.getvalue())

    def test_big_discount(self):
        output = self.run_code_with_vars(2, "Perishable")
        expected = normalize_text("Big discount applied")
        _dynamic_test(
            self,
            expected in output,
            "Big discount applied when days <= 3",
            f"Expected '{expected}', got '{output}'"
        )

    def test_small_discount(self):
        output = self.run_code_with_vars(5, "Perishable")
        expected = normalize_text("Small discount applied")
        _dynamic_test(
            self,
            expected in output,
            "Small discount applied when days > 3",
            f"Expected '{expected}', got '{output}'"
        )

    def test_non_perishable(self):
        output = self.run_code_with_vars(1, "Non-Perishable")
        expected = normalize_text("No discount for non-perishable items.")
        _dynamic_test(
            self,
            expected in output,
            "No discount message for non-perishable items",
            f"Expected '{expected}', got '{output}'"
        )

    def test_nested_if_used(self):
        with open("user_code.py", "r", encoding="utf-8") as f:
            code = f.read()
        code = "\\n".join([line for line in code.splitlines() if not line.strip().startswith("#")])
        if_count = len(re.findall(r"\\bif\\b", code))
        _dynamic_test(
            self,
            if_count >= 2,
            "Uses nested if statements (outer + inner)",
            "Expected at least two 'if' statements."
        )


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


test_main.py

Python is a high-level, interpreted, general-purpose programming
language. Distinguished from languages such as HTML, CSS, and JavaScript, which are mainly
utilized in web development, Python boasts versatility across multiple domains, including
software development, data science, and back-end development. This course will guide you
through Python's fundamental concepts, equipping you with the skills to create your own
functions by the conclusion of the program.

In this section, you will explore the fundamentals of Python, get acquainted
with your workspace, perform simple math operations, and display your findings.

In this section, you'll discover how to save items such as numbers and text
in computer memory and retrieve them by name. Additionally, you'll gain an introduction to text
manipulation in Python.

In this section, you'll explore the boolean data type and learn how it is used
to develop programs that react to certain conditions.

In this section, you will continue learning about data types and discover
how to organize various attributes in a single variable using lists, tuples, and dictionaries.

In this section, you'll learn how to create loops in Python — an essential skill
for iterating through lists, tuples, and dictionaries.

To conclude this introductory course, you will explore some built-in
functions and then begin to develop your own!

Challenge: Product Management Capstone

Solution

Challenge: Product Management Capstone

Solution