2.7. Creating Custom Descriptors for Attribute Management

Descriptors provide fine control over attribute access. Let’s create a descriptor that validates attribute values.

Descriptors are objects that help manage and control access to attributes in Python classes. They give you the ability to customize how attributes are set, retrieved, or deleted. By creating a descriptor, you can enforce certain rules, like ensuring that only values of a specific type are set for an attribute.

Think of a descriptor like a security guard at a club. The guard checks if the person wanting to enter matches certain criteria (like age). In this way, the descriptor ensures that only the right kind of data ('age' must be an integer) is allowed into your classes.

class Typed: def init(self, name, expected_type): self.name = name self.expected_type = expected_type

def __get__(self, instance, owner):
    if instance is None:
        return self
    return instance.__dict__[self.name]

def __set__(self, instance, value):
    if not isinstance(value, self.expected_type):
        raise TypeError(f"Expected {self.expected_type}")
    instance.__dict__[self.name] = value

def __delete__(self, instance):
    raise AttributeError("Can't delete attribute")

class Person: name = Typed('name', str) age = Typed('age', int) def init(self, name, age): self.name = name self.age = age

p = Person("Alice", 30) print(p.name) # Alice p.age = 31 # Works fine

p.age = "Thirty" # Raises TypeError: Expected <class 'int'>

The Typed class here is a custom descriptor that validates the types of attributes. When you create an instance of Typed, you give it a name and the expected type. The __set__ method checks if the value being assigned matches the expected type. If it doesn't, it raises a TypeError. The __get__ method retrieves the value when accessed, while the __delete__ method prevents deletion of the attribute by raising an error. This means you can maintain strict control over what types of values are assigned to attributes in your class.

Imagine you have a box labeled 'Important Documents' where you only want to store certain types of papers (like legal documents or contracts). The Typed descriptor acts like a strict organizer: it checks every item that goes into the box. If someone tries to put in a non-related paper (like a flyer), the organizer will stop them and say, 'That's not allowed here!' Just like how the descriptor prevents us from assigning incorrect types to class attributes.

class Person: name = Typed('name', str) age = Typed('age', int) def init(self, name, age): self.name = name self.age = age

p = Person("Alice", 30) print(p.name) # Alice p.age = 31 # Works fine

p.age = "Thirty" # Raises TypeError: Expected <class 'int'>

In the Person class, we've defined two attributes, name and age, using the Typed descriptor. When we create an instance of Person, the attributes are set through the descriptor. When we attempt to access p.name, it retrieves 'Alice' successfully. If we try to set p.age to a valid integer, it works without issues. However, if we attempt to assign a string like 'Thirty' to p.age, it raises a TypeError, enforcing the rule set in our descriptor that only integers are valid for the age attribute.

Consider a driver's license application process where applicants must meet specific age criteria (like being at least 16 years old). The Typed descriptor is like the official reviewer who checks the applicant's age before approving the license. If an applicant states an age that does not meet the criteria, the reviewer will reject the application, just like how our descriptor prevents invalid age assignments.

● Typed controls the setting and getting of name and age. ● The attribute value is stored in the instance's dict. ● Type validation enforces correct types on assignment.

In summary, custom descriptors provide a powerful way to manage class attributes in Python. The Typed descriptor manages both how attributes are accessed (using __get__) and how they are set (using __set__), along with type validation. By storing the actual value in the instance's __dict__, it maintains the state of the object while ensuring that only appropriate data types are assigned to specific attributes. This leads to more robust and maintainable code.

Think of this as a quality control process. If you're manufacturing a product (like a smartphone), you want to ensure each component (like the battery or screen) meets specific standards before assembly. The custom descriptor acts like a quality control inspector, ensuring that each part (or attribute) meets the necessary specifications, leading to a better outcome (or well-behaved object).

--