How to create dynamic methods with python?

Exception Value: 'UserFilter' object has no attribute 'is_bound'

You are getting this error because the class methods you are generating, are not bound to any class. To bound them to the class, you need to use setattr()

Try this on a console:

class MyClass(object):
    pass

@classmethod 
def unbound(cls):
    print "Now I'm bound to ", cls


print unbound
setattr(MyClass, "bound", unbound) 
print MyClass.bound 
print MyClass.bound()

Traceback: UserFilter = type('Foo', (django_filters.FilterSet, ), create_filter_dict().update({'Meta':type('Meta',(), {'model': get_user_model(), 'fields':[]} )})) TypeError: type() argument 3 must be dict, not None

Now, this is failing because dict.update() doesn't return the same instance, returns None. That can be fixed easily

class_dict = create_filter_dict()
class_dict.update({'Meta':type('Meta',(), {'model': get_user_model(), 'fields':[]})}
UserFilter = type('Foo', (django_filters.FilterSet, ), class_dict))

However, just look how messy that code looks. I recommend to you to try to be clearer with the code you write even if it requires to write a few extra lines. In the long run, the code will be easier to maintain for you and your team.

meta_model_dict = {'model': get_user_model(), 'fields':[]}
meta_type = type('Meta',(), meta_model_dict)

filter_dict = create_filter_dict()
filter_dict['Meta'] = meta_type
UserFilter = type('Foo', (django_filters.FilterSet,), filter_dict)

This code might not be perfect but it is more readable than the original line of code you posted:

UserFilter = type('Foo', (django_filters.FilterSet, ), create_filter_dict().update({'Meta':type('Meta',(), {'model': get_user_model(), 'fields':[]})}))

And removes a complication on an already kinda difficult concept to grasp.

You might want to learn about metaclasses. Maybe you can overwrite the new method of a class. I can recommend you 1 or 2 posts about that.

Another option is that maybe you are not adding the filters correctly or in a way django doesn't expect? That would explain why you get no errors but none of your functions gets called.

You can use classmethod. Here is example how you can use it:

class UserFilter:
    @classmethod
    def filter_field(cls, queryset, value, field = None):
        # do somthing
        return "{0} ==> {1} {2}".format(field, queryset, value)
    @classmethod
    def init(cls,list_of_fields ):
        for field in list_of_fields:
            ff = lambda cls, queryset, value, field=field: cls.filter_field(queryset, value, field )
            setattr(cls, 'filter_'+field, classmethod( ff ))

UserFilter.init( ['a','b'] )
print(UserFilter.filter_a(1,2)) # a ==> 1 2
print(UserFilter.filter_b(3,4)) # b ==> 3 4

You are asking for:

custom (Class) methods.

So we take an existing class and derive a subclass where you can add new methods or overwrite the methods of the original existing class (look into the code of the original class for the methods you need) like this:

from universe import World
class NewEarth(World.Earth):
   def newDirectionUpsideDown(self,direction):
       self.rotationDirection = direction

All the other Methods and features of World.Earth apply to NewEarth only you can now change the direction to make the world turn your new way.

To overwrite an existing method of a class is as as easy as this.

class NewEarth(World.Earth):
   def leIitRain(self,amount): # let's assume leIitRain() is a standard-function of our world
       return self.asteroidStorm(amount) #let's assume this is possible Method of World.Earth

So if someone likes a cool shower on earth he/she/it or whatever makes room for new development on the toy marble the burning way.

So have fun in your way learning python - and don't start with complicated things.

If I got you completely wrong - you might explain your problem in more detail - so more wise people than me can share their wisdom.