Python code generation

[Andre S. Veteran]

I'm kind of a newbie in Python and I'd like to know if the following is possible. All of the following happens at run-time. The application's presentation is basically a Python interpreter like the IDLE, where the user types Python code, hits enter and sees the results immediately. The difference is that this interpreter can generate new types on the fly, given a type definition is some arbitrary format (xml for instance). When it receives that type definition, it generates a new python class based on that type definition, with the same methods and fields etc. It also generates some extra code in the methods of that new type. The new type is then available to the user on the console so he can instantiate it and use it.

Basic use case :

User types "load type "MyType.xml"

MyType.xml :

<class>
	<name>MyType</name>
	<fields>
		<field>
			<type>int</type>
			<name>myInt</name>
   .etc

MyType is now a python class loaded in the interpreter.

User types "mt = MyType()", uses mt's fields, methods, etc.

So basically this requires some metaprogramming ability and I wonder if that's possible in Python? If so, using what libraries/types? I've browsed the documentation and I'm not really sure. I understand that I can create a new run-time type using the function type, but I feel like that's insufficient given I also need to be able to plug some more code in there, and all that has to happen automatically, the user just specifies where to find the type definition and it should be available to him.

Thanks for any help.

[Andre S. Veteran]

I understand that my original question is a bit confusing, so I'll try to specify.

Consider the following python code :

def MyMethod(self):
	print "Hello!"
C = type("AClass", (object,), {})
C.method = MyMethod
c = C()
c.method()

This ouputs:

Hello!

What we're doing here is creating a new type at run-time, "AClass". Actually the code name for that type here is C, but we could have named it AClass to the same effect. We are also able to bind a method to that type. When we instantiate a "C", we are then able to call method() on it.

However, this lacks a lot of flexibility. Notice that the method MyMethod is hard-coded. I want to be able to generate a method at run-time based on an arbitrary signature, for example one read from a text file, described in C or XML or whatever.

One solution I'm thinking about is to generate new Python code at run-time as a text file, and then import the file as a module, although I'm not sure about the syntaxical details. Is there a way I can generate a custom type with custom methods at run-time, based on a type and method definitions?

I hope that makes it more clear.

Thanks.

[Andre S. Veteran]

In case it's of interest to anyone reading this topic, I found a solution and it is pretty simple :

>>> method1 = '''
def method1(self):
	print "hello from method1 !"
'''
>>> method2 = '''
def method2(self):
	print "hello from method2 !"
'''
>>> classdict = {}
>>> exec method1 in classdict
>>> exec method2 in classdict
>>> MyClass = type("MyClass", (object,), classdict)
>>> myObject = MyClass()
>>> myObject.method1()
hello from method1 !
>>> myObject.method2()
hello from method2 !

We create classes and methods from strings, so they can be defined at run-time. For instance the user can input his own type definition as any format, we just have to convert it to a string of equivalent python code, and then we can generate the python type on-the-fly.