Dynamically modifying a class upon creation

Question

I have a classmethod that I want to be called automatically before or when any child of the class it belongs to gets created. How can I achieve that?

Since I understand this can be an XY problem, here is why I (think I) need it, and my basic implementation.

I have a class that gets inherited, and the children of that class can specify a list of parameters that need to be converted into properties. Here is the relevant code:

class BaseData:
    @staticmethod
    def internalName(name: str) -> str:
        return '_' + name

    def __init__(self):
        for k, v in self._dataProperties.items():
            setattr(self, BaseData.internalName(k), v)
        self._isModified = False
    
    @classmethod
    def initProperties(cls):
        for k, v in cls._dataProperties.items():
            # Create dynamic getter and setter function
            getterFunc = eval(f'lambda self: self.getProperty("{k}")')
            setterFunc = eval(f'lambda self, v: self.setProperty("{k}", v)')

            # Make them a property
            setattr(cls, k, property(fget=getterFunc, fset=setterFunc))

class ChildData(BaseData):
    _dataProperties = {
        'date': None,
        'value': '0',
    }

ChildData.initProperties()

Function initProperties need to be called once for each child, and to enforce that I need to write it below function definition. I find it a bit ugly, so.. Is there any other wat to do it?

I already tried to put the code in __init__, but it does not get called when I unpickle the objects.

So, basically:

1. Generic question: is there any way to force a function to be called the first time a child class is used (even when __init__ does not get called)?
2. If not, more specific question: is there a way to automatically call a specific function (it can be __init__, but also another one) when unpickling?
3. If not, single use-case question: Is there a better way to do what I'm doing here?

I already read Python class constructor (static), and while it has the same question I did not find a reply that could solve my use case.

Answer 1

To achieve the behavior you described, you can use a metaclass. A metaclass is a class that creates classes. You can define a metaclass for BaseData that calls initProperties automatically when a child class is defined.

Here is an example implementation:

class InitPropertiesMeta(type):
    def __new__(cls, name, bases, attrs):
        new_class = super().__new__(cls, name, bases, attrs)
        if name != 'BaseData':
            new_class.initProperties()
        return new_class

class BaseData(metaclass=InitPropertiesMeta):
    @staticmethod
    def internalName(name: str) -> str:
        return '_' + name

    def __init__(self):
        for k, v in self._dataProperties.items():
            setattr(self, BaseData.internalName(k), v)
        self._isModified = False
    
    @classmethod
    def initProperties(cls):
        for k, v in cls._dataProperties.items():
            # Create dynamic getter and setter function
            getterFunc = eval(f'lambda self: self.getProperty("{k}")')
            setterFunc = eval(f'lambda self, v: self.setProperty("{k}", v)')

            # Make them a property
            setattr(cls, k, property(fget=getterFunc, fset=setterFunc))

class ChildData(BaseData):
    _dataProperties = {
        'date': None,
        'value': '0',
    }

The InitPropertiesMeta metaclass overrides the new method, which is called when a new class is defined. When BaseData is defined, new is called with name equal to 'BaseData', so it does nothing. When a child class like ChildData is defined, new is called with name equal to the name of the child class, so it calls initProperties on the child class.

With this implementation, you no longer need to call initProperties explicitly for each child class. Instead, it will be called automatically when the child class is defined.

Regarding your more specific question about unpickling, you can define the getstate and setstate methods in your class to control pickling and unpickling behavior. For example, you could define getstate to return a tuple of the values you want to pickle, and setstate to set those values when unpickling. i hope this help you :)

Answer 2

Use __init_subclass__ instead of initProperties. (This class method—special-cased so that you don't need to decorate it with classmethod—was added to handle many of the things a metaclass would otherwise be necessary for.)

class BaseData:
    @staticmethod
    def internalName(name: str) -> str:
        return '_' + name

    def __init__(self):
        for k, v in self._dataProperties.items():
            setattr(self, BaseData.internalName(k), v)
        self._isModified = False
    
    def __init_subclass__(cls):
        for k, v in cls._dataProperties.items():
            # Create dynamic getter and setter function
            getterFunc = eval(f'lambda self: self.getProperty("{k}")')
            setterFunc = eval(f'lambda self, v: self.setProperty("{k}", v)')

            # Make them a property
            setattr(cls, k, property(fget=getterFunc, fset=setterFunc))

class ChildData(BaseData):
    _dataProperties = {
        'date': None,
        'value': '0',
    }

A custom descriptor, though, to avoid the need for eval (or similar steps to capture the current value of k and v) is cleaner.

Answer 3

There are several tools you can use for this:

1. Ask Python to do something when the class is first created, e.g. dynamically creating class methods and class attributes.
2. Use a decorator that modifies the class immediately upon creation.
3. Use a descriptor for each attribute. For the sake of space and time I will leave this to another answer.

Option 1: Metaclass

The first solution corresponds more or less to your proposed "Y" solution. A metaclass is the type/class of a class object, and you can use this to customize the class object before it is created.

This solution is demonstrated in the other answer so I will not go into detail on its usage. However you can refer to What are metaclasses in Python? and the Python docs (1 2) for more information.

For another usage example, abstract base classes in the standard library are implemented using a metaclass. You can check out the source code if you want to see the implementation.

Option 2: Decorator

Instead of changing the type of the class and customizing its creation, you can also just write a function that modifies the class, and then call that function on the class after creating it. Python makes this very ergonomic using decorators.

def initProperties(cls):
    for k, v in cls._dataProperties.items():
        getterFunc = eval(f'lambda self: self.getProperty("{k}")')
        setterFunc = eval(f'lambda self, v: self.setProperty("{k}", v)')
        setattr(cls, k, property(fget=getterFunc, fset=setterFunc))


class BaseData():
    @staticmethod
    def internalName(name: str) -> str:
        return '_' + name

    def __init__(self):
        for k, v in self._dataProperties.items():
            setattr(self, BaseData.internalName(k), v)
        self._isModified = False


@initProperties
class ChildData(BaseData):
    _dataProperties = {
        'date': None,
        'value': '0',
    }

The popular Attrs library uses this decorator technique instead of metaclasses.

Option 3: Descriptor

For the sake of space and time, I will let another answer cover this in detail. The Python Descriptor Howto guide linked by zvone in the comments also provides comprehensive coverage of the topic.

Usage of the descriptor technique might look very similar to the "placeholders for data properties" described below:

class ChildData(BaseData):
    date = DataProperty(None)
    value = DataProperty('0')

This is arguably the most Pythonic solution!

Notes

Placeholders for data properties

Some libraries take the approach of using special placeholder objects in place of your _dataProperties dict. These libraries then walk through all class attributes, looking for (and maybe even removing) those attributes and acting as needed.

For example:

import inspect


class DataProperty:
    def __init__(self, value):
        self.value = value


def isDataProperty(obj):
    return isinstance(obj, DataProperty)


def initProperties(cls):
    for k, v in inspect.getmembers(cls, isDataProperty):
        getterFunc = eval(f'lambda self: self.getProperty("{k}")')
        setterFunc = eval(f'lambda self, v: self.setProperty("{k}", v)')
        setattr(cls, k, property(fget=getterFunc, fset=setterFunc))


class BaseData():
    @staticmethod
    def internalName(name: str) -> str:
        return '_' + name

    def __init__(self):
        for k, v in self._dataProperties.items():
            setattr(self, BaseData.internalName(k), v)
        self._isModified = False


@initProperties
class ChildData(BaseData):
    date = DataProperty(None)
    value = DataProperty('0')

More recently, libraries have been using class variable annotations for the same purpose, instead of placeholder objects. Attrs for example implements both versions.

Dynamic code generation

You almost certainly do not need or want to dynamically generate these particular functions using eval(). I am willing to assume that these are placeholders for more complicated dynamic code generation.

However, you should strongly consider alternative design patterns like factory functions, callable objects, and partial function application whenever possible.

Dynamic source code generation should be considered an absolute last resort!