Index: src/org/python/core/PyModule.java
===================================================================
--- src/org/python/core/PyModule.java	(revision 3142)
+++ src/org/python/core/PyModule.java	(working copy)
@@ -3,17 +3,201 @@
 
 public class PyModule extends PyObject
 {
+    //~ BEGIN GENERATED REGION -- DO NOT EDIT SEE gexpose.py
+    /* type info */
+
+    public static final String exposed_name="module";
+
+    public static void typeSetup(PyObject dict,PyType.Newstyle marker) {
+        dict.__setitem__("__dict__",new PyGetSetDescr("__dict__",PyModule.class,"getDict","setDict","delDict"));
+        dict.__setitem__("__doc__",new PyGetSetDescr("__doc__",PyModule.class,"getDoc",null,null));
+        class exposed___repr__ extends PyBuiltinMethodNarrow {
+
+            exposed___repr__(PyObject self,PyBuiltinFunction.Info info) {
+                super(self,info);
+            }
+
+            public PyBuiltinFunction bind(PyObject self) {
+                return new exposed___repr__(self,info);
+            }
+
+            public PyObject __call__() {
+                return new PyString(((PyModule)self).module_toString());
+            }
+
+        }
+        dict.__setitem__("__repr__",new PyMethodDescr("__repr__",PyModule.class,0,0,new exposed___repr__(null,null)));
+        class exposed___setattr__ extends PyBuiltinMethodNarrow {
+
+            exposed___setattr__(PyObject self,PyBuiltinFunction.Info info) {
+                super(self,info);
+            }
+
+            public PyBuiltinFunction bind(PyObject self) {
+                return new exposed___setattr__(self,info);
+            }
+
+            public PyObject __call__(PyObject arg0,PyObject arg1) {
+                try {
+                    ((PyModule)self).module___setattr__(arg0.asName(0),arg1);
+                    return Py.None;
+                } catch (PyObject.ConversionException e) {
+                    String msg;
+                    switch (e.index) {
+                    case 0:
+                        msg="attribute name must be a string";
+                        break;
+                    default:
+                        msg="xxx";
+                    }
+                    throw Py.TypeError(msg);
+                }
+            }
+
+        }
+        dict.__setitem__("__setattr__",new PyMethodDescr("__setattr__",PyModule.class,2,2,new exposed___setattr__(null,null)));
+        class exposed___delattr__ extends PyBuiltinMethodNarrow {
+
+            exposed___delattr__(PyObject self,PyBuiltinFunction.Info info) {
+                super(self,info);
+            }
+
+            public PyBuiltinFunction bind(PyObject self) {
+                return new exposed___delattr__(self,info);
+            }
+
+            public PyObject __call__(PyObject arg0) {
+                try {
+                    ((PyModule)self).module___delattr__(arg0.asName(0));
+                    return Py.None;
+                } catch (PyObject.ConversionException e) {
+                    String msg;
+                    switch (e.index) {
+                    case 0:
+                        msg="attribute name must be a string";
+                        break;
+                    default:
+                        msg="xxx";
+                    }
+                    throw Py.TypeError(msg);
+                }
+            }
+
+        }
+        dict.__setitem__("__delattr__",new PyMethodDescr("__delattr__",PyModule.class,1,1,new exposed___delattr__(null,null)));
+        class exposed___init__ extends PyBuiltinMethod {
+
+            exposed___init__(PyObject self,PyBuiltinFunction.Info info) {
+                super(self,info);
+            }
+
+            public PyBuiltinFunction bind(PyObject self) {
+                return new exposed___init__(self,info);
+            }
+
+            public PyObject __call__(PyObject[]args) {
+                return __call__(args,Py.NoKeywords);
+            }
+
+            public PyObject __call__(PyObject[]args,String[]keywords) {
+                ((PyModule)self).module_init(args,keywords);
+                return Py.None;
+            }
+
+        }
+        dict.__setitem__("__init__",new PyMethodDescr("__init__",PyModule.class,-1,-1,new exposed___init__(null,null)));
+        dict.__setitem__("__new__",new PyNewWrapper(PyModule.class,"__new__",-1,-1) {
+
+                                                                                        public PyObject new_impl(boolean init,PyType subtype,PyObject[]args,String[]keywords) {
+                                                                                            PyModule newobj;
+                                                                                            if (for_type==subtype) {
+                                                                                                newobj=new PyModule();
+                                                                                                if (init)
+                                                                                                    newobj.module_init(args,keywords);
+                                                                                            } else {
+                                                                                                newobj=new PyModuleDerived(subtype);
+                                                                                            }
+                                                                                            return newobj;
+                                                                                        }
+
+                                                                                    });
+    }
+    //~ END GENERATED REGION -- DO NOT EDIT SEE gexpose.py
+
+    private final PyObject module_doc = new PyString(
+      "module(name[, doc])\n" +
+      "\n" +
+      "Create a module object.\n" + 
+      "The name must be a string; the optional doc argument can have any type.");
+
     public PyObject __dict__;
 
+    public PyModule() {
+        super();
+    }
+
+    public PyModule(PyType subType) {
+        super(subType);
+    }
+
+    public PyModule(PyType subType, String name) {
+        super(subType);
+        module_init(new PyString(name), Py.None);
+    }
+
+    public PyModule(String name) {
+        this(name, null);
+    }
+
     public PyModule(String name, PyObject dict) {
-        if (dict == null)
-            __dict__ = new PyStringMap();
-        else
-            __dict__ = dict;
-        __dict__.__setitem__("__name__", new PyString(name));
-        __dict__.__setitem__("__doc__", Py.None);
+        super();
+        __dict__ = dict;
+        module_init(new PyString(name), Py.None);
     }
 
+    final void module_init(PyObject name, PyObject doc) {
+        ensureDict();
+        __dict__.__setitem__("__name__", name);
+        __dict__.__setitem__("__doc__", doc);
+    }
+
+    final void module_init(PyObject[] args, String[] keywords) {
+      ArgParser ap = new ArgParser("__init__", args, keywords, new String[] {"name",
+                                                                             "doc"});
+      PyObject name = ap.getPyObject(0);
+      PyObject docs = ap.getPyObject(1, Py.None);
+      module_init(name, docs);
+    }
+
+    public PyObject fastGetDict() {
+        return __dict__;
+    }
+
+    public PyObject getDict() {
+        if (__dict__ == null)
+            return Py.None;
+        return __dict__;
+    }
+  
+    public void setDict(PyObject newDict) {
+        throw Py.TypeError("readonly attribute");
+    }
+
+    public void delDict() {
+        throw Py.TypeError("readonly attribute");
+    }
+
+    public PyObject getDoc() {
+        PyObject d = fastGetDict();
+        if (d != null) {
+            PyObject doc = d.__finditem__("__doc__");
+            if (doc != null) {
+                return doc;
+            }
+        }
+        return module_doc;
+    }
+
     protected PyObject impAttr(String attr) {
         PyObject path = __dict__.__finditem__("__path__");
         PyObject pyname = __dict__.__finditem__("__name__");
@@ -53,18 +237,27 @@
         }
 
         return null;
+    }
 
+    public PyObject __findattr__(String attr) {
+        return module___findattr__(attr);
     }
 
-    public PyObject __findattr__(String attr) {
+    final PyObject module___findattr__(String attr) {
         PyObject ret;
 
-        ret = __dict__.__finditem__(attr);
-        if (ret != null) return ret;
+        if (__dict__ != null) {
+          ret = __dict__.__finditem__(attr);
+          if (ret != null) return ret;
+        }
 
         ret = super.__findattr__(attr);
         if (ret != null) return ret;
 
+        if (__dict__ == null) {
+            return null;
+        }
+
         PyObject pyname = __dict__.__finditem__("__name__");
         if (pyname == null) return null;
 
@@ -72,21 +265,52 @@
     }
 
     public void __setattr__(String attr, PyObject value) {
-        __dict__.__setitem__(attr, value);
+        module___setattr__(attr, value);
     }
 
+    final void module___setattr__(String attr, PyObject value) {
+        if (attr != "__dict__")
+            ensureDict();
+        super.__setattr__(attr, value);
+    }
+
     public void __delattr__(String attr) {
-        __dict__.__delitem__(attr);
+        module___delattr__(attr);
     }
 
+    final void module___delattr__(String attr) {
+        super.__delattr__(attr);
+    }
+
+    public String toString()  {
+        return module_toString();
+    }
+
+    final String module_toString()  {
+        PyObject name = null;
+        PyObject filename = null;
+        if (__dict__ != null) {
+          name = __dict__.__finditem__("__name__");
+          filename = __dict__.__finditem__("__file__");
+        }
+        if (name == null)
+            name = new PyString("?");
+        if (filename == null)
+            filename = new PyString("(built-in)");
+        else
+            filename = new PyString("from '" + filename + "'");
+        return "<module '" + name + "' " + filename + ">";
+    }
+
     public PyObject __dir__() {
+        if (__dict__ == null)
+            throw Py.TypeError("module.__dict__ is not a dictionary");
         return __dict__.invoke("keys");
     }
 
-    public String toString()  {
-        PyObject name = __dict__.__finditem__("__name__");
-        PyObject file = __dict__.__finditem__("__file__");
-        return "<module '"+ name + "' from '" + file + "'>";
+    private void ensureDict() {
+        if (__dict__ == null)
+            __dict__ = new PyStringMap();
     }
 
     static private PyObject silly_list = null;
@@ -106,13 +330,4 @@
         }
     }
 
-    /**
-     * @see org.python.core.PyObject#safeRepr()
-     */
-    public String safeRepr() throws PyIgnoreMethodTag {
-        PyObject name = __dict__.__finditem__("__name__");
-        if (name == null) return "unnamed module";
-        return "module '"+name+"'";
-    }
-
 }
Index: src/org/python/core/PyModuleDerived.java
===================================================================
--- src/org/python/core/PyModuleDerived.java	(revision 0)
+++ src/org/python/core/PyModuleDerived.java	(revision 0)
@@ -0,0 +1,930 @@
+package org.python.core;
+
+public class PyModuleDerived extends PyModule implements Slotted {
+
+    public PyObject getSlot(int index) {
+        return slots[index];
+    }
+
+    public void setSlot(int index,PyObject value) {
+        slots[index]=value;
+    }
+
+    private PyObject[]slots;
+
+    public PyModuleDerived(PyType subtype) {
+        super(subtype);
+        slots=new PyObject[subtype.getNumSlots()];
+    }
+
+    public PyString __str__() {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__str__");
+        if (impl!=null) {
+            PyObject res=impl.__get__(this,self_type).__call__();
+            if (res instanceof PyString)
+                return(PyString)res;
+            throw Py.TypeError("__str__"+" should return a "+"string");
+        }
+        return super.__str__();
+    }
+
+    public PyString __repr__() {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__repr__");
+        if (impl!=null) {
+            PyObject res=impl.__get__(this,self_type).__call__();
+            if (res instanceof PyString)
+                return(PyString)res;
+            throw Py.TypeError("__repr__"+" should return a "+"string");
+        }
+        return super.__repr__();
+    }
+
+    public PyString __hex__() {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__hex__");
+        if (impl!=null) {
+            PyObject res=impl.__get__(this,self_type).__call__();
+            if (res instanceof PyString)
+                return(PyString)res;
+            throw Py.TypeError("__hex__"+" should return a "+"string");
+        }
+        return super.__hex__();
+    }
+
+    public PyString __oct__() {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__oct__");
+        if (impl!=null) {
+            PyObject res=impl.__get__(this,self_type).__call__();
+            if (res instanceof PyString)
+                return(PyString)res;
+            throw Py.TypeError("__oct__"+" should return a "+"string");
+        }
+        return super.__oct__();
+    }
+
+    public PyFloat __float__() {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__float__");
+        if (impl!=null) {
+            PyObject res=impl.__get__(this,self_type).__call__();
+            if (res instanceof PyFloat)
+                return(PyFloat)res;
+            throw Py.TypeError("__float__"+" should return a "+"float");
+        }
+        return super.__float__();
+    }
+
+    public PyLong __long__() {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__long__");
+        if (impl!=null) {
+            PyObject res=impl.__get__(this,self_type).__call__();
+            if (res instanceof PyLong)
+                return(PyLong)res;
+            throw Py.TypeError("__long__"+" should return a "+"long");
+        }
+        return super.__long__();
+    }
+
+    public PyComplex __complex__() {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__complex__");
+        if (impl!=null) {
+            PyObject res=impl.__get__(this,self_type).__call__();
+            if (res instanceof PyComplex)
+                return(PyComplex)res;
+            throw Py.TypeError("__complex__"+" should return a "+"complex");
+        }
+        return super.__complex__();
+    }
+
+    public PyObject __pos__() {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__pos__");
+        if (impl!=null)
+            return impl.__get__(this,self_type).__call__();
+        return super.__pos__();
+    }
+
+    public PyObject __neg__() {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__neg__");
+        if (impl!=null)
+            return impl.__get__(this,self_type).__call__();
+        return super.__neg__();
+    }
+
+    public PyObject __abs__() {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__abs__");
+        if (impl!=null)
+            return impl.__get__(this,self_type).__call__();
+        return super.__abs__();
+    }
+
+    public PyObject __invert__() {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__invert__");
+        if (impl!=null)
+            return impl.__get__(this,self_type).__call__();
+        return super.__invert__();
+    }
+
+    public PyObject __reduce__() {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__reduce__");
+        if (impl!=null)
+            return impl.__get__(this,self_type).__call__();
+        return super.__reduce__();
+    }
+
+    public PyObject __add__(PyObject other) {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__add__");
+        if (impl!=null) {
+            PyObject res=impl.__get__(this,self_type).__call__(other);
+            if (res==Py.NotImplemented)
+                return null;
+            return res;
+        }
+        return super.__add__(other);
+    }
+
+    public PyObject __radd__(PyObject other) {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__radd__");
+        if (impl!=null) {
+            PyObject res=impl.__get__(this,self_type).__call__(other);
+            if (res==Py.NotImplemented)
+                return null;
+            return res;
+        }
+        return super.__radd__(other);
+    }
+
+    public PyObject __sub__(PyObject other) {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__sub__");
+        if (impl!=null) {
+            PyObject res=impl.__get__(this,self_type).__call__(other);
+            if (res==Py.NotImplemented)
+                return null;
+            return res;
+        }
+        return super.__sub__(other);
+    }
+
+    public PyObject __rsub__(PyObject other) {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__rsub__");
+        if (impl!=null) {
+            PyObject res=impl.__get__(this,self_type).__call__(other);
+            if (res==Py.NotImplemented)
+                return null;
+            return res;
+        }
+        return super.__rsub__(other);
+    }
+
+    public PyObject __mul__(PyObject other) {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__mul__");
+        if (impl!=null) {
+            PyObject res=impl.__get__(this,self_type).__call__(other);
+            if (res==Py.NotImplemented)
+                return null;
+            return res;
+        }
+        return super.__mul__(other);
+    }
+
+    public PyObject __rmul__(PyObject other) {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__rmul__");
+        if (impl!=null) {
+            PyObject res=impl.__get__(this,self_type).__call__(other);
+            if (res==Py.NotImplemented)
+                return null;
+            return res;
+        }
+        return super.__rmul__(other);
+    }
+
+    public PyObject __div__(PyObject other) {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__div__");
+        if (impl!=null) {
+            PyObject res=impl.__get__(this,self_type).__call__(other);
+            if (res==Py.NotImplemented)
+                return null;
+            return res;
+        }
+        return super.__div__(other);
+    }
+
+    public PyObject __rdiv__(PyObject other) {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__rdiv__");
+        if (impl!=null) {
+            PyObject res=impl.__get__(this,self_type).__call__(other);
+            if (res==Py.NotImplemented)
+                return null;
+            return res;
+        }
+        return super.__rdiv__(other);
+    }
+
+    public PyObject __floordiv__(PyObject other) {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__floordiv__");
+        if (impl!=null) {
+            PyObject res=impl.__get__(this,self_type).__call__(other);
+            if (res==Py.NotImplemented)
+                return null;
+            return res;
+        }
+        return super.__floordiv__(other);
+    }
+
+    public PyObject __rfloordiv__(PyObject other) {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__rfloordiv__");
+        if (impl!=null) {
+            PyObject res=impl.__get__(this,self_type).__call__(other);
+            if (res==Py.NotImplemented)
+                return null;
+            return res;
+        }
+        return super.__rfloordiv__(other);
+    }
+
+    public PyObject __truediv__(PyObject other) {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__truediv__");
+        if (impl!=null) {
+            PyObject res=impl.__get__(this,self_type).__call__(other);
+            if (res==Py.NotImplemented)
+                return null;
+            return res;
+        }
+        return super.__truediv__(other);
+    }
+
+    public PyObject __rtruediv__(PyObject other) {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__rtruediv__");
+        if (impl!=null) {
+            PyObject res=impl.__get__(this,self_type).__call__(other);
+            if (res==Py.NotImplemented)
+                return null;
+            return res;
+        }
+        return super.__rtruediv__(other);
+    }
+
+    public PyObject __mod__(PyObject other) {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__mod__");
+        if (impl!=null) {
+            PyObject res=impl.__get__(this,self_type).__call__(other);
+            if (res==Py.NotImplemented)
+                return null;
+            return res;
+        }
+        return super.__mod__(other);
+    }
+
+    public PyObject __rmod__(PyObject other) {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__rmod__");
+        if (impl!=null) {
+            PyObject res=impl.__get__(this,self_type).__call__(other);
+            if (res==Py.NotImplemented)
+                return null;
+            return res;
+        }
+        return super.__rmod__(other);
+    }
+
+    public PyObject __divmod__(PyObject other) {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__divmod__");
+        if (impl!=null) {
+            PyObject res=impl.__get__(this,self_type).__call__(other);
+            if (res==Py.NotImplemented)
+                return null;
+            return res;
+        }
+        return super.__divmod__(other);
+    }
+
+    public PyObject __rdivmod__(PyObject other) {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__rdivmod__");
+        if (impl!=null) {
+            PyObject res=impl.__get__(this,self_type).__call__(other);
+            if (res==Py.NotImplemented)
+                return null;
+            return res;
+        }
+        return super.__rdivmod__(other);
+    }
+
+    public PyObject __pow__(PyObject other) {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__pow__");
+        if (impl!=null) {
+            PyObject res=impl.__get__(this,self_type).__call__(other);
+            if (res==Py.NotImplemented)
+                return null;
+            return res;
+        }
+        return super.__pow__(other);
+    }
+
+    public PyObject __rpow__(PyObject other) {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__rpow__");
+        if (impl!=null) {
+            PyObject res=impl.__get__(this,self_type).__call__(other);
+            if (res==Py.NotImplemented)
+                return null;
+            return res;
+        }
+        return super.__rpow__(other);
+    }
+
+    public PyObject __lshift__(PyObject other) {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__lshift__");
+        if (impl!=null) {
+            PyObject res=impl.__get__(this,self_type).__call__(other);
+            if (res==Py.NotImplemented)
+                return null;
+            return res;
+        }
+        return super.__lshift__(other);
+    }
+
+    public PyObject __rlshift__(PyObject other) {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__rlshift__");
+        if (impl!=null) {
+            PyObject res=impl.__get__(this,self_type).__call__(other);
+            if (res==Py.NotImplemented)
+                return null;
+            return res;
+        }
+        return super.__rlshift__(other);
+    }
+
+    public PyObject __rshift__(PyObject other) {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__rshift__");
+        if (impl!=null) {
+            PyObject res=impl.__get__(this,self_type).__call__(other);
+            if (res==Py.NotImplemented)
+                return null;
+            return res;
+        }
+        return super.__rshift__(other);
+    }
+
+    public PyObject __rrshift__(PyObject other) {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__rrshift__");
+        if (impl!=null) {
+            PyObject res=impl.__get__(this,self_type).__call__(other);
+            if (res==Py.NotImplemented)
+                return null;
+            return res;
+        }
+        return super.__rrshift__(other);
+    }
+
+    public PyObject __and__(PyObject other) {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__and__");
+        if (impl!=null) {
+            PyObject res=impl.__get__(this,self_type).__call__(other);
+            if (res==Py.NotImplemented)
+                return null;
+            return res;
+        }
+        return super.__and__(other);
+    }
+
+    public PyObject __rand__(PyObject other) {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__rand__");
+        if (impl!=null) {
+            PyObject res=impl.__get__(this,self_type).__call__(other);
+            if (res==Py.NotImplemented)
+                return null;
+            return res;
+        }
+        return super.__rand__(other);
+    }
+
+    public PyObject __or__(PyObject other) {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__or__");
+        if (impl!=null) {
+            PyObject res=impl.__get__(this,self_type).__call__(other);
+            if (res==Py.NotImplemented)
+                return null;
+            return res;
+        }
+        return super.__or__(other);
+    }
+
+    public PyObject __ror__(PyObject other) {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__ror__");
+        if (impl!=null) {
+            PyObject res=impl.__get__(this,self_type).__call__(other);
+            if (res==Py.NotImplemented)
+                return null;
+            return res;
+        }
+        return super.__ror__(other);
+    }
+
+    public PyObject __xor__(PyObject other) {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__xor__");
+        if (impl!=null) {
+            PyObject res=impl.__get__(this,self_type).__call__(other);
+            if (res==Py.NotImplemented)
+                return null;
+            return res;
+        }
+        return super.__xor__(other);
+    }
+
+    public PyObject __rxor__(PyObject other) {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__rxor__");
+        if (impl!=null) {
+            PyObject res=impl.__get__(this,self_type).__call__(other);
+            if (res==Py.NotImplemented)
+                return null;
+            return res;
+        }
+        return super.__rxor__(other);
+    }
+
+    public PyObject __lt__(PyObject other) {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__lt__");
+        if (impl!=null) {
+            PyObject res=impl.__get__(this,self_type).__call__(other);
+            if (res==Py.NotImplemented)
+                return null;
+            return res;
+        }
+        return super.__lt__(other);
+    }
+
+    public PyObject __le__(PyObject other) {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__le__");
+        if (impl!=null) {
+            PyObject res=impl.__get__(this,self_type).__call__(other);
+            if (res==Py.NotImplemented)
+                return null;
+            return res;
+        }
+        return super.__le__(other);
+    }
+
+    public PyObject __gt__(PyObject other) {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__gt__");
+        if (impl!=null) {
+            PyObject res=impl.__get__(this,self_type).__call__(other);
+            if (res==Py.NotImplemented)
+                return null;
+            return res;
+        }
+        return super.__gt__(other);
+    }
+
+    public PyObject __ge__(PyObject other) {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__ge__");
+        if (impl!=null) {
+            PyObject res=impl.__get__(this,self_type).__call__(other);
+            if (res==Py.NotImplemented)
+                return null;
+            return res;
+        }
+        return super.__ge__(other);
+    }
+
+    public PyObject __eq__(PyObject other) {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__eq__");
+        if (impl!=null) {
+            PyObject res=impl.__get__(this,self_type).__call__(other);
+            if (res==Py.NotImplemented)
+                return null;
+            return res;
+        }
+        return super.__eq__(other);
+    }
+
+    public PyObject __ne__(PyObject other) {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__ne__");
+        if (impl!=null) {
+            PyObject res=impl.__get__(this,self_type).__call__(other);
+            if (res==Py.NotImplemented)
+                return null;
+            return res;
+        }
+        return super.__ne__(other);
+    }
+
+    public PyObject __iadd__(PyObject other) {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__iadd__");
+        if (impl!=null)
+            return impl.__get__(this,self_type).__call__(other);
+        return super.__iadd__(other);
+    }
+
+    public PyObject __isub__(PyObject other) {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__isub__");
+        if (impl!=null)
+            return impl.__get__(this,self_type).__call__(other);
+        return super.__isub__(other);
+    }
+
+    public PyObject __imul__(PyObject other) {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__imul__");
+        if (impl!=null)
+            return impl.__get__(this,self_type).__call__(other);
+        return super.__imul__(other);
+    }
+
+    public PyObject __idiv__(PyObject other) {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__idiv__");
+        if (impl!=null)
+            return impl.__get__(this,self_type).__call__(other);
+        return super.__idiv__(other);
+    }
+
+    public PyObject __ifloordiv__(PyObject other) {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__ifloordiv__");
+        if (impl!=null)
+            return impl.__get__(this,self_type).__call__(other);
+        return super.__ifloordiv__(other);
+    }
+
+    public PyObject __itruediv__(PyObject other) {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__itruediv__");
+        if (impl!=null)
+            return impl.__get__(this,self_type).__call__(other);
+        return super.__itruediv__(other);
+    }
+
+    public PyObject __imod__(PyObject other) {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__imod__");
+        if (impl!=null)
+            return impl.__get__(this,self_type).__call__(other);
+        return super.__imod__(other);
+    }
+
+    public PyObject __ipow__(PyObject other) {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__ipow__");
+        if (impl!=null)
+            return impl.__get__(this,self_type).__call__(other);
+        return super.__ipow__(other);
+    }
+
+    public PyObject __ilshift__(PyObject other) {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__ilshift__");
+        if (impl!=null)
+            return impl.__get__(this,self_type).__call__(other);
+        return super.__ilshift__(other);
+    }
+
+    public PyObject __irshift__(PyObject other) {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__irshift__");
+        if (impl!=null)
+            return impl.__get__(this,self_type).__call__(other);
+        return super.__irshift__(other);
+    }
+
+    public PyObject __iand__(PyObject other) {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__iand__");
+        if (impl!=null)
+            return impl.__get__(this,self_type).__call__(other);
+        return super.__iand__(other);
+    }
+
+    public PyObject __ior__(PyObject other) {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__ior__");
+        if (impl!=null)
+            return impl.__get__(this,self_type).__call__(other);
+        return super.__ior__(other);
+    }
+
+    public PyObject __ixor__(PyObject other) {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__ixor__");
+        if (impl!=null)
+            return impl.__get__(this,self_type).__call__(other);
+        return super.__ixor__(other);
+    }
+
+    public PyObject __int__() {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__int__");
+        if (impl!=null) {
+            PyObject res=impl.__get__(this,self_type).__call__();
+            if (res instanceof PyInteger||res instanceof PyLong)
+                return(PyObject)res;
+            throw Py.TypeError("__int__"+" should return an integer");
+        }
+        return super.__int__();
+    }
+
+    public String toString() {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__repr__");
+        if (impl!=null) {
+            PyObject res=impl.__get__(this,self_type).__call__();
+            if (!(res instanceof PyString))
+                throw Py.TypeError("__repr__ should return a string");
+            return((PyString)res).toString();
+        }
+        return super.toString();
+    }
+
+    public int hashCode() {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__hash__");
+        if (impl!=null) {
+            PyObject res=impl.__get__(this,self_type).__call__();
+            if (res instanceof PyInteger)
+                return((PyInteger)res).getValue();
+            throw Py.TypeError("__hash__ should return a int");
+        }
+        if (self_type.lookup("__eq__")!=null||self_type.lookup("__cmp__")!=null)
+            throw Py.TypeError("unhashable type");
+        return super.hashCode();
+    }
+
+    public PyUnicode __unicode__() {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__unicode__");
+        if (impl!=null) {
+            PyObject res=impl.__get__(this,self_type).__call__();
+            if (res instanceof PyUnicode)
+                return(PyUnicode)res;
+            if (res instanceof PyString)
+                return new PyUnicode((PyString)res);
+            throw Py.TypeError("__unicode__"+" should return a "+"unicode");
+        }
+        return super.__unicode__();
+    }
+
+    public int __cmp__(PyObject other) {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__cmp__");
+        if (impl!=null) {
+            PyObject res=impl.__get__(this,self_type).__call__(other);
+            if (res instanceof PyInteger) {
+                int v=((PyInteger)res).getValue();
+                return v<0?-1:v>0?1:0;
+            }
+            throw Py.TypeError("__cmp__ should return a int");
+        }
+        return super.__cmp__(other);
+    }
+
+    public boolean __nonzero__() {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__nonzero__");
+        if (impl==null) {
+            impl=self_type.lookup("__len__");
+            if (impl==null)
+                return super.__nonzero__();
+        }
+        return impl.__get__(this,self_type).__call__().__nonzero__();
+    }
+
+    public boolean __contains__(PyObject o) {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__contains__");
+        if (impl==null)
+            return super.__contains__(o);
+        return impl.__get__(this,self_type).__call__(o).__nonzero__();
+    }
+
+    public int __len__() {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__len__");
+        if (impl!=null) {
+            PyObject res=impl.__get__(this,self_type).__call__();
+            if (res instanceof PyInteger)
+                return((PyInteger)res).getValue();
+            throw Py.TypeError("__len__ should return a int");
+        }
+        return super.__len__();
+    }
+
+    public PyObject __iter__() {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__iter__");
+        if (impl!=null)
+            return impl.__get__(this,self_type).__call__();
+        impl=self_type.lookup("__getitem__");
+        if (impl==null)
+            return super.__iter__();
+        return new PySequenceIter(this);
+    }
+
+    public PyObject __iternext__() {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("next");
+        if (impl!=null) {
+            try {
+                return impl.__get__(this,self_type).__call__();
+            } catch (PyException exc) {
+                if (Py.matchException(exc,Py.StopIteration))
+                    return null;
+                throw exc;
+            }
+        }
+        return super.__iternext__(); // ???
+    }
+
+    public PyObject __finditem__(PyObject key) { // ???
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__getitem__");
+        if (impl!=null)
+            try {
+                return impl.__get__(this,self_type).__call__(key);
+            } catch (PyException exc) {
+                if (Py.matchException(exc,Py.LookupError))
+                    return null;
+                throw exc;
+            }
+        return super.__finditem__(key);
+    }
+
+    public void __setitem__(PyObject key,PyObject value) { // ???
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__setitem__");
+        if (impl!=null) {
+            impl.__get__(this,self_type).__call__(key,value);
+            return;
+        }
+        super.__setitem__(key,value);
+    }
+
+    public PyObject __getslice__(PyObject start,PyObject stop,PyObject step) { // ???
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__getslice__");
+        if (impl!=null)
+            try {
+                return impl.__get__(this,self_type).__call__(start,stop);
+            } catch (PyException exc) {
+                if (Py.matchException(exc,Py.LookupError))
+                    return null;
+                throw exc;
+            }
+        return super.__getslice__(start,stop,step);
+    }
+
+    public void __delitem__(PyObject key) { // ???
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__delitem__");
+        if (impl!=null) {
+            impl.__get__(this,self_type).__call__(key);
+            return;
+        }
+        super.__delitem__(key);
+    }
+
+    public PyObject __call__(PyObject args[],String keywords[]) {
+        ThreadState ts=Py.getThreadState();
+        if (ts.recursion_depth++>ts.systemState.getrecursionlimit())
+            throw Py.RuntimeError("maximum __call__ recursion depth exceeded");
+        try {
+            PyType self_type=getType();
+            PyObject impl=self_type.lookup("__call__");
+            if (impl!=null)
+                return impl.__get__(this,self_type).__call__(args,keywords);
+            return super.__call__(args,keywords);
+        } finally {
+            --ts.recursion_depth;
+        }
+    }
+
+    public PyObject __findattr__(String name) {
+        PyType self_type=getType();
+        PyObject getattribute=self_type.lookup("__getattribute__");
+        PyString py_name=null;
+        try {
+            if (getattribute!=null) {
+                return getattribute.__get__(this,self_type).__call__(py_name=new PyString(name));
+            } else {
+                return super.__findattr__(name);
+            }
+        } catch (PyException e) {
+            if (Py.matchException(e,Py.AttributeError)) {
+                PyObject getattr=self_type.lookup("__getattr__");
+                if (getattr!=null)
+                    try {
+                        return getattr.__get__(this,self_type).__call__(py_name!=null?py_name:new PyString(name));
+                    } catch (PyException e1) {
+                        if (!Py.matchException(e1,Py.AttributeError))
+                            throw e1;
+                    }
+                return null;
+            }
+            throw e;
+        }
+    }
+
+    public void __setattr__(String name,PyObject value) {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__setattr__");
+        if (impl!=null) {
+            impl.__get__(this,self_type).__call__(new PyString(name),value);
+            return;
+        }
+        super.__setattr__(name,value);
+    }
+
+    public void __delattr__(String name) {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__delattr__");
+        if (impl!=null) {
+            impl.__get__(this,self_type).__call__(new PyString(name));
+            return;
+        }
+        super.__delattr__(name);
+    }
+
+    public PyObject __get__(PyObject obj,PyObject type) {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__get__");
+        if (impl!=null) {
+            if (obj==null)
+                obj=Py.None;
+            if (type==null)
+                type=Py.None;
+            return impl.__get__(this,self_type).__call__(obj,type);
+        }
+        return super.__get__(obj,type);
+    }
+
+    public void __set__(PyObject obj,PyObject value) {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__set__");
+        if (impl!=null) {
+            impl.__get__(this,self_type).__call__(obj,value);
+            return;
+        }
+        super.__set__(obj,value);
+    }
+
+    public void __delete__(PyObject obj) {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__delete__");
+        if (impl!=null) {
+            impl.__get__(this,self_type).__call__(obj);
+            return;
+        }
+        super.__delete__(obj);
+    }
+
+    public void dispatch__init__(PyType type,PyObject[]args,String[]keywords) {
+        PyType self_type=getType();
+        if (self_type.isSubType(type)) {
+            PyObject impl=self_type.lookup("__init__");
+            if (impl!=null)
+                impl.__get__(this,self_type).__call__(args,keywords);
+        }
+    }
+
+}
Index: src/templates/mappings
===================================================================
--- src/templates/mappings	(revision 3142)
+++ src/templates/mappings	(working copy)
@@ -33,6 +33,8 @@
 list.expose:org.python.core.PyList
 long.derived:org.python.core.PyLongDerived
 long.expose:org.python.core.PyLong
+module.derived:org.python.core.PyModuleDerived
+module.expose:org.python.core.PyModule
 None.expose:org.python.core.PyNone
 object.derived:org.python.core.PyObjectDerived
 object.expose:org.python.core.PyObject
Index: src/templates/module.derived
===================================================================
--- src/templates/module.derived	(revision 0)
+++ src/templates/module.derived	(revision 0)
@@ -0,0 +1,4 @@
+base_class: PyModule
+want_dict: false
+ctr:
+incl: object
Index: src/templates/module.expose
===================================================================
--- src/templates/module.expose	(revision 0)
+++ src/templates/module.expose	(revision 0)
@@ -0,0 +1,15 @@
+# setup
+type_name: module
+type_class: PyModule
+# getsets
+expose_getset: __dict__ getDict setDict delDict
+expose_getset: __doc__ getDoc
+# exposed methods
+expose_meth: __repr__
+  `sdeleg`(toString);
+expose_new_mutable:
+expose_meth: :- __setattr__ n{attribute name}o
+expose_meth: :- __delattr__ n{attribute name}
+expose_wide_meth: __init__ -1 -1
+  `vdeleg`(init);
+  `void;
Index: Lib/test/test_module.py
===================================================================
--- Lib/test/test_module.py	(revision 0)
+++ Lib/test/test_module.py	(revision 0)
@@ -0,0 +1,80 @@
+# Test the module type
+
+from test_support import verify, vereq, verbose, TestFailed
+from types import ModuleType as module
+
+# XXX:
+#import sys
+#module = type(sys)
+
+# An uninitialized module has no __dict__ or __name__, and __doc__ is None
+foo = module.__new__(module)
+verify(foo.__dict__ is None)
+try:
+    s = foo.__name__
+except AttributeError:
+    pass
+else:
+    raise TestFailed, "__name__ = %s" % repr(s)
+# XXX:
+#vereq(foo.__doc__, module.__doc__)
+
+try:
+    foo_dir = dir(foo)
+except TypeError:
+    pass
+else:
+    raise TestFailed, "__dict__ = %s" % repr(foo_dir)
+
+try:
+    del foo.somename
+except AttributeError:
+    pass
+else:
+    raise TestFailed, "del foo.somename"
+
+try:
+    del foo.__dict__
+except TypeError:
+    pass
+else:
+    raise TestFailed, "del foo.__dict__"
+
+try:
+    foo.__dict__ = {}
+except TypeError:
+    pass
+else:
+    raise TestFailed, "foo.__dict__ = {}"
+verify(foo.__dict__ is None)
+
+# Regularly initialized module, no docstring
+foo = module("foo")
+vereq(foo.__name__, "foo")
+vereq(foo.__doc__, None)
+vereq(foo.__dict__, {"__name__": "foo", "__doc__": None})
+
+# ASCII docstring
+foo = module("foo", "foodoc")
+vereq(foo.__name__, "foo")
+vereq(foo.__doc__, "foodoc")
+vereq(foo.__dict__, {"__name__": "foo", "__doc__": "foodoc"})
+
+# Unicode docstring
+foo = module("foo", u"foodoc\u1234")
+vereq(foo.__name__, "foo")
+vereq(foo.__doc__, u"foodoc\u1234")
+vereq(foo.__dict__, {"__name__": "foo", "__doc__": u"foodoc\u1234"})
+
+# Reinitialization should not replace the __dict__
+foo.bar = 42
+d = foo.__dict__
+foo.__init__("foo", "foodoc")
+vereq(foo.__name__, "foo")
+vereq(foo.__doc__, "foodoc")
+vereq(foo.bar, 42)
+vereq(foo.__dict__, {"__name__": "foo", "__doc__": "foodoc", "bar": 42})
+verify(foo.__dict__ is d)
+
+if verbose:
+    print "All OK"
Index: Lib/test/test_descr.py
===================================================================
--- Lib/test/test_descr.py	(revision 3142)
+++ Lib/test/test_descr.py	(working copy)
@@ -345,8 +345,11 @@
     verify('im_self' in dir(a.Amethod))
 
     # Try a module subclass.
-    import sys
-    class M(type(sys)):
+    # XXX:
+    #import sys
+    #class M(type(sys)):
+    from types import ModuleType
+    class M(ModuleType):
         pass
     minstance = M("m")
     minstance.b = 2
@@ -749,8 +752,10 @@
 def pymods():
     if verbose: print "Testing Python subclass of module..."
     log = []
-    import sys
-    MT = type(sys)
+    # XXX:
+    #import sys
+    #MT = type(sys)
+    from types import ModuleType as MT
     class MM(MT):
         def __init__(self, name):
             MT.__init__(self, name)