getattribute and setattr

'getattribute' and 'setattr' are two special methods (dunder methods) used to control access to a class's attributes. Here's a clear explanation of their role and differences:

getattribute(self, name)

Role: Called every time an attribute is accessed (read), even if the attribute doesn't exist

Default behavior: Searches for the attribute in the instance, then in the class, and then in the parent classes

usefulness

• Intercept access to an attribute to add logic (e.g., logging, validation)
• Raise an exception if the attribute is not allowed

Caution

If you override 'getattribute', you must call 'super().getattribute(name)' to avoid blocking access to internal attributes

setattr(self, name, value)

Role: Called whenever an attribute is modified (written)

Default behavior: Stores the value in the instance

usefulness

• Validate or modify the value before assigning it
• Prevent modification of certain attributes
• Synchronize attributes with other data

Caution

If you override 'setattr', you must use 'self.dict[name] = value' to avoid infinite recursion

example

class Temperature:
    def __get__(self, obj, objtype):
        print("desc __get__")
        return obj._temperature

    def __set__(self, obj, value):
        print(f"desc __set__ {value}")
        obj._temperature = value

class Maison:
    def __init__(self, temperature):
        self.temperature = temperature

    def __getattribute__(self, attr):
        print(f"__getattribute__ : {attr}")
        return object.__getattribute__(self, attr)

    def __setattr__(self, attr, value):
        print(f"__setatt__ : {attr} - {value}")
        return object.__setattr__(self, attr, value)

    temperature = Temperature()

m = Maison(18)
__setatt__ : temperature - 18
desc __set__ 18
__setatt__ : _temperature - 18

m.temperature
__getattribute__ : temperature
desc __get__
__getattribute__ : _temperature

m.temperature = 22
__setatt__ : temperature - 22
desc __set__ 22
__setatt__ : _temperature - 22

m.x = 10
__setatt__ : x - 10

m.x
__getattribute__ : x

m.y
__getattribute__ : y
__getattribute__ : __dir__
__getattribute__ : __dict__
__getattribute__ : __class__
AttributeError: 'Maison' object has no attribute 'y'

getattr(self, name)

'getattr' is a special method (or dunder method) that is called when an attribute is not found in a class instance using the standard methods (getattribute, hasattr, etc.)

It allows you to dynamically manage access to missing attributes

usefulness

• Creating attributes on the fly

• Implementing default behaviors for undefined attributes

• Proxies or wrappers: To redirect attribute calls to another object

• Dynamic attributes: To generate values ​​based on the attribute name

• Compatibility with external APIs: To manage attributes that do not yet exist in a class

example

class Redirector:

    def __init__(self, id):
        self.id = id

    def __repr__(self):
        return f"Redirector2({self.id})"

    def __getattr__(self, name):
        def forwarder(arg):
            return f"{self.id} -> {name}({arg})"
        return forwarder

R = Redirector(2)
print(R)
print(R.bar(20))

metaclass

A metaclass is a class that defines the behavior of other classes. By default, in Python, classes are instances of 'type', which is the default metaclass. However, you can create your own metaclasses to control class creation, add attributes, or modify class behavior.

usefulness

• Control class creation: Add attributes, validate properties, or modify the class before it is finalized
• Singleton: Ensure that a class has only one instance
• Automatic validation: Verify that certain methods or attributes exist in the classes that use them
• Automatic registration: Register classes in a registry (for example, for a plugin system)

new

• Role: 'new' is responsible for memory allocation and instance creation
• Signature: new(cls, name, bases, namespace)
• Return: It must return a new instance of the class (or another class if necessary)

usefulness

• To create singletons (a single instance of a class)
• To modify the type of the returned instance (for example, to return a subclass)
• To control object creation (e.g., validation before creation)

class LowerAttrType(type):
    def __new__(cls, name, bases, namespace, **kwds):
        namespace = {(n.lower() if not n.startswith('__') else n): obj for n, obj in namespace.items()}
        bases = (BaseOfAll,)
        return type.__new__(cls, name, bases, namespace, **kwds)    

class BaseOfAll:
    def common_func(self):
        return f"in common_func"

class C(metaclass=LowerAttrType):
    def fUnc_bAd_CAP(selfself):
        return f"in fUnc_bAd_CAP"

c = C()
print('func_bad_cap', 'func_bad_cap' in c.__dir__())
>>> True
print('fUnc_bAd_CAP', 'fUnc_bAd_CAP' in c.__dir__())
>>> False
print('c.common_func', c.common_func())
>>> c.common_func in common_func
print('c.func_bad_cap', c.func_bad_cap())
>>> c.func_bad_cap in fUnc_bAd_CAP

https://wiki.python.org/moin/PythonDecoratorLibrary

function decorator

A decorator in Python is a function that allows you to modify or extend the behavior of another function or method without altering its source code. It is a powerful tool for adding reusable functionality (such as logging, time measurement, validation, etc.) in a clean and modular way.

@decorator
def my_function(): pass
# is equivalent to
def my_function(): pass
my_function = decorator(my_function)

usefulness

• Custom logging
• Argument validation
• Caching (Memoization)
• Timing

decorator as a class

class without arguments

class CallCounter:

    def __init__(self, f):
        self.call_counter = 0
        self.f = f

    def __call__(self, *args, **kargs):
        self.call_counter += 1
        print(f"{self.f.__name__} : {self.call_counter} call(s)")
        return self.f(*args, **kargs)

@CallCounter
def accumulate(*args):
    if args and len(args) == 1 and hasattr(args, '__iter__'):
        args = args[0]
    sum_items = 0
    return sum(sum_items := sum_items + i for i in args)

print(accumulate(1,2,3,4,5,6,7,8,9))
>>> accumulate : 1 call(s)
>>> accumulate(10) 165
print(accumulate(range(10)))
>>> accumulate : 2 call(s)
>>> accumulate(10) 165
print(accumulate(range(100)))
>>> accumulate : 3 call(s)
>>> accumulate(10) 166650

class with arguments

class CallCounter:

    def __init__(self, step = 1):
        self.step = step
        self.call_counter = 0

    def __call__(self, f):
        def wrapper(*args, **kargs):
            self.call_counter += self.step
            print(f"{f.__name__}: {self.call_counter} call(s)")
            return f(*args, **kargs)
        return wrapper

@CallCounter(step = 2)
def accumulate(*args):
    if args and len(args) == 1 and hasattr(args, '__iter__'):
        args = args[0]
    sum_items = 0
    return sum(sum_items := sum_items + i for i in args)

print(accumulate(1,2,3,4,5,6,7,8,9))
print(accumulate(range(10)))
print(accumulate(range(20)))

decorator as a function

function without arguments

a timer

def mytimer(function):
    from datetime import datetime
    def wrapper(*args, **kwargs):
        d1 = datetime.now()
        result = function(*args, **kwargs)
        d2 = datetime.now()
        print(*args, '->', result)
        print('result', result)
        print(d2-d1)
        return result
    return wrapper

@mytimer
def powerful_digit_sum(limit):
    max_sum = (2, 2, 1)
    for a in range(2, limit):
        for b in range(1, limit):
            sum_digits = sum(int(i) for i in str(a**b))
            max_sum = (sum_digits, a, b)  if sum_digits > max_sum[0] else max_sum
return max_sum

limit = 100
powerful_digit_sum(limit)

memoize or cache

def memoize(f):
    '''decorator to keep data in cache'''
    from functools import wraps
    # preserves the metadata of f and not of wrapper. See below functools
    @wraps(f)
    def wrapper(*args):
        try:
            return wrapper.cache[args]
        except TypeError:
            return f(*args)
        except KeyError:
            result = f(*args)
            wrapper.cache[args] = result
            return result
    # instantiated in module interpretation, before fibo_cache() calling.
    # define after function definition
    # wrapper is returned to fibo_cache: fibo_cache = memoize(fibo_cache)
    wrapper.cache = {}
    return wrapper

# @functools.cache # functools.cache is twice as fast. See below
@memoize
def fibo_cache(n):
    '''One super-slow fibonacci'''
    return n if n <= 1 else fibo_cache(n-1) + fibo_cache(n-2)

print(fibo_cache(100))
>>> 354224848179261915075
print(len(fibo_cache.cache))
>>> 101
print(fibo_cache.__doc__) # thanks to functools.wrap
>>> One super-slow fibonacci

function with arguments

specific cache

def cache_with_size(max_size):
    def decorator(f):
        cache = {}
        def wrapper(*args):
            if args in cache:
                print("Result retrieved from cache")
                return cache[args]
            result = f(*args)
            if len(cache) >= max_size:
                # Remove the first inserted element (FIFO)
                cache.pop(next(iter(cache)))
            cache[args] = result
            return result
        return wrapper
    return decorator

@cache_with_size(max_size=2)
def expensive_function(x):
    print(f"Calculation for {x}...")
    return x * x

# Appel
print(expensive_function(2))  # Calculation for 2... → 4
print(expensive_function(3))  # Calculation for 3... → 9
print(expensive_function(2))  # Result retrieved from cache → 4

def memoize_expire(timeout):
    '''decorator to keep data in cache with an expiration delay'''
    def memoize(f):
        import time
        from functools import wraps
        # preserves the metadata of f and not of wrapper. See below functools
        @wraps(f)
        def wrapper(*args):
            try:
                value, timestamp = wrapper.cache[args]
                if (time.time() - timestamp) <= timeout:
                    return value
                else:
                    raise KeyError
            except TypeError:
                return f(*args)
            except KeyError:
                value = f(*args)
                wrapper.cache[args] = value, time.time()
                return value
        # instantiated in module interpretation, before fibo_cache() calling.
        # define after function definition
        # wrapper is returned to fibo_cache: fibo_cache = memoize(fibo_cache)
        wrapper.cache = {}
        return wrapper
    return memoize

# @functools.cache # functools.cache is twice as fast. See below
@memoize_expire(600)
def fibo_cache(n):
    '''One super-slow fibonacci'''
    return n if n <= 1 else fibo_cache(n-1) + fibo_cache(n-2)

print(fibo_cache(100))

class decorator

A class decorator in Python is a function that allows you to modify or extend the behavior of a class without directly modifying its code. It applies to the class itself, unlike method decorators which apply to methods.

@decorator
class MyClass: pass
# is equivalent to
class MyClass: pass
MyClass = decorator(MyClass)

@decorator(arg)
class MyClass: pass
# is equivalent to
class MyClass: pass
MyClass = (decorator(arg))(MyClass)

usefulness

• Add metadata (version, author, etc.)
• Register classes in a plugin system
• Modify method behavior (logging, validation, etc.)
• Apply mixins dynamically
• Check or validate the class before use

decorator as a function

function without arguments

def has_add(cls):
    if not hasattr(cls, '__add__'):
        raise AttributeError(f"{cls.__name__} missing attribute: __add__")
    return cls

@has_add
class Foo:
    '''test class for class decorator'''

    def __str__(self):
        return f"repr {__class__} !"

f = Foo()
print(f)

function with arguments

def add_field(argdec):
    def decorator(cls):
        setattr(cls, argdec, 'default')
        return cls
    return decorator

@add_field('name')
@add_field('address')
class Foo:
    '''test class for class decorator'''

    def __repr__(self):
        return f"{__name__}: name: {self.name} address: {self.address}"

f = Foo()
print(f)
print(f.__doc__)

functools

@wraps

'functools.wraps' is a decorator built into Python's 'functools' module. It is used to preserve the metadata of an original function when it is decorated by another function (a wrapper).

import functools
@functools.cache
def my_function():
    pass

@cache

import functools
@functools.cache
def my_function():
    pass

@lru_cache

import functools
@functools.lru_cache(maxsize=128, typed=False)
def my_function():
    pass

decorators' collection

https://wiki.python.org/moin/PythonDecoratorLibrary