1

I've got simple metaclass, that turns methods of classes starting with "get_" to properties:

class PropertyConvertMetaclass(type):
    def __new__(mcs, future_class_name, future_class_parents, future_class_attr):
        new_attr = {}
        for name, val in future_class_attr.items():
            if not name.startswith('__'):
                if name.startswith('get_'):
                    new_attr[name[4:]] = property(val)
            else:
                new_attr[name] = val
        return type.__new__(mcs, future_class_name, future_class_parents, new_attr)

Imagine I have TestClass:

class TestClass():
    def __init__(self, x: int):
        self._x = x

    def get_x(self):
        print("this is property")
        return self._x

I want it to work like this: I create some new class that kinda inherits from them both

class NewTestClass(TestClass, PropertyConvertMetaclass):
    pass

and I could reuse their both methods like this:

obj = NewTestClass(8)
obj.get_x() # 8
obj.x       # 8

As I take it, I should create a new class, lets name it PropertyConvert and make NewTestClass inherit from It:

class PropertyConvert(metaclass=PropertyConvertMetaclass):
    pass

class NewTestClass(TestClass, PropertyConvert):
    pass

But it doesn't help, I still can't use new property method with NewClassTest. How can I make PropertyConvert inherit all the methods from its brother, not doing anything inside NewClassTest, changing only PropertyConverterMetaclass or PropertyConverter? I'm new to metaclasses, so I'm sorry, if this question might seem silly.

Improve this question
12
  • 1
    Did you want the metaclass to be a metaclass at some point? Because inheriting from it just makes it a weird object. You need metaclass=... at some point to actually use it in place of type. Commented Dec 15, 2021 at 4:21
  • 1
    new_attr in your metaclass ends up discarding all the non get_* attributes, including dunders. Did you mean to put an else in there somewhere? Also, you don't need the redundant ifs: anything starting with get_ obviously does not start with __. Commented Dec 15, 2021 at 4:23
  • Yes, I see that it's weird, but unfortunately It's a task from my programming courses. Commented Dec 15, 2021 at 4:23
  • You at least need to call future_class_attr.update(new_attr) at the end of the loop... Commented Dec 15, 2021 at 4:25
  • Even if you did class NewTestClass(TestClass, metaclass=PropertyConvertMetaclass): it wouldn't help. Since NewTestClass does not define any methods in its body, there is nothing for the metaclass to operate on. The TestClass object is created before the metaclass comes into play Commented Dec 15, 2021 at 4:27

3 Answers 3

Reset to default
1

When you do TestClass():, the body of the class is run in a namespace which becomes the class __dict__. The metaclass just informs the construction of that namespace via __new__ and __init__. In this case, you have set up the metaclass of TestClass to be type.

When you inherit from TestClass, e. g. with class NewTestClass(TestClass, PropertyConverter):, the version of PropertyConvertMetaclass you wrote operates on the __dict__ of NewTestClass only. TestClass has been created at that point, with no properties, because its metaclass way type, and the child class is empty, so you see no properties.

There are a couple of possible solutions here. The simpler one, but out of reach because of your assignment, is to do class TestClass(metaclass=PropertyConvertMetaclass):. All children of TestClass will have PropertyConvertMetaclass and so all getters will be converted to properties.

The alternative is to look carefully at the arguments of PropertyConvertMetaclass.__new__. Under normal circumstances, you only operate on the future_class_attr attribute. However, you have access to future_class_bases as well. If you want to upgrade the immediate siblings of PropertyConverter, that's all you need:

class PropertyConvertMetaclass(type):
    def __new__(mcs, future_class_name, future_class_parents, future_class_attr):
        # The loop is the same for each base __dict__ as for future_class_attr,
        # so factor it out into a function
        def update(d):
            for name, value in d.items():
                # Don't check for dunders: dunder can't start with `get_`
                if name.startswith('get_') and callable(value):
                    prop = name[4:]
                    # Getter and setter can't be defined in separate classes
                    if 'set_' + prop in d and callable(d['set_' + prop]):
                        setter = d['set_' + prop]
                    else:
                        setter = None
                    if 'del_' + prop in d and callable(d['del_' + prop]):
                        deleter = d['del_' + prop]
                    else:
                        deleter = None
                    future_class_attr[prop] = property(getter, setter, deleter)

        update(future_class_dict)
        for base in future_class_parents:
            # Won't work well with __slots__ or custom __getattr__
            update(base.__dict__)
    return super().__new__(mcs, future_class_name, future_class_parents, future_class_attr)

This is probably adequate for your assignment, but lacks a certain amount of finesse. Specifically, there are two deficiencies that I can see:

  1. There is no lookup beyond the immediate base classes.
  2. You can't define a getter in one class and a setter in another.

To address the first issue, you will have to traverse the MRO of the class. As @jsbueno suggests, this is easier to do on the fully constructed class using __init__ rather than the pre-class dictionary. I would solve the second issue by making a table of available getters and setters before making any properties. You could also make the properties respect MRO by doing this. The only complication with using __init__ is that you have to call setattr on the class rather than simply updating its future __dict__.

class PropertyConvertMetaclass(type):
    def __init__(cls, class_name, class_parents, class_attr):
        getters = set()
        setters = set()
        deleters = set()

        for base in cls.__mro__:
            for name, value in base.__dict__.items():
                if name.startswith('get_') and callable(value):
                    getters.add(name[4:])
                if name.startswith('set_') and callable(value):
                    setters.add(name[4:])
                if name.startswith('del_') and callable(value):
                    deleters.add(name[4:])

        for name in getters:
            def getter(self, *args, **kwargs):
                return getattr(super(cls, self), 'get_' + name)(*args, **kwargs)
            if name in setters:
                def setter(self, *args, **kwargs):
                    return getattr(super(cls, self), 'set_' + name)(*args, **kwargs)
            else:
                setter = None
            if name in deleters:
                def deleter(self, *args, **kwargs):
                    return getattr(super(cls, self), 'del_' + name)(*args, **kwargs)
            else:
                deleter = None
            setattr(cls, name, property(getter, setter, deleter)

Anything that you do in the __init__ of a metaclass can just as easily be done with a class decorator. The main difference is that the metaclass will apply to all child classes, while a decorator only applies where it is used.

Improve this answer
Sign up to request clarification or add additional context in comments.

3 Comments

thank you. it seems though, that must be some way (I edited my question a bit).
it is not "impossible", you just have to introspect the base classes instead of only looking at the current class namespace.
@jsbueno. Your right, unusual but not impossible. This is what happens when I answer questions late as night.
1

There is nothing "impossible" there. It is a problem that, however unusual, can be solved with metaclasses.

Your approach is good - the problem you got is that when you look into the "future_class_attr" (also known as the namespace in the classbody), it only contains the methods and attributes for the class currently being defined . In your examples, NewTestClass is empty, and so is "future_class_attr".

The way to overcome that is to check instead on all base classes, looking for the methods that match the pattern you are looking for, and then creating the appropriate property.

Doing this correctly before creating the target class would be tricky - for one would have to do attribute searching in the correct mro (method resolution order) of all superclasses -and there can be a lot of corner cases. (but note it is not "impossible", nonetheless)

But nothing prevents you of doing that after creating the new class. For that, you can just assign the return value of super().__new__(mcls, ...) to a variable (by the way, prefer using super().__new__ instead of hardcoding type.__new__: this allows your metaclass to be colaborative and be combined with, say, collections.ABC or enum.Enum). That variable is them your completed class and you can use dir on it to check for all attribute and method names, already consolidating all superclasses - then, just create your new properties and assign then to the newly created class with setattr(cls_variable, property_name, property_object).

Better yet, write the metaclass __init__ instead of its __new__ method: you retrieve the new class already created, and can proceed to introspecting it with dir and adding the properties immediately. (don't forget to call super().__init__(...) even though your class don't need it.)

Also, note that since Python 3.6, the same results can be achieved with no metaclass at all, if one just implements the needed logic in the __init_subclass__ method of a base class.

Improve this answer

3 Comments

It doesn't have to be tricky because MRO is handled correctly by super.
Also, you could apply a decorator and use dir, which actually would be trickier
I updated my answer to show a way to do this pretty generally using super without having to worry about MRO. Thanks for the pointer.
0

One of the solutions of my problem is parsing parents' dicts in PropertyConvertMetaclass:

class PropertyConvertMetaclass(type):
    def __new__(mcs, future_class_name, future_class_parents, future_class_attr):
        new_attr = {}
        for parent in future_class_parents:
            for name, val in parent.__dict__.items():
                if not name.startswith('__'):
                    if name.startswith('get_'):
                        new_attr[name[4:]] = property(val, parent.__dict__['set_' + name[4:]])
                new_attr[name] = val

        for name, val in future_class_attr.items():
            if not name.startswith('__'):
                if name.startswith('get_'):
                    new_attr[name[4:]] = property(val, future_class_attr['set_'+name[4:]])
            new_attr[name] = val
        return type.__new__(mcs, future_class_name, future_class_parents, new_attr)
Improve this answer

2 Comments

I posted a very similar answer, but with cleaned up code (didn't see yours on mobile). Will update to avoid duplication
See my updated version. It's much more general: you can define getters, setter and deleters in different classes now, and have a property correctly generated.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.