Talks: dynclasses.py

import types

# One of the nicest things about Python is that you can put pieces together.
# You only have to learn each piece once.

3                # an integer
3, 4, 5          # a tuple of integers, also written (3, 4, 5)
x = 3, 4, 5      # assignment

def f():         # a function
    x = 3, 4, 5
    return x

class Foo(object):   # a class
    def f(self):     # ok, we had to add self
        x = 3, 4, 5
        return x

foo = Foo()
assert foo.f() == (3, 4, 5)  # ok, sometimes you need the ()s


# Another nice thing is that you can just type things in, line-by-line.

# So the question is, how do I do what I just did line-by-line (dynamically)?


class Foo(object):  # a class
    pass  # ok, we need this so we can unindent.  Any value would work too.

def f(self):        # same again, but it's not part of Foo yet
    x = 3, 4, 5
    return x

Foo.f = f     # is it really that easy?

foo = Foo()
assert foo.f() == (3, 4, 5)  # yes!


# But what about this?

Foo.g = f

assert foo.g() == (3, 4, 5)  # yes!  And I didn't even change foo!


# There's no difference between bound and unbound method types:

assert type(f) is types.FunctionType
assert type(Foo.f) is types.MethodType  # (how did that happen?)
assert type(foo.f) is types.MethodType
assert type(Foo.g) is types.MethodType
assert type(foo.g) is types.MethodType


# Ok, but what about sticking a function on a particular instance?

foo.h = f

try:
    foo.h()
except TypeError, e:
    assert str(e) == 'f() takes exactly 1 argument (0 given)'
    # oops, it has the wrong name too!


# So what went wrong?

assert type(foo.f) == types.MethodType
assert type(foo.h) == types.FunctionType

# Or in terms of what you'd see if you entered "type(foo.f)" at the console:
assert repr(type(foo.f)) == "<type 'instancemethod'>"  # types.MethodType
assert repr(type(foo.h)) == "<type 'function'>"        # types.FunctionType

# foo.f is a method, but foo.h is still a function.
# Only methods get magically bound to foo when accessed as foo.name.

# Except actually, foo.f isn't really a method.
assert repr(type(Foo.__dict__['f'])) == "<type 'function'>"  # FunctionType

# "a class attribute reference [which] would yield a user-defined function
#  ... is transformed into an unbound user-defined method object whose
# im_class attribute is [the class]."
#    -- http://docs.python.org/reference/datamodel.html

# i.e. f is still sitting there as a function in Foo.__dict__,
# but it gets converted to a method when accessed as Foo.f (unbound)
# or foo.f (bound to foo).

# So how do we turn foo.h into a method?  With any of these:

foo.h = types.MethodType(f, foo)       # Bind f to foo and assign to foo.h
foo.h = types.MethodType(f, foo, Foo)  # Require a Foo instance for "self"

foo.h = f.__get__(foo)                 # Bind f to foo and assign to foo.h
foo.h = f.__get__(foo, Foo)            # Require a Foo instance for "self"


# Is that all it takes?

assert repr(type(foo.h)) == "<type 'instancemethod'>"  # types.MethodType
assert foo.h() == (3, 4, 5)  # yes!

assert foo.h.__name__ == 'f'

# It still has the wrong name though... and you can't change a method's name.


# Ok, how do I get the function back?

h = foo.h.im_func            # im is short for instance method I presume

assert h(foo) == (3, 4, 5)

h.__name__ = 'h'  # Better.  Let's put it back to being a method...

foo.h = h.__get__(foo)
assert foo.h.__name__ == 'h'
assert foo.f.__name__ == 'h'  # Oops.  (Exercise for the reader.)


# Does ".im_func" work on methods that didn't start off as functions?

class Foo(object):   # a class
    def f(self):     # ok, we had to add self
        x = 3, 4, 5
        return x

f = foo.f.im_func

assert f(foo) == (3, 4, 5)  # yes!  Except...


# ... that was a trick question.

# Let's watch the original definition of Foo again.

class Foo(object):
    def f(self):
        x = 3, 4, 5
        return x
    # Stop!
    # What is f *right here*?  A function or a method?  Does it exist at all?




    # Of course it does.  It's a function.
    assert type(f) == types.FunctionType



# But *right here* ...
assert type(Foo.f) == types.MethodType  # ... it's a method.  Huh?



# All methods start off as functions.
# (Except the ones implemented in C, such as built-ins and extensions.)


# Ok, this is what actually happens as we define class Foo.

# class Foo(object):
#     ...

# "class Foo(object):" is delayed until its body has been processed...

body = '''

def f(self):
    x = 3, 4, 5
    return x

'''

tempdict = {}
exec body in tempdict

# Minor detail: classes have a __module__ attribute.
# sys.modules[SomeClass.__module__] is the module SomeClass was defined in.

tempdict['__module__'] = __name__


# At the end of the class body, create the class itself:

Foo = type('Foo', (object,), tempdict)  # "class Foo(object):" <= tempdict
foo = Foo()
assert foo.f() == (3, 4, 5)

# The "type()" built-in doesn't just query the class of objects,
# it can make new classes!



# Ok, here's a challenge.  Is it possible to define a VanishingClass
# so that:
#     x = VanishingClass()
#     x is None
# ?



class VanishingClass(object):
    def __new__(newclass, *args, **kwargs):
        return None

x = VanishingClass()
assert x is None  # yes!

# "MyClass(1, 2, x=3)" means "MyClass.__new__(MyClass, 1, 2, x=3)".
# It's object.__new__ that calls __init__ when you create a class (I think).



# Ok, another challenge.  Is it possible to define a SingletonClass
# so that "SingletonClass() is SingletonClass()"?



class SingletonClass(object):
    def __new__(newclass, *args, **kwargs):
        try:
            return SingletonClass.instance
        except AttributeError:
            singleton = object.__new__(newclass, *args, **kwargs)
            SingletonClass.instance = singleton
            return singleton


assert SingletonClass() is SingletonClass()  # yes!



# And if we're being pedantic...
assert VanishingClass() is VanishingClass()  # VanishingClass is a singleton!
# ... or a zerogleton.


# Ok, but is any of this *useful*?

# Well, I've used SingletonClass for a DatabaseObject class, where
# DatabaseObject('Fred') would create or retrieve Fred's record.

# I've even used VanishingClass in a type-checking hack:

# /*
#  * You are not expected to understand this.
#  */
class Integer(object):  # a variant on VanishingClass
    def __new__(newclass, *args, **kwargs):
        if args and args[0] is newclass:
            return None  # Integer(Integer) => vanish!
        # Just create it normally.  (I may have this wrong...)
        self = newclass.__bases__[0].__new__(
                    newclass.__bases__[0], *args, **kwargs)
        self.__class__ = newclass
        return self


def public_api_function(arg=Integer):
    return implementation(arg=Integer(arg))

def implementation(arg=None):
    pass  # ...




# The main reason all this is worth describing is to explain Python classes,
# but also because it lets you create classes completely on-the-fly, or
# really friendly-looking declarative APIs:

'''

class MyForm(object):
    name = String()
    age = Integer()
    ...

'''
# If you need an order on fields, you're in trouble - remember tempdict?
# There's a clever hack though: give the field constructors a global counter.


# A final example:

class Word(object):  # a basic class that prints out as "Word()"
    def __repr__(self):
        return '%s()' % self.__class__.__name__

input = '''No-one expects the Spanish Inquisition!'''

words = []
for word in input.split():
    newclass = type(word, (Word,), {})  # create a new class
    words.append(newclass())            # create an instance
    globals()[word] = newclass          # publish the class under its name

assert repr(words)=='[No-one(), expects(), the(), Spanish(), Inquisition!()]'
# Yes, those are some very strange class names!
spanish = Spanish()
assert repr(spanish)=='Spanish()'
inquisition = globals()['Inquisition!']()
assert repr(inquisition)=='Inquisition!()'