Python basic to advance

🚀 Day 46: The Miniature API! ✨

Ever wondered how `@property` works, or how powerful libraries like ORMs manage database fields? Meet Python's Descriptors! These fundamental objects allow you to customize attribute access (get, set, delete) at a low level, giving you incredible control over how your class attributes behave.

With the magic of `__set_name__`, your descriptor instance even knows the name of the attribute it's managing within the owner class. This makes your descriptors self-aware, enabling more generic error messages, logging, or complex setup without needing manual configuration. Dive in to craft elegant, robust, and reusable attribute behavior! 🐍

```python
class ValidatedString:
"""
A descriptor that ensures an attribute is a non-empty string and
can enforce min/max length, using __set_name__ for self-awareness.
"""
def __init__(self, min_len=1, max_len=float('inf')):
self.min_len = min_len
self.max_len = max_len

def __set_name__(self, owner, name):
# 'owner' is the class the descriptor is attached to (e.g., User)
# 'name' is the attribute name it's assigned to (e.g., 'username')
self.public_name = name
self.private_name = f'_{name}' # Store the actual value in a private attribute

def __get__(self, obj, objtype=None):
if obj is None:
return self # Accessing the descriptor itself via the class
return getattr(obj, self.private_name, '') # Return the private value

def __set__(self, obj, value):
if not isinstance(value, str):
raise TypeError(f"'{self.public_name}' must be a string.")
if not (self.min_len <= len(value) <= self.max_len):
if self.max_len == float('inf'):
raise ValueError(
f"'{self.public_name}' must be at least {self.min_len} characters long."
)
else:
raise ValueError(
f"'{self.public_name}' must be between {self.min_len} and "
f"{self.max_len} characters long."
)
setattr(obj, self.private_name, value) # Set the private value

class User:
username = ValidatedString(min_len=3, max_len=20)
email = ValidatedString(min_len=5) # No max_len constraint here

def __init__(self, username, email):
self.username = username
self.email = email

# --- Demonstration ---
try:
user1 = User("Alice", "alice@example.com")
print(f"User 1: {user1.username}, {user1.email}")

user1.username = "BobTheBuilder" # Valid update
print(f"User 1 (updated username): {user1.username}")

# Attempt to set an invalid username (too short)
user1.username = "Bo"
except ValueError as e:
print(f"Error caught: {e}")

try:
# Attempt to create a user with invalid email (too short)
user2 = User("Charlie", "c@ex")
except ValueError as e:
print(f"Error caught: {e}")

try:
# Attempt to create a user with non-string username
user3 = User(123, "test@example.com")
except TypeError as e:
print(f"Error caught: {e}")
```

Output example:
```
User 1: Alice, alice@example.com
User 1 (updated username): BobTheBuilder
Error caught: 'username' must be at least 3 characters long.
Error caught: 'email' must be at least 5 characters long.
Error caught: 'username' must be a string.
```

💡 Your Challenge: Can you create a `PositiveNumber` descriptor that ensures an attribute (like `age` or `quantity`) is always an integer greater than zero? Or perhaps a `ReadOnly` descriptor that allows setting a value only once during initialization? Go ahead, build your own miniature API! 🛠️

---

9 views06:09