You are building a data model for a financial application. Your task is to implement a validated descriptor that enforces type and range constraints on numeric attributes.

You are given the following class skeleton:

```python
class BoundedFloat:
    pass

class Position:
    quantity = BoundedFloat(min_value=0.0, max_value=10000.0)
    price = BoundedFloat(min_value=0.01, max_value=999999.99)

    def __init__(self, ticker, quantity, price):
        self.ticker = ticker
        self.quantity = quantity
        self.price = price
```

import unittest
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_bounded_float_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, "BoundedFloat"),
            "The `BoundedFloat` class is declared.",
            "Expected `BoundedFloat` to be declared."
        )

    def test_bounded_float_has_get(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code.BoundedFloat, "__get__"),
            "The `BoundedFloat` descriptor defines `__get__`.",
            "Expected `BoundedFloat` to define `__get__`."
        )

    def test_bounded_float_has_set(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code.BoundedFloat, "__set__"),
            "The `BoundedFloat` descriptor defines `__set__`.",
            "Expected `BoundedFloat` to define `__set__`."
        )

    def test_bounded_float_has_set_name(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code.BoundedFloat, "__set_name__"),
            "The `BoundedFloat` descriptor defines `__set_name__`.",
            "Expected `BoundedFloat` to define `__set_name__`."
        )

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

    def test_qty_is_correct(self):
        import user_code
        try:
            condition = user_code.qty == 100.0
            failure_message = f"Expected `qty` to be `100.0`, but got `{user_code.qty}`."
        except AttributeError:
            condition = False
            failure_message = "The `qty` variable is not declared."
        _dynamic_test(
            self,
            condition,
            "The `qty` variable equals `100.0`.",
            failure_message
        )

    def test_prc_is_correct(self):
        import user_code
        try:
            condition = user_code.prc == 189.50
            failure_message = f"Expected `prc` to be `189.5`, but got `{user_code.prc}`."
        except AttributeError:
            condition = False
            failure_message = "The `prc` variable is not declared."
        _dynamic_test(
            self,
            condition,
            "The `prc` variable equals `189.5`.",
            failure_message
        )

    def test_type_error_raised(self):
        import user_code
        condition = False
        failure_message = "Expected `TypeError` when setting `quantity` to a non-numeric value."
        try:
            test_position = user_code.Position("MSFT", "not_a_number", 100.0)
        except TypeError:
            condition = True
        except Exception:
            failure_message = "Expected `TypeError`, but a different exception was raised."
        _dynamic_test(
            self,
            condition,
            "`BoundedFloat` raises `TypeError` when a non-numeric value is assigned.",
            failure_message
        )

    def test_value_error_raised(self):
        import user_code
        condition = False
        failure_message = "Expected `ValueError` when setting `quantity` below `min_value`."
        try:
            test_position = user_code.Position("MSFT", -1.0, 100.0)
        except ValueError:
            condition = True
        except Exception:
            failure_message = "Expected `ValueError`, but a different exception was raised."
        _dynamic_test(
            self,
            condition,
            "`BoundedFloat` raises `ValueError` when the value is outside the allowed range.",
            failure_message
        )

    def test_is_data_descriptor(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code.BoundedFloat, "__get__") and hasattr(user_code.BoundedFloat, "__set__"),
            "`BoundedFloat` is a data descriptor – it defines both `__get__` and `__set__`.",
            "Expected `BoundedFloat` to define both `__get__` and `__set__` to be a data descriptor."
        )


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

test_main.py

Unlock the power of Python descriptors to control attribute access, validation, and caching. Explore the descriptor protocol, see how built-in features use descriptors, and learn to craft your own for robust, maintainable code.

Discover how Python manages attribute access and the role of descriptors in customizing object behavior. Learn the core protocol and distinguish between descriptor types.

See how Python’s built-in features leverage descriptors for properties, methods, and memory optimization. Analyze real-world descriptor usage.

Master advanced descriptor patterns for validation, lazy loading, and caching. Build robust, reusable components for real-world projects.

Challenge: Your First Descriptor

Solution