diff --git a/base_object.h b/base_object.h
index d266bd34..882ed9bd 100644
--- a/base_object.h
+++ b/base_object.h
@@ -10,53 +10,53 @@
 # define BASE_OBJECT_DWA051600_H_
 
 # include "pyconfig.h"
-# include "signatures.h" // really just for Type<>
+# include "signatures.h" // really just for type<>
 # include "wrap_python.h"
 # include <cstring>
 
-namespace py { namespace detail {
+namespace python { namespace detail {
 
-// BaseObject - adds a constructor and non-virtual destructor to a
+// base_object - adds a constructor and non-virtual destructor to a
 // base Python type (e.g. PyObject, PyTypeObject).
-template <class PythonType>
-struct BaseObject : PythonType
+template <class python_type>
+struct base_object : python_type
 {
-    typedef PythonType BasePythonType;
+    typedef python_type base_python_type;
 
-    // Initializes type and reference count. All other fields of BasePythonType are 0
-    BaseObject(PyTypeObject* type_object);
+    // Initializes type and reference count. All other fields of base_python_type are 0
+    base_object(PyTypeObject* type_obj);
 
     // Decrements reference count on the type
-    ~BaseObject();
+    ~base_object();
 };
 
 // Easy typedefs for common usage
-typedef BaseObject<PyObject> PythonObject;
-typedef BaseObject<PyTypeObject> PythonType;
+typedef base_object<PyObject> python_object;
+typedef base_object<PyTypeObject> python_type;
 
 
 //
-// Class template member function implementations 
+// class_t template member function implementations 
 //
-template <class PythonType>
-BaseObject<PythonType>::BaseObject(PyTypeObject* type_object)
+template <class python_type>
+base_object<python_type>::base_object(PyTypeObject* type_obj)
 {
-    BasePythonType* bp = this;
+    base_python_type* bp = this;
 #if !defined(_MSC_VER) || defined(__STLPORT)
     std::
 #endif
-		memset(bp, 0, sizeof(BasePythonType));
+		memset(bp, 0, sizeof(base_python_type));
     ob_refcnt = 1;
-    ob_type = type_object;
-    Py_INCREF(type_object);
+    ob_type = type_obj;
+    Py_INCREF(type_obj);
 }
 
-template <class PythonType>
-inline BaseObject<PythonType>::~BaseObject()
+template <class python_type>
+inline base_object<python_type>::~base_object()
 {
     Py_DECREF(ob_type);
 }
 
-}} // namespace py::detail
+}} // namespace python::detail
 
 #endif // BASE_OBJECT_DWA051600_H_
diff --git a/callback.h b/callback.h
index 292dac14..e6faf03d 100644
--- a/callback.h
+++ b/callback.h
@@ -6,7 +6,7 @@
 //  The author gratefully acknowleges the support of Dragon Systems, Inc., in
 //  producing this work.
 //
-//  This file was generated for 10-argument python callbacks by gen_callback.py
+//  This file was generated for 10-argument python callbacks by gen_callback.python
 
 #ifndef CALLBACK_DWA_052100_H_
 # define CALLBACK_DWA_052100_H_
@@ -14,190 +14,190 @@
 # include "pyconfig.h"
 # include "py.h"
 
-namespace py {
+namespace python {
 
 namespace detail {
   template <class T>
-  inline void callback_adjust_refcount(PyObject*, Type<T>) {}
+  inline void callback_adjust_refcount(PyObject*, type<T>) {}
   
-  inline void callback_adjust_refcount(PyObject* p, Type<PyObject*>)
+  inline void callback_adjust_refcount(PyObject* p, type<PyObject*>)
       { Py_INCREF(p); }
 }
 
 // Calling Python from C++
 template <class R>
-struct Callback
+struct callback
 {
     static R call_method(PyObject* self, const char* name)
     {
-        Ptr result(PyEval_CallMethod(self, const_cast<char*>(name),
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
                                      const_cast<char*>("()")));
-        detail::callback_adjust_refcount(result.get(), Type<R>());
-        return from_python(result.get(), Type<R>());
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
     }
 
     static R call(PyObject* self)
     {
-        Ptr result(PyEval_CallFunction(self, const_cast<char*>("()")));
-        detail::callback_adjust_refcount(result.get(), Type<R>());
-        return from_python(result.get(), Type<R>());
+        ref result(PyEval_CallFunction(self, const_cast<char*>("()")));
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
     }
 
     template <class A1>
     static R call_method(PyObject* self, const char* name, const A1& a1)
     {
-        Ptr p1(to_python(a1));
-        Ptr result(PyEval_CallMethod(self, const_cast<char*>(name),
+        ref p1(to_python(a1));
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
                                      const_cast<char*>("(O)"),
                                      p1.get()));
-        detail::callback_adjust_refcount(result.get(), Type<R>());
-        return from_python(result.get(), Type<R>());
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
     }
 
     template <class A1>
     static R call(PyObject* self, const A1& a1)
     {
-        Ptr p1(to_python(a1));
-        Ptr result(PyEval_CallFunction(self, const_cast<char*>("(O)"),
+        ref p1(to_python(a1));
+        ref result(PyEval_CallFunction(self, const_cast<char*>("(O)"),
                                        p1.get()));
-        detail::callback_adjust_refcount(result.get(), Type<R>());
-        return from_python(result.get(), Type<R>());
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
     }
 
     template <class A1, class A2>
     static R call_method(PyObject* self, const char* name, const A1& a1, const A2& a2)
     {
-        Ptr p1(to_python(a1));
-        Ptr p2(to_python(a2));
-        Ptr result(PyEval_CallMethod(self, const_cast<char*>(name),
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
                                      const_cast<char*>("(OO)"),
                                      p1.get(),
                                      p2.get()));
-        detail::callback_adjust_refcount(result.get(), Type<R>());
-        return from_python(result.get(), Type<R>());
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
     }
 
     template <class A1, class A2>
     static R call(PyObject* self, const A1& a1, const A2& a2)
     {
-        Ptr p1(to_python(a1));
-        Ptr p2(to_python(a2));
-        Ptr result(PyEval_CallFunction(self, const_cast<char*>("(OO)"),
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref result(PyEval_CallFunction(self, const_cast<char*>("(OO)"),
                                        p1.get(),
                                        p2.get()));
-        detail::callback_adjust_refcount(result.get(), Type<R>());
-        return from_python(result.get(), Type<R>());
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
     }
 
     template <class A1, class A2, class A3>
     static R call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3)
     {
-        Ptr p1(to_python(a1));
-        Ptr p2(to_python(a2));
-        Ptr p3(to_python(a3));
-        Ptr result(PyEval_CallMethod(self, const_cast<char*>(name),
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
                                      const_cast<char*>("(OOO)"),
                                      p1.get(),
                                      p2.get(),
                                      p3.get()));
-        detail::callback_adjust_refcount(result.get(), Type<R>());
-        return from_python(result.get(), Type<R>());
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
     }
 
     template <class A1, class A2, class A3>
     static R call(PyObject* self, const A1& a1, const A2& a2, const A3& a3)
     {
-        Ptr p1(to_python(a1));
-        Ptr p2(to_python(a2));
-        Ptr p3(to_python(a3));
-        Ptr result(PyEval_CallFunction(self, const_cast<char*>("(OOO)"),
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOO)"),
                                        p1.get(),
                                        p2.get(),
                                        p3.get()));
-        detail::callback_adjust_refcount(result.get(), Type<R>());
-        return from_python(result.get(), Type<R>());
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
     }
 
     template <class A1, class A2, class A3, class A4>
     static R call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4)
     {
-        Ptr p1(to_python(a1));
-        Ptr p2(to_python(a2));
-        Ptr p3(to_python(a3));
-        Ptr p4(to_python(a4));
-        Ptr result(PyEval_CallMethod(self, const_cast<char*>(name),
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
                                      const_cast<char*>("(OOOO)"),
                                      p1.get(),
                                      p2.get(),
                                      p3.get(),
                                      p4.get()));
-        detail::callback_adjust_refcount(result.get(), Type<R>());
-        return from_python(result.get(), Type<R>());
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
     }
 
     template <class A1, class A2, class A3, class A4>
     static R call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4)
     {
-        Ptr p1(to_python(a1));
-        Ptr p2(to_python(a2));
-        Ptr p3(to_python(a3));
-        Ptr p4(to_python(a4));
-        Ptr result(PyEval_CallFunction(self, const_cast<char*>("(OOOO)"),
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOO)"),
                                        p1.get(),
                                        p2.get(),
                                        p3.get(),
                                        p4.get()));
-        detail::callback_adjust_refcount(result.get(), Type<R>());
-        return from_python(result.get(), Type<R>());
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
     }
 
     template <class A1, class A2, class A3, class A4, class A5>
     static R call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5)
     {
-        Ptr p1(to_python(a1));
-        Ptr p2(to_python(a2));
-        Ptr p3(to_python(a3));
-        Ptr p4(to_python(a4));
-        Ptr p5(to_python(a5));
-        Ptr result(PyEval_CallMethod(self, const_cast<char*>(name),
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
                                      const_cast<char*>("(OOOOO)"),
                                      p1.get(),
                                      p2.get(),
                                      p3.get(),
                                      p4.get(),
                                      p5.get()));
-        detail::callback_adjust_refcount(result.get(), Type<R>());
-        return from_python(result.get(), Type<R>());
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
     }
 
     template <class A1, class A2, class A3, class A4, class A5>
     static R call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5)
     {
-        Ptr p1(to_python(a1));
-        Ptr p2(to_python(a2));
-        Ptr p3(to_python(a3));
-        Ptr p4(to_python(a4));
-        Ptr p5(to_python(a5));
-        Ptr result(PyEval_CallFunction(self, const_cast<char*>("(OOOOO)"),
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOO)"),
                                        p1.get(),
                                        p2.get(),
                                        p3.get(),
                                        p4.get(),
                                        p5.get()));
-        detail::callback_adjust_refcount(result.get(), Type<R>());
-        return from_python(result.get(), Type<R>());
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
     }
 
     template <class A1, class A2, class A3, class A4, class A5, class A6>
     static R call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6)
     {
-        Ptr p1(to_python(a1));
-        Ptr p2(to_python(a2));
-        Ptr p3(to_python(a3));
-        Ptr p4(to_python(a4));
-        Ptr p5(to_python(a5));
-        Ptr p6(to_python(a6));
-        Ptr result(PyEval_CallMethod(self, const_cast<char*>(name),
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref p6(to_python(a6));
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
                                      const_cast<char*>("(OOOOOO)"),
                                      p1.get(),
                                      p2.get(),
@@ -205,41 +205,41 @@ struct Callback
                                      p4.get(),
                                      p5.get(),
                                      p6.get()));
-        detail::callback_adjust_refcount(result.get(), Type<R>());
-        return from_python(result.get(), Type<R>());
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
     }
 
     template <class A1, class A2, class A3, class A4, class A5, class A6>
     static R call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6)
     {
-        Ptr p1(to_python(a1));
-        Ptr p2(to_python(a2));
-        Ptr p3(to_python(a3));
-        Ptr p4(to_python(a4));
-        Ptr p5(to_python(a5));
-        Ptr p6(to_python(a6));
-        Ptr result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOO)"),
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref p6(to_python(a6));
+        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOO)"),
                                        p1.get(),
                                        p2.get(),
                                        p3.get(),
                                        p4.get(),
                                        p5.get(),
                                        p6.get()));
-        detail::callback_adjust_refcount(result.get(), Type<R>());
-        return from_python(result.get(), Type<R>());
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
     }
 
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
     static R call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7)
     {
-        Ptr p1(to_python(a1));
-        Ptr p2(to_python(a2));
-        Ptr p3(to_python(a3));
-        Ptr p4(to_python(a4));
-        Ptr p5(to_python(a5));
-        Ptr p6(to_python(a6));
-        Ptr p7(to_python(a7));
-        Ptr result(PyEval_CallMethod(self, const_cast<char*>(name),
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref p6(to_python(a6));
+        ref p7(to_python(a7));
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
                                      const_cast<char*>("(OOOOOOO)"),
                                      p1.get(),
                                      p2.get(),
@@ -248,21 +248,21 @@ struct Callback
                                      p5.get(),
                                      p6.get(),
                                      p7.get()));
-        detail::callback_adjust_refcount(result.get(), Type<R>());
-        return from_python(result.get(), Type<R>());
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
     }
 
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
     static R call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7)
     {
-        Ptr p1(to_python(a1));
-        Ptr p2(to_python(a2));
-        Ptr p3(to_python(a3));
-        Ptr p4(to_python(a4));
-        Ptr p5(to_python(a5));
-        Ptr p6(to_python(a6));
-        Ptr p7(to_python(a7));
-        Ptr result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOO)"),
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref p6(to_python(a6));
+        ref p7(to_python(a7));
+        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOO)"),
                                        p1.get(),
                                        p2.get(),
                                        p3.get(),
@@ -270,22 +270,22 @@ struct Callback
                                        p5.get(),
                                        p6.get(),
                                        p7.get()));
-        detail::callback_adjust_refcount(result.get(), Type<R>());
-        return from_python(result.get(), Type<R>());
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
     }
 
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
     static R call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8)
     {
-        Ptr p1(to_python(a1));
-        Ptr p2(to_python(a2));
-        Ptr p3(to_python(a3));
-        Ptr p4(to_python(a4));
-        Ptr p5(to_python(a5));
-        Ptr p6(to_python(a6));
-        Ptr p7(to_python(a7));
-        Ptr p8(to_python(a8));
-        Ptr result(PyEval_CallMethod(self, const_cast<char*>(name),
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref p6(to_python(a6));
+        ref p7(to_python(a7));
+        ref p8(to_python(a8));
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
                                      const_cast<char*>("(OOOOOOOO)"),
                                      p1.get(),
                                      p2.get(),
@@ -295,22 +295,22 @@ struct Callback
                                      p6.get(),
                                      p7.get(),
                                      p8.get()));
-        detail::callback_adjust_refcount(result.get(), Type<R>());
-        return from_python(result.get(), Type<R>());
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
     }
 
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
     static R call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8)
     {
-        Ptr p1(to_python(a1));
-        Ptr p2(to_python(a2));
-        Ptr p3(to_python(a3));
-        Ptr p4(to_python(a4));
-        Ptr p5(to_python(a5));
-        Ptr p6(to_python(a6));
-        Ptr p7(to_python(a7));
-        Ptr p8(to_python(a8));
-        Ptr result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOOO)"),
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref p6(to_python(a6));
+        ref p7(to_python(a7));
+        ref p8(to_python(a8));
+        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOOO)"),
                                        p1.get(),
                                        p2.get(),
                                        p3.get(),
@@ -319,23 +319,23 @@ struct Callback
                                        p6.get(),
                                        p7.get(),
                                        p8.get()));
-        detail::callback_adjust_refcount(result.get(), Type<R>());
-        return from_python(result.get(), Type<R>());
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
     }
 
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
     static R call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9)
     {
-        Ptr p1(to_python(a1));
-        Ptr p2(to_python(a2));
-        Ptr p3(to_python(a3));
-        Ptr p4(to_python(a4));
-        Ptr p5(to_python(a5));
-        Ptr p6(to_python(a6));
-        Ptr p7(to_python(a7));
-        Ptr p8(to_python(a8));
-        Ptr p9(to_python(a9));
-        Ptr result(PyEval_CallMethod(self, const_cast<char*>(name),
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref p6(to_python(a6));
+        ref p7(to_python(a7));
+        ref p8(to_python(a8));
+        ref p9(to_python(a9));
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
                                      const_cast<char*>("(OOOOOOOOO)"),
                                      p1.get(),
                                      p2.get(),
@@ -346,23 +346,23 @@ struct Callback
                                      p7.get(),
                                      p8.get(),
                                      p9.get()));
-        detail::callback_adjust_refcount(result.get(), Type<R>());
-        return from_python(result.get(), Type<R>());
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
     }
 
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
     static R call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9)
     {
-        Ptr p1(to_python(a1));
-        Ptr p2(to_python(a2));
-        Ptr p3(to_python(a3));
-        Ptr p4(to_python(a4));
-        Ptr p5(to_python(a5));
-        Ptr p6(to_python(a6));
-        Ptr p7(to_python(a7));
-        Ptr p8(to_python(a8));
-        Ptr p9(to_python(a9));
-        Ptr result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOOOO)"),
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref p6(to_python(a6));
+        ref p7(to_python(a7));
+        ref p8(to_python(a8));
+        ref p9(to_python(a9));
+        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOOOO)"),
                                        p1.get(),
                                        p2.get(),
                                        p3.get(),
@@ -372,24 +372,24 @@ struct Callback
                                        p7.get(),
                                        p8.get(),
                                        p9.get()));
-        detail::callback_adjust_refcount(result.get(), Type<R>());
-        return from_python(result.get(), Type<R>());
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
     }
 
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
     static R call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9, const A10& a10)
     {
-        Ptr p1(to_python(a1));
-        Ptr p2(to_python(a2));
-        Ptr p3(to_python(a3));
-        Ptr p4(to_python(a4));
-        Ptr p5(to_python(a5));
-        Ptr p6(to_python(a6));
-        Ptr p7(to_python(a7));
-        Ptr p8(to_python(a8));
-        Ptr p9(to_python(a9));
-        Ptr p10(to_python(a10));
-        Ptr result(PyEval_CallMethod(self, const_cast<char*>(name),
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref p6(to_python(a6));
+        ref p7(to_python(a7));
+        ref p8(to_python(a8));
+        ref p9(to_python(a9));
+        ref p10(to_python(a10));
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
                                      const_cast<char*>("(OOOOOOOOOO)"),
                                      p1.get(),
                                      p2.get(),
@@ -401,24 +401,24 @@ struct Callback
                                      p8.get(),
                                      p9.get(),
                                      p10.get()));
-        detail::callback_adjust_refcount(result.get(), Type<R>());
-        return from_python(result.get(), Type<R>());
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
     }
 
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
     static R call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9, const A10& a10)
     {
-        Ptr p1(to_python(a1));
-        Ptr p2(to_python(a2));
-        Ptr p3(to_python(a3));
-        Ptr p4(to_python(a4));
-        Ptr p5(to_python(a5));
-        Ptr p6(to_python(a6));
-        Ptr p7(to_python(a7));
-        Ptr p8(to_python(a8));
-        Ptr p9(to_python(a9));
-        Ptr p10(to_python(a10));
-        Ptr result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOOOOO)"),
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref p6(to_python(a6));
+        ref p7(to_python(a7));
+        ref p8(to_python(a8));
+        ref p9(to_python(a9));
+        ref p10(to_python(a10));
+        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOOOOO)"),
                                        p1.get(),
                                        p2.get(),
                                        p3.get(),
@@ -429,8 +429,8 @@ struct Callback
                                        p8.get(),
                                        p9.get(),
                                        p10.get()));
-        detail::callback_adjust_refcount(result.get(), Type<R>());
-        return from_python(result.get(), Type<R>());
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
     }
 };
 
@@ -438,25 +438,25 @@ struct Callback
 // void g();
 // void f() { return g(); }
 template <>
-struct Callback<void>
+struct callback<void>
 {
 
     static void call_method(PyObject* self, const char* name)
     {
-        Ptr result(PyEval_CallMethod(self, const_cast<char*>(name),
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
                                      const_cast<char*>("()")));
     }
 
     static void call(PyObject* self)
     {
-        Ptr result(PyEval_CallFunction(self, const_cast<char*>("()")));
+        ref result(PyEval_CallFunction(self, const_cast<char*>("()")));
     }
 
     template <class A1>
     static void call_method(PyObject* self, const char* name, const A1& a1)
     {
-        Ptr p1(to_python(a1));
-        Ptr result(PyEval_CallMethod(self, const_cast<char*>(name),
+        ref p1(to_python(a1));
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
                                      const_cast<char*>("(O)"),
                                      p1.get()));
     }
@@ -464,17 +464,17 @@ struct Callback<void>
     template <class A1>
     static void call(PyObject* self, const A1& a1)
     {
-        Ptr p1(to_python(a1));
-        Ptr result(PyEval_CallFunction(self, const_cast<char*>("(O)"),
+        ref p1(to_python(a1));
+        ref result(PyEval_CallFunction(self, const_cast<char*>("(O)"),
                                        p1.get()));
     }
 
     template <class A1, class A2>
     static void call_method(PyObject* self, const char* name, const A1& a1, const A2& a2)
     {
-        Ptr p1(to_python(a1));
-        Ptr p2(to_python(a2));
-        Ptr result(PyEval_CallMethod(self, const_cast<char*>(name),
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
                                      const_cast<char*>("(OO)"),
                                      p1.get(),
                                      p2.get()));
@@ -483,9 +483,9 @@ struct Callback<void>
     template <class A1, class A2>
     static void call(PyObject* self, const A1& a1, const A2& a2)
     {
-        Ptr p1(to_python(a1));
-        Ptr p2(to_python(a2));
-        Ptr result(PyEval_CallFunction(self, const_cast<char*>("(OO)"),
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref result(PyEval_CallFunction(self, const_cast<char*>("(OO)"),
                                        p1.get(),
                                        p2.get()));
     }
@@ -493,10 +493,10 @@ struct Callback<void>
     template <class A1, class A2, class A3>
     static void call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3)
     {
-        Ptr p1(to_python(a1));
-        Ptr p2(to_python(a2));
-        Ptr p3(to_python(a3));
-        Ptr result(PyEval_CallMethod(self, const_cast<char*>(name),
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
                                      const_cast<char*>("(OOO)"),
                                      p1.get(),
                                      p2.get(),
@@ -506,10 +506,10 @@ struct Callback<void>
     template <class A1, class A2, class A3>
     static void call(PyObject* self, const A1& a1, const A2& a2, const A3& a3)
     {
-        Ptr p1(to_python(a1));
-        Ptr p2(to_python(a2));
-        Ptr p3(to_python(a3));
-        Ptr result(PyEval_CallFunction(self, const_cast<char*>("(OOO)"),
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOO)"),
                                        p1.get(),
                                        p2.get(),
                                        p3.get()));
@@ -518,11 +518,11 @@ struct Callback<void>
     template <class A1, class A2, class A3, class A4>
     static void call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4)
     {
-        Ptr p1(to_python(a1));
-        Ptr p2(to_python(a2));
-        Ptr p3(to_python(a3));
-        Ptr p4(to_python(a4));
-        Ptr result(PyEval_CallMethod(self, const_cast<char*>(name),
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
                                      const_cast<char*>("(OOOO)"),
                                      p1.get(),
                                      p2.get(),
@@ -533,11 +533,11 @@ struct Callback<void>
     template <class A1, class A2, class A3, class A4>
     static void call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4)
     {
-        Ptr p1(to_python(a1));
-        Ptr p2(to_python(a2));
-        Ptr p3(to_python(a3));
-        Ptr p4(to_python(a4));
-        Ptr result(PyEval_CallFunction(self, const_cast<char*>("(OOOO)"),
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOO)"),
                                        p1.get(),
                                        p2.get(),
                                        p3.get(),
@@ -547,12 +547,12 @@ struct Callback<void>
     template <class A1, class A2, class A3, class A4, class A5>
     static void call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5)
     {
-        Ptr p1(to_python(a1));
-        Ptr p2(to_python(a2));
-        Ptr p3(to_python(a3));
-        Ptr p4(to_python(a4));
-        Ptr p5(to_python(a5));
-        Ptr result(PyEval_CallMethod(self, const_cast<char*>(name),
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
                                      const_cast<char*>("(OOOOO)"),
                                      p1.get(),
                                      p2.get(),
@@ -564,12 +564,12 @@ struct Callback<void>
     template <class A1, class A2, class A3, class A4, class A5>
     static void call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5)
     {
-        Ptr p1(to_python(a1));
-        Ptr p2(to_python(a2));
-        Ptr p3(to_python(a3));
-        Ptr p4(to_python(a4));
-        Ptr p5(to_python(a5));
-        Ptr result(PyEval_CallFunction(self, const_cast<char*>("(OOOOO)"),
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOO)"),
                                        p1.get(),
                                        p2.get(),
                                        p3.get(),
@@ -580,13 +580,13 @@ struct Callback<void>
     template <class A1, class A2, class A3, class A4, class A5, class A6>
     static void call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6)
     {
-        Ptr p1(to_python(a1));
-        Ptr p2(to_python(a2));
-        Ptr p3(to_python(a3));
-        Ptr p4(to_python(a4));
-        Ptr p5(to_python(a5));
-        Ptr p6(to_python(a6));
-        Ptr result(PyEval_CallMethod(self, const_cast<char*>(name),
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref p6(to_python(a6));
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
                                      const_cast<char*>("(OOOOOO)"),
                                      p1.get(),
                                      p2.get(),
@@ -599,13 +599,13 @@ struct Callback<void>
     template <class A1, class A2, class A3, class A4, class A5, class A6>
     static void call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6)
     {
-        Ptr p1(to_python(a1));
-        Ptr p2(to_python(a2));
-        Ptr p3(to_python(a3));
-        Ptr p4(to_python(a4));
-        Ptr p5(to_python(a5));
-        Ptr p6(to_python(a6));
-        Ptr result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOO)"),
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref p6(to_python(a6));
+        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOO)"),
                                        p1.get(),
                                        p2.get(),
                                        p3.get(),
@@ -617,14 +617,14 @@ struct Callback<void>
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
     static void call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7)
     {
-        Ptr p1(to_python(a1));
-        Ptr p2(to_python(a2));
-        Ptr p3(to_python(a3));
-        Ptr p4(to_python(a4));
-        Ptr p5(to_python(a5));
-        Ptr p6(to_python(a6));
-        Ptr p7(to_python(a7));
-        Ptr result(PyEval_CallMethod(self, const_cast<char*>(name),
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref p6(to_python(a6));
+        ref p7(to_python(a7));
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
                                      const_cast<char*>("(OOOOOOO)"),
                                      p1.get(),
                                      p2.get(),
@@ -638,14 +638,14 @@ struct Callback<void>
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
     static void call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7)
     {
-        Ptr p1(to_python(a1));
-        Ptr p2(to_python(a2));
-        Ptr p3(to_python(a3));
-        Ptr p4(to_python(a4));
-        Ptr p5(to_python(a5));
-        Ptr p6(to_python(a6));
-        Ptr p7(to_python(a7));
-        Ptr result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOO)"),
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref p6(to_python(a6));
+        ref p7(to_python(a7));
+        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOO)"),
                                        p1.get(),
                                        p2.get(),
                                        p3.get(),
@@ -658,15 +658,15 @@ struct Callback<void>
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
     static void call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8)
     {
-        Ptr p1(to_python(a1));
-        Ptr p2(to_python(a2));
-        Ptr p3(to_python(a3));
-        Ptr p4(to_python(a4));
-        Ptr p5(to_python(a5));
-        Ptr p6(to_python(a6));
-        Ptr p7(to_python(a7));
-        Ptr p8(to_python(a8));
-        Ptr result(PyEval_CallMethod(self, const_cast<char*>(name),
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref p6(to_python(a6));
+        ref p7(to_python(a7));
+        ref p8(to_python(a8));
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
                                      const_cast<char*>("(OOOOOOOO)"),
                                      p1.get(),
                                      p2.get(),
@@ -681,15 +681,15 @@ struct Callback<void>
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
     static void call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8)
     {
-        Ptr p1(to_python(a1));
-        Ptr p2(to_python(a2));
-        Ptr p3(to_python(a3));
-        Ptr p4(to_python(a4));
-        Ptr p5(to_python(a5));
-        Ptr p6(to_python(a6));
-        Ptr p7(to_python(a7));
-        Ptr p8(to_python(a8));
-        Ptr result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOOO)"),
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref p6(to_python(a6));
+        ref p7(to_python(a7));
+        ref p8(to_python(a8));
+        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOOO)"),
                                        p1.get(),
                                        p2.get(),
                                        p3.get(),
@@ -703,16 +703,16 @@ struct Callback<void>
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
     static void call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9)
     {
-        Ptr p1(to_python(a1));
-        Ptr p2(to_python(a2));
-        Ptr p3(to_python(a3));
-        Ptr p4(to_python(a4));
-        Ptr p5(to_python(a5));
-        Ptr p6(to_python(a6));
-        Ptr p7(to_python(a7));
-        Ptr p8(to_python(a8));
-        Ptr p9(to_python(a9));
-        Ptr result(PyEval_CallMethod(self, const_cast<char*>(name),
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref p6(to_python(a6));
+        ref p7(to_python(a7));
+        ref p8(to_python(a8));
+        ref p9(to_python(a9));
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
                                      const_cast<char*>("(OOOOOOOOO)"),
                                      p1.get(),
                                      p2.get(),
@@ -728,16 +728,16 @@ struct Callback<void>
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
     static void call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9)
     {
-        Ptr p1(to_python(a1));
-        Ptr p2(to_python(a2));
-        Ptr p3(to_python(a3));
-        Ptr p4(to_python(a4));
-        Ptr p5(to_python(a5));
-        Ptr p6(to_python(a6));
-        Ptr p7(to_python(a7));
-        Ptr p8(to_python(a8));
-        Ptr p9(to_python(a9));
-        Ptr result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOOOO)"),
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref p6(to_python(a6));
+        ref p7(to_python(a7));
+        ref p8(to_python(a8));
+        ref p9(to_python(a9));
+        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOOOO)"),
                                        p1.get(),
                                        p2.get(),
                                        p3.get(),
@@ -752,17 +752,17 @@ struct Callback<void>
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
     static void call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9, const A10& a10)
     {
-        Ptr p1(to_python(a1));
-        Ptr p2(to_python(a2));
-        Ptr p3(to_python(a3));
-        Ptr p4(to_python(a4));
-        Ptr p5(to_python(a5));
-        Ptr p6(to_python(a6));
-        Ptr p7(to_python(a7));
-        Ptr p8(to_python(a8));
-        Ptr p9(to_python(a9));
-        Ptr p10(to_python(a10));
-        Ptr result(PyEval_CallMethod(self, const_cast<char*>(name),
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref p6(to_python(a6));
+        ref p7(to_python(a7));
+        ref p8(to_python(a8));
+        ref p9(to_python(a9));
+        ref p10(to_python(a10));
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
                                      const_cast<char*>("(OOOOOOOOOO)"),
                                      p1.get(),
                                      p2.get(),
@@ -779,17 +779,17 @@ struct Callback<void>
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
     static void call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9, const A10& a10)
     {
-        Ptr p1(to_python(a1));
-        Ptr p2(to_python(a2));
-        Ptr p3(to_python(a3));
-        Ptr p4(to_python(a4));
-        Ptr p5(to_python(a5));
-        Ptr p6(to_python(a6));
-        Ptr p7(to_python(a7));
-        Ptr p8(to_python(a8));
-        Ptr p9(to_python(a9));
-        Ptr p10(to_python(a10));
-        Ptr result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOOOOO)"),
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
+        ref p3(to_python(a3));
+        ref p4(to_python(a4));
+        ref p5(to_python(a5));
+        ref p6(to_python(a6));
+        ref p7(to_python(a7));
+        ref p8(to_python(a8));
+        ref p9(to_python(a9));
+        ref p10(to_python(a10));
+        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOOOOO)"),
                                        p1.get(),
                                        p2.get(),
                                        p3.get(),
@@ -806,24 +806,24 @@ struct Callback<void>
 // Make it a compile-time error to try to return a const char* from a virtual
 // function. The standard conversion
 //
-//      from_python(PyObject* string, py::Type<const char*>)
+//      from_python(PyObject* string, python::type<const char*>)
 //
 // returns a pointer to the character array which is internal to string. The
 // problem with trying to do this in a standard callback function is that the
 // Python string would likely be destroyed upon return from the calling function
-// (py::Callback<const char*>::call[_method]) when its reference count is
+// (python::callback<const char*>::call[_method]) when its reference count is
 // decremented. If you absolutely need to do this and you're sure it's safe (it
 // usually isn't), you can use
 //
-//      py::String result(py::Callback<py::String>::call[_method](...args...));
+//      python::string result(python::callback<python::string>::call[_method](...args...));
 //      ...result.c_str()... // access the char* array
 template <>
-struct Callback<const char*>
+struct callback<const char*>
 {
     // Try hard to generate a readable error message
     typedef struct unsafe_since_python_string_may_be_destroyed {} call, call_method;
 };
 
-} // namespace py
+} // namespace python
 
 #endif // CALLBACK_DWA_052100_H_
diff --git a/caller.h b/caller.h
index 7dd2a590..00cf65b7 100644
--- a/caller.h
+++ b/caller.h
@@ -7,7 +7,7 @@
 //  producing this work.
 //
 //  This file generated for 10-argument member functions and 11-argument free
-//  functions by gen_caller.py
+//  functions by gen_caller.python
 
 #ifndef CALLER_DWA05090_H_
 # define CALLER_DWA05090_H_
@@ -18,18 +18,18 @@
 # include "signatures.h"
 # include "none.h"
 
-namespace py {
+namespace python {
 
 // Calling C++ from Python
 template <class R>
-struct Caller
+struct caller
 {
     template <class T>
     static PyObject* call(R (T::*pmf)(), PyObject* args, PyObject* /* keywords */ ) {
         PyObject* self;
         if (!PyArg_ParseTuple(args, const_cast<char*>("O"), &self))
             return 0;
-        T& target = from_python(self, Type<T&>());
+        T& target = from_python(self, type<T&>());
         return to_python((target.*pmf)());
     }
 
@@ -39,8 +39,8 @@ struct Caller
         PyObject* a1;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OO"), &self, &a1))
             return 0;
-        T& target = from_python(self, Type<T&>());
-        return to_python((target.*pmf)(from_python(a1, Type<A1>())));
+        T& target = from_python(self, type<T&>());
+        return to_python((target.*pmf)(from_python(a1, type<A1>())));
     }
 
     template <class T, class A1, class A2>
@@ -50,9 +50,9 @@ struct Caller
         PyObject* a2;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOO"), &self, &a1, &a2))
             return 0;
-        T& target = from_python(self, Type<T&>());
-        return to_python((target.*pmf)(from_python(a1, Type<A1>()),
-                        from_python(a2, Type<A2>())));
+        T& target = from_python(self, type<T&>());
+        return to_python((target.*pmf)(from_python(a1, type<A1>()),
+                        from_python(a2, type<A2>())));
     }
 
     template <class T, class A1, class A2, class A3>
@@ -63,10 +63,10 @@ struct Caller
         PyObject* a3;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOO"), &self, &a1, &a2, &a3))
             return 0;
-        T& target = from_python(self, Type<T&>());
-        return to_python((target.*pmf)(from_python(a1, Type<A1>()),
-                        from_python(a2, Type<A2>()),
-                        from_python(a3, Type<A3>())));
+        T& target = from_python(self, type<T&>());
+        return to_python((target.*pmf)(from_python(a1, type<A1>()),
+                        from_python(a2, type<A2>()),
+                        from_python(a3, type<A3>())));
     }
 
     template <class T, class A1, class A2, class A3, class A4>
@@ -78,11 +78,11 @@ struct Caller
         PyObject* a4;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOO"), &self, &a1, &a2, &a3, &a4))
             return 0;
-        T& target = from_python(self, Type<T&>());
-        return to_python((target.*pmf)(from_python(a1, Type<A1>()),
-                        from_python(a2, Type<A2>()),
-                        from_python(a3, Type<A3>()),
-                        from_python(a4, Type<A4>())));
+        T& target = from_python(self, type<T&>());
+        return to_python((target.*pmf)(from_python(a1, type<A1>()),
+                        from_python(a2, type<A2>()),
+                        from_python(a3, type<A3>()),
+                        from_python(a4, type<A4>())));
     }
 
     template <class T, class A1, class A2, class A3, class A4, class A5>
@@ -95,12 +95,12 @@ struct Caller
         PyObject* a5;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOO"), &self, &a1, &a2, &a3, &a4, &a5))
             return 0;
-        T& target = from_python(self, Type<T&>());
-        return to_python((target.*pmf)(from_python(a1, Type<A1>()),
-                        from_python(a2, Type<A2>()),
-                        from_python(a3, Type<A3>()),
-                        from_python(a4, Type<A4>()),
-                        from_python(a5, Type<A5>())));
+        T& target = from_python(self, type<T&>());
+        return to_python((target.*pmf)(from_python(a1, type<A1>()),
+                        from_python(a2, type<A2>()),
+                        from_python(a3, type<A3>()),
+                        from_python(a4, type<A4>()),
+                        from_python(a5, type<A5>())));
     }
 
     template <class T, class A1, class A2, class A3, class A4, class A5, class A6>
@@ -114,13 +114,13 @@ struct Caller
         PyObject* a6;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOO"), &self, &a1, &a2, &a3, &a4, &a5, &a6))
             return 0;
-        T& target = from_python(self, Type<T&>());
-        return to_python((target.*pmf)(from_python(a1, Type<A1>()),
-                        from_python(a2, Type<A2>()),
-                        from_python(a3, Type<A3>()),
-                        from_python(a4, Type<A4>()),
-                        from_python(a5, Type<A5>()),
-                        from_python(a6, Type<A6>())));
+        T& target = from_python(self, type<T&>());
+        return to_python((target.*pmf)(from_python(a1, type<A1>()),
+                        from_python(a2, type<A2>()),
+                        from_python(a3, type<A3>()),
+                        from_python(a4, type<A4>()),
+                        from_python(a5, type<A5>()),
+                        from_python(a6, type<A6>())));
     }
 
     template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
@@ -135,14 +135,14 @@ struct Caller
         PyObject* a7;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOO"), &self, &a1, &a2, &a3, &a4, &a5, &a6, &a7))
             return 0;
-        T& target = from_python(self, Type<T&>());
-        return to_python((target.*pmf)(from_python(a1, Type<A1>()),
-                        from_python(a2, Type<A2>()),
-                        from_python(a3, Type<A3>()),
-                        from_python(a4, Type<A4>()),
-                        from_python(a5, Type<A5>()),
-                        from_python(a6, Type<A6>()),
-                        from_python(a7, Type<A7>())));
+        T& target = from_python(self, type<T&>());
+        return to_python((target.*pmf)(from_python(a1, type<A1>()),
+                        from_python(a2, type<A2>()),
+                        from_python(a3, type<A3>()),
+                        from_python(a4, type<A4>()),
+                        from_python(a5, type<A5>()),
+                        from_python(a6, type<A6>()),
+                        from_python(a7, type<A7>())));
     }
 
     template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
@@ -158,15 +158,15 @@ struct Caller
         PyObject* a8;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOOO"), &self, &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8))
             return 0;
-        T& target = from_python(self, Type<T&>());
-        return to_python((target.*pmf)(from_python(a1, Type<A1>()),
-                        from_python(a2, Type<A2>()),
-                        from_python(a3, Type<A3>()),
-                        from_python(a4, Type<A4>()),
-                        from_python(a5, Type<A5>()),
-                        from_python(a6, Type<A6>()),
-                        from_python(a7, Type<A7>()),
-                        from_python(a8, Type<A8>())));
+        T& target = from_python(self, type<T&>());
+        return to_python((target.*pmf)(from_python(a1, type<A1>()),
+                        from_python(a2, type<A2>()),
+                        from_python(a3, type<A3>()),
+                        from_python(a4, type<A4>()),
+                        from_python(a5, type<A5>()),
+                        from_python(a6, type<A6>()),
+                        from_python(a7, type<A7>()),
+                        from_python(a8, type<A8>())));
     }
 
     template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
@@ -183,16 +183,16 @@ struct Caller
         PyObject* a9;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOOOO"), &self, &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9))
             return 0;
-        T& target = from_python(self, Type<T&>());
-        return to_python((target.*pmf)(from_python(a1, Type<A1>()),
-                        from_python(a2, Type<A2>()),
-                        from_python(a3, Type<A3>()),
-                        from_python(a4, Type<A4>()),
-                        from_python(a5, Type<A5>()),
-                        from_python(a6, Type<A6>()),
-                        from_python(a7, Type<A7>()),
-                        from_python(a8, Type<A8>()),
-                        from_python(a9, Type<A9>())));
+        T& target = from_python(self, type<T&>());
+        return to_python((target.*pmf)(from_python(a1, type<A1>()),
+                        from_python(a2, type<A2>()),
+                        from_python(a3, type<A3>()),
+                        from_python(a4, type<A4>()),
+                        from_python(a5, type<A5>()),
+                        from_python(a6, type<A6>()),
+                        from_python(a7, type<A7>()),
+                        from_python(a8, type<A8>()),
+                        from_python(a9, type<A9>())));
     }
 
     template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
@@ -210,17 +210,17 @@ struct Caller
         PyObject* a10;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOOOOO"), &self, &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9, &a10))
             return 0;
-        T& target = from_python(self, Type<T&>());
-        return to_python((target.*pmf)(from_python(a1, Type<A1>()),
-                        from_python(a2, Type<A2>()),
-                        from_python(a3, Type<A3>()),
-                        from_python(a4, Type<A4>()),
-                        from_python(a5, Type<A5>()),
-                        from_python(a6, Type<A6>()),
-                        from_python(a7, Type<A7>()),
-                        from_python(a8, Type<A8>()),
-                        from_python(a9, Type<A9>()),
-                        from_python(a10, Type<A10>())));
+        T& target = from_python(self, type<T&>());
+        return to_python((target.*pmf)(from_python(a1, type<A1>()),
+                        from_python(a2, type<A2>()),
+                        from_python(a3, type<A3>()),
+                        from_python(a4, type<A4>()),
+                        from_python(a5, type<A5>()),
+                        from_python(a6, type<A6>()),
+                        from_python(a7, type<A7>()),
+                        from_python(a8, type<A8>()),
+                        from_python(a9, type<A9>()),
+                        from_python(a10, type<A10>())));
     }
 
 
@@ -229,7 +229,7 @@ struct Caller
         PyObject* self;
         if (!PyArg_ParseTuple(args, const_cast<char*>("O"), &self))
             return 0;
-        T& target = from_python(self, Type<T&>());
+        T& target = from_python(self, type<T&>());
         return to_python((target.*pmf)());
     }
 
@@ -239,8 +239,8 @@ struct Caller
         PyObject* a1;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OO"), &self, &a1))
             return 0;
-        T& target = from_python(self, Type<T&>());
-        return to_python((target.*pmf)(from_python(a1, Type<A1>())));
+        T& target = from_python(self, type<T&>());
+        return to_python((target.*pmf)(from_python(a1, type<A1>())));
     }
 
     template <class T, class A1, class A2>
@@ -250,9 +250,9 @@ struct Caller
         PyObject* a2;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOO"), &self, &a1, &a2))
             return 0;
-        T& target = from_python(self, Type<T&>());
-        return to_python((target.*pmf)(from_python(a1, Type<A1>()),
-                        from_python(a2, Type<A2>())));
+        T& target = from_python(self, type<T&>());
+        return to_python((target.*pmf)(from_python(a1, type<A1>()),
+                        from_python(a2, type<A2>())));
     }
 
     template <class T, class A1, class A2, class A3>
@@ -263,10 +263,10 @@ struct Caller
         PyObject* a3;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOO"), &self, &a1, &a2, &a3))
             return 0;
-        T& target = from_python(self, Type<T&>());
-        return to_python((target.*pmf)(from_python(a1, Type<A1>()),
-                        from_python(a2, Type<A2>()),
-                        from_python(a3, Type<A3>())));
+        T& target = from_python(self, type<T&>());
+        return to_python((target.*pmf)(from_python(a1, type<A1>()),
+                        from_python(a2, type<A2>()),
+                        from_python(a3, type<A3>())));
     }
 
     template <class T, class A1, class A2, class A3, class A4>
@@ -278,11 +278,11 @@ struct Caller
         PyObject* a4;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOO"), &self, &a1, &a2, &a3, &a4))
             return 0;
-        T& target = from_python(self, Type<T&>());
-        return to_python((target.*pmf)(from_python(a1, Type<A1>()),
-                        from_python(a2, Type<A2>()),
-                        from_python(a3, Type<A3>()),
-                        from_python(a4, Type<A4>())));
+        T& target = from_python(self, type<T&>());
+        return to_python((target.*pmf)(from_python(a1, type<A1>()),
+                        from_python(a2, type<A2>()),
+                        from_python(a3, type<A3>()),
+                        from_python(a4, type<A4>())));
     }
 
     template <class T, class A1, class A2, class A3, class A4, class A5>
@@ -295,12 +295,12 @@ struct Caller
         PyObject* a5;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOO"), &self, &a1, &a2, &a3, &a4, &a5))
             return 0;
-        T& target = from_python(self, Type<T&>());
-        return to_python((target.*pmf)(from_python(a1, Type<A1>()),
-                        from_python(a2, Type<A2>()),
-                        from_python(a3, Type<A3>()),
-                        from_python(a4, Type<A4>()),
-                        from_python(a5, Type<A5>())));
+        T& target = from_python(self, type<T&>());
+        return to_python((target.*pmf)(from_python(a1, type<A1>()),
+                        from_python(a2, type<A2>()),
+                        from_python(a3, type<A3>()),
+                        from_python(a4, type<A4>()),
+                        from_python(a5, type<A5>())));
     }
 
     template <class T, class A1, class A2, class A3, class A4, class A5, class A6>
@@ -314,13 +314,13 @@ struct Caller
         PyObject* a6;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOO"), &self, &a1, &a2, &a3, &a4, &a5, &a6))
             return 0;
-        T& target = from_python(self, Type<T&>());
-        return to_python((target.*pmf)(from_python(a1, Type<A1>()),
-                        from_python(a2, Type<A2>()),
-                        from_python(a3, Type<A3>()),
-                        from_python(a4, Type<A4>()),
-                        from_python(a5, Type<A5>()),
-                        from_python(a6, Type<A6>())));
+        T& target = from_python(self, type<T&>());
+        return to_python((target.*pmf)(from_python(a1, type<A1>()),
+                        from_python(a2, type<A2>()),
+                        from_python(a3, type<A3>()),
+                        from_python(a4, type<A4>()),
+                        from_python(a5, type<A5>()),
+                        from_python(a6, type<A6>())));
     }
 
     template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
@@ -335,14 +335,14 @@ struct Caller
         PyObject* a7;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOO"), &self, &a1, &a2, &a3, &a4, &a5, &a6, &a7))
             return 0;
-        T& target = from_python(self, Type<T&>());
-        return to_python((target.*pmf)(from_python(a1, Type<A1>()),
-                        from_python(a2, Type<A2>()),
-                        from_python(a3, Type<A3>()),
-                        from_python(a4, Type<A4>()),
-                        from_python(a5, Type<A5>()),
-                        from_python(a6, Type<A6>()),
-                        from_python(a7, Type<A7>())));
+        T& target = from_python(self, type<T&>());
+        return to_python((target.*pmf)(from_python(a1, type<A1>()),
+                        from_python(a2, type<A2>()),
+                        from_python(a3, type<A3>()),
+                        from_python(a4, type<A4>()),
+                        from_python(a5, type<A5>()),
+                        from_python(a6, type<A6>()),
+                        from_python(a7, type<A7>())));
     }
 
     template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
@@ -358,15 +358,15 @@ struct Caller
         PyObject* a8;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOOO"), &self, &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8))
             return 0;
-        T& target = from_python(self, Type<T&>());
-        return to_python((target.*pmf)(from_python(a1, Type<A1>()),
-                        from_python(a2, Type<A2>()),
-                        from_python(a3, Type<A3>()),
-                        from_python(a4, Type<A4>()),
-                        from_python(a5, Type<A5>()),
-                        from_python(a6, Type<A6>()),
-                        from_python(a7, Type<A7>()),
-                        from_python(a8, Type<A8>())));
+        T& target = from_python(self, type<T&>());
+        return to_python((target.*pmf)(from_python(a1, type<A1>()),
+                        from_python(a2, type<A2>()),
+                        from_python(a3, type<A3>()),
+                        from_python(a4, type<A4>()),
+                        from_python(a5, type<A5>()),
+                        from_python(a6, type<A6>()),
+                        from_python(a7, type<A7>()),
+                        from_python(a8, type<A8>())));
     }
 
     template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
@@ -383,16 +383,16 @@ struct Caller
         PyObject* a9;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOOOO"), &self, &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9))
             return 0;
-        T& target = from_python(self, Type<T&>());
-        return to_python((target.*pmf)(from_python(a1, Type<A1>()),
-                        from_python(a2, Type<A2>()),
-                        from_python(a3, Type<A3>()),
-                        from_python(a4, Type<A4>()),
-                        from_python(a5, Type<A5>()),
-                        from_python(a6, Type<A6>()),
-                        from_python(a7, Type<A7>()),
-                        from_python(a8, Type<A8>()),
-                        from_python(a9, Type<A9>())));
+        T& target = from_python(self, type<T&>());
+        return to_python((target.*pmf)(from_python(a1, type<A1>()),
+                        from_python(a2, type<A2>()),
+                        from_python(a3, type<A3>()),
+                        from_python(a4, type<A4>()),
+                        from_python(a5, type<A5>()),
+                        from_python(a6, type<A6>()),
+                        from_python(a7, type<A7>()),
+                        from_python(a8, type<A8>()),
+                        from_python(a9, type<A9>())));
     }
 
     template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
@@ -410,17 +410,17 @@ struct Caller
         PyObject* a10;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOOOOO"), &self, &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9, &a10))
             return 0;
-        T& target = from_python(self, Type<T&>());
-        return to_python((target.*pmf)(from_python(a1, Type<A1>()),
-                        from_python(a2, Type<A2>()),
-                        from_python(a3, Type<A3>()),
-                        from_python(a4, Type<A4>()),
-                        from_python(a5, Type<A5>()),
-                        from_python(a6, Type<A6>()),
-                        from_python(a7, Type<A7>()),
-                        from_python(a8, Type<A8>()),
-                        from_python(a9, Type<A9>()),
-                        from_python(a10, Type<A10>())));
+        T& target = from_python(self, type<T&>());
+        return to_python((target.*pmf)(from_python(a1, type<A1>()),
+                        from_python(a2, type<A2>()),
+                        from_python(a3, type<A3>()),
+                        from_python(a4, type<A4>()),
+                        from_python(a5, type<A5>()),
+                        from_python(a6, type<A6>()),
+                        from_python(a7, type<A7>()),
+                        from_python(a8, type<A8>()),
+                        from_python(a9, type<A9>()),
+                        from_python(a10, type<A10>())));
     }
 
     // Free functions
@@ -435,7 +435,7 @@ struct Caller
         PyObject* a1;
         if (!PyArg_ParseTuple(args, const_cast<char*>("O"), &a1))
             return 0;
-        return to_python(f(from_python(a1, Type<A1>())));
+        return to_python(f(from_python(a1, type<A1>())));
     }
 
     template <class A1, class A2>
@@ -444,8 +444,8 @@ struct Caller
         PyObject* a2;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OO"), &a1, &a2))
             return 0;
-        return to_python(f(from_python(a1, Type<A1>()),
-                        from_python(a2, Type<A2>())));
+        return to_python(f(from_python(a1, type<A1>()),
+                        from_python(a2, type<A2>())));
     }
 
     template <class A1, class A2, class A3>
@@ -455,9 +455,9 @@ struct Caller
         PyObject* a3;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOO"), &a1, &a2, &a3))
             return 0;
-        return to_python(f(from_python(a1, Type<A1>()),
-                        from_python(a2, Type<A2>()),
-                        from_python(a3, Type<A3>())));
+        return to_python(f(from_python(a1, type<A1>()),
+                        from_python(a2, type<A2>()),
+                        from_python(a3, type<A3>())));
     }
 
     template <class A1, class A2, class A3, class A4>
@@ -468,10 +468,10 @@ struct Caller
         PyObject* a4;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOO"), &a1, &a2, &a3, &a4))
             return 0;
-        return to_python(f(from_python(a1, Type<A1>()),
-                        from_python(a2, Type<A2>()),
-                        from_python(a3, Type<A3>()),
-                        from_python(a4, Type<A4>())));
+        return to_python(f(from_python(a1, type<A1>()),
+                        from_python(a2, type<A2>()),
+                        from_python(a3, type<A3>()),
+                        from_python(a4, type<A4>())));
     }
 
     template <class A1, class A2, class A3, class A4, class A5>
@@ -483,11 +483,11 @@ struct Caller
         PyObject* a5;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOO"), &a1, &a2, &a3, &a4, &a5))
             return 0;
-        return to_python(f(from_python(a1, Type<A1>()),
-                        from_python(a2, Type<A2>()),
-                        from_python(a3, Type<A3>()),
-                        from_python(a4, Type<A4>()),
-                        from_python(a5, Type<A5>())));
+        return to_python(f(from_python(a1, type<A1>()),
+                        from_python(a2, type<A2>()),
+                        from_python(a3, type<A3>()),
+                        from_python(a4, type<A4>()),
+                        from_python(a5, type<A5>())));
     }
 
     template <class A1, class A2, class A3, class A4, class A5, class A6>
@@ -500,12 +500,12 @@ struct Caller
         PyObject* a6;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOO"), &a1, &a2, &a3, &a4, &a5, &a6))
             return 0;
-        return to_python(f(from_python(a1, Type<A1>()),
-                        from_python(a2, Type<A2>()),
-                        from_python(a3, Type<A3>()),
-                        from_python(a4, Type<A4>()),
-                        from_python(a5, Type<A5>()),
-                        from_python(a6, Type<A6>())));
+        return to_python(f(from_python(a1, type<A1>()),
+                        from_python(a2, type<A2>()),
+                        from_python(a3, type<A3>()),
+                        from_python(a4, type<A4>()),
+                        from_python(a5, type<A5>()),
+                        from_python(a6, type<A6>())));
     }
 
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
@@ -519,13 +519,13 @@ struct Caller
         PyObject* a7;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOO"), &a1, &a2, &a3, &a4, &a5, &a6, &a7))
             return 0;
-        return to_python(f(from_python(a1, Type<A1>()),
-                        from_python(a2, Type<A2>()),
-                        from_python(a3, Type<A3>()),
-                        from_python(a4, Type<A4>()),
-                        from_python(a5, Type<A5>()),
-                        from_python(a6, Type<A6>()),
-                        from_python(a7, Type<A7>())));
+        return to_python(f(from_python(a1, type<A1>()),
+                        from_python(a2, type<A2>()),
+                        from_python(a3, type<A3>()),
+                        from_python(a4, type<A4>()),
+                        from_python(a5, type<A5>()),
+                        from_python(a6, type<A6>()),
+                        from_python(a7, type<A7>())));
     }
 
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
@@ -540,14 +540,14 @@ struct Caller
         PyObject* a8;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOO"), &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8))
             return 0;
-        return to_python(f(from_python(a1, Type<A1>()),
-                        from_python(a2, Type<A2>()),
-                        from_python(a3, Type<A3>()),
-                        from_python(a4, Type<A4>()),
-                        from_python(a5, Type<A5>()),
-                        from_python(a6, Type<A6>()),
-                        from_python(a7, Type<A7>()),
-                        from_python(a8, Type<A8>())));
+        return to_python(f(from_python(a1, type<A1>()),
+                        from_python(a2, type<A2>()),
+                        from_python(a3, type<A3>()),
+                        from_python(a4, type<A4>()),
+                        from_python(a5, type<A5>()),
+                        from_python(a6, type<A6>()),
+                        from_python(a7, type<A7>()),
+                        from_python(a8, type<A8>())));
     }
 
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
@@ -563,15 +563,15 @@ struct Caller
         PyObject* a9;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOOO"), &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9))
             return 0;
-        return to_python(f(from_python(a1, Type<A1>()),
-                        from_python(a2, Type<A2>()),
-                        from_python(a3, Type<A3>()),
-                        from_python(a4, Type<A4>()),
-                        from_python(a5, Type<A5>()),
-                        from_python(a6, Type<A6>()),
-                        from_python(a7, Type<A7>()),
-                        from_python(a8, Type<A8>()),
-                        from_python(a9, Type<A9>())));
+        return to_python(f(from_python(a1, type<A1>()),
+                        from_python(a2, type<A2>()),
+                        from_python(a3, type<A3>()),
+                        from_python(a4, type<A4>()),
+                        from_python(a5, type<A5>()),
+                        from_python(a6, type<A6>()),
+                        from_python(a7, type<A7>()),
+                        from_python(a8, type<A8>()),
+                        from_python(a9, type<A9>())));
     }
 
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
@@ -588,16 +588,16 @@ struct Caller
         PyObject* a10;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOOOO"), &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9, &a10))
             return 0;
-        return to_python(f(from_python(a1, Type<A1>()),
-                        from_python(a2, Type<A2>()),
-                        from_python(a3, Type<A3>()),
-                        from_python(a4, Type<A4>()),
-                        from_python(a5, Type<A5>()),
-                        from_python(a6, Type<A6>()),
-                        from_python(a7, Type<A7>()),
-                        from_python(a8, Type<A8>()),
-                        from_python(a9, Type<A9>()),
-                        from_python(a10, Type<A10>())));
+        return to_python(f(from_python(a1, type<A1>()),
+                        from_python(a2, type<A2>()),
+                        from_python(a3, type<A3>()),
+                        from_python(a4, type<A4>()),
+                        from_python(a5, type<A5>()),
+                        from_python(a6, type<A6>()),
+                        from_python(a7, type<A7>()),
+                        from_python(a8, type<A8>()),
+                        from_python(a9, type<A9>()),
+                        from_python(a10, type<A10>())));
     }
 
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11>
@@ -615,30 +615,30 @@ struct Caller
         PyObject* a11;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOOOOO"), &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9, &a10, &a11))
             return 0;
-        return to_python(f(from_python(a1, Type<A1>()),
-                        from_python(a2, Type<A2>()),
-                        from_python(a3, Type<A3>()),
-                        from_python(a4, Type<A4>()),
-                        from_python(a5, Type<A5>()),
-                        from_python(a6, Type<A6>()),
-                        from_python(a7, Type<A7>()),
-                        from_python(a8, Type<A8>()),
-                        from_python(a9, Type<A9>()),
-                        from_python(a10, Type<A10>()),
-                        from_python(a11, Type<A11>())));
+        return to_python(f(from_python(a1, type<A1>()),
+                        from_python(a2, type<A2>()),
+                        from_python(a3, type<A3>()),
+                        from_python(a4, type<A4>()),
+                        from_python(a5, type<A5>()),
+                        from_python(a6, type<A6>()),
+                        from_python(a7, type<A7>()),
+                        from_python(a8, type<A8>()),
+                        from_python(a9, type<A9>()),
+                        from_python(a10, type<A10>()),
+                        from_python(a11, type<A11>())));
     }
 
 };
                            
 template <>
-struct Caller<void>
+struct caller<void>
 {
     template <class T>
     static PyObject* call(void (T::*pmf)(), PyObject* args, PyObject* /* keywords */ ) {
         PyObject* self;
         if (!PyArg_ParseTuple(args, const_cast<char*>("O"), &self))
             return 0;
-        T& target = from_python(self, Type<T&>());
+        T& target = from_python(self, type<T&>());
         (target.*pmf)();
         return detail::none();
     }
@@ -649,8 +649,8 @@ struct Caller<void>
         PyObject* a1;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OO"), &self, &a1))
             return 0;
-        T& target = from_python(self, Type<T&>());
-        (target.*pmf)(from_python(a1, Type<A1>()));
+        T& target = from_python(self, type<T&>());
+        (target.*pmf)(from_python(a1, type<A1>()));
         return detail::none();
     }
 
@@ -661,9 +661,9 @@ struct Caller<void>
         PyObject* a2;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOO"), &self, &a1, &a2))
             return 0;
-        T& target = from_python(self, Type<T&>());
-        (target.*pmf)(from_python(a1, Type<A1>()),
-                        from_python(a2, Type<A2>()));
+        T& target = from_python(self, type<T&>());
+        (target.*pmf)(from_python(a1, type<A1>()),
+                        from_python(a2, type<A2>()));
         return detail::none();
     }
 
@@ -675,10 +675,10 @@ struct Caller<void>
         PyObject* a3;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOO"), &self, &a1, &a2, &a3))
             return 0;
-        T& target = from_python(self, Type<T&>());
-        (target.*pmf)(from_python(a1, Type<A1>()),
-                        from_python(a2, Type<A2>()),
-                        from_python(a3, Type<A3>()));
+        T& target = from_python(self, type<T&>());
+        (target.*pmf)(from_python(a1, type<A1>()),
+                        from_python(a2, type<A2>()),
+                        from_python(a3, type<A3>()));
         return detail::none();
     }
 
@@ -691,11 +691,11 @@ struct Caller<void>
         PyObject* a4;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOO"), &self, &a1, &a2, &a3, &a4))
             return 0;
-        T& target = from_python(self, Type<T&>());
-        (target.*pmf)(from_python(a1, Type<A1>()),
-                        from_python(a2, Type<A2>()),
-                        from_python(a3, Type<A3>()),
-                        from_python(a4, Type<A4>()));
+        T& target = from_python(self, type<T&>());
+        (target.*pmf)(from_python(a1, type<A1>()),
+                        from_python(a2, type<A2>()),
+                        from_python(a3, type<A3>()),
+                        from_python(a4, type<A4>()));
         return detail::none();
     }
 
@@ -709,12 +709,12 @@ struct Caller<void>
         PyObject* a5;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOO"), &self, &a1, &a2, &a3, &a4, &a5))
             return 0;
-        T& target = from_python(self, Type<T&>());
-        (target.*pmf)(from_python(a1, Type<A1>()),
-                        from_python(a2, Type<A2>()),
-                        from_python(a3, Type<A3>()),
-                        from_python(a4, Type<A4>()),
-                        from_python(a5, Type<A5>()));
+        T& target = from_python(self, type<T&>());
+        (target.*pmf)(from_python(a1, type<A1>()),
+                        from_python(a2, type<A2>()),
+                        from_python(a3, type<A3>()),
+                        from_python(a4, type<A4>()),
+                        from_python(a5, type<A5>()));
         return detail::none();
     }
 
@@ -729,13 +729,13 @@ struct Caller<void>
         PyObject* a6;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOO"), &self, &a1, &a2, &a3, &a4, &a5, &a6))
             return 0;
-        T& target = from_python(self, Type<T&>());
-        (target.*pmf)(from_python(a1, Type<A1>()),
-                        from_python(a2, Type<A2>()),
-                        from_python(a3, Type<A3>()),
-                        from_python(a4, Type<A4>()),
-                        from_python(a5, Type<A5>()),
-                        from_python(a6, Type<A6>()));
+        T& target = from_python(self, type<T&>());
+        (target.*pmf)(from_python(a1, type<A1>()),
+                        from_python(a2, type<A2>()),
+                        from_python(a3, type<A3>()),
+                        from_python(a4, type<A4>()),
+                        from_python(a5, type<A5>()),
+                        from_python(a6, type<A6>()));
         return detail::none();
     }
 
@@ -751,14 +751,14 @@ struct Caller<void>
         PyObject* a7;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOO"), &self, &a1, &a2, &a3, &a4, &a5, &a6, &a7))
             return 0;
-        T& target = from_python(self, Type<T&>());
-        (target.*pmf)(from_python(a1, Type<A1>()),
-                        from_python(a2, Type<A2>()),
-                        from_python(a3, Type<A3>()),
-                        from_python(a4, Type<A4>()),
-                        from_python(a5, Type<A5>()),
-                        from_python(a6, Type<A6>()),
-                        from_python(a7, Type<A7>()));
+        T& target = from_python(self, type<T&>());
+        (target.*pmf)(from_python(a1, type<A1>()),
+                        from_python(a2, type<A2>()),
+                        from_python(a3, type<A3>()),
+                        from_python(a4, type<A4>()),
+                        from_python(a5, type<A5>()),
+                        from_python(a6, type<A6>()),
+                        from_python(a7, type<A7>()));
         return detail::none();
     }
 
@@ -775,15 +775,15 @@ struct Caller<void>
         PyObject* a8;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOOO"), &self, &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8))
             return 0;
-        T& target = from_python(self, Type<T&>());
-        (target.*pmf)(from_python(a1, Type<A1>()),
-                        from_python(a2, Type<A2>()),
-                        from_python(a3, Type<A3>()),
-                        from_python(a4, Type<A4>()),
-                        from_python(a5, Type<A5>()),
-                        from_python(a6, Type<A6>()),
-                        from_python(a7, Type<A7>()),
-                        from_python(a8, Type<A8>()));
+        T& target = from_python(self, type<T&>());
+        (target.*pmf)(from_python(a1, type<A1>()),
+                        from_python(a2, type<A2>()),
+                        from_python(a3, type<A3>()),
+                        from_python(a4, type<A4>()),
+                        from_python(a5, type<A5>()),
+                        from_python(a6, type<A6>()),
+                        from_python(a7, type<A7>()),
+                        from_python(a8, type<A8>()));
         return detail::none();
     }
 
@@ -801,16 +801,16 @@ struct Caller<void>
         PyObject* a9;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOOOO"), &self, &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9))
             return 0;
-        T& target = from_python(self, Type<T&>());
-        (target.*pmf)(from_python(a1, Type<A1>()),
-                        from_python(a2, Type<A2>()),
-                        from_python(a3, Type<A3>()),
-                        from_python(a4, Type<A4>()),
-                        from_python(a5, Type<A5>()),
-                        from_python(a6, Type<A6>()),
-                        from_python(a7, Type<A7>()),
-                        from_python(a8, Type<A8>()),
-                        from_python(a9, Type<A9>()));
+        T& target = from_python(self, type<T&>());
+        (target.*pmf)(from_python(a1, type<A1>()),
+                        from_python(a2, type<A2>()),
+                        from_python(a3, type<A3>()),
+                        from_python(a4, type<A4>()),
+                        from_python(a5, type<A5>()),
+                        from_python(a6, type<A6>()),
+                        from_python(a7, type<A7>()),
+                        from_python(a8, type<A8>()),
+                        from_python(a9, type<A9>()));
         return detail::none();
     }
 
@@ -829,17 +829,17 @@ struct Caller<void>
         PyObject* a10;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOOOOO"), &self, &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9, &a10))
             return 0;
-        T& target = from_python(self, Type<T&>());
-        (target.*pmf)(from_python(a1, Type<A1>()),
-                        from_python(a2, Type<A2>()),
-                        from_python(a3, Type<A3>()),
-                        from_python(a4, Type<A4>()),
-                        from_python(a5, Type<A5>()),
-                        from_python(a6, Type<A6>()),
-                        from_python(a7, Type<A7>()),
-                        from_python(a8, Type<A8>()),
-                        from_python(a9, Type<A9>()),
-                        from_python(a10, Type<A10>()));
+        T& target = from_python(self, type<T&>());
+        (target.*pmf)(from_python(a1, type<A1>()),
+                        from_python(a2, type<A2>()),
+                        from_python(a3, type<A3>()),
+                        from_python(a4, type<A4>()),
+                        from_python(a5, type<A5>()),
+                        from_python(a6, type<A6>()),
+                        from_python(a7, type<A7>()),
+                        from_python(a8, type<A8>()),
+                        from_python(a9, type<A9>()),
+                        from_python(a10, type<A10>()));
         return detail::none();
     }
 
@@ -849,7 +849,7 @@ struct Caller<void>
         PyObject* self;
         if (!PyArg_ParseTuple(args, const_cast<char*>("O"), &self))
             return 0;
-        T& target = from_python(self, Type<T&>());
+        T& target = from_python(self, type<T&>());
         (target.*pmf)();
         return detail::none();
     }
@@ -860,8 +860,8 @@ struct Caller<void>
         PyObject* a1;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OO"), &self, &a1))
             return 0;
-        T& target = from_python(self, Type<T&>());
-        (target.*pmf)(from_python(a1, Type<A1>()));
+        T& target = from_python(self, type<T&>());
+        (target.*pmf)(from_python(a1, type<A1>()));
         return detail::none();
     }
 
@@ -872,9 +872,9 @@ struct Caller<void>
         PyObject* a2;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOO"), &self, &a1, &a2))
             return 0;
-        T& target = from_python(self, Type<T&>());
-        (target.*pmf)(from_python(a1, Type<A1>()),
-                        from_python(a2, Type<A2>()));
+        T& target = from_python(self, type<T&>());
+        (target.*pmf)(from_python(a1, type<A1>()),
+                        from_python(a2, type<A2>()));
         return detail::none();
     }
 
@@ -886,10 +886,10 @@ struct Caller<void>
         PyObject* a3;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOO"), &self, &a1, &a2, &a3))
             return 0;
-        T& target = from_python(self, Type<T&>());
-        (target.*pmf)(from_python(a1, Type<A1>()),
-                        from_python(a2, Type<A2>()),
-                        from_python(a3, Type<A3>()));
+        T& target = from_python(self, type<T&>());
+        (target.*pmf)(from_python(a1, type<A1>()),
+                        from_python(a2, type<A2>()),
+                        from_python(a3, type<A3>()));
         return detail::none();
     }
 
@@ -902,11 +902,11 @@ struct Caller<void>
         PyObject* a4;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOO"), &self, &a1, &a2, &a3, &a4))
             return 0;
-        T& target = from_python(self, Type<T&>());
-        (target.*pmf)(from_python(a1, Type<A1>()),
-                        from_python(a2, Type<A2>()),
-                        from_python(a3, Type<A3>()),
-                        from_python(a4, Type<A4>()));
+        T& target = from_python(self, type<T&>());
+        (target.*pmf)(from_python(a1, type<A1>()),
+                        from_python(a2, type<A2>()),
+                        from_python(a3, type<A3>()),
+                        from_python(a4, type<A4>()));
         return detail::none();
     }
 
@@ -920,12 +920,12 @@ struct Caller<void>
         PyObject* a5;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOO"), &self, &a1, &a2, &a3, &a4, &a5))
             return 0;
-        T& target = from_python(self, Type<T&>());
-        (target.*pmf)(from_python(a1, Type<A1>()),
-                        from_python(a2, Type<A2>()),
-                        from_python(a3, Type<A3>()),
-                        from_python(a4, Type<A4>()),
-                        from_python(a5, Type<A5>()));
+        T& target = from_python(self, type<T&>());
+        (target.*pmf)(from_python(a1, type<A1>()),
+                        from_python(a2, type<A2>()),
+                        from_python(a3, type<A3>()),
+                        from_python(a4, type<A4>()),
+                        from_python(a5, type<A5>()));
         return detail::none();
     }
 
@@ -940,13 +940,13 @@ struct Caller<void>
         PyObject* a6;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOO"), &self, &a1, &a2, &a3, &a4, &a5, &a6))
             return 0;
-        T& target = from_python(self, Type<T&>());
-        (target.*pmf)(from_python(a1, Type<A1>()),
-                        from_python(a2, Type<A2>()),
-                        from_python(a3, Type<A3>()),
-                        from_python(a4, Type<A4>()),
-                        from_python(a5, Type<A5>()),
-                        from_python(a6, Type<A6>()));
+        T& target = from_python(self, type<T&>());
+        (target.*pmf)(from_python(a1, type<A1>()),
+                        from_python(a2, type<A2>()),
+                        from_python(a3, type<A3>()),
+                        from_python(a4, type<A4>()),
+                        from_python(a5, type<A5>()),
+                        from_python(a6, type<A6>()));
         return detail::none();
     }
 
@@ -962,14 +962,14 @@ struct Caller<void>
         PyObject* a7;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOO"), &self, &a1, &a2, &a3, &a4, &a5, &a6, &a7))
             return 0;
-        T& target = from_python(self, Type<T&>());
-        (target.*pmf)(from_python(a1, Type<A1>()),
-                        from_python(a2, Type<A2>()),
-                        from_python(a3, Type<A3>()),
-                        from_python(a4, Type<A4>()),
-                        from_python(a5, Type<A5>()),
-                        from_python(a6, Type<A6>()),
-                        from_python(a7, Type<A7>()));
+        T& target = from_python(self, type<T&>());
+        (target.*pmf)(from_python(a1, type<A1>()),
+                        from_python(a2, type<A2>()),
+                        from_python(a3, type<A3>()),
+                        from_python(a4, type<A4>()),
+                        from_python(a5, type<A5>()),
+                        from_python(a6, type<A6>()),
+                        from_python(a7, type<A7>()));
         return detail::none();
     }
 
@@ -986,15 +986,15 @@ struct Caller<void>
         PyObject* a8;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOOO"), &self, &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8))
             return 0;
-        T& target = from_python(self, Type<T&>());
-        (target.*pmf)(from_python(a1, Type<A1>()),
-                        from_python(a2, Type<A2>()),
-                        from_python(a3, Type<A3>()),
-                        from_python(a4, Type<A4>()),
-                        from_python(a5, Type<A5>()),
-                        from_python(a6, Type<A6>()),
-                        from_python(a7, Type<A7>()),
-                        from_python(a8, Type<A8>()));
+        T& target = from_python(self, type<T&>());
+        (target.*pmf)(from_python(a1, type<A1>()),
+                        from_python(a2, type<A2>()),
+                        from_python(a3, type<A3>()),
+                        from_python(a4, type<A4>()),
+                        from_python(a5, type<A5>()),
+                        from_python(a6, type<A6>()),
+                        from_python(a7, type<A7>()),
+                        from_python(a8, type<A8>()));
         return detail::none();
     }
 
@@ -1012,16 +1012,16 @@ struct Caller<void>
         PyObject* a9;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOOOO"), &self, &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9))
             return 0;
-        T& target = from_python(self, Type<T&>());
-        (target.*pmf)(from_python(a1, Type<A1>()),
-                        from_python(a2, Type<A2>()),
-                        from_python(a3, Type<A3>()),
-                        from_python(a4, Type<A4>()),
-                        from_python(a5, Type<A5>()),
-                        from_python(a6, Type<A6>()),
-                        from_python(a7, Type<A7>()),
-                        from_python(a8, Type<A8>()),
-                        from_python(a9, Type<A9>()));
+        T& target = from_python(self, type<T&>());
+        (target.*pmf)(from_python(a1, type<A1>()),
+                        from_python(a2, type<A2>()),
+                        from_python(a3, type<A3>()),
+                        from_python(a4, type<A4>()),
+                        from_python(a5, type<A5>()),
+                        from_python(a6, type<A6>()),
+                        from_python(a7, type<A7>()),
+                        from_python(a8, type<A8>()),
+                        from_python(a9, type<A9>()));
         return detail::none();
     }
 
@@ -1040,17 +1040,17 @@ struct Caller<void>
         PyObject* a10;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOOOOO"), &self, &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9, &a10))
             return 0;
-        T& target = from_python(self, Type<T&>());
-        (target.*pmf)(from_python(a1, Type<A1>()),
-                        from_python(a2, Type<A2>()),
-                        from_python(a3, Type<A3>()),
-                        from_python(a4, Type<A4>()),
-                        from_python(a5, Type<A5>()),
-                        from_python(a6, Type<A6>()),
-                        from_python(a7, Type<A7>()),
-                        from_python(a8, Type<A8>()),
-                        from_python(a9, Type<A9>()),
-                        from_python(a10, Type<A10>()));
+        T& target = from_python(self, type<T&>());
+        (target.*pmf)(from_python(a1, type<A1>()),
+                        from_python(a2, type<A2>()),
+                        from_python(a3, type<A3>()),
+                        from_python(a4, type<A4>()),
+                        from_python(a5, type<A5>()),
+                        from_python(a6, type<A6>()),
+                        from_python(a7, type<A7>()),
+                        from_python(a8, type<A8>()),
+                        from_python(a9, type<A9>()),
+                        from_python(a10, type<A10>()));
         return detail::none();
     }
 
@@ -1068,7 +1068,7 @@ struct Caller<void>
         PyObject* a1;
         if (!PyArg_ParseTuple(args, const_cast<char*>("O"), &a1))
             return 0;
-        f(from_python(a1, Type<A1>()));
+        f(from_python(a1, type<A1>()));
         return detail::none();
     }
 
@@ -1078,8 +1078,8 @@ struct Caller<void>
         PyObject* a2;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OO"), &a1, &a2))
             return 0;
-        f(from_python(a1, Type<A1>()),
-                        from_python(a2, Type<A2>()));
+        f(from_python(a1, type<A1>()),
+                        from_python(a2, type<A2>()));
         return detail::none();
     }
 
@@ -1090,9 +1090,9 @@ struct Caller<void>
         PyObject* a3;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOO"), &a1, &a2, &a3))
             return 0;
-        f(from_python(a1, Type<A1>()),
-                        from_python(a2, Type<A2>()),
-                        from_python(a3, Type<A3>()));
+        f(from_python(a1, type<A1>()),
+                        from_python(a2, type<A2>()),
+                        from_python(a3, type<A3>()));
         return detail::none();
     }
 
@@ -1104,10 +1104,10 @@ struct Caller<void>
         PyObject* a4;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOO"), &a1, &a2, &a3, &a4))
             return 0;
-        f(from_python(a1, Type<A1>()),
-                        from_python(a2, Type<A2>()),
-                        from_python(a3, Type<A3>()),
-                        from_python(a4, Type<A4>()));
+        f(from_python(a1, type<A1>()),
+                        from_python(a2, type<A2>()),
+                        from_python(a3, type<A3>()),
+                        from_python(a4, type<A4>()));
         return detail::none();
     }
 
@@ -1120,11 +1120,11 @@ struct Caller<void>
         PyObject* a5;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOO"), &a1, &a2, &a3, &a4, &a5))
             return 0;
-        f(from_python(a1, Type<A1>()),
-                        from_python(a2, Type<A2>()),
-                        from_python(a3, Type<A3>()),
-                        from_python(a4, Type<A4>()),
-                        from_python(a5, Type<A5>()));
+        f(from_python(a1, type<A1>()),
+                        from_python(a2, type<A2>()),
+                        from_python(a3, type<A3>()),
+                        from_python(a4, type<A4>()),
+                        from_python(a5, type<A5>()));
         return detail::none();
     }
 
@@ -1138,12 +1138,12 @@ struct Caller<void>
         PyObject* a6;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOO"), &a1, &a2, &a3, &a4, &a5, &a6))
             return 0;
-        f(from_python(a1, Type<A1>()),
-                        from_python(a2, Type<A2>()),
-                        from_python(a3, Type<A3>()),
-                        from_python(a4, Type<A4>()),
-                        from_python(a5, Type<A5>()),
-                        from_python(a6, Type<A6>()));
+        f(from_python(a1, type<A1>()),
+                        from_python(a2, type<A2>()),
+                        from_python(a3, type<A3>()),
+                        from_python(a4, type<A4>()),
+                        from_python(a5, type<A5>()),
+                        from_python(a6, type<A6>()));
         return detail::none();
     }
 
@@ -1158,13 +1158,13 @@ struct Caller<void>
         PyObject* a7;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOO"), &a1, &a2, &a3, &a4, &a5, &a6, &a7))
             return 0;
-        f(from_python(a1, Type<A1>()),
-                        from_python(a2, Type<A2>()),
-                        from_python(a3, Type<A3>()),
-                        from_python(a4, Type<A4>()),
-                        from_python(a5, Type<A5>()),
-                        from_python(a6, Type<A6>()),
-                        from_python(a7, Type<A7>()));
+        f(from_python(a1, type<A1>()),
+                        from_python(a2, type<A2>()),
+                        from_python(a3, type<A3>()),
+                        from_python(a4, type<A4>()),
+                        from_python(a5, type<A5>()),
+                        from_python(a6, type<A6>()),
+                        from_python(a7, type<A7>()));
         return detail::none();
     }
 
@@ -1180,14 +1180,14 @@ struct Caller<void>
         PyObject* a8;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOO"), &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8))
             return 0;
-        f(from_python(a1, Type<A1>()),
-                        from_python(a2, Type<A2>()),
-                        from_python(a3, Type<A3>()),
-                        from_python(a4, Type<A4>()),
-                        from_python(a5, Type<A5>()),
-                        from_python(a6, Type<A6>()),
-                        from_python(a7, Type<A7>()),
-                        from_python(a8, Type<A8>()));
+        f(from_python(a1, type<A1>()),
+                        from_python(a2, type<A2>()),
+                        from_python(a3, type<A3>()),
+                        from_python(a4, type<A4>()),
+                        from_python(a5, type<A5>()),
+                        from_python(a6, type<A6>()),
+                        from_python(a7, type<A7>()),
+                        from_python(a8, type<A8>()));
         return detail::none();
     }
 
@@ -1204,15 +1204,15 @@ struct Caller<void>
         PyObject* a9;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOOO"), &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9))
             return 0;
-        f(from_python(a1, Type<A1>()),
-                        from_python(a2, Type<A2>()),
-                        from_python(a3, Type<A3>()),
-                        from_python(a4, Type<A4>()),
-                        from_python(a5, Type<A5>()),
-                        from_python(a6, Type<A6>()),
-                        from_python(a7, Type<A7>()),
-                        from_python(a8, Type<A8>()),
-                        from_python(a9, Type<A9>()));
+        f(from_python(a1, type<A1>()),
+                        from_python(a2, type<A2>()),
+                        from_python(a3, type<A3>()),
+                        from_python(a4, type<A4>()),
+                        from_python(a5, type<A5>()),
+                        from_python(a6, type<A6>()),
+                        from_python(a7, type<A7>()),
+                        from_python(a8, type<A8>()),
+                        from_python(a9, type<A9>()));
         return detail::none();
     }
 
@@ -1230,16 +1230,16 @@ struct Caller<void>
         PyObject* a10;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOOOO"), &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9, &a10))
             return 0;
-        f(from_python(a1, Type<A1>()),
-                        from_python(a2, Type<A2>()),
-                        from_python(a3, Type<A3>()),
-                        from_python(a4, Type<A4>()),
-                        from_python(a5, Type<A5>()),
-                        from_python(a6, Type<A6>()),
-                        from_python(a7, Type<A7>()),
-                        from_python(a8, Type<A8>()),
-                        from_python(a9, Type<A9>()),
-                        from_python(a10, Type<A10>()));
+        f(from_python(a1, type<A1>()),
+                        from_python(a2, type<A2>()),
+                        from_python(a3, type<A3>()),
+                        from_python(a4, type<A4>()),
+                        from_python(a5, type<A5>()),
+                        from_python(a6, type<A6>()),
+                        from_python(a7, type<A7>()),
+                        from_python(a8, type<A8>()),
+                        from_python(a9, type<A9>()),
+                        from_python(a10, type<A10>()));
         return detail::none();
     }
 
@@ -1258,17 +1258,17 @@ struct Caller<void>
         PyObject* a11;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOOOOO"), &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9, &a10, &a11))
             return 0;
-        f(from_python(a1, Type<A1>()),
-                        from_python(a2, Type<A2>()),
-                        from_python(a3, Type<A3>()),
-                        from_python(a4, Type<A4>()),
-                        from_python(a5, Type<A5>()),
-                        from_python(a6, Type<A6>()),
-                        from_python(a7, Type<A7>()),
-                        from_python(a8, Type<A8>()),
-                        from_python(a9, Type<A9>()),
-                        from_python(a10, Type<A10>()),
-                        from_python(a11, Type<A11>()));
+        f(from_python(a1, type<A1>()),
+                        from_python(a2, type<A2>()),
+                        from_python(a3, type<A3>()),
+                        from_python(a4, type<A4>()),
+                        from_python(a5, type<A5>()),
+                        from_python(a6, type<A6>()),
+                        from_python(a7, type<A7>()),
+                        from_python(a8, type<A8>()),
+                        from_python(a9, type<A9>()),
+                        from_python(a10, type<A10>()),
+                        from_python(a11, type<A11>()));
         return detail::none();
     }
 
diff --git a/cast.h b/cast.h
index 93e95215..c5a59ade 100644
--- a/cast.h
+++ b/cast.h
@@ -12,12 +12,12 @@
 # include "wrap_python.h"
 # include <boost/operators.hpp>
 
-namespace py {
+namespace python {
 
 namespace detail {
   // The default way of converting a PyObject* or PyTypeObject* to a T*
   template <class T>
-  struct DowncastTraits
+  struct downcast_traits
   {
       template <class U>
       static T* cast(U* p) { return static_cast<T*>(p); }
@@ -51,22 +51,22 @@ inline PyObject* as_object(PyTypeObject* p) { return reinterpret_cast<PyObject*>
 // If I didn't have to support stupid MSVC6 we could just use a simple template function:
 // template <class T> T* downcast(PyObject*).
 template <class T>
-struct Downcast : boost::dereferenceable<Downcast<T>, T*>
+struct downcast : boost::dereferenceable<downcast<T>, T*>
 {
-    Downcast(PyObject* p)
-        : m_p(detail::DowncastTraits<T>::cast(detail::as_base_object((T*)0, p)))
+    downcast(PyObject* p)
+        : m_p(detail::downcast_traits<T>::cast(detail::as_base_object((T*)0, p)))
         {}
     
-    Downcast(const PyObject* p)
-        : m_p(detail::DowncastTraits<T>::cast(detail::as_base_object((const T*)0, p)))
+    downcast(const PyObject* p)
+        : m_p(detail::downcast_traits<T>::cast(detail::as_base_object((const T*)0, p)))
         {}
     
-    Downcast(PyTypeObject* p)
-        : m_p(detail::DowncastTraits<T>::cast(p))
+    downcast(PyTypeObject* p)
+        : m_p(detail::downcast_traits<T>::cast(p))
         {}
     
-    Downcast(const PyTypeObject* p)
-        : m_p(detail::DowncastTraits<T>::cast(p))
+    downcast(const PyTypeObject* p)
+        : m_p(detail::downcast_traits<T>::cast(p))
         {}
     
     operator T*() const { return m_p; }
@@ -76,6 +76,6 @@ struct Downcast : boost::dereferenceable<Downcast<T>, T*>
     T* m_p;
 };
 
-} // namespace py
+} // namespace python
 
 #endif // CAST_DWA052500_H_
diff --git a/class_wrapper.h b/class_wrapper.h
index f7955729..f006aa50 100644
--- a/class_wrapper.h
+++ b/class_wrapper.h
@@ -8,45 +8,45 @@
 #include "cast.h"
 #include "pyptr.h"
 
-namespace py {
+namespace python {
 
 // Syntactic sugar to make wrapping classes more convenient
-template <class T, class U = detail::HeldInstance<T> >
-class ClassWrapper
+template <class T, class U = detail::held_instance<T> >
+class class_builder
     : PyExtensionClassConverters<T, U> // Works around MSVC6.x/GCC2.95.2 bug described below
 {
  public:
-    ClassWrapper(Module& module, const char* name)
-        : m_class(new detail::ExtensionClass<T, U>(name))
+    class_builder(module_builder& module, const char* name)
+        : m_class(new detail::extension_class<T, U>(name))
     {
-        module.add(Ptr(as_object(m_class.get()), Ptr::new_ref), name);
+        module.add(ref(as_object(m_class.get()), ref::increment_count), name);
     }
     
-    ~ClassWrapper()
+    ~class_builder()
     {}
     
     // define constructors
-    template <class Signature>
-    void def(const Signature& signature)
+    template <class signature>
+    void def(const signature& signature)
         { m_class->def(signature); }
 
     // export heterogeneous reverse-argument operators 
     // (type of lhs: 'left', of rhs: 'right')
-    // usage:  foo_class.def(py::operators<(py::op_add | py::op_sub), Foo>(),
-    //                       py::left_operand<int const &>());
+    // usage:  foo_class.def(python::operators<(python::op_add | python::op_sub), Foo>(),
+    //                       python::left_operand<int const &>());
     template <long which, class left, class right>
     void def(operators<which, right> o1, left_operand<left> o2)
         { m_class->def(o1, o2); }
 
     // export heterogeneous operators (type of lhs: 'left', of rhs: 'right')
-    // usage:  foo_class.def(py::operators<(py::op_add | py::op_sub), Foo>(),
-    //                       py::right_operand<int const &>());
+    // usage:  foo_class.def(python::operators<(python::op_add | python::op_sub), Foo>(),
+    //                       python::right_operand<int const &>());
     template <long which, class left, class right>
     void def(operators<which, left> o1, right_operand<right> o2)
         { m_class->def(o1, o2); }
 
     // define a function that passes Python arguments and keywords
-    // to C++ verbatim (as a 'Tuple const &' and 'Dict const &' 
+    // to C++ verbatim (as a 'tuple const &' and 'dictionary const &' 
     // respectively). This is useful for manual argument passing.
     // It's also the only possibility to pass keyword arguments to C++.
     // Fn must have a signatur that is compatible to 
@@ -71,23 +71,23 @@ class ClassWrapper
         { m_class->def(fn, name, default_fn); }
 
     // Provide a function which implements x.<name>, reading from the given
-    // member (pm) of the T instance
+    // member (pm) of the T obj
     template <class MemberType>
     void def_getter(MemberType T::*pm, const char* name)
         { m_class->def_getter(pm, name); }
     
     // Provide a function which implements assignment to x.<name>, writing to
-    // the given member (pm) of the T instance
+    // the given member (pm) of the T obj
     template <class MemberType>
     void def_setter(MemberType T::*pm, const char* name)
         { m_class->def_getter(pm, name); }
     
-    // Expose the given member (pm) of the T instance as a read-only attribute
+    // Expose the given member (pm) of the T obj as a read-only attribute
     template <class MemberType>
     void def_readonly(MemberType T::*pm, const char* name)
         { m_class->def_readonly(pm, name); }
     
-    // Expose the given member (pm) of the T instance as a read/write attribute
+    // Expose the given member (pm) of the T obj as a read/write attribute
     template <class MemberType>
     void def_read_write(MemberType T::*pm, const char* name)
         { m_class->def_read_write(pm, name); }
@@ -99,7 +99,7 @@ class ClassWrapper
     // declare the given class a base class of this one and register 
     // conversion functions
     template <class S, class V>
-    void declare_base(ClassWrapper<S, V> const & base)
+    void declare_base(class_builder<S, V> const & base)
     {
         m_class->declare_base(base.get_extension_class());
     }
@@ -107,13 +107,13 @@ class ClassWrapper
     // declare the given class a base class of this one and register 
     // upcast conversion function
     template <class S, class V>
-    void declare_base(ClassWrapper<S, V> const & base, WithoutDowncast)
+    void declare_base(class_builder<S, V> const & base, without_downcast_t)
     {
         m_class->declare_base(base.get_extension_class(), without_downcast);
     }
 
     // get the embedded ExtensioClass object
-    detail::ExtensionClass<T, U> * get_extension_class() const 
+    detail::extension_class<T, U> * get_extension_class() const 
     {
         return m_class.get();
     }
@@ -122,13 +122,13 @@ class ClassWrapper
     // e.g. enums
     void add(PyObject* x, const char* name)
         { m_class->set_attribute(name, x); }
-    void add(Ptr x, const char* name)
+    void add(ref x, const char* name)
         { m_class->set_attribute(name, x); }
  private:
     // declare the given class a base class of this one and register 
     // conversion functions
     template <class S, class V>
-    void declare_base(detail::ExtensionClass<S, V> * base)
+    void declare_base(detail::extension_class<S, V> * base)
     {
         m_class->declare_base(base);
     }
@@ -136,12 +136,12 @@ class ClassWrapper
     // declare the given class a base class of this one and register 
     // upcast conversion function
     template <class S, class V>
-    void declare_base(detail::ExtensionClass<S, V> * base, WithoutDowncast)
+    void declare_base(detail::extension_class<S, V> * base, without_downcast_t)
     {
         m_class->declare_base(base, without_downcast);
     }
     
-    PyPtr<detail::ExtensionClass<T, U> > m_class;
+    reference<detail::extension_class<T, U> > m_class;
 };
 
 // The bug mentioned at the top of this file is that on certain compilers static
diff --git a/comparisons.html b/comparisons.html
index 70143db3..84cda747 100644
--- a/comparisons.html
+++ b/comparisons.html
@@ -31,7 +31,7 @@
         with the C++ Standard Library (a.k.a. STL) by providing iterators into
         Python Lists and Dictionaries, but the claim is unfortunately
         unsupportable. The problem is that in general, access to Python sequence and
-        mapping elements through iterators requires the use of Proxy objects as
+        mapping elements through iterators requires the use of proxy objects as
         the return value of iterator dereference operations. This usage
         conflicts with the basic ForwardIterator requirements in <a
         href="http://anubis.dkuug.dk/jtc1/sc22/open/n2356/lib-iterators.html#lib.forward.iterators">
diff --git a/doctest.py b/doctest.py
index 892f2ab5..248da82a 100644
--- a/doctest.py
+++ b/doctest.py
@@ -4,7 +4,7 @@
 
 # Provided as-is; use at your own risk; no warranty; no promises; enjoy!
 
-"""Module doctest -- a framework for running examples in docstrings.
+"""module_builder doctest -- a framework for running examples in docstrings.
 
 NORMAL USAGE
 
@@ -20,7 +20,7 @@ if __name__ == "__main__":
 Then running the module as a script will cause the examples in the
 docstrings to get executed and verified:
 
-python M.py
+python M.python
 
 This won't display anything unless an example fails, in which case
 the failing example(s) and the cause(s) of the failure(s) are printed
@@ -29,7 +29,7 @@ and the final line of output is "Test failed.".
 
 Run it with the -v switch instead:
 
-python M.py -v
+python M.python -v
 
 and a detailed report of all examples tried is printed to stdout, along
 with assorted summaries at the end.
@@ -55,7 +55,7 @@ WHICH DOCSTRINGS ARE EXAMINED?
 
 + If M.__test__ exists and "is true", it must be a dict, and
   each entry maps a (string) name to a function object, class object, or
-  string.  Function and class object docstrings found from M.__test__
+  string.  function and class object docstrings found from M.__test__
   are searched even if the name is private, and strings are searched
   directly as if they were docstrings.  In output, a key K in M.__test__
   appears with name
@@ -74,7 +74,7 @@ by passing your own "isprivate" function to testmod.
 If you want to test docstrings in objects with private names too, stuff
 them into an M.__test__ dict, or see ADVANCED USAGE below (e.g., pass your
 own isprivate function to Tester's constructor, or call the rundoc method
-of a Tester instance).
+of a Tester obj).
 
 Warning:  imports can cause trouble; e.g., if you do
 
@@ -112,7 +112,7 @@ of M.__dict__ merged with the globals from other imported modules.
 WHAT IF I WANT TO TEST A WHOLE PACKAGE?
 
 Piece o' cake, provided the modules do their testing from docstrings.
-Here's the test.py I use for the world's most elaborate Rational/
+Here's the test.python I use for the world's most elaborate Rational/
 floating-base-conversion pkg (which I'll distribute some day):
 
 from Rational import Cvt
@@ -172,9 +172,9 @@ ADVANCED USAGE
 doctest.testmod() captures the testing policy I find most useful most
 often.  You may want other policies.
 
-testmod() actually creates a local instance of class doctest.Tester,
+testmod() actually creates a local obj of class doctest.Tester,
 runs appropriate methods of that class, and merges the results into
-global Tester instance doctest.master.
+global Tester obj doctest.master.
 
 You can create your own instances of doctest.Tester, and so build your
 own policies, or even run methods of doctest.master directly.  See
@@ -326,7 +326,7 @@ Test passed.
 #        function
 #    by default a name now considered to be private iff it begins with
 #        an underscore but doesn't both begin & end with two of 'em; so
-#        e.g. Class.__init__ etc are searched now -- as they always
+#        e.g. class_t.__init__ etc are searched now -- as they always
 #        should have been
 # 0,9,3    18-Mar-1999
 #    added .flush stub to _SpoofOut (JPython buglet diagnosed by
@@ -472,7 +472,7 @@ def _tag_out(printer, *tag_msg_pairs):
             printer("\n")
 
 # Run list of examples, in context globs.  "out" can be used to display
-# stuff to "the real" stdout, and fakeout is an instance of _SpoofOut
+# stuff to "the real" stdout, and fakeout is an obj of _SpoofOut
 # that captures the examples' std output.  Return (#failures, #tries).
 
 def _run_examples_inner(out, fakeout, examples, globs, verbose, name):
@@ -592,7 +592,7 @@ def is_private(prefix, base):
     return base[:1] == "_" and not base[:2] == "__" == base[-2:]
 
 class Tester:
-    """Class Tester -- runs docstring examples and accumulates stats.
+    """class_t Tester -- runs docstring examples and accumulates stats.
 
 In normal use, function doctest.testmod() hides all this from you,
 so use that if you can.  Create your own instances of Tester to do
@@ -619,7 +619,7 @@ Methods:
         (#failures, #tries).
 
     merge(other)
-        Merge in the test results from Tester instance "other".
+        Merge in the test results from Tester obj "other".
 
 >>> from doctest import Tester
 >>> t = Tester(globs={'x': 42}, verbose=0)
@@ -900,7 +900,7 @@ see its docs for details.
 
     def merge(self, other):
         """
-        other -> merge in test results from the other Tester instance.
+        other -> merge in test results from the other Tester obj.
 
         If self and other both have a test result for something
         with the same name, the (#failures, #tests) results are
@@ -1007,9 +1007,9 @@ def testmod(m=None, name=None, globs=None, verbose=None, isprivate=None,
     else prints nothing at the end.  In verbose mode, the summary is
     detailed, else very brief (in fact, empty if all tests passed).
 
-    Advanced tomfoolery:  testmod runs methods of a local instance of
+    Advanced tomfoolery:  testmod runs methods of a local obj of
     class doctest.Tester, then merges the results into (or creates)
-    global Tester instance doctest.master.  Methods of doctest.master
+    global Tester obj doctest.master.  Methods of doctest.master
     can be called directly too, if you want to do something  unusual.
     Passing report=0 to testmod is especially useful then, to delay
     displaying a summary.  Invoke doctest.master.summarize(verbose)
diff --git a/enums.html b/enums.html
index 77bfea6a..44274df0 100644
--- a/enums.html
+++ b/enums.html
@@ -17,22 +17,22 @@ you can write some simple <code>from_python()</code> and
 
 <p>If you are satisfied with a Python int as a way to represent your enum
 values, py_cpp provides a shorthand for these functions. You just need to
-instantiate <code>py::enum_as_int_converters&lt;EnumType&gt;</code> where
+instantiate <code>python::enum_as_int_converters&lt;EnumType&gt;</code> where
 <code>EnumType</code> is your enumerated type. There are two convenient ways to do this:
 
 <ol>
 <li><blockquote>
 <pre>
-// drop into namespace py and explicitly instantiate
-namespace py {
+// drop into namespace python and explicitly instantiate
+BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE // this is a gcc 2.95.2 bug workaround
   template class enum_as_int_converters<extclass_demo::EnumOwner::enum_type>;
-}
+BOOST_PYTHON_END_CONVERSION_NAMESPACE
 </pre>
 </blockquote>
 <li><blockquote><pre>
 // instantiate as base class in any namespace
 struct EnumTypeConverters
-    : py::py_enum_as_int_converters<EnumType>
+    : python::py_enum_as_int_converters<EnumType>
 {
 };
 </blockquote></pre>
@@ -40,25 +40,25 @@ struct EnumTypeConverters
 
 <p>Either of the above is equivalent to the following declarations:
 <blockquote><pre>
-PY_BEGIN_CONVERSION_NAMESPACE // this is a gcc 2.95.2 bug workaround
+BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE // this is a gcc 2.95.2 bug workaround
 
-  MyEnumType from_python(PyObject* x, py::Type&lt;MyEnumType&gt;)
+  MyEnumType from_python(PyObject* x, python::type&lt;MyEnumType&gt;)
   {
       return static_cast&lt;MyEnum&gt;(
-        from_python(x, py::Type&lt;long&gt;()));
+        from_python(x, python::type&lt;long&gt;()));
   }
 
-  MyEnumType from_python(PyObject* x, py::Type&lt;const MyEnumType&amp;&gt;)
+  MyEnumType from_python(PyObject* x, python::type&lt;const MyEnumType&amp;&gt;)
   {
       return static_cast&lt;MyEnum&gt;(
-        from_python(x, py::Type&lt;long&gt;()));
+        from_python(x, python::type&lt;long&gt;()));
   }
 
   PyObject* to_python(MyEnumType x)
   {
       return to_python(static_cast&lt;long&gt;(x));
   }
-PY_END_CONVERSION_NAMESPACE
+BOOST_PYTHON_END_CONVERSION_NAMESPACE
 </pre></blockquote>
 
 <p>This technique defines the conversions of
@@ -69,8 +69,8 @@ You may also want to add a bunch of lines like this to your module
 initialization:
 
 <blockquote><pre>
-mymodule.add(py::to_python(enum_value_1), "enum_value_1");
-mymodule.add(py::to_python(enum_value_2), "enum_value_2");
+mymodule.add(python::to_python(enum_value_1), "enum_value_1");
+mymodule.add(python::to_python(enum_value_2), "enum_value_2");
 ...
 </pre></blockquote>
 
@@ -78,8 +78,8 @@ You can also add these to an extension class definition, if your enum happens to
 be local to a class and you want the analogous interface in Python:
 
 <blockquote><pre>
-my_class.add(py::to_python(enum_value_1), "enum_value_1");
-my_class.add(py::to_python(enum_value_2), "enum_value_2");
+my_class.add(python::to_python(enum_value_1), "enum_value_1");
+my_class.add(python::to_python(enum_value_2), "enum_value_2");
 ...
 </pre></blockquote>
       <p>
diff --git a/errors.h b/errors.h
index 8dee0fd0..cd4b6837 100644
--- a/errors.h
+++ b/errors.h
@@ -9,10 +9,10 @@
 #ifndef ERRORS_DWA052500_H_
 # define ERRORS_DWA052500_H_
 
-namespace py {
+namespace python {
 
-struct ErrorAlreadySet {};
-struct ArgumentError : ErrorAlreadySet {};
+struct error_already_set {};
+struct argument_error : error_already_set {};
 
 // Handles exceptions caught just before returning to Python code.
 void handle_exception();
@@ -21,10 +21,10 @@ template <class T>
 T* expect_non_null(T* x)
 {
     if (x == 0)
-        throw ErrorAlreadySet();
+        throw error_already_set();
     return x;
 }
 
-} // namespace py
+} // namespace python
 
 #endif // ERRORS_DWA052500_H_
diff --git a/example1.cpp b/example1.cpp
index 11f8f683..17098208 100644
--- a/example1.cpp
+++ b/example1.cpp
@@ -25,13 +25,13 @@ void inithello()
     try
     {
        // create an object representing this extension module
-       py::Module hello("hello");
+       python::module_builder hello("hello");
 
        // Create the Python type object for our extension class
-       py::ClassWrapper<hello::world> world_class(hello, "world");
+       python::class_builder<hello::world> world_class(hello, "world");
 
        // Add the __init__ function
-       world_class.def(py::Constructor<int>());
+       world_class.def(python::constructor<int>());
        // Add a regular member function
        world_class.def(&hello::world::get, "get");
 
@@ -40,7 +40,7 @@ void inithello()
     }
     catch(...)
     {
-       py::handle_exception();    // Deal with the exception for Python
+       python::handle_exception();    // Deal with the exception for Python
     }
 }
 
diff --git a/example1.html b/example1.html
index 3eaf87c5..5ee59a03 100644
--- a/example1.html
+++ b/example1.html
@@ -47,11 +47,11 @@ void inithello()
     try
     {
        // create an object representing this extension module
-       py::Module hello("hello");
+       python::module_builder hello("hello");
        // Create the Python type object for our extension class
-       py::ClassWrapper&lt;hello::world&gt; world_class(hello, "world");
+       python::class_builder&lt;hello::world&gt; world_class(hello, "world");
        // Add the __init__ function
-       world_class.def(py::Constructor&lt;int&gt;());
+       world_class.def(python::constructor&lt;int&gt;());
        // Add a regular member function
        world_class.def(&amp;hello::world::get, "get");
        // Add a regular function to the module
@@ -59,7 +59,7 @@ void inithello()
     }
     catch(...)
     {
-       py::handle_exception();    // Deal with the exception for Python
+       python::handle_exception();    // Deal with the exception for Python
     }
 }
 // Win32 DLL boilerplate
diff --git a/extclass.cpp b/extclass.cpp
index b76853b6..94d9bf68 100644
--- a/extclass.cpp
+++ b/extclass.cpp
@@ -10,19 +10,19 @@
 #include <cstring>
 #include <boost/utility.hpp>
 
-namespace py {
+namespace python {
 namespace detail {
 
   struct operator_dispatcher
       : public PyObject
   {
-      static PyTypeObject type_object;
+      static PyTypeObject type_obj;
       static PyNumberMethods number_methods;
 
-      static operator_dispatcher* create(const Ptr& o, const Ptr& s);     
+      static operator_dispatcher* create(const ref& o, const ref& s);     
       
-      Ptr m_object;
-      Ptr m_self;
+      ref m_object;
+      ref m_self;
 
       // data members for allocation/deallocation optimization
       operator_dispatcher* m_free_list_link;
@@ -30,55 +30,55 @@ namespace detail {
 
   private: 
       // only accessible through create()
-      operator_dispatcher(const Ptr& o, const Ptr& s);
+      operator_dispatcher(const ref& o, const ref& s);
   };
   
   operator_dispatcher* operator_dispatcher::free_list = 0;
 
 }}
 
-PY_BEGIN_CONVERSION_NAMESPACE
+BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
 
-inline PyObject* to_python(py::detail::operator_dispatcher* n) { return n; }
+inline PyObject* to_python(python::detail::operator_dispatcher* n) { return n; }
 
-PY_END_CONVERSION_NAMESPACE
+BOOST_PYTHON_END_CONVERSION_NAMESPACE
 
 
-namespace py{ 
+namespace python{ 
 
 namespace detail {
 
-  Tuple extension_class_coerce(Ptr l, Ptr r)
+  tuple extension_class_coerce(ref l, ref r)
   {
       // Introduced sequence points for exception-safety.
-      Ptr first(operator_dispatcher::create(l, l));
-      Ptr second;
+      ref first(operator_dispatcher::create(l, l));
+      ref second;
       
-      if(r->ob_type == &operator_dispatcher::type_object)
+      if(r->ob_type == &operator_dispatcher::type_obj)
       {
            second = r;
       }
       else
       {
-           second = Ptr(operator_dispatcher::create(r, Ptr()));
+           second = ref(operator_dispatcher::create(r, ref()));
       }
-      return py::Tuple(first, second);
+      return python::tuple(first, second);
   }
 
   enum { unwrap_exception_code = -1000 };
 
   int unwrap_args(PyObject* left, PyObject* right, PyObject*& self, PyObject*& other)
   {
-      if (left->ob_type != &operator_dispatcher::type_object ||
-          right->ob_type != &operator_dispatcher::type_object)
+      if (left->ob_type != &operator_dispatcher::type_obj ||
+          right->ob_type != &operator_dispatcher::type_obj)
       {
           PyErr_SetString(PyExc_RuntimeError, "operator_dispatcher::unwrap_args(): expecting operator_dispatcher arguments only!");
           return unwrap_exception_code;
       }
 
-      typedef PyPtr<operator_dispatcher> DPtr;
-      DPtr lwrapper(static_cast<operator_dispatcher*>(left), DPtr::new_ref);
-      DPtr rwrapper(static_cast<operator_dispatcher*>(right), DPtr::new_ref);
+      typedef reference<operator_dispatcher> DPtr;
+      DPtr lwrapper(static_cast<operator_dispatcher*>(left), DPtr::increment_count);
+      DPtr rwrapper(static_cast<operator_dispatcher*>(right), DPtr::increment_count);
       
       if (lwrapper->m_self.get() != 0)
       {
@@ -97,18 +97,18 @@ namespace detail {
   int unwrap_pow_args(PyObject* left, PyObject* right, PyObject* m,
                                   PyObject*& self, PyObject*& first, PyObject*& second)
   {
-      if (left->ob_type != &operator_dispatcher::type_object ||
-          right->ob_type != &operator_dispatcher::type_object ||
-          m->ob_type != &operator_dispatcher::type_object)
+      if (left->ob_type != &operator_dispatcher::type_obj ||
+          right->ob_type != &operator_dispatcher::type_obj ||
+          m->ob_type != &operator_dispatcher::type_obj)
       {
           PyErr_SetString(PyExc_RuntimeError, "operator_dispatcher::unwrap_pow_args(): expecting operator_dispatcher arguments only!");
           return unwrap_exception_code;
       }
       
-      typedef PyPtr<operator_dispatcher> DPtr;
-      DPtr lwrapper(static_cast<operator_dispatcher*>(left), DPtr::new_ref);
-      DPtr rwrapper(static_cast<operator_dispatcher*>(right), DPtr::new_ref);
-      DPtr mwrapper(static_cast<operator_dispatcher*>(m), DPtr::new_ref);
+      typedef reference<operator_dispatcher> DPtr;
+      DPtr lwrapper(static_cast<operator_dispatcher*>(left), DPtr::increment_count);
+      DPtr rwrapper(static_cast<operator_dispatcher*>(right), DPtr::increment_count);
+      DPtr mwrapper(static_cast<operator_dispatcher*>(m), DPtr::increment_count);
       
       if (lwrapper->m_self.get() != 0)
       {
@@ -133,41 +133,41 @@ namespace detail {
       }
   }
 
-ExtensionInstance* get_extension_instance(PyObject* p)
+extension_instance* get_extension_instance(PyObject* p)
 {
-    // The object's type will just be some Class<ExtensionInstance> object,
-    // but if its meta-type is right, then it is an ExtensionInstance.
+    // The object's type will just be some class_t<extension_instance> object,
+    // but if its meta-type is right, then it is an extension_instance.
     if (p->ob_type->ob_type != extension_meta_class())
     {
         PyErr_SetString(PyExc_TypeError, p->ob_type->tp_name);
-        throw py::ArgumentError();
+        throw python::argument_error();
     }
-    return static_cast<ExtensionInstance*>(p);
+    return static_cast<extension_instance*>(p);
 }
 
 void
-ExtensionInstance::add_implementation(std::auto_ptr<InstanceHolderBase> holder)
+extension_instance::add_implementation(std::auto_ptr<instance_holder_base> holder)
 {
-    for (WrappedObjects::const_iterator p = m_wrapped_objects.begin();
+    for (held_objects::const_iterator p = m_wrapped_objects.begin();
          p != m_wrapped_objects.end(); ++p)
     {
         if (typeid(*holder) == typeid(**p))
         {
             PyErr_SetString(PyExc_RuntimeError, "Base class already initialized");
-            throw ErrorAlreadySet();
+            throw error_already_set();
         }
     }
     m_wrapped_objects.push_back(holder.release());
 }
 
-ExtensionInstance::ExtensionInstance(PyTypeObject* class_)
-    : Instance(class_)
+extension_instance::extension_instance(PyTypeObject* class_)
+    : instance(class_)
 {
 }
 
-ExtensionInstance::~ExtensionInstance()
+extension_instance::~extension_instance()
 {
-    for (WrappedObjects::const_iterator p = m_wrapped_objects.begin(),
+    for (held_objects::const_iterator p = m_wrapped_objects.begin(),
              finish = m_wrapped_objects.end();
          p != finish; ++p)
     {
@@ -175,19 +175,19 @@ ExtensionInstance::~ExtensionInstance()
     }
 }
     
-MetaClass<ExtensionInstance>* extension_meta_class()
+meta_class<extension_instance>* extension_meta_class()
 {
-    static MetaClass<ExtensionInstance> result;
+    static meta_class<extension_instance> result;
     return &result;
 }
 
-typedef Class<ExtensionInstance> ExtClass;
+typedef class_t<extension_instance> extension_class_t;
 
-bool is_subclass(const ExtClass* derived,
+bool is_subclass(const extension_class_t* derived,
                  const PyObject* possible_base)
 {
 
-    Tuple bases = derived->bases();
+    tuple bases = derived->bases();
     
     for (std::size_t i = 0, size = bases.size(); i < size; ++i)
     {
@@ -198,7 +198,7 @@ bool is_subclass(const ExtClass* derived,
         
         if (base->ob_type == extension_meta_class())
         {
-            const ExtClass* base_class = Downcast<const ExtClass>(base);
+            const extension_class_t* base_class = downcast<const extension_class_t>(base);
             if (is_subclass(base_class, possible_base))
                 return true;
         }
@@ -206,16 +206,16 @@ bool is_subclass(const ExtClass* derived,
     return false;
 }
 
-// Return true iff instance is an instance of target_class
-bool is_instance(ExtensionInstance* instance,
-                 Class<ExtensionInstance>* target_class)
+// Return true iff obj is an obj of target_class
+bool is_instance(extension_instance* obj,
+                 class_t<extension_instance>* target_class)
 {
-    if (instance->ob_type == target_class)
+    if (obj->ob_type == target_class)
         return true;
     else
     {
         return is_subclass(
-            Downcast<Class<ExtensionInstance> >(instance->ob_type).get(),
+            downcast<class_t<extension_instance> >(obj->ob_type).get(),
             as_object(target_class));
     }
 }
@@ -223,9 +223,9 @@ bool is_instance(ExtensionInstance* instance,
 void two_string_error(PyObject* exception_object, const char* format, const char* s1, const char* s2)
 {
     char buffer[256];
-    std::size_t format_length = PY_CSTD_::strlen(format);
-    std::size_t length1 = PY_CSTD_::strlen(s1);
-    std::size_t length2 = PY_CSTD_::strlen(s2);
+    std::size_t format_length = BOOST_CSTD_::strlen(format);
+    std::size_t length1 = BOOST_CSTD_::strlen(s1);
+    std::size_t length2 = BOOST_CSTD_::strlen(s2);
 
     std::size_t additional_length = length1 + length2;
     if (additional_length + format_length > format_length - 1)
@@ -239,29 +239,29 @@ void two_string_error(PyObject* exception_object, const char* format, const char
                 
     PyErr_SetString(exception_object, buffer);
     if (exception_object == PyExc_TypeError)
-        throw ArgumentError();
+        throw argument_error();
     else
-        throw ErrorAlreadySet();
+        throw error_already_set();
 }
 
-// This is called when an attempt has been made to convert the given instance to
-// a C++ type for which it doesn't have any instance data. In that case, either
-// the instance was not derived from the target_class, or the appropriate
-// __init__ function wasn't called to initialize the instance data of the target class.
+// This is called when an attempt has been made to convert the given obj to
+// a C++ type for which it doesn't have any obj data. In that case, either
+// the obj was not derived from the target_class, or the appropriate
+// __init__ function wasn't called to initialize the obj data of the target class.
 void report_missing_instance_data(
-    ExtensionInstance* instance,                // The object being converted
-    Class<ExtensionInstance>* target_class,     // the extension class of the C++ type
+    extension_instance* obj,                // The object being converted
+    class_t<extension_instance>* target_class,     // the extension class of the C++ type
     const std::type_info& target_typeid,        // The typeid of the C++ type
     bool target_is_ptr)
 {
     char buffer[256];
-    if (is_instance(instance, target_class))
+    if (is_instance(obj, target_class))
     {
         if (target_is_ptr)
         {
             two_string_error(PyExc_RuntimeError,
                              "Object of extension class '%.*s' does not wrap <%.*s>.",
-                             instance->ob_type->tp_name, target_typeid.name());
+                             obj->ob_type->tp_name, target_typeid.name());
         }
         else
         {
@@ -280,24 +280,24 @@ void report_missing_instance_data(
     else    
     {
         two_string_error(PyExc_TypeError, "extension class '%.*s' is not convertible into '%.*s'.",
-                         instance->ob_type->tp_name, target_class->tp_name);
+                         obj->ob_type->tp_name, target_class->tp_name);
     }
 }
 
 void report_missing_instance_data(
-    ExtensionInstance* instance,                // The object being converted
-    Class<ExtensionInstance>* target_class,     // the extension class of the C++ type
+    extension_instance* obj,                // The object being converted
+    class_t<extension_instance>* target_class,     // the extension class of the C++ type
     const std::type_info& target_typeid)        // The typeid of the C++ type
 {
-    report_missing_instance_data(instance, target_class, target_typeid, false);
+    report_missing_instance_data(obj, target_class, target_typeid, false);
 }
 
 void report_missing_ptr_data(
-    ExtensionInstance* instance,                // The object being converted
-    Class<ExtensionInstance>* target_class,     // the extension class of the C++ type
+    extension_instance* obj,                // The object being converted
+    class_t<extension_instance>* target_class,     // the extension class of the C++ type
     const std::type_info& target_typeid)        // The typeid of the C++ type
 {
-    report_missing_instance_data(instance, target_class, target_typeid, true);
+    report_missing_instance_data(obj, target_class, target_typeid, true);
 }
 
 void report_missing_class_object(const std::type_info& info)
@@ -306,7 +306,7 @@ void report_missing_class_object(const std::type_info& info)
     const char message[] = "Cannot convert <%.*s> to python; its Python class was never created or has been deleted.";
     sprintf(buffer, message, sizeof(buffer) - sizeof(message) - 1, info.name());
     PyErr_SetString(PyExc_RuntimeError, buffer);
-    throw ErrorAlreadySet();
+    throw error_already_set();
 }
 
 void report_released_smart_pointer(const std::type_info& info)
@@ -315,28 +315,28 @@ void report_released_smart_pointer(const std::type_info& info)
     const char message[] = "Converting from python, pointer or smart pointer to <%.*s> is NULL.";
     sprintf(buffer, message, sizeof(buffer) - sizeof(message) - 1, info.name());
     PyErr_SetString(PyExc_RuntimeError, buffer);
-    throw ArgumentError();
+    throw argument_error();
 }
 
-ReadOnlySetattrFunction::ReadOnlySetattrFunction(const char* name)
+read_only_setattr_function::read_only_setattr_function(const char* name)
     : m_name(name)
 {
 }
 
-PyObject* ReadOnlySetattrFunction::do_call(PyObject* /*args*/, PyObject* /*keywords*/) const
+PyObject* read_only_setattr_function::do_call(PyObject* /*args*/, PyObject* /*keywords*/) const
 {
     PyErr_SetObject(PyExc_AttributeError, ("'" + m_name + "' attribute is read-only").get());
     return 0;
 }
 
-const char* ReadOnlySetattrFunction::description() const
+const char* read_only_setattr_function::description() const
 {
     return "uncallable";
 }
 
-ExtensionClassBase::ExtensionClassBase(const char* name)
-    : Class<ExtensionInstance>(
-        extension_meta_class(), String(name), Tuple(), Dict())
+extension_class_base::extension_class_base(const char* name)
+    : class_t<extension_instance>(
+        extension_meta_class(), string(name), tuple(), dictionary())
 {
 }
 
@@ -356,10 +356,10 @@ ExtensionClassBase::ExtensionClassBase(const char* name)
 //  conversion functions will return a NULL pointer.
 
 //  The function extract_object_from_holder() attempts to actually extract the pointer 
-//  to the contained object from an InstanceHolderBase (a wrapper class). A conversion
+//  to the contained object from an instance_holder_base (a wrapper class). A conversion
 //  of the held object to 'T *' is allowed when the conversion 
-//  'dynamic_cast<InstanceHolder<T> *>(an_instance_holder_base)' succeeds.
-void* ExtensionClassBase::try_class_conversions(InstanceHolderBase* object) const
+//  'dynamic_cast<instance_holder<T> *>(an_instance_holder_base)' succeeds.
+void* extension_class_base::try_class_conversions(instance_holder_base* object) const
 {
     void* result = try_derived_class_conversions(object);
     if (result) 
@@ -371,7 +371,7 @@ void* ExtensionClassBase::try_class_conversions(InstanceHolderBase* object) cons
         return 0;
 }
 
-void* ExtensionClassBase::try_base_class_conversions(InstanceHolderBase* object) const
+void* extension_class_base::try_base_class_conversions(instance_holder_base* object) const
 {
     for (std::size_t i = 0; i < base_classes().size(); ++i)
     {
@@ -388,7 +388,7 @@ void* ExtensionClassBase::try_base_class_conversions(InstanceHolderBase* object)
     return 0;
 }
 
-void* ExtensionClassBase::try_derived_class_conversions(InstanceHolderBase* object) const
+void* extension_class_base::try_derived_class_conversions(instance_holder_base* object) const
 {
     for (std::size_t i = 0; i < derived_classes().size(); ++i)
     {
@@ -403,60 +403,60 @@ void* ExtensionClassBase::try_derived_class_conversions(InstanceHolderBase* obje
     return 0;
 }
 
-void ExtensionClassBase::add_method(Function* method, const char* name)
+void extension_class_base::add_method(function* method, const char* name)
 {
-    add_method(PyPtr<Function>(method), name);
+    add_method(reference<function>(method), name);
 }
     
-void ExtensionClassBase::add_method(PyPtr<Function> method, const char* name)
+void extension_class_base::add_method(reference<function> method, const char* name)
 {
     // Add the attribute to the computed target
-    Function::add_to_namespace(method, name, this->dict().get());
+    function::add_to_namespace(method, name, this->dict().get());
 
     // If it is a special member function it should be enabled both here and there.
     detail::enable_named_method(this, name);
 }
 
-void ExtensionClassBase::add_constructor_object(Function* init_function)
+void extension_class_base::add_constructor_object(function* init_fn)
 {
-    add_method(init_function, "__init__");
+    add_method(init_fn, "__init__");
 }
 
-void ExtensionClassBase::add_setter_method(Function* setter_, const char* name)
+void extension_class_base::add_setter_method(function* setter_, const char* name)
 {
-    PyPtr<Function> setter(setter_);
+    reference<function> setter(setter_);
     add_method(setter, (detail::setattr_string() + name + "__").c_str());
 }
 
-void ExtensionClassBase::add_getter_method(Function* getter_, const char* name)
+void extension_class_base::add_getter_method(function* getter_, const char* name)
 {
-    PyPtr<Function> getter(getter_);
+    reference<function> getter(getter_);
     add_method(getter, (detail::getattr_string() + name + "__").c_str());
 }
 
-void ExtensionClassBase::set_attribute(const char* name, PyObject* x_)
+void extension_class_base::set_attribute(const char* name, PyObject* x_)
 {
-    Ptr x(x_);
+    ref x(x_);
     set_attribute(name, x);
 }
 
-void ExtensionClassBase::set_attribute(const char* name, Ptr x)
+void extension_class_base::set_attribute(const char* name, ref x)
 {
-    dict().set_item(String(name), x);
+    dict().set_item(string(name), x);
     if (PyCallable_Check(x.get()))
         detail::enable_named_method(this, name);
 }
 
-operator_dispatcher::operator_dispatcher(const Ptr& o, const Ptr& s)
+operator_dispatcher::operator_dispatcher(const ref& o, const ref& s)
     : m_object(o), m_self(s), m_free_list_link(0)
 
 {
     ob_refcnt = 1;
-    ob_type = &type_object;
+    ob_type = &type_obj;
 }
 
 operator_dispatcher* 
-operator_dispatcher::create(const Ptr& object, const Ptr& self)
+operator_dispatcher::create(const ref& object, const ref& self)
 {
     operator_dispatcher* const result = free_list;
     if (result == 0)
@@ -474,11 +474,11 @@ extern "C"
 
 void operator_dispatcher_dealloc(PyObject* self) 
 { 
-    operator_dispatcher* instance = static_cast<operator_dispatcher*>(self);
-    instance->m_free_list_link = operator_dispatcher::free_list;
-    operator_dispatcher::free_list = instance;
-    instance->m_object.reset();
-    instance->m_self.reset();
+    operator_dispatcher* obj = static_cast<operator_dispatcher*>(self);
+    obj->m_free_list_link = operator_dispatcher::free_list;
+    operator_dispatcher::free_list = obj;
+    obj->m_object.reset();
+    obj->m_self.reset();
 } 
 
 int operator_dispatcher_coerce(PyObject** l, PyObject** r)
@@ -486,7 +486,7 @@ int operator_dispatcher_coerce(PyObject** l, PyObject** r)
     Py_INCREF(*l);
     try
     {
-        *r = operator_dispatcher::create(Ptr(*r, Ptr::new_ref), Ptr());
+        *r = operator_dispatcher::create(ref(*r, ref::increment_count), ref());
     }
     catch(...)
     {
@@ -608,7 +608,7 @@ int operator_dispatcher_call_cmp(PyObject* left, PyObject* right)
     {
         try
         {
-            return PY_CONVERSION::from_python(result, Type<int>());
+            return BOOST_PYTHON_CONVERSION::from_python(result, type<int>());
         }
         catch(...)
         {
@@ -621,7 +621,7 @@ int operator_dispatcher_call_cmp(PyObject* left, PyObject* right)
 
 } // extern "C"
     
-PyTypeObject operator_dispatcher::type_object = 
+PyTypeObject operator_dispatcher::type_obj = 
 { 
     PyObject_HEAD_INIT(&PyType_Type) 
     0, 
@@ -680,4 +680,4 @@ PyNumberMethods operator_dispatcher::number_methods =
 
 } // namespace detail
 
-} // namespace py
+} // namespace python
diff --git a/extclass.h b/extclass.h
index dd46ca08..b12a995f 100644
--- a/extclass.h
+++ b/extclass.h
@@ -7,7 +7,7 @@
 //  producing this work.
 //
 //  This file automatically generated for 10-argument constructors by
-//  gen_extclass.py
+//  gen_extclass.python
 
 #ifndef EXTENSION_CLASS_DWA052000_H_
 # define EXTENSION_CLASS_DWA052000_H_
@@ -23,33 +23,33 @@
 # include <typeinfo>
 # include <boost/smart_ptr.hpp>
 
-namespace py {
+namespace python {
 
 // forward declarations
 template <long which, class operand> struct operators;
 template <class T> struct left_operand;
 template <class T> struct right_operand;
 
-enum WithoutDowncast { without_downcast };
+enum without_downcast_t { without_downcast };
 
 namespace detail {
 
 // forward declarations
-class ExtensionInstance;
-class ExtensionClassBase;
-template <class T> class InstanceHolder;
-template <class T, class U> class InstanceValueHolder;
-template <class Ptr, class T> class InstancePtrHolder;
+class extension_instance;
+class extension_class_base;
+template <class T> class instance_holder;
+template <class T, class U> class instance_value_holder;
+template <class ref, class T> class instance_ptr_holder;
 template <class Specified> struct operand_select;
   template <long> struct choose_op;
   template <long> struct choose_rop;
   template <long> struct choose_unary_op;
   template <long> struct define_operator;
 
-MetaClass<ExtensionInstance>* extension_meta_class();
-ExtensionInstance* get_extension_instance(PyObject* p);
-void report_missing_instance_data(ExtensionInstance*, Class<ExtensionInstance>*, const std::type_info&);
-void report_missing_ptr_data(ExtensionInstance*, Class<ExtensionInstance>*, const std::type_info&);
+meta_class<extension_instance>* extension_meta_class();
+extension_instance* get_extension_instance(PyObject* p);
+void report_missing_instance_data(extension_instance*, class_t<extension_instance>*, const std::type_info&);
+void report_missing_ptr_data(extension_instance*, class_t<extension_instance>*, const std::type_info&);
 void report_missing_class_object(const std::type_info&);
 void report_released_smart_pointer(const std::type_info&);
     
@@ -61,87 +61,87 @@ T* check_non_null(T* p)
     return p;
 }
 
-template <class T> class HeldInstance;
+template <class T> class held_instance;
 
 typedef void* (*ConversionFunction)(void*);
 
 struct BaseClassInfo
 {
-    BaseClassInfo(ExtensionClassBase* t, ConversionFunction f)
+    BaseClassInfo(extension_class_base* t, ConversionFunction f)
         :class_object(t), convert(f)
         {}
     
-    ExtensionClassBase* class_object;
+    extension_class_base* class_object;
     ConversionFunction convert;
 };
 
-typedef BaseClassInfo DerivedClassInfo;
+typedef BaseClassInfo derived_class_info;
 
 struct add_operator_base;
 
-class ExtensionClassBase : public Class<ExtensionInstance>
+class extension_class_base : public class_t<extension_instance>
 {
  public:
-    ExtensionClassBase(const char* name);
+    extension_class_base(const char* name);
     
  public:
     // the purpose of try_class_conversions() and its related functions 
     // is explained in extclass.cpp
-    void* try_class_conversions(InstanceHolderBase*) const;
-    void* try_base_class_conversions(InstanceHolderBase*) const;
-    void* try_derived_class_conversions(InstanceHolderBase*) const;
+    void* try_class_conversions(instance_holder_base*) const;
+    void* try_base_class_conversions(instance_holder_base*) const;
+    void* try_derived_class_conversions(instance_holder_base*) const;
 
     void set_attribute(const char* name, PyObject* x);
-    void set_attribute(const char* name, Ptr x);
+    void set_attribute(const char* name, ref x);
     
  private:
-    virtual void* extract_object_from_holder(InstanceHolderBase* v) const = 0;
+    virtual void* extract_object_from_holder(instance_holder_base* v) const = 0;
     virtual std::vector<BaseClassInfo> const& base_classes() const = 0;
-    virtual std::vector<DerivedClassInfo> const& derived_classes() const = 0;
+    virtual std::vector<derived_class_info> const& derived_classes() const = 0;
 
  protected:
     friend struct add_operator_base;
-    void add_method(PyPtr<Function> method, const char* name);
-    void add_method(Function* method, const char* name);
+    void add_method(reference<function> method, const char* name);
+    void add_method(function* method, const char* name);
     
-    void add_constructor_object(Function*);
-    void add_setter_method(Function*, const char* name);
-    void add_getter_method(Function*, const char* name);
+    void add_constructor_object(function*);
+    void add_setter_method(function*, const char* name);
+    void add_getter_method(function*, const char* name);
 };
 
 template <class T>
-class ClassRegistry
+class class_registry
 {
  public:
-    static ExtensionClassBase* class_object()
+    static extension_class_base* class_object()
         { return static_class_object; }
 
     // Register/unregister the Python class object corresponding to T
-    static void register_class(ExtensionClassBase*);
-    static void unregister_class(ExtensionClassBase*);
+    static void register_class(extension_class_base*);
+    static void unregister_class(extension_class_base*);
 
     // Establish C++ inheritance relationships
     static void register_base_class(BaseClassInfo const&);
-    static void register_derived_class(DerivedClassInfo const&);
+    static void register_derived_class(derived_class_info const&);
 
     // Query the C++ inheritance relationships
     static std::vector<BaseClassInfo> const& base_classes();
-    static std::vector<DerivedClassInfo> const& derived_classes();
+    static std::vector<derived_class_info> const& derived_classes();
  private:
-    static ExtensionClassBase* static_class_object;
+    static extension_class_base* static_class_object;
     static std::vector<BaseClassInfo> static_base_class_info;
-    static std::vector<DerivedClassInfo> static_derived_class_info;
+    static std::vector<derived_class_info> static_derived_class_info;
 };
 
-}} // namespace py::detail
+}} // namespace python::detail
 
-PY_BEGIN_CONVERSION_NAMESPACE
+BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
 
 // This class' only job is to define from_python and to_python converters for T
 // and U. T is the class the user really intends to wrap. U is a class derived
 // from T with some virtual function overriding boilerplate, or if there are no
-// virtual functions, U = HeldInstance<T>.
-template <class T, class U = py::detail::HeldInstance<T> >
+// virtual functions, U = held_instance<T>.
+template <class T, class U = python::detail::held_instance<T> >
 class PyExtensionClassConverters
 {
  public:
@@ -154,7 +154,7 @@ class PyExtensionClassConverters
     // pop up. Now, if T hasn't been wrapped as an extension class, the user
     // will see an error message about the lack of an eligible
     // py_extension_class_converters() function.
-    friend PyExtensionClassConverters py_extension_class_converters(py::Type<T>)
+    friend PyExtensionClassConverters py_extension_class_converters(python::type<T>)
     { 
         return PyExtensionClassConverters();
     }
@@ -172,118 +172,118 @@ class PyExtensionClassConverters
     // writes code which causes us to try to copy a T.
     PyObject* to_python(const T& x) const
     {
-        py::PyPtr<py::detail::ExtensionInstance> result(create_instance());
+        python::reference<python::detail::extension_instance> result(create_instance());
         result->add_implementation(
-            std::auto_ptr<py::detail::InstanceHolderBase>(
-                new py::detail::InstanceValueHolder<T,U>(result.get(), x)));
+            std::auto_ptr<python::detail::instance_holder_base>(
+                new python::detail::instance_value_holder<T,U>(result.get(), x)));
         return result.release();
     }
     
     // Convert to T*
-    friend T* from_python(PyObject* obj, py::Type<T*>)
+    friend T* from_python(PyObject* obj, python::type<T*>)
     {
-        // Downcast to an ExtensionInstance, then find the actual T
-        py::detail::ExtensionInstance* self = py::detail::get_extension_instance(obj);
-        typedef std::vector<py::detail::InstanceHolderBase*>::const_iterator Iterator;
-        for (Iterator p = self->wrapped_objects().begin();
+        // downcast to an extension_instance, then find the actual T
+        python::detail::extension_instance* self = python::detail::get_extension_instance(obj);
+        typedef std::vector<python::detail::instance_holder_base*>::const_iterator iterator;
+        for (iterator p = self->wrapped_objects().begin();
              p != self->wrapped_objects().end(); ++p)
         {
-            py::detail::InstanceHolder<T>* held = dynamic_cast<py::detail::InstanceHolder<T>*>(*p);
+            python::detail::instance_holder<T>* held = dynamic_cast<python::detail::instance_holder<T>*>(*p);
             if (held != 0)
                 return held->target();
 
             // see extclass.cpp for an explanation of try_class_conversions()
-            void* target = py::detail::ClassRegistry<T>::class_object()->try_class_conversions(*p);
+            void* target = python::detail::class_registry<T>::class_object()->try_class_conversions(*p);
             if(target) 
                 return static_cast<T*>(target);
         }
-        py::detail::report_missing_instance_data(self, py::detail::ClassRegistry<T>::class_object(), typeid(T));
-        throw py::ArgumentError();
+        python::detail::report_missing_instance_data(self, python::detail::class_registry<T>::class_object(), typeid(T));
+        throw python::argument_error();
     }
 
     // Convert to PtrType, where PtrType can be dereferenced to obtain a T.
     template <class PtrType>
-    static PtrType& ptr_from_python(PyObject* obj, py::Type<PtrType>)
+    static PtrType& ptr_from_python(PyObject* obj, python::type<PtrType>)
     {
-        // Downcast to an ExtensionInstance, then find the actual T
-        py::detail::ExtensionInstance* self = py::detail::get_extension_instance(obj);
-        typedef std::vector<py::detail::InstanceHolderBase*>::const_iterator Iterator;
-        for (Iterator p = self->wrapped_objects().begin();
+        // downcast to an extension_instance, then find the actual T
+        python::detail::extension_instance* self = python::detail::get_extension_instance(obj);
+        typedef std::vector<python::detail::instance_holder_base*>::const_iterator iterator;
+        for (iterator p = self->wrapped_objects().begin();
              p != self->wrapped_objects().end(); ++p)
         {
-            py::detail::InstancePtrHolder<PtrType, T>* held =
-                dynamic_cast<py::detail::InstancePtrHolder<PtrType, T>*>(*p);
+            python::detail::instance_ptr_holder<PtrType, T>* held =
+                dynamic_cast<python::detail::instance_ptr_holder<PtrType, T>*>(*p);
             if (held != 0)
                 return held->ptr();
         }
-        py::detail::report_missing_ptr_data(self, py::detail::ClassRegistry<T>::class_object(), typeid(T));
-        throw py::ArgumentError();
+        python::detail::report_missing_ptr_data(self, python::detail::class_registry<T>::class_object(), typeid(T));
+        throw python::argument_error();
     }
 
     template <class PtrType>
     static PyObject* ptr_to_python(PtrType x)
     {
-        py::PyPtr<py::detail::ExtensionInstance> result(create_instance());
+        python::reference<python::detail::extension_instance> result(create_instance());
         result->add_implementation(
-            std::auto_ptr<py::detail::InstanceHolderBase>(
-                new py::detail::InstancePtrHolder<PtrType,T>(x)));
+            std::auto_ptr<python::detail::instance_holder_base>(
+                new python::detail::instance_ptr_holder<PtrType,T>(x)));
         return result.release();
     }
 
-    static py::PyPtr<py::detail::ExtensionInstance> create_instance()
+    static python::reference<python::detail::extension_instance> create_instance()
     {
-        PyTypeObject* class_object = py::detail::ClassRegistry<T>::class_object();
+        PyTypeObject* class_object = python::detail::class_registry<T>::class_object();
         if (class_object == 0)
-            py::detail::report_missing_class_object(typeid(T));
+            python::detail::report_missing_class_object(typeid(T));
             
-        return py::PyPtr<py::detail::ExtensionInstance>(
-            new py::detail::ExtensionInstance(class_object));
+        return python::reference<python::detail::extension_instance>(
+            new python::detail::extension_instance(class_object));
     }
 
     // Convert to const T*
-    friend const T* from_python(PyObject* p, py::Type<const T*>)
-        { return from_python(p, py::Type<T*>()); }
+    friend const T* from_python(PyObject* p, python::type<const T*>)
+        { return from_python(p, python::type<T*>()); }
 
     // Convert to const T* const&
-    friend const T* from_python(PyObject* p, py::Type<const T*const&>)
-         { return from_python(p, py::Type<const T*>()); }
+    friend const T* from_python(PyObject* p, python::type<const T*const&>)
+         { return from_python(p, python::type<const T*>()); }
   
     // Convert to T* const&
-    friend T* from_python(PyObject* p, py::Type<T* const&>)
-         { return from_python(p, py::Type<T*>()); }
+    friend T* from_python(PyObject* p, python::type<T* const&>)
+         { return from_python(p, python::type<T*>()); }
  
     // Convert to T&
-    friend T& from_python(PyObject* p, py::Type<T&>)
-        { return *py::detail::check_non_null(from_python(p, py::Type<T*>())); }
+    friend T& from_python(PyObject* p, python::type<T&>)
+        { return *python::detail::check_non_null(from_python(p, python::type<T*>())); }
 
     // Convert to const T&
-    friend const T& from_python(PyObject* p, py::Type<const T&>)
-        { return from_python(p, py::Type<T&>()); }
+    friend const T& from_python(PyObject* p, python::type<const T&>)
+        { return from_python(p, python::type<T&>()); }
 
     // Convert to T
-    friend const T& from_python(PyObject* p, py::Type<T>)
-        { return from_python(p, py::Type<T&>()); }
+    friend const T& from_python(PyObject* p, python::type<T>)
+        { return from_python(p, python::type<T&>()); }
 
-    friend std::auto_ptr<T>& from_python(PyObject* p, py::Type<std::auto_ptr<T>&>)
-        { return ptr_from_python(p, py::Type<std::auto_ptr<T> >()); }
+    friend std::auto_ptr<T>& from_python(PyObject* p, python::type<std::auto_ptr<T>&>)
+        { return ptr_from_python(p, python::type<std::auto_ptr<T> >()); }
     
-    friend std::auto_ptr<T>& from_python(PyObject* p, py::Type<std::auto_ptr<T> >)
-        { return ptr_from_python(p, py::Type<std::auto_ptr<T> >()); }
+    friend std::auto_ptr<T>& from_python(PyObject* p, python::type<std::auto_ptr<T> >)
+        { return ptr_from_python(p, python::type<std::auto_ptr<T> >()); }
     
-    friend const std::auto_ptr<T>& from_python(PyObject* p, py::Type<const std::auto_ptr<T>&>)
-        { return ptr_from_python(p, py::Type<std::auto_ptr<T> >()); }
+    friend const std::auto_ptr<T>& from_python(PyObject* p, python::type<const std::auto_ptr<T>&>)
+        { return ptr_from_python(p, python::type<std::auto_ptr<T> >()); }
 
     friend PyObject* to_python(std::auto_ptr<T> x)
         { return ptr_to_python(x); }
 
-    friend boost::shared_ptr<T>& from_python(PyObject* p, py::Type<boost::shared_ptr<T>&>)
-        { return ptr_from_python(p, py::Type<boost::shared_ptr<T> >()); }
+    friend boost::shared_ptr<T>& from_python(PyObject* p, python::type<boost::shared_ptr<T>&>)
+        { return ptr_from_python(p, python::type<boost::shared_ptr<T> >()); }
     
-    friend boost::shared_ptr<T>& from_python(PyObject* p, py::Type<boost::shared_ptr<T> >)
-        { return ptr_from_python(p, py::Type<boost::shared_ptr<T> >()); }
+    friend boost::shared_ptr<T>& from_python(PyObject* p, python::type<boost::shared_ptr<T> >)
+        { return ptr_from_python(p, python::type<boost::shared_ptr<T> >()); }
     
-    friend const boost::shared_ptr<T>& from_python(PyObject* p, py::Type<const boost::shared_ptr<T>&>)
-        { return ptr_from_python(p, py::Type<boost::shared_ptr<T> >()); }
+    friend const boost::shared_ptr<T>& from_python(PyObject* p, python::type<const boost::shared_ptr<T>&>)
+        { return ptr_from_python(p, python::type<boost::shared_ptr<T> >()); }
 
     friend PyObject* to_python(boost::shared_ptr<T> x)
         { return ptr_to_python(x); }
@@ -296,31 +296,31 @@ class PyExtensionClassConverters
 template <class T>
 PyObject* to_python(const T& x)
 {
-    return py_extension_class_converters(py::Type<T>()).to_python(x);
+    return py_extension_class_converters(python::type<T>()).to_python(x);
 }
 
-PY_END_CONVERSION_NAMESPACE
+BOOST_PYTHON_END_CONVERSION_NAMESPACE
 
-namespace py {
+namespace python {
 
-PY_IMPORT_CONVERSION(PyExtensionClassConverters);
+BOOST_PYTHON_IMPORT_CONVERSION(PyExtensionClassConverters);
 
 namespace detail {
 
-template <class T> class InstanceHolder;
+template <class T> class instance_holder;
 
-class ReadOnlySetattrFunction : public Function
+class read_only_setattr_function : public function
 {
  public:
-    ReadOnlySetattrFunction(const char* name);
+    read_only_setattr_function(const char* name);
     PyObject* do_call(PyObject* args, PyObject* keywords) const;
     const char* description() const;
  private:
-    String m_name;
+    string m_name;
 };
 
   template <class From, class To>
-  struct DefineConversion
+  struct define_conversion
   {
       static void* upcast_ptr(void* v)
       {
@@ -334,7 +334,7 @@ class ReadOnlySetattrFunction : public Function
   };
 
 // An easy way to make an extension base class which wraps T. Note that Python
-// subclasses of this class will simply be Class<ExtensionInstance> objects.
+// subclasses of this class will simply be class_t<extension_instance> objects.
 //
 // U should be a class derived from T which overrides virtual functions with
 // boilerplate code to call back into Python. See extclass_demo.h for examples.
@@ -343,50 +343,50 @@ class ReadOnlySetattrFunction : public Function
 // Python which are called from C++ if you don't supply it. If you just want to
 // be able to use T in python without overriding member functions, you can omit
 // U.
-template <class T, class U = HeldInstance<T> >
-class ExtensionClass
+template <class T, class U = held_instance<T> >
+class extension_class
     : public PyExtensionClassConverters<T, U>, // This generates the to_python/from_python functions
-      public ExtensionClassBase
+      public extension_class_base
 {
  public:
-    typedef T WrappedType;
-    typedef U CallbackType;
+    typedef T wrapped_type;
+    typedef U callback_type;
     
     // Construct with a name that comes from typeid(T).name(). The name only
     // affects the objects of this class are represented through repr()
-    ExtensionClass();
+    extension_class();
     
     // Construct with the given name. The name only affects the objects of this
     // class are represented through repr()
-    ExtensionClass(const char* name);
+    extension_class(const char* name);
     
-    ~ExtensionClass();
+    ~extension_class();
 
     // define constructors
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
-    inline void def(Constructor<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>)
-    // The following incantation builds a Signature1, Signature2,... object. It
+    inline void def(constructor<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>)
+    // The following incantation builds a signature1, signature2,... object. It
     // should _all_ get optimized away.
     { add_constructor(
-        prepend(Type<A1>::Id(),
-        prepend(Type<A2>::Id(),
-        prepend(Type<A3>::Id(),
-        prepend(Type<A4>::Id(),
-        prepend(Type<A5>::Id(),
-        prepend(Type<A6>::Id(),
-        prepend(Type<A7>::Id(),
-        prepend(Type<A8>::Id(),
-        prepend(Type<A9>::Id(),
-        prepend(Type<A10>::Id(),
-                Signature0())))))))))));
+        prepend(type<A1>::id(),
+        prepend(type<A2>::id(),
+        prepend(type<A3>::id(),
+        prepend(type<A4>::id(),
+        prepend(type<A5>::id(),
+        prepend(type<A6>::id(),
+        prepend(type<A7>::id(),
+        prepend(type<A8>::id(),
+        prepend(type<A9>::id(),
+        prepend(type<A10>::id(),
+                signature0())))))))))));
     }
 
 
     // export homogeneous operators (type of both lhs and rhs is 'operator')
-    // usage:  foo_class.def(py::operators<(py::op_add | py::op_sub), Foo>());
+    // usage:  foo_class.def(python::operators<(python::op_add | python::op_sub), Foo>());
     
     // export homogeneous operators (type of both lhs and rhs is 'T const&')
-    // usage:  foo_class.def(py::operators<(py::op_add | py::op_sub)>());
+    // usage:  foo_class.def(python::operators<(python::op_add | python::op_sub)>());
     template <long which, class Operand>
     inline void def(operators<which,Operand>)
     {
@@ -395,12 +395,12 @@ class ExtensionClass
     }
 
     // export heterogeneous operators (type of lhs: 'left', of rhs: 'right')
-    // usage:  foo_class.def(py::operators<(py::op_add | py::op_sub), Foo>(),
-    //                       py::right_operand<int const&>());
+    // usage:  foo_class.def(python::operators<(python::op_add | python::op_sub), Foo>(),
+    //                       python::right_operand<int const&>());
 
     // export heterogeneous operators (type of lhs: 'T const&', of rhs: 'right')
-    // usage:  foo_class.def(py::operators<(py::op_add | py::op_sub)>(),
-    //                       py::right_operand<int const&>());
+    // usage:  foo_class.def(python::operators<(python::op_add | python::op_sub)>(),
+    //                       python::right_operand<int const&>());
     template <long which, class Left, class Right>
     inline void def(operators<which,Left>, right_operand<Right> r)
     {
@@ -410,13 +410,13 @@ class ExtensionClass
 
     // export heterogeneous reverse-argument operators 
     // (type of lhs: 'left', of rhs: 'right')
-    // usage:  foo_class.def(py::operators<(py::op_add | py::op_sub), Foo>(),
-    //                       py::left_operand<int const&>());
+    // usage:  foo_class.def(python::operators<(python::op_add | python::op_sub), Foo>(),
+    //                       python::left_operand<int const&>());
     
     // export heterogeneous reverse-argument operators 
     // (type of lhs: 'left', of rhs: 'T const&')
-    // usage:  foo_class.def(py::operators<(py::op_add | py::op_sub)>(),
-    //                       py::left_operand<int const&>());
+    // usage:  foo_class.def(python::operators<(python::op_add | python::op_sub)>(),
+    //                       python::left_operand<int const&>());
     template <long which, class Left, class Right>
     inline void def(operators<which,Right>, left_operand<Left> l)
     {
@@ -425,7 +425,7 @@ class ExtensionClass
     }
 
     // define a function that passes Python arguments and keywords
-    // to C++ verbatim (as a 'Tuple const&' and 'Dict const&' 
+    // to C++ verbatim (as a 'tuple const&' and 'dictionary const&' 
     // respectively). This is useful for manual argument passing.
     // It's also the only possibility to pass keyword arguments to C++.
     // Fn must have a signatur that is compatible to 
@@ -452,34 +452,34 @@ class ExtensionClass
     template <class Fn, class DefaultFn>
     inline void def(Fn fn, const char* name, DefaultFn default_fn)
     {
-        this->add_method(new_virtual_function(Type<T>(), fn, default_fn), name);
+        this->add_method(new_virtual_function(type<T>(), fn, default_fn), name);
     }
 
     // Provide a function which implements x.<name>, reading from the given
-    // member (pm) of the T instance
+    // member (pm) of the T obj
     template <class MemberType>
     inline void def_getter(MemberType T::*pm, const char* name)
     {
-        this->add_getter_method(new GetterFunction<T, MemberType>(pm), name);
+        this->add_getter_method(new getter_function<T, MemberType>(pm), name);
     }
     
     // Provide a function which implements assignment to x.<name>, writing to
-    // the given member (pm) of the T instance
+    // the given member (pm) of the T obj
     template <class MemberType>
     inline void def_setter(MemberType T::*pm, const char* name)
     {
-        this->add_setter_method(new SetterFunction<T, MemberType>(pm), name);
+        this->add_setter_method(new setter_function<T, MemberType>(pm), name);
     }
     
-    // Expose the given member (pm) of the T instance as a read-only attribute
+    // Expose the given member (pm) of the T obj as a read-only attribute
     template <class MemberType>
     inline void def_readonly(MemberType T::*pm, const char* name)
     {
-        this->add_setter_method(new ReadOnlySetattrFunction(name), name);
+        this->add_setter_method(new read_only_setattr_function(name), name);
         this->def_getter(pm, name);
     }
     
-    // Expose the given member (pm) of the T instance as a read/write attribute
+    // Expose the given member (pm) of the T obj as a read/write attribute
     template <class MemberType>
     inline void def_read_write(MemberType T::*pm, const char* name)
     {
@@ -493,43 +493,43 @@ class ExtensionClass
     // declare the given class a base class of this one and register 
     // up and down conversion functions
     template <class S, class V>
-    void declare_base(ExtensionClass<S, V>* base)
+    void declare_base(extension_class<S, V>* base)
     {
         // see extclass.cpp for an explanation of why we need to register
         // conversion functions
         BaseClassInfo baseInfo(base, 
-                            &DefineConversion<S, T>::downcast_ptr);
-        ClassRegistry<T>::register_base_class(baseInfo);
-        add_base(Ptr(as_object(base), Ptr::new_ref));
+                            &define_conversion<S, T>::downcast_ptr);
+        class_registry<T>::register_base_class(baseInfo);
+        add_base(ref(as_object(base), ref::increment_count));
         
-        DerivedClassInfo derivedInfo(this, 
-                            &DefineConversion<T, S>::upcast_ptr);
-        ClassRegistry<S>::register_derived_class(derivedInfo);
+        derived_class_info derivedInfo(this, 
+                            &define_conversion<T, S>::upcast_ptr);
+        class_registry<S>::register_derived_class(derivedInfo);
     }
         
     // declare the given class a base class of this one and register 
     // only up conversion function
     template <class S, class V>
-    void declare_base(ExtensionClass<S, V>* base, WithoutDowncast)
+    void declare_base(extension_class<S, V>* base, without_downcast_t)
     {
         // see extclass.cpp for an explanation of why we need to register
         // conversion functions
         BaseClassInfo baseInfo(base, 0);
-        ClassRegistry<T>::register_base_class(baseInfo);
-        add_base(Ptr(as_object(base), Ptr::new_ref));
+        class_registry<T>::register_base_class(baseInfo);
+        add_base(ref(as_object(base), ref::increment_count));
         
-        DerivedClassInfo derivedInfo(this, 
-                           &DefineConversion<T, S>::upcast_ptr);
-        ClassRegistry<S>::register_derived_class(derivedInfo);
+        derived_class_info derivedInfo(this, 
+                           &define_conversion<T, S>::upcast_ptr);
+        class_registry<S>::register_derived_class(derivedInfo);
     }
     
  private: // types
-    typedef InstanceValueHolder<T,U> Holder;
+    typedef instance_value_holder<T,U> holder;
 
- private: // ExtensionClassBase virtual function implementations
+ private: // extension_class_base virtual function implementations
     std::vector<BaseClassInfo> const& base_classes() const;
-    std::vector<DerivedClassInfo> const& derived_classes() const;
-    void* extract_object_from_holder(InstanceHolderBase* v) const;
+    std::vector<derived_class_info> const& derived_classes() const;
+    void* extract_object_from_holder(instance_holder_base* v) const;
 
  private: // Utility functions
     template <long which, class Operand>
@@ -604,57 +604,57 @@ class ExtensionClass
         choose_rop<(which & op_cmp)>::template args<Left,Right>::add(this);
     }
     
-    template <class Signature>
-    void add_constructor(Signature sig)
+    template <class signature>
+    void add_constructor(signature sig)
     {
-        this->add_constructor_object(InitFunction<Holder>::create(sig));
+        this->add_constructor_object(init_function<holder>::create(sig));
     }
 };
 
-// A simple wrapper over a T which allows us to use ExtensionClass<T> with a
-// single template parameter only. See ExtensionClass<T>, above.
+// A simple wrapper over a T which allows us to use extension_class<T> with a
+// single template parameter only. See extension_class<T>, above.
 template <class T>
-class HeldInstance : public T
+class held_instance : public T
 {
     // There are no member functions: we want to avoid inadvertently overriding
     // any virtual functions in T.
 public:
-    HeldInstance(PyObject*) : T() {}
+    held_instance(PyObject*) : T() {}
     template <class A1>
-    HeldInstance(PyObject*, A1 a1) : T(a1) {}
+    held_instance(PyObject*, A1 a1) : T(a1) {}
     template <class A1, class A2>
-    HeldInstance(PyObject*, A1 a1, A2 a2) : T(a1, a2) {}
+    held_instance(PyObject*, A1 a1, A2 a2) : T(a1, a2) {}
     template <class A1, class A2, class A3>
-    HeldInstance(PyObject*, A1 a1, A2 a2, A3 a3) : T(a1, a2, a3) {}
+    held_instance(PyObject*, A1 a1, A2 a2, A3 a3) : T(a1, a2, a3) {}
     template <class A1, class A2, class A3, class A4>
-    HeldInstance(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4) : T(a1, a2, a3, a4) {}
+    held_instance(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4) : T(a1, a2, a3, a4) {}
     template <class A1, class A2, class A3, class A4, class A5>
-    HeldInstance(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) : T(a1, a2, a3, a4, a5) {}
+    held_instance(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) : T(a1, a2, a3, a4, a5) {}
     template <class A1, class A2, class A3, class A4, class A5, class A6>
-    HeldInstance(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) : T(a1, a2, a3, a4, a5, a6) {}
+    held_instance(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) : T(a1, a2, a3, a4, a5, a6) {}
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-    HeldInstance(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) : T(a1, a2, a3, a4, a5, a6, a7) {}
+    held_instance(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) : T(a1, a2, a3, a4, a5, a6, a7) {}
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-    HeldInstance(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) : T(a1, a2, a3, a4, a5, a6, a7, a8) {}
+    held_instance(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) : T(a1, a2, a3, a4, a5, a6, a7, a8) {}
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-    HeldInstance(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) : T(a1, a2, a3, a4, a5, a6, a7, a8, a9) {}
+    held_instance(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) : T(a1, a2, a3, a4, a5, a6, a7, a8, a9) {}
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
-    HeldInstance(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) : T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {}
+    held_instance(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) : T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {}
 };
 
-// Abstract base class for all instance holders. Base for template class
-// InstanceHolder<>, below.
-class InstanceHolderBase
+// Abstract base class for all obj holders. Base for template class
+// instance_holder<>, below.
+class instance_holder_base
 {
 public:
-    virtual ~InstanceHolderBase() {}
+    virtual ~instance_holder_base() {}
     virtual bool held_by_value() = 0;
 };
 
 // Abstract base class which holds a Held, somehow. Provides a uniform way to
 // get a pointer to the held object
 template <class Held>
-class InstanceHolder : public InstanceHolderBase
+class instance_holder : public instance_holder_base
 {
 public:
     virtual Held*target() = 0;
@@ -665,49 +665,49 @@ public:
 // corresponding constructor for arguments (PyObject*, A1...An). Wrapper is
 // neccessary to implement virtual function callbacks (there must be a
 // back-pointer to the actual Python object so that we can call any
-// overrides). HeldInstance (above) is used as a default Wrapper class when
+// overrides). held_instance (above) is used as a default Wrapper class when
 // there are no virtual functions.
 template <class Held, class Wrapper>
-class InstanceValueHolder : public InstanceHolder<Held>
+class instance_value_holder : public instance_holder<Held>
 {
 public:
     Held* target() { return &m_held; }
     Wrapper* value_target() { return &m_held; }
 
-    InstanceValueHolder(ExtensionInstance* p) :
+    instance_value_holder(extension_instance* p) :
         m_held(p) {}
     template <class A1>
-    InstanceValueHolder(ExtensionInstance* p, A1 a1) :
+    instance_value_holder(extension_instance* p, A1 a1) :
         m_held(p, a1) {}
     template <class A1, class A2>
-    InstanceValueHolder(ExtensionInstance* p, A1 a1, A2 a2) :
+    instance_value_holder(extension_instance* p, A1 a1, A2 a2) :
         m_held(p, a1, a2) {}
     template <class A1, class A2, class A3>
-    InstanceValueHolder(ExtensionInstance* p, A1 a1, A2 a2, A3 a3) :
+    instance_value_holder(extension_instance* p, A1 a1, A2 a2, A3 a3) :
         m_held(p, a1, a2, a3) {}
     template <class A1, class A2, class A3, class A4>
-    InstanceValueHolder(ExtensionInstance* p, A1 a1, A2 a2, A3 a3, A4 a4) :
+    instance_value_holder(extension_instance* p, A1 a1, A2 a2, A3 a3, A4 a4) :
         m_held(p, a1, a2, a3, a4) {}
     template <class A1, class A2, class A3, class A4, class A5>
-    InstanceValueHolder(ExtensionInstance* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) :
+    instance_value_holder(extension_instance* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) :
         m_held(p, a1, a2, a3, a4, a5) {}
     template <class A1, class A2, class A3, class A4, class A5, class A6>
-    InstanceValueHolder(ExtensionInstance* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) :
+    instance_value_holder(extension_instance* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) :
         m_held(p, a1, a2, a3, a4, a5, a6) {}
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-    InstanceValueHolder(ExtensionInstance* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) :
+    instance_value_holder(extension_instance* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) :
         m_held(p, a1, a2, a3, a4, a5, a6, a7) {}
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-    InstanceValueHolder(ExtensionInstance* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) :
+    instance_value_holder(extension_instance* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) :
         m_held(p, a1, a2, a3, a4, a5, a6, a7, a8) {}
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-    InstanceValueHolder(ExtensionInstance* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) :
+    instance_value_holder(extension_instance* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) :
         m_held(p, a1, a2, a3, a4, a5, a6, a7, a8, a9) {}
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
-    InstanceValueHolder(ExtensionInstance* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) :
+    instance_value_holder(extension_instance* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) :
         m_held(p, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {}
 
- public: // implementation of InstanceHolderBase required interface
+ public: // implementation of instance_holder_base required interface
     bool held_by_value() { return true; }
 
  private:
@@ -718,59 +718,59 @@ public:
 // PtrType. By default, these are only generated for PtrType ==
 // std::auto_ptr<HeldType> and PtrType == boost::shared_ptr<HeldType>.
 template <class PtrType, class HeldType>
-class InstancePtrHolder : public InstanceHolder<HeldType>
+class instance_ptr_holder : public instance_holder<HeldType>
 {
  public:
     HeldType* target() { return &*m_ptr; }
     PtrType& ptr() { return m_ptr; }
 
-    InstancePtrHolder(PtrType ptr) : m_ptr(ptr) {}
+    instance_ptr_holder(PtrType ptr) : m_ptr(ptr) {}
     
- public: // implementation of InstanceHolderBase required interface
+ public: // implementation of instance_holder_base required interface
     bool held_by_value() { return false; }
  private:
     PtrType m_ptr;
 };
 
-class ExtensionInstance : public Instance
+class extension_instance : public instance
 {
  public:
-    ExtensionInstance(PyTypeObject* class_);
-    ~ExtensionInstance();
+    extension_instance(PyTypeObject* class_);
+    ~extension_instance();
     
-    void add_implementation(std::auto_ptr<InstanceHolderBase> holder);
+    void add_implementation(std::auto_ptr<instance_holder_base> holder);
 
-    typedef std::vector<InstanceHolderBase*> WrappedObjects;
-    const WrappedObjects& wrapped_objects() const
+    typedef std::vector<instance_holder_base*> held_objects;
+    const held_objects& wrapped_objects() const
         { return m_wrapped_objects; }
  private:
-    WrappedObjects m_wrapped_objects;
+    held_objects m_wrapped_objects;
 };
 
 //
 // Template function implementations
 //
 
-Tuple extension_class_coerce(Ptr l, Ptr r);
+tuple extension_class_coerce(ref l, ref r);
 
 template <class T, class U>
-ExtensionClass<T, U>::ExtensionClass()
-    : ExtensionClassBase(typeid(T).name())
+extension_class<T, U>::extension_class()
+    : extension_class_base(typeid(T).name())
 {
-    ClassRegistry<T>::register_class(this);
+    class_registry<T>::register_class(this);
 }
 
 template <class T, class U>
-ExtensionClass<T, U>::ExtensionClass(const char* name)
-    : ExtensionClassBase(name)
+extension_class<T, U>::extension_class(const char* name)
+    : extension_class_base(name)
 {
-    ClassRegistry<T>::register_class(this);
+    class_registry<T>::register_class(this);
 }
 
 template <class T, class U>
-void ExtensionClass<T, U>::def_standard_coerce()
+void extension_class<T, U>::def_standard_coerce()
 {
-    Ptr coerce_fct = dict().get_item(String("__coerce__"));
+    ref coerce_fct = dict().get_item(string("__coerce__"));
     
     if(coerce_fct.get() == 0) // not yet defined
         this->def(&extension_class_coerce, "__coerce__");
@@ -779,36 +779,36 @@ void ExtensionClass<T, U>::def_standard_coerce()
 template <class T, class U>
 inline
 std::vector<BaseClassInfo> const& 
-ExtensionClass<T, U>::base_classes() const
+extension_class<T, U>::base_classes() const
 {
-    return ClassRegistry<T>::base_classes();
+    return class_registry<T>::base_classes();
 }
 
 template <class T, class U>
 inline
-std::vector<DerivedClassInfo> const& 
-ExtensionClass<T, U>::derived_classes() const
+std::vector<derived_class_info> const& 
+extension_class<T, U>::derived_classes() const
 {
-    return ClassRegistry<T>::derived_classes();
+    return class_registry<T>::derived_classes();
 }
        
 template <class T, class U>
-void* ExtensionClass<T, U>::extract_object_from_holder(InstanceHolderBase* v) const
+void* extension_class<T, U>::extract_object_from_holder(instance_holder_base* v) const
 {
-    InstanceHolder<T>* held = dynamic_cast<InstanceHolder<T>*>(v);
+    instance_holder<T>* held = dynamic_cast<instance_holder<T>*>(v);
     if(held)
         return held->target();
     return 0;
 }
 
 template <class T, class U>
-ExtensionClass<T, U>::~ExtensionClass()
+extension_class<T, U>::~extension_class()
 {
-    ClassRegistry<T>::unregister_class(this);
+    class_registry<T>::unregister_class(this);
 }
 
 template <class T>
-inline void ClassRegistry<T>::register_class(ExtensionClassBase* p)
+inline void class_registry<T>::register_class(extension_class_base* p)
 {
     // You're not expected to create more than one of these!
     assert(static_class_object == 0);
@@ -816,7 +816,7 @@ inline void ClassRegistry<T>::register_class(ExtensionClassBase* p)
 }
 
 template <class T>
-inline void ClassRegistry<T>::unregister_class(ExtensionClassBase* p)
+inline void class_registry<T>::unregister_class(extension_class_base* p)
 {
     // The user should be destroying the same object they created.
     assert(static_class_object == p);
@@ -825,25 +825,25 @@ inline void ClassRegistry<T>::unregister_class(ExtensionClassBase* p)
 }
 
 template <class T>
-void ClassRegistry<T>::register_base_class(BaseClassInfo const& i)
+void class_registry<T>::register_base_class(BaseClassInfo const& i)
 {
     static_base_class_info.push_back(i);
 }
 
 template <class T>
-void ClassRegistry<T>::register_derived_class(DerivedClassInfo const& i)
+void class_registry<T>::register_derived_class(derived_class_info const& i)
 {
     static_derived_class_info.push_back(i);
 }
 
 template <class T>
-std::vector<BaseClassInfo> const& ClassRegistry<T>::base_classes()
+std::vector<BaseClassInfo> const& class_registry<T>::base_classes()
 {
     return static_base_class_info;
 }
 
 template <class T>
-std::vector<DerivedClassInfo> const& ClassRegistry<T>::derived_classes()
+std::vector<derived_class_info> const& class_registry<T>::derived_classes()
 {
     return static_derived_class_info;
 }
@@ -852,12 +852,12 @@ std::vector<DerivedClassInfo> const& ClassRegistry<T>::derived_classes()
 // Static data member declaration.
 //
 template <class T>
-ExtensionClassBase* ClassRegistry<T>::static_class_object;
+extension_class_base* class_registry<T>::static_class_object;
 template <class T>
-std::vector<BaseClassInfo> ClassRegistry<T>::static_base_class_info;
+std::vector<BaseClassInfo> class_registry<T>::static_base_class_info;
 template <class T>
-std::vector<DerivedClassInfo> ClassRegistry<T>::static_derived_class_info;
+std::vector<derived_class_info> class_registry<T>::static_derived_class_info;
 
-}} // namespace py::detail
+}} // namespace python::detail
 
 #endif // EXTENSION_CLASS_DWA052000_H_
diff --git a/extclass_demo.cpp b/extclass_demo.cpp
index 68716e06..b8e90c02 100644
--- a/extclass_demo.cpp
+++ b/extclass_demo.cpp
@@ -21,7 +21,7 @@ FooCallback::FooCallback(PyObject* self, int x)
 int FooCallback::add_len(const char* x) const
 {
     // Try to call the "add_len" method on the corresponding Python object.
-    return py::Callback<int>::call_method(m_self, "add_len", x);
+    return python::callback<int>::call_method(m_self, "add_len", x);
 }
 
 // A function which Python can call in case bar is not overridden from
@@ -41,13 +41,13 @@ int FooCallback::default_add_len(const Foo* self, const char* x)
 // exception at runtime when pure() is called.
 std::string FooCallback::pure() const
 {
-    return py::Callback<std::string>::call_method(m_self, "pure");
+    return python::callback<std::string>::call_method(m_self, "pure");
 }
 
-Foo::PythonClass::PythonClass(py::Module& m)
-    : py::ClassWrapper<Foo,FooCallback>(m, "Foo")
+Foo::PythonClass::PythonClass(python::module_builder& m)
+    : python::class_builder<Foo,FooCallback>(m, "Foo")
 {
-    def(py::Constructor<int>());
+    def(python::constructor<int>());
     def(&Foo::mumble, "mumble");
     def(&Foo::set, "set");
     def(&Foo::call_pure, "call_pure");
@@ -59,19 +59,19 @@ Foo::PythonClass::PythonClass(py::Module& m)
     // Since pure() is pure virtual, we are leaving it undefined.
 }
 
-BarPythonClass::BarPythonClass(py::Module& m)
-    : py::ClassWrapper<Bar>(m, "Bar")
+BarPythonClass::BarPythonClass(python::module_builder& m)
+    : python::class_builder<Bar>(m, "Bar")
 {
-    def(py::Constructor<int, int>());
+    def(python::constructor<int, int>());
     def(&Bar::first, "first");
     def(&Bar::second, "second");
     def(&Bar::pass_baz, "pass_baz");
 }
 
-BazPythonClass::BazPythonClass(py::Module& m)
-    : py::ClassWrapper<Baz>(m, "Baz") // optional
+BazPythonClass::BazPythonClass(python::module_builder& m)
+    : python::class_builder<Baz>(m, "Baz") // optional
 {
-    def(py::Constructor<>());
+    def(python::constructor<>());
     def(&Baz::pass_bar, "pass_bar");
     def(&Baz::clone, "clone");
     def(&Baz::create_foo, "create_foo");
@@ -79,10 +79,10 @@ BazPythonClass::BazPythonClass(py::Module& m)
     def(&Baz::eat_baz, "eat_baz");
 }
 
-StringMapPythonClass::StringMapPythonClass(py::Module& m)
-    : py::ClassWrapper<StringMap >(m, "StringMap")
+StringMapPythonClass::StringMapPythonClass(python::module_builder& m)
+    : python::class_builder<StringMap >(m, "StringMap")
 {
-    def(py::Constructor<>());
+    def(python::constructor<>());
     def(&StringMap::size, "__len__");
     def(&get_item, "__getitem__");
     def(&set_item, "__setitem__");
@@ -102,13 +102,13 @@ void set_first(IntPair& p, int value)
 void del_first(const IntPair&)
 {
     PyErr_SetString(PyExc_AttributeError, "first can't be deleted!");
-    throw py::ErrorAlreadySet();
+    throw python::error_already_set();
 }
 
-IntPairPythonClass::IntPairPythonClass(py::Module& m)
-    : py::ClassWrapper<IntPair>(m, "IntPair")
+IntPairPythonClass::IntPairPythonClass(python::module_builder& m)
+    : python::class_builder<IntPair>(m, "IntPair")
 {
-    def(py::Constructor<int, int>());
+    def(python::constructor<int, int>());
     def(&getattr, "__getattr__");
     def(&setattr, "__setattr__");
     def(&delattr, "__delattr__");
@@ -126,14 +126,14 @@ void IntPairPythonClass::setattr(IntPair& x, const std::string& name, int value)
     else
     {
         PyErr_SetString(PyExc_AttributeError, name.c_str());
-        throw py::ErrorAlreadySet();
+        throw python::error_already_set();
     }
 }
 
 void IntPairPythonClass::delattr(IntPair&, const char*)
 {
     PyErr_SetString(PyExc_AttributeError, "Attributes can't be deleted!");
-    throw py::ErrorAlreadySet();
+    throw python::error_already_set();
 }
 
 int IntPairPythonClass::getattr(const IntPair& p, const std::string& s)
@@ -145,7 +145,7 @@ int IntPairPythonClass::getattr(const IntPair& p, const std::string& s)
     else
     {
         PyErr_SetString(PyExc_AttributeError, s.c_str());
-        throw py::ErrorAlreadySet();
+        throw python::error_already_set();
     }
 #if defined(__MWERKS__) && __MWERKS__ <= 0x2400
     return 0;
@@ -157,8 +157,8 @@ void throw_key_error_if_end(const StringMap& m, StringMap::const_iterator p, std
 {
     if (p == m.end())
     {
-		PyErr_SetObject(PyExc_KeyError, PY_CONVERSION::to_python(key));
-        throw py::ErrorAlreadySet();
+		PyErr_SetObject(PyExc_KeyError, BOOST_PYTHON_CONVERSION::to_python(key));
+        throw python::error_already_set();
     }
 }
 }} // namespace <anonymous>::file_local
@@ -230,7 +230,7 @@ int Foo::call_add_len(const char* s) const
 
 int Foo::add_len(const char* s) const         // sum the held value and the length of s
 {
-    return PY_CSTD_::strlen(s) + static_cast<int>(m_x);
+    return BOOST_CSTD_::strlen(s) + static_cast<int>(m_x);
 }
 
 boost::shared_ptr<Foo> Baz::create_foo()
@@ -265,11 +265,11 @@ int stringpair_compare(const StringPair& sp1, const StringPair& sp2)
     return sp1 < sp2 ? -1 : sp2 < sp1 ? 1 : 0;
 }
 
-py::String range_str(const Range& r)
+python::string range_str(const Range& r)
 {
     char buf[200];
     sprintf(buf, "(%d, %d)", r.m_start, r.m_finish);
-    return py::String(buf);
+    return python::string(buf);
 }
 
 int range_compare(const Range& r1, const Range& r2)
@@ -450,11 +450,11 @@ struct CallbackTestCallback : public CallbackTest
   
   int callback(int x) 
   { 
-    return py::Callback<int>::call_method(m_self, "callback", x); 
+    return python::callback<int>::call_method(m_self, "callback", x); 
   }
   std::string callbackString(std::string const & x) 
   { 
-    return py::Callback<std::string>::call_method(m_self, "callback", x); 
+    return python::callback<std::string>::call_method(m_self, "callback", x); 
   }
 
   static int default_callback(CallbackTest* self, int x) 
@@ -522,8 +522,8 @@ std::auto_ptr<B1> factoryCasB1() { return std::auto_ptr<B1>(new C); }
 struct B_callback : B1 {
    B_callback(PyObject* self) : m_self(self) {}
    
-   std::string overrideA1() const { return py::Callback<std::string>::call_method(m_self, "overrideA1"); }
-   std::string overrideB1() const { return py::Callback<std::string>::call_method(m_self, "overrideB1"); }
+   std::string overrideA1() const { return python::callback<std::string>::call_method(m_self, "overrideA1"); }
+   std::string overrideB1() const { return python::callback<std::string>::call_method(m_self, "overrideB1"); }
    
    static std::string default_overrideA1(B1& x) { return x.B1::overrideA1(); }
    static std::string default_overrideB1(B1& x) { return x.B1::overrideB1(); }
@@ -534,8 +534,8 @@ struct B_callback : B1 {
 struct A_callback : A1 {
    A_callback(PyObject* self) : m_self(self) {}
    
-   std::string overrideA1() const { return py::Callback<std::string>::call_method(m_self, "overrideA1"); }
-   std::string inheritA1() const { return py::Callback<std::string>::call_method(m_self, "inheritA1"); }
+   std::string overrideA1() const { return python::callback<std::string>::call_method(m_self, "overrideA1"); }
+   std::string inheritA1() const { return python::callback<std::string>::call_method(m_self, "inheritA1"); }
    
    static std::string default_overrideA1(A1& x) { return x.A1::overrideA1(); }
    static std::string default_inheritA1(A1& x) { return x.A1::inheritA1(); }
@@ -557,14 +557,14 @@ struct RawTest
     int i_;
 };
 
-PyObject* raw(py::Tuple const & args, py::Dict const & keywords);
+PyObject* raw(python::tuple const & args, python::dictionary const & keywords);
 
 int raw1(PyObject* args, PyObject* keywords)
 {
     return PyTuple_Size(args) + PyDict_Size(keywords);
 }
 
-int raw2(py::Ptr args, py::Ptr keywords)
+int raw2(python::ref args, python::ref keywords)
 {
     return PyTuple_Size(args.get()) + PyDict_Size(keywords.get());
 }
@@ -579,7 +579,7 @@ int raw2(py::Ptr args, py::Ptr keywords)
 
 typedef boost::rational<int> Ratio;
 
-py::String ratio_str(const Ratio& r)
+python::string ratio_str(const Ratio& r)
 {
     char buf[200];
     
@@ -588,19 +588,19 @@ py::String ratio_str(const Ratio& r)
     else
         sprintf(buf, "%d/%d", r.numerator(), r.denominator());
     
-    return py::String(buf);
+    return python::string(buf);
 }
 
-py::String ratio_repr(const Ratio& r)
+python::string ratio_repr(const Ratio& r)
 {
     char buf[200];
     sprintf(buf, "Rational(%d, %d)", r.numerator(), r.denominator());
-    return py::String(buf);
+    return python::string(buf);
 }
 
-py::Tuple ratio_coerce(const Ratio& r1, int r2)
+python::tuple ratio_coerce(const Ratio& r1, int r2)
 {
-    return py::Tuple(r1, Ratio(r2));
+    return python::tuple(r1, Ratio(r2));
 }
 
 // The most reliable way, across compilers, to grab the particular abs function
@@ -688,7 +688,7 @@ std::ostream & operator<<(std::ostream & o, Int const & r) { return (o << r.i_);
 /* double tests from Mark Evans(<mark.evans@clarisay.com>)  */
 /*                                                          */
 /************************************************************/
-double sizelist(py::List list) { return list.size(); }
+double sizelist(python::list list) { return list.size(); }
 void vd_push_back(std::vector<double>& vd, const double& x)
 {
     vd.push_back(x);
@@ -714,16 +714,16 @@ const Record* get_record()
     return &v;
 }
 
-template class py::ClassWrapper<Record>; // explicitly instantiate
+template class python::class_builder<Record>; // explicitly instantiate
 
 } // namespace extclass_demo
 
-PY_BEGIN_CONVERSION_NAMESPACE
+BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
 inline PyObject* to_python(const extclass_demo::Record* p)
 {
     return to_python(*p);
 }
-PY_END_CONVERSION_NAMESPACE
+BOOST_PYTHON_END_CONVERSION_NAMESPACE
 
 /************************************************************/
 /*                                                          */
@@ -752,14 +752,14 @@ struct EnumOwner
 
 }
 
-namespace py {
+namespace python {
   template class enum_as_int_converters<extclass_demo::EnumOwner::enum_type>;
   using extclass_demo::pow;
 }
 
 // This is just a way of getting the converters instantiated
 //struct EnumOwner_enum_type_Converters
-//    : py::py_enum_as_int_converters<EnumOwner::enum_type>
+//    : python::py_enum_as_int_converters<EnumOwner::enum_type>
 //{
 //};
 
@@ -786,29 +786,29 @@ namespace extclass_demo {
   };
 
   // Support for pickle.
-  py::Tuple world_getinitargs(const world& w)
+  python::tuple world_getinitargs(const world& w)
   {
-      py::Tuple result(1);
+      python::tuple result(1);
       result.set_item(0, w.get_country());
       return result;
   }
 
-  py::Tuple world_getstate(const world& w)
+  python::tuple world_getstate(const world& w)
   {
-      py::Tuple result(1);
+      python::tuple result(1);
       result.set_item(0, w.get_secret_number());
       return result;
   }
 
-  void world_setstate(world& w, py::Tuple state)
+  void world_setstate(world& w, python::tuple state)
   {
       if (state.size() != 1) {
           PyErr_SetString(PyExc_ValueError,
                           "Unexpected argument in call to __setstate__.");
-          throw py::ErrorAlreadySet();
+          throw python::error_already_set();
       }
     
-      const int number = PY_CONVERSION::from_python(state[0].get(), py::Type<int>());
+      const int number = BOOST_PYTHON_CONVERSION::from_python(state[0].get(), python::type<int>());
       if (number != 42)
           w.set_secret_number(number);
   }
@@ -819,21 +819,21 @@ namespace extclass_demo {
 /*                                                          */
 /************************************************************/
 
-void init_module(py::Module& m)
+void init_module(python::module_builder& m)
 {
     m.def(get_record, "get_record");
-    py::ClassWrapper<Record> record_class(m, "Record");
+    python::class_builder<Record> record_class(m, "Record");
     record_class.def_readonly(&Record::value, "value");
     
     m.def(sizelist, "sizelist");
     
-    py::ClassWrapper<std::vector<double> >  vector_double(m, "vector_double");
-    vector_double.def(py::Constructor<>());
+    python::class_builder<std::vector<double> >  vector_double(m, "vector_double");
+    vector_double.def(python::constructor<>());
     vector_double.def(vd_push_back, "push_back");
     
-    py::ClassWrapper<Fubar> fubar(m, "Fubar");
-    fubar.def(py::Constructor<Foo&>());
-    fubar.def(py::Constructor<int>());
+    python::class_builder<Fubar> fubar(m, "Fubar");
+    fubar.def(python::constructor<Foo&>());
+    fubar.def(python::constructor<int>());
 
     Foo::PythonClass foo(m);
     BarPythonClass bar(m);
@@ -843,8 +843,8 @@ void init_module(py::Module& m)
     m.def(make_pair, "make_pair");
     CompareIntPairPythonClass compare_int_pair(m);
 
-    py::ClassWrapper<StringPair> string_pair(m, "StringPair");
-    string_pair.def(py::Constructor<std::string, std::string>());
+    python::class_builder<StringPair> string_pair(m, "StringPair");
+    string_pair.def(python::constructor<std::string, std::string>());
     string_pair.def_readonly(&StringPair::first, "first");
     string_pair.def_read_write(&StringPair::second, "second");
     string_pair.def(&stringpair_repr, "__repr__");
@@ -853,10 +853,10 @@ void init_module(py::Module& m)
     m.def(second_string, "second_string");
 
     // This shows the wrapping of a 3rd-party numeric type.
-    py::ClassWrapper<boost::rational<int> > rational(m, "Rational");
-    rational.def(py::Constructor<int, int>());
-    rational.def(py::Constructor<int>());
-    rational.def(py::Constructor<>());
+    python::class_builder<boost::rational<int> > rational(m, "Rational");
+    rational.def(python::constructor<int, int>());
+    rational.def(python::constructor<int>());
+    rational.def(python::constructor<>());
     rational.def(StandardOps<Ratio>::add, "__add__");
     rational.def(StandardOps<Ratio>::sub, "__sub__");
     rational.def(StandardOps<Ratio>::mul, "__mul__");
@@ -867,9 +867,9 @@ void init_module(py::Module& m)
     rational.def(ratio_repr, "__repr__");
     rational.def(ratio_abs, "__abs__");
     
-    py::ClassWrapper<Range> range(m, "Range");
-    range.def(py::Constructor<int>());
-    range.def(py::Constructor<int, int>());
+    python::class_builder<Range> range(m, "Range");
+    range.def(python::constructor<int>());
+    range.def(python::constructor<int, int>());
     range.def((void (Range::*)(std::size_t))&Range::length, "__len__");
     range.def((std::size_t (Range::*)() const)&Range::length, "__len__");
     range.def(&Range::operator[], "__getitem__");
@@ -888,14 +888,14 @@ void init_module(py::Module& m)
     m.def(&test4, "overloaded");
     m.def(&test5, "overloaded");
 
-    py::ClassWrapper<OverloadTest> over(m, "OverloadTest");
-    over.def(py::Constructor<>());
-    over.def(py::Constructor<OverloadTest const &>());
-    over.def(py::Constructor<int>());
-    over.def(py::Constructor<int, int>());
-    over.def(py::Constructor<int, int, int>());
-    over.def(py::Constructor<int, int, int, int>());
-    over.def(py::Constructor<int, int, int, int, int>());
+    python::class_builder<OverloadTest> over(m, "OverloadTest");
+    over.def(python::constructor<>());
+    over.def(python::constructor<OverloadTest const &>());
+    over.def(python::constructor<int>());
+    over.def(python::constructor<int, int>());
+    over.def(python::constructor<int, int, int>());
+    over.def(python::constructor<int, int, int, int>());
+    over.def(python::constructor<int, int, int, int, int>());
     over.def(&getX, "getX");
     over.def(&OverloadTest::setX, "setX");
     over.def(&OverloadTest::x, "overloaded");
@@ -905,19 +905,19 @@ void init_module(py::Module& m)
     over.def(&OverloadTest::p4, "overloaded");
     over.def(&OverloadTest::p5, "overloaded");
     
-    py::ClassWrapper<Base> base(m, "Base");
+    python::class_builder<Base> base(m, "Base");
     base.def(&Base::x, "x");
     
-    py::ClassWrapper<Derived1> derived1(m, "Derived1");    
+    python::class_builder<Derived1> derived1(m, "Derived1");    
     // this enables conversions between Base and Derived1
     // and makes wrapped methods of Base available 
     derived1.declare_base(base);
-    derived1.def(py::Constructor<int>());
+    derived1.def(python::constructor<int>());
 
-    py::ClassWrapper<Derived2> derived2(m, "Derived2");    
+    python::class_builder<Derived2> derived2(m, "Derived2");    
     // don't enable downcast from Base to Derived2 
-    derived2.declare_base(base, py::without_downcast);
-    derived2.def(py::Constructor<int>());
+    derived2.declare_base(base, python::without_downcast);
+    derived2.def(python::constructor<int>());
     
     m.def(&testUpcast, "testUpcast");
     m.def(&derived1Factory, "derived1Factory");
@@ -925,12 +925,12 @@ void init_module(py::Module& m)
     m.def(&testDowncast1, "testDowncast1");
     m.def(&testDowncast2, "testDowncast2");
 
-    py::ClassWrapper<CallbackTestBase> callbackTestBase(m, "CallbackTestBase");
+    python::class_builder<CallbackTestBase> callbackTestBase(m, "CallbackTestBase");
     callbackTestBase.def(&CallbackTestBase::testCallback, "testCallback");
     m.def(&testCallback, "testCallback");
 
-    py::ClassWrapper<CallbackTest, CallbackTestCallback> callbackTest(m, "CallbackTest");
-    callbackTest.def(py::Constructor<>());
+    python::class_builder<CallbackTest, CallbackTestCallback> callbackTest(m, "CallbackTest");
+    callbackTest.def(python::constructor<>());
     callbackTest.def(&CallbackTest::callback, "callback", 
                    &CallbackTestCallback::default_callback);
     callbackTest.def(&CallbackTest::callbackString, "callback", 
@@ -938,28 +938,28 @@ void init_module(py::Module& m)
 
     callbackTest.declare_base(callbackTestBase);     
 
-    py::ClassWrapper<A1, A_callback> a1_class(m, "A1");
-    a1_class.def(py::Constructor<>());
+    python::class_builder<A1, A_callback> a1_class(m, "A1");
+    a1_class.def(python::constructor<>());
     a1_class.def(&A1::overrideA1, "overrideA1", &A_callback::default_overrideA1);
     a1_class.def(&A1::inheritA1, "inheritA1", &A_callback::default_inheritA1);
 
-    py::ClassWrapper<A2> a2_class(m, "A2");
-    a2_class.def(py::Constructor<>());
+    python::class_builder<A2> a2_class(m, "A2");
+    a2_class.def(python::constructor<>());
     a2_class.def(&A2::inheritA2, "inheritA2");
 
-    py::ClassWrapper<B1, B_callback> b1_class(m, "B1");
+    python::class_builder<B1, B_callback> b1_class(m, "B1");
     b1_class.declare_base(a1_class);  
     b1_class.declare_base(a2_class);  
 
-    b1_class.def(py::Constructor<>());
+    b1_class.def(python::constructor<>());
     b1_class.def(&B1::overrideA1, "overrideA1", &B_callback::default_overrideA1); 
     b1_class.def(&B1::overrideB1, "overrideB1", &B_callback::default_overrideB1); 
 
-    py::ClassWrapper<B2> b2_class(m, "B2");
+    python::class_builder<B2> b2_class(m, "B2");
     b2_class.declare_base(a1_class);  
     b2_class.declare_base(a2_class);  
 
-    b2_class.def(py::Constructor<>());
+    b2_class.def(python::constructor<>());
     b2_class.def(&B2::overrideA1, "overrideA1"); 
     b2_class.def(&B2::inheritB2, "inheritB2"); 
     
@@ -976,40 +976,40 @@ void init_module(py::Module& m)
     m.def(factoryB1asB1, "factoryB1asB1");    
     m.def(factoryCasB1, "factoryCasB1");    
     
-    py::ClassWrapper<RawTest> rawtest_class(m, "RawTest");
-    rawtest_class.def(py::Constructor<int>());
+    python::class_builder<RawTest> rawtest_class(m, "RawTest");
+    rawtest_class.def(python::constructor<int>());
     rawtest_class.def_raw(&raw, "raw");
     
     m.def_raw(&raw, "raw");
     m.def_raw(&raw1, "raw1");
     m.def_raw(&raw2, "raw2");
     
-    py::ClassWrapper<Int> int_class(m, "Int");
-    int_class.def(py::Constructor<int>());
+    python::class_builder<Int> int_class(m, "Int");
+    int_class.def(python::constructor<int>());
     int_class.def(&Int::i, "i");
 
     // wrap homogeneous operators
-    int_class.def(py::operators<(py::op_add | py::op_sub | py::op_neg | 
-          py::op_cmp | py::op_str | py::op_divmod | py::op_pow )>());
+    int_class.def(python::operators<(python::op_add | python::op_sub | python::op_neg | 
+          python::op_cmp | python::op_str | python::op_divmod | python::op_pow )>());
     // export non-operator functions as homogeneous operators
     int_class.def(&mul, "__mul__");
     int_class.def(&powmod, "__pow__");
 
     // wrap heterogeneous operators (lhs: Int const &, rhs: int const &)
-    int_class.def(py::operators<(py::op_add | py::op_sub | py::op_cmp | py::op_pow)>(), 
-                  py::right_operand<int const & >());
+    int_class.def(python::operators<(python::op_add | python::op_sub | python::op_cmp | python::op_pow)>(), 
+                  python::right_operand<int const & >());
     // export non-operator function as heterogeneous operator
     int_class.def(&imul, "__mul__");
 
     // wrap heterogeneous operators (lhs: int const &, rhs: Int const &)
-    int_class.def(py::operators<(py::op_add | py::op_sub | py::op_cmp)>(), 
-                  py::left_operand<int const & >());
+    int_class.def(python::operators<(python::op_add | python::op_sub | python::op_cmp)>(), 
+                  python::left_operand<int const & >());
     // export non-operator function as heterogeneous reverse-argument operator
     int_class.def(&rmul, "__rmul__");
     
 
-    py::ClassWrapper<EnumOwner> enum_owner(m, "EnumOwner");
-    enum_owner.def(py::Constructor<EnumOwner::enum_type, const EnumOwner::enum_type&>());
+    python::class_builder<EnumOwner> enum_owner(m, "EnumOwner");
+    enum_owner.def(python::constructor<EnumOwner::enum_type, const EnumOwner::enum_type&>());
     enum_owner.def(&EnumOwner::set_first, "__setattr__first__");
     enum_owner.def(&EnumOwner::set_second, "__setattr__second__");
     enum_owner.def(&EnumOwner::first, "__getattr__first__");
@@ -1021,10 +1021,10 @@ void init_module(py::Module& m)
     // pickling support
     
     // Create the Python type object for our extension class.
-    py::ClassWrapper<world> world_class(m, "world");
+    python::class_builder<world> world_class(m, "world");
 
     // Add the __init__ function.
-    world_class.def(py::Constructor<std::string>());
+    world_class.def(python::constructor<std::string>());
     // Add a regular member function.
     world_class.def(&world::greet, "greet");
     world_class.def(&world::get_secret_number, "get_secret_number");
@@ -1036,30 +1036,30 @@ void init_module(py::Module& m)
     world_class.def(world_setstate, "__setstate__");
 }
 
-PyObject* raw(py::Tuple const& args, py::Dict const& keywords)
+PyObject* raw(python::tuple const& args, python::dictionary const& keywords)
 {
     if(args.size() != 2 || keywords.size() != 2)
     {
         PyErr_SetString(PyExc_TypeError, "wrong number of arguments");
-        throw py::ArgumentError();
+        throw python::argument_error();
     }
     
-    RawTest* first = PY_CONVERSION::from_python(args[0].get(), py::Type<RawTest*>());
-    int second = PY_CONVERSION::from_python(args[1].get(), py::Type<int>());
+    RawTest* first = BOOST_PYTHON_CONVERSION::from_python(args[0].get(), python::type<RawTest*>());
+    int second = BOOST_PYTHON_CONVERSION::from_python(args[1].get(), python::type<int>());
     
-    int third = PY_CONVERSION::from_python(keywords[py::String("third")].get(), py::Type<int>());
-    int fourth = PY_CONVERSION::from_python(keywords[py::String("fourth")].get(), py::Type<int>());
+    int third = BOOST_PYTHON_CONVERSION::from_python(keywords[python::string("third")].get(), python::type<int>());
+    int fourth = BOOST_PYTHON_CONVERSION::from_python(keywords[python::string("fourth")].get(), python::type<int>());
     
-    return PY_CONVERSION::to_python(first->i_ + second + third + fourth);
+    return BOOST_PYTHON_CONVERSION::to_python(first->i_ + second + third + fourth);
 }
 
 void init_module()
 {
-    py::Module demo("demo");
+    python::module_builder demo("demo");
     init_module(demo);
 
     // Just for giggles, add a raw metaclass.
-    demo.add(new py::MetaClass<py::Instance>);
+    demo.add(new python::meta_class<python::instance>);
 }
 
 extern "C"
@@ -1072,14 +1072,14 @@ void initdemo()
         extclass_demo::init_module();
     }
     catch(...) {
-        py::handle_exception();
+        python::handle_exception();
     } // Need a way to report other errors here
 }
 
-CompareIntPairPythonClass::CompareIntPairPythonClass(py::Module& m)
-    : py::ClassWrapper<CompareIntPair>(m, "CompareIntPair")
+CompareIntPairPythonClass::CompareIntPairPythonClass(python::module_builder& m)
+    : python::class_builder<CompareIntPair>(m, "CompareIntPair")
 {
-    def(py::Constructor<>());
+    def(python::constructor<>());
     def(&CompareIntPair::operator(), "__call__");
 }
 
@@ -1096,7 +1096,7 @@ CompareIntPairPythonClass::CompareIntPairPythonClass(py::Module& m)
 # endif
 extern "C" BOOL WINAPI DllMain ( HINSTANCE hInst, DWORD wDataSeg, LPVOID lpvReserved );
 
-# ifdef PY_COMPILER_IS_MSVC
+# ifdef BOOST_MSVC
 extern "C" void structured_exception_translator(unsigned int, EXCEPTION_POINTERS*)
 {
     throw;
@@ -1104,7 +1104,7 @@ extern "C" void structured_exception_translator(unsigned int, EXCEPTION_POINTERS
 # endif
 
 #ifndef NDEBUG
-namespace py { namespace detail { extern int total_Dispatchers; }}
+namespace python { namespace detail { extern int total_Dispatchers; }}
 #endif
 
 BOOL WINAPI DllMain(
@@ -1113,7 +1113,7 @@ BOOL WINAPI DllMain(
     LPVOID  // lpvReserved
     )
 {
-# ifdef PY_COMPILER_IS_MSVC
+# ifdef BOOST_MSVC
     _set_se_translator(structured_exception_translator);
 #endif
     (void)fdwReason; // warning suppression.
diff --git a/extclass_demo.h b/extclass_demo.h
index c9938c92..fd21dfb6 100644
--- a/extclass_demo.h
+++ b/extclass_demo.h
@@ -52,7 +52,7 @@ class Foo                // prohibit copying, proving that it doesn't choke
  public: // friend declarations
     // If you have private virtual functions such as add_len which you want to
     // override in Python and have default implementations, they must be
-    // accessible by the thing making the def() call on the ExtensionClass (in
+    // accessible by the thing making the def() call on the extension_class (in
     // this case, the nested PythonClass itself), and by the C++ derived class
     // which is used to cause the Python callbacks (in this case,
     // FooCallback). See the definition of FooCallback::add_len()
@@ -180,25 +180,25 @@ class FooCallback : public Foo
     std::string pure() const;
 
  private: // Required boilerplate if functions will be overridden
-    PyObject* m_self; // No, we don't want a py::Ptr here, or we'd get an ownership cycle.
+    PyObject* m_self; // No, we don't want a python::ref here, or we'd get an ownership cycle.
 };
 
 // Define the Python base class
-struct Foo::PythonClass : py::ClassWrapper<Foo, FooCallback> { PythonClass(py::Module&); };
+struct Foo::PythonClass : python::class_builder<Foo, FooCallback> { PythonClass(python::module_builder&); };
 
 // No virtual functions on Bar or Baz which are actually supposed to behave
 // virtually from C++, so we'll rely on the library to define a wrapper for
-// us. Even so, Python Class types for each type we're wrapping should be
+// us. Even so, Python class_t types for each type we're wrapping should be
 // _defined_ here in a header where they can be seen by other extension class
-// definitions, since it is the definition of the py::ClassWrapper<> that
+// definitions, since it is the definition of the python::class_builder<> that
 // causes to_python/from_python conversion functions to be generated.
-struct BarPythonClass : py::ClassWrapper<Bar> { BarPythonClass(py::Module&); };
-struct BazPythonClass : py::ClassWrapper<Baz> { BazPythonClass(py::Module&); };
+struct BarPythonClass : python::class_builder<Bar> { BarPythonClass(python::module_builder&); };
+struct BazPythonClass : python::class_builder<Baz> { BazPythonClass(python::module_builder&); };
 
 struct StringMapPythonClass
-    : py::ClassWrapper<StringMap>
+    : python::class_builder<StringMap>
 {
-    StringMapPythonClass(py::Module&);
+    StringMapPythonClass(python::module_builder&);
     
     // These static functions implement the right argument protocols for
     // implementing the Python "special member functions" for mapping on
@@ -209,9 +209,9 @@ struct StringMapPythonClass
 };
 
 struct IntPairPythonClass
-    : py::ClassWrapper<IntPair>
+    : python::class_builder<IntPair>
 {
-    IntPairPythonClass(py::Module&);
+    IntPairPythonClass(python::module_builder&);
     
     // The following could just as well be a free function; it implements the
     // getattr functionality for IntPair.
@@ -221,9 +221,9 @@ struct IntPairPythonClass
 };
 
 struct CompareIntPairPythonClass
-    : py::ClassWrapper<CompareIntPair>
+    : python::class_builder<CompareIntPair>
 {
-    CompareIntPairPythonClass(py::Module&);
+    CompareIntPairPythonClass(python::module_builder&);
 };
 
 } // namespace extclass_demo
diff --git a/functions.cpp b/functions.cpp
index 7e07c4d8..0cd24306 100644
--- a/functions.cpp
+++ b/functions.cpp
@@ -12,30 +12,30 @@
 #include "objects.h"
 #include "errors.h"
 
-namespace py { namespace detail {
+namespace python { namespace detail {
 
-struct Function::TypeObject :
-        Singleton<Function::TypeObject, Callable<py::detail::TypeObject<Function> > >
+struct function::type_object :
+        singleton<function::type_object, callable<python::detail::type_object<function> > >
 {
-    TypeObject() : SingletonBase(&PyType_Type) {}
+    type_object() : singleton_base(&PyType_Type) {}
 };
 
 
-void Function::add_to_namespace(PyPtr<Function> new_function, const char* name, PyObject* dict)
+void function::add_to_namespace(reference<function> new_function, const char* name, PyObject* dict)
 {
-    Dict d(Ptr(dict, Ptr::borrowed));
-    String key(name);
+    dictionary d(ref(dict, ref::increment_count));
+    string key(name);
     
-    Ptr existing_object = d.get_item(key.reference());
+    ref existing_object = d.get_item(key.reference());
     if (existing_object.get() == 0)
     {
-        d[key] = Ptr(new_function.get(), Ptr::borrowed);
+        d[key] = ref(new_function.get(), ref::increment_count);
     }
     else
     {
-        if (existing_object->ob_type == TypeObject::singleton())
+        if (existing_object->ob_type == type_object::instance())
         {
-            Function* f = static_cast<Function*>(existing_object.get());
+            function* f = static_cast<function*>(existing_object.get());
             while (f->m_overloads.get() != 0)
                 f = f->m_overloads.get();
             f->m_overloads = new_function;
@@ -43,22 +43,22 @@ void Function::add_to_namespace(PyPtr<Function> new_function, const char* name,
         else
         {
             PyErr_SetObject(PyExc_RuntimeError,
-                            (String("Attempt to overload ") + name
+                            (string("Attempt to overload ") + name
                              + " failed. The existing attribute has type "
                              + existing_object->ob_type->tp_name).get());
-            throw ErrorAlreadySet();
+            throw error_already_set();
         }
     }
 }
 
-Function::Function()
-    : PythonObject(TypeObject::singleton())
+function::function()
+    : python_object(type_object::instance())
 {
 }
 
-PyObject* Function::call(PyObject* args, PyObject* keywords) const
+PyObject* function::call(PyObject* args, PyObject* keywords) const
 {
-    for (const Function* f = this; f != 0; f = f->m_overloads.get())
+    for (const function* f = this; f != 0; f = f->m_overloads.get())
     {
         PyErr_Clear();
         try
@@ -67,7 +67,7 @@ PyObject* Function::call(PyObject* args, PyObject* keywords) const
             if (result != 0)
                 return result;
         }
-        catch(const ArgumentError&)
+        catch(const argument_error&)
         {
         }
     }
@@ -76,8 +76,8 @@ PyObject* Function::call(PyObject* args, PyObject* keywords) const
         return 0;
 
     PyErr_Clear();
-    String message("No overloaded functions match (");
-    Tuple arguments(Ptr(args, Ptr::borrowed));
+    string message("No overloaded functions match (");
+    tuple arguments(ref(args, ref::increment_count));
     for (std::size_t i = 0; i < arguments.size(); ++i)
     {
         if (i != 0)
@@ -86,7 +86,7 @@ PyObject* Function::call(PyObject* args, PyObject* keywords) const
     }
 
     message += "). Candidates are:\n";
-    for (const Function* f1 = this; f1 != 0; f1 = f1->m_overloads.get())
+    for (const function* f1 = this; f1 != 0; f1 = f1->m_overloads.get())
     {
         if (f1 != this)
             message += "\n";
@@ -97,11 +97,11 @@ PyObject* Function::call(PyObject* args, PyObject* keywords) const
     return 0;
 }
 
-BoundFunction* BoundFunction::create(const Ptr& target, const Ptr& fn)
+bound_function* bound_function::create(const ref& target, const ref& fn)
 {
-    BoundFunction* const result = free_list;
+    bound_function* const result = free_list;
     if (result == 0)
-        return new BoundFunction(target, fn);
+        return new bound_function(target, fn);
     
     free_list = result->m_free_list_link;
     result->m_target = target;
@@ -110,21 +110,21 @@ BoundFunction* BoundFunction::create(const Ptr& target, const Ptr& fn)
     return result;
 }
 
-// The singleton class whose instance represents the type of BoundFunction
-// objects in Python. BoundFunctions must be GetAttrable so the __doc__
+// The instance class whose obj represents the type of bound_function
+// objects in Python. bound_functions must be GetAttrable so the __doc__
 // attribute of built-in Python functions can be accessed when bound.
-struct BoundFunction::TypeObject :
-    Singleton<BoundFunction::TypeObject,
-              Getattrable<Callable<py::detail::TypeObject<BoundFunction> > > >
+struct bound_function::type_object :
+    singleton<bound_function::type_object,
+              getattrable<callable<python::detail::type_object<bound_function> > > >
 {
-    TypeObject() : SingletonBase(&PyType_Type) {}
+    type_object() : singleton_base(&PyType_Type) {}
     
-private: // TypeObject<BoundFunction> hook override
-    void dealloc(BoundFunction*) const;
+private: // type_object<bound_function> hook override
+    void dealloc(bound_function*) const;
 };
 
-BoundFunction::BoundFunction(const Ptr& target, const Ptr& fn)
-    : PythonObject(TypeObject::singleton()),
+bound_function::bound_function(const ref& target, const ref& fn)
+    : python_object(type_object::instance()),
       m_target(target),
       m_unbound_function(fn),
       m_free_list_link(0)
@@ -132,11 +132,11 @@ BoundFunction::BoundFunction(const Ptr& target, const Ptr& fn)
 }
 
 PyObject*
-BoundFunction::call(PyObject* args, PyObject* keywords) const
+bound_function::call(PyObject* args, PyObject* keywords) const
 {
     // Build a new tuple which prepends the target to the arguments
-    Tuple tail_arguments(Ptr(args, Ptr::borrowed));
-    Ptr all_arguments(PyTuple_New(tail_arguments.size() + 1));
+    tuple tail_arguments(ref(args, ref::increment_count));
+    ref all_arguments(PyTuple_New(tail_arguments.size() + 1));
 
     PyTuple_SET_ITEM(all_arguments.get(), 0, m_target.get());
     Py_INCREF(m_target.get());
@@ -149,19 +149,19 @@ BoundFunction::call(PyObject* args, PyObject* keywords) const
     return PyEval_CallObjectWithKeywords(m_unbound_function.get(), all_arguments.get(), keywords);
 }
 
-PyObject* BoundFunction::getattr(const char* name) const
+PyObject* bound_function::getattr(const char* name) const
 {
     return PyObject_GetAttrString(m_unbound_function.get(), const_cast<char*>(name));
 }
 
-void BoundFunction::TypeObject::dealloc(BoundFunction* instance) const
+void bound_function::type_object::dealloc(bound_function* obj) const
 {
-    instance->m_free_list_link = free_list;
-    free_list = instance;
-    instance->m_target.reset();
-    instance->m_unbound_function.reset();
+    obj->m_free_list_link = free_list;
+    free_list = obj;
+    obj->m_target.reset();
+    obj->m_unbound_function.reset();
 }
 
-BoundFunction* BoundFunction::free_list;
+bound_function* bound_function::free_list;
 
-}} // namespace py::detail
+}} // namespace python::detail
diff --git a/functions.h b/functions.h
index 36c6de13..ec982f53 100644
--- a/functions.h
+++ b/functions.h
@@ -20,36 +20,36 @@
 # include <typeinfo>
 # include <vector>
 
-namespace py { namespace detail {
+namespace python { namespace detail {
 
 // forward declaration
-class ExtensionInstance;
+class extension_instance;
 
 
-// Function --
+// function --
 //      the common base class for all overloadable function and method objects
 //      supplied by the library.
-class Function : public PythonObject
+class function : public python_object
 {
  public:
-    Function();
-    // Function objects are reasonably rare, so we guess we can afford a virtual table.
+    function();
+    // function objects are reasonably rare, so we guess we can afford a virtual table.
     // This cuts down on the number of distinct type objects which need to be defined.
-    virtual ~Function() {}
+    virtual ~function() {}
 
     PyObject* call(PyObject* args, PyObject* keywords) const;
-    static void add_to_namespace(PyPtr<Function> f, const char* name, PyObject* dict);
+    static void add_to_namespace(reference<function> f, const char* name, PyObject* dict);
     
  private:
     virtual PyObject* do_call(PyObject* args, PyObject* keywords) const = 0;
     virtual const char* description() const = 0;
  private:
-    struct TypeObject;
+    struct type_object;
  private:
-    PyPtr<Function> m_overloads;
+    reference<function> m_overloads;
 };
 
-// WrappedFunctionPointer<> --
+// wrapped_function_pointer<> --
 //      A single function or member function pointer wrapped and presented to
 //      Python as a callable object.
 //
@@ -57,22 +57,22 @@ class Function : public PythonObject
 //      R - the return type of the function pointer
 //      F - the complete type of the wrapped function pointer
 template <class R, class F>
-struct WrappedFunctionPointer : Function
+struct wrapped_function_pointer : function
 {
-	typedef F PtrFun; // pointer-to--function or pointer-to-member-function
+	typedef F ptr_fun; // pointer-to--function or pointer-to-member-function
 	
-	WrappedFunctionPointer(PtrFun pf)
+	wrapped_function_pointer(ptr_fun pf)
         : m_pf(pf) {}
 
  private:
 	PyObject* do_call(PyObject* args, PyObject* keywords) const
-        { return Caller<R>::call(m_pf, args, keywords); }
+        { return caller<R>::call(m_pf, args, keywords); }
     
     const char* description() const
         { return typeid(F).name(); }
     
  private:
-	const PtrFun m_pf;
+	const ptr_fun m_pf;
 };
 
 // raw_arguments_function
@@ -80,30 +80,30 @@ struct WrappedFunctionPointer : Function
 //      verbatim to C++ (useful for customized argument parsing and variable
 //      argument lists)
 template <class Ret, class Args, class Keywords>
-struct raw_arguments_function : Function
+struct raw_arguments_function : function
 {
-	typedef Ret (*PtrFun)(Args, Keywords); 
+	typedef Ret (*ptr_fun)(Args, Keywords); 
 	
-	raw_arguments_function(PtrFun pf)
+	raw_arguments_function(ptr_fun pf)
         : m_pf(pf) {}
 
  private:
 	PyObject* do_call(PyObject* args, PyObject* keywords) const
     { 
-        Ptr dict(keywords ? 
-                 Ptr(keywords, Ptr::new_ref) :
-                 Ptr(PyDict_New()));
+        ref dict(keywords ? 
+                 ref(keywords, ref::increment_count) :
+                 ref(PyDict_New()));
             
         return to_python(
-            (*m_pf)(from_python(args, py::Type<Args>()),
-                    from_python(dict.get(), py::Type<Keywords>()))); 
+            (*m_pf)(from_python(args, python::type<Args>()),
+                    from_python(dict.get(), python::type<Keywords>()))); 
     }
     
     const char* description() const
-        { return typeid(PtrFun).name(); }
+        { return typeid(ptr_fun).name(); }
     
  private:
-	const PtrFun m_pf;
+	const ptr_fun m_pf;
 };
 
 // virtual_function<> --
@@ -119,7 +119,7 @@ struct raw_arguments_function : Function
 //          parameter and calls T::f on it /non-virtually/, where V
 //          approximates &T::f.
 template <class T, class R, class V, class D>
-class virtual_function : public Function
+class virtual_function : public function
 {
  public:
 	virtual_function(V virtual_function_ptr, D default_implementation)
@@ -140,92 +140,92 @@ class virtual_function : public Function
 
 // A helper function for new_member_function(), below.  Implements the core
 // functionality once the return type has already been deduced. R is expected to
-// be Type<X>, where X is the actual return type of pmf.
+// be type<X>, where X is the actual return type of pmf.
 template <class F, class R>
-Function* new_wrapped_function_aux(R, F pmf)
+function* new_wrapped_function_aux(R, F pmf)
 {
     // We can't just use "typename R::Type" below because MSVC (incorrectly) pukes.
-    typedef typename R::Type ReturnType;
-    return new WrappedFunctionPointer<ReturnType, F>(pmf);
+    typedef typename R::type return_type;
+    return new wrapped_function_pointer<return_type, F>(pmf);
 }
 
 // Create and return a new member function object wrapping the given
 // pointer-to-member function
 template <class F>
-inline Function* new_wrapped_function(F pmf)
+inline function* new_wrapped_function(F pmf)
 {
     // Deduce the return type and pass it off to the helper function above
 	return new_wrapped_function_aux(return_value(pmf), pmf);
 }
 
-template <class R, class Args, class Keywords>
-Function* new_raw_arguments_function(R (*pmf)(Args, Keywords))
+template <class R, class Args, class keywords>
+function* new_raw_arguments_function(R (*pmf)(Args, keywords))
 {
-    return new raw_arguments_function<R, Args, Keywords>(pmf);
+    return new raw_arguments_function<R, Args, keywords>(pmf);
 }
 
 
 // A helper function for new_virtual_function(), below.  Implements the core
 // functionality once the return type has already been deduced. R is expected to
-// be Type<X>, where X is the actual return type of V.
+// be type<X>, where X is the actual return type of V.
 template <class T, class R, class V, class D>
-inline Function* new_virtual_function_aux(
-    Type<T>, R, V virtual_function_ptr, D default_implementation
+inline function* new_virtual_function_aux(
+    type<T>, R, V virtual_function_ptr, D default_implementation
     )
 {
     // We can't just use "typename R::Type" below because MSVC (incorrectly) pukes.
-    typedef typename R::Type ReturnType;
-    return new virtual_function<T, ReturnType, V, D>(
+    typedef typename R::type return_type;
+    return new virtual_function<T, return_type, V, D>(
         virtual_function_ptr, default_implementation);
 }
 
 // Create and return a new virtual_function object wrapping the given
 // virtual_function_ptr and default_implementation
 template <class T, class V, class D>
-inline Function* new_virtual_function(
-    Type<T>, V virtual_function_ptr, D default_implementation
+inline function* new_virtual_function(
+    type<T>, V virtual_function_ptr, D default_implementation
     )
 {
     // Deduce the return type and pass it off to the helper function above
     return new_virtual_function_aux(
-        Type<T>(), return_value(virtual_function_ptr),
+        type<T>(), return_value(virtual_function_ptr),
         virtual_function_ptr, default_implementation);
 }
 
 // A function with a bundled "bound target" object. This is what is produced by
-// the expression a.b where a is an Instance or ExtensionInstance object and b
-// is a callable object not found in the instance namespace but on its class or
+// the expression a.b where a is an instance or extension_instance object and b
+// is a callable object not found in the obj namespace but on its class or
 // a base class.
-class BoundFunction : public PythonObject
+class bound_function : public python_object
 {
  public:
-    static BoundFunction* create(const Ptr& target, const Ptr& fn);
+    static bound_function* create(const ref& target, const ref& fn);
     
-    BoundFunction(const Ptr& target, const Ptr& fn);
+    bound_function(const ref& target, const ref& fn);
     PyObject* call(PyObject*args, PyObject* keywords) const;
     PyObject* getattr(const char* name) const;
     
  private:
-    struct TypeObject;
-    friend struct TypeObject;
+    struct type_object;
+    friend struct type_object;
     
-    Ptr m_target;
-    Ptr m_unbound_function;
+    ref m_target;
+    ref m_unbound_function;
     
  private: // data members for allocation/deallocation optimization
-    BoundFunction* m_free_list_link;
+    bound_function* m_free_list_link;
 
-	static BoundFunction* free_list;
+	static bound_function* free_list;
 };
 
 // Special functions designed to access data members of a wrapped C++ object.
 template <class ClassType, class MemberType>
-class GetterFunction : public Function
+class getter_function : public function
 {
  public:
-    typedef MemberType ClassType::* PointerToMember;
+    typedef MemberType ClassType::* pointer_to_member;
     
-    GetterFunction(PointerToMember pm)
+    getter_function(pointer_to_member pm)
         : m_pm(pm) {}
 
  private:
@@ -234,16 +234,16 @@ class GetterFunction : public Function
     const char* description() const
         { return typeid(MemberType (*)(const ClassType&)).name(); }
  private:
-    PointerToMember m_pm;
+    pointer_to_member m_pm;
 };
 
 template <class ClassType, class MemberType>
-class SetterFunction : public Function
+class setter_function : public function
 {
  public:
-    typedef MemberType ClassType::* PointerToMember;
+    typedef MemberType ClassType::* pointer_to_member;
     
-    SetterFunction(PointerToMember pm)
+    setter_function(pointer_to_member pm)
         : m_pm(pm) {}
 
  private:
@@ -252,11 +252,11 @@ class SetterFunction : public Function
     const char* description() const
         { return typeid(void (*)(const ClassType&, const MemberType&)).name(); }
  private:
-    PointerToMember m_pm;
+    pointer_to_member m_pm;
 };
 
 template <class ClassType, class MemberType>
-PyObject* GetterFunction<ClassType, MemberType>::do_call(
+PyObject* getter_function<ClassType, MemberType>::do_call(
     PyObject* args, PyObject* /* keywords */) const
 {
     PyObject* self;
@@ -264,11 +264,11 @@ PyObject* GetterFunction<ClassType, MemberType>::do_call(
         return 0;
 
     return to_python(
-        from_python(self, Type<const ClassType*>())->*m_pm);
+        from_python(self, type<const ClassType*>())->*m_pm);
 }
 
 template <class ClassType, class MemberType>
-PyObject* SetterFunction<ClassType, MemberType>::do_call(
+PyObject* setter_function<ClassType, MemberType>::do_call(
     PyObject* args, PyObject* /* keywords */) const
 {
     PyObject* self;
@@ -276,9 +276,9 @@ PyObject* SetterFunction<ClassType, MemberType>::do_call(
     if (!PyArg_ParseTuple(args, const_cast<char*>("OO"), &self, &value))
         return 0;
     
-    typedef typename boost::call_traits<MemberType>::const_reference ExtractType;
-    from_python(self, Type<ClassType*>())->*m_pm
-        = from_python(value, Type<ExtractType>());
+    typedef typename boost::call_traits<MemberType>::const_reference extract_type;
+    from_python(self, type<ClassType*>())->*m_pm
+        = from_python(value, type<extract_type>());
     
     return none();
 }
@@ -291,16 +291,16 @@ PyObject* virtual_function<T,R,V,D>::do_call(PyObject* args, PyObject* keywords)
     PyObject* target = PyTuple_GetItem(args, 0);
     if (target != 0)
     {
-        ExtensionInstance* self = get_extension_instance(target);
+        extension_instance* self = get_extension_instance(target);
         if (self->wrapped_objects().size() == 1
             && !self->wrapped_objects()[0]->held_by_value())
         {
-            return Caller<R>::call(m_virtual_function_ptr, args, keywords);
+            return caller<R>::call(m_virtual_function_ptr, args, keywords);
         }
     }
-    return Caller<R>::call(m_default_implementation, args, keywords);
+    return caller<R>::call(m_default_implementation, args, keywords);
 }
     
-}} // namespace py::detail
+}} // namespace python::detail
 
 #endif // FUNCTIONS_DWA051400_H_
diff --git a/gen_all.py b/gen_all.py
index c6c00c1f..fd8d78cc 100644
--- a/gen_all.py
+++ b/gen_all.py
@@ -10,7 +10,7 @@ def gen_all(args):
     open('caller.h', 'w').write(gen_caller(args))
     open('init_function.h', 'w').write(gen_init_function(args))
     open('signatures.h', 'w').write(gen_signatures(args))
-    open('singleton.h', 'w').write(gen_singleton(args))
+    open('instance.h', 'w').write(gen_singleton(args))
     open('extclass.h', 'w').write(gen_extclass(args))
 
 if __name__ == '__main__':
diff --git a/gen_callback.py b/gen_callback.py
index 1f34f9d7..c907e612 100644
--- a/gen_callback.py
+++ b/gen_callback.py
@@ -11,7 +11,7 @@ def gen_callback(args):
 //  The author gratefully acknowleges the support of Dragon Systems, Inc., in
 //  producing this work.
 //
-//  This file was generated for %d-argument python callbacks by gen_callback.py
+//  This file was generated for %d-argument python callbacks by gen_callback.python
 
 #ifndef CALLBACK_DWA_052100_H_
 # define CALLBACK_DWA_052100_H_
@@ -19,41 +19,41 @@ def gen_callback(args):
 # include "pyconfig.h"
 # include "py.h"
 
-namespace py {
+namespace python {
 
 namespace detail {
   template <class T>
-  inline void callback_adjust_refcount(PyObject*, Type<T>) {}
+  inline void callback_adjust_refcount(PyObject*, type<T>) {}
   
-  inline void callback_adjust_refcount(PyObject* p, Type<PyObject*>)
+  inline void callback_adjust_refcount(PyObject* p, type<PyObject*>)
       { Py_INCREF(p); }
 }
 
 // Calling Python from C++
 template <class R>
-struct Callback
+struct callback
 {""" % args
 
     + gen_functions('''
 %{    template <%(class A%n%:, %)>
 %}    static R call_method(PyObject* self, const char* name%(, const A%n& a%n%))
     {%(
-        Ptr p%n(to_python(a%n));%)
-        Ptr result(PyEval_CallMethod(self, const_cast<char*>(name),
+        ref p%n(to_python(a%n));%)
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
                                      const_cast<char*>("(%(O%))")%(,
                                      p%n.get()%)));
-        detail::callback_adjust_refcount(result.get(), Type<R>());
-        return from_python(result.get(), Type<R>());
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
     }
 
 %{    template <%(class A%n%:, %)>
 %}    static R call(PyObject* self%(, const A%n& a%n%))
     {%(
-        Ptr p%n(to_python(a%n));%)
-        Ptr result(PyEval_CallFunction(self, const_cast<char*>("(%(O%))")%(,
+        ref p%n(to_python(a%n));%)
+        ref result(PyEval_CallFunction(self, const_cast<char*>("(%(O%))")%(,
                                        p%n.get()%)));
-        detail::callback_adjust_refcount(result.get(), Type<R>());
-        return from_python(result.get(), Type<R>());
+        detail::callback_adjust_refcount(result.get(), type<R>());
+        return from_python(result.get(), type<R>());
     }
 ''', args)
         + 
@@ -63,15 +63,15 @@ struct Callback
 // void g();
 // void f() { return g(); }
 template <>
-struct Callback<void>
+struct callback<void>
 {
 """
         + gen_functions('''
 %{    template <%(class A%n%:, %)>
 %}    static void call_method(PyObject* self, const char* name%(, const A%n& a%n%))
     {%(
-        Ptr p%n(to_python(a%n));%)
-        Ptr result(PyEval_CallMethod(self, const_cast<char*>(name),
+        ref p%n(to_python(a%n));%)
+        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
                                      const_cast<char*>("(%(O%))")%(,
                                      p%n.get()%)));
     }
@@ -79,8 +79,8 @@ struct Callback<void>
 %{    template <%(class A%n%:, %)>
 %}    static void call(PyObject* self%(, const A%n& a%n%))
     {%(
-        Ptr p%n(to_python(a%n));%)
-        Ptr result(PyEval_CallFunction(self, const_cast<char*>("(%(O%))")%(,
+        ref p%n(to_python(a%n));%)
+        ref result(PyEval_CallFunction(self, const_cast<char*>("(%(O%))")%(,
                                        p%n.get()%)));
     }
 ''', args)
@@ -90,25 +90,25 @@ struct Callback<void>
 // Make it a compile-time error to try to return a const char* from a virtual
 // function. The standard conversion
 //
-//      from_python(PyObject* string, py::Type<const char*>)
+//      from_python(PyObject* string, python::type<const char*>)
 //
 // returns a pointer to the character array which is internal to string. The
 // problem with trying to do this in a standard callback function is that the
 // Python string would likely be destroyed upon return from the calling function
-// (py::Callback<const char*>::call[_method]) when its reference count is
+// (python::callback<const char*>::call[_method]) when its reference count is
 // decremented. If you absolutely need to do this and you're sure it's safe (it
 // usually isn't), you can use
 //
-//      py::String result(py::Callback<py::String>::call[_method](...args...));
+//      python::string result(python::callback<python::string>::call[_method](...args...));
 //      ...result.c_str()... // access the char* array
 template <>
-struct Callback<const char*>
+struct callback<const char*>
 {
     // Try hard to generate a readable error message
     typedef struct unsafe_since_python_string_may_be_destroyed {} call, call_method;
 };
 
-} // namespace py
+} // namespace python
 
 #endif // CALLBACK_DWA_052100_H_
 """)
diff --git a/gen_caller.py b/gen_caller.py
index c8b8ca00..f0e65d49 100644
--- a/gen_caller.py
+++ b/gen_caller.py
@@ -18,7 +18,7 @@ header = '''//  (C) Copyright David Abrahams 2000. Permission to copy, use, modi
 //  producing this work.
 //
 //  This file generated for %d-argument member functions and %d-argument free
-//  functions by gen_caller.py
+//  functions by gen_caller.python
 '''
 
 body_sections = (
@@ -32,11 +32,11 @@ body_sections = (
 # include "signatures.h"
 # include "none.h"
 
-namespace py {
+namespace python {
 
 // Calling C++ from Python
 template <class R>
-struct Caller
+struct caller
 {
 ''',
 '''
@@ -46,7 +46,7 @@ struct Caller
 '''};
                            
 template <>
-struct Caller<void>
+struct caller<void>
 {
 ''',
 '''
@@ -69,8 +69,8 @@ member_function = '''    template <class T%(, class A%n%)>
 %(        PyObject* a%n;
 %)        if (!PyArg_ParseTuple(args, const_cast<char*>("O%(O%)"), &self%(, &a%n%)))
             return 0;
-        T& target = from_python(self, Type<T&>());
-        %3(target.*pmf)(%(from_python(a%n, Type<A%n>())%:,
+        T& target = from_python(self, type<T&>());
+        %3(target.*pmf)(%(from_python(a%n, type<A%n>())%:,
                         %))%4
     }
 
@@ -81,7 +81,7 @@ free_function = '''%{    template <%(class A%n%:, %)>
 %(        PyObject* a%n;
 %)        if (!PyArg_ParseTuple(args, const_cast<char*>("%(O%)")%(, &a%n%)))
             return 0;
-        %2f(%(from_python(a%n, Type<A%n>())%:,
+        %2f(%(from_python(a%n, type<A%n>())%:,
                         %))%3
     }
 
diff --git a/gen_extclass.py b/gen_extclass.py
index 2eab3ecf..69dfd577 100644
--- a/gen_extclass.py
+++ b/gen_extclass.py
@@ -12,7 +12,7 @@ def gen_extclass(args):
 //  producing this work.
 //
 //  This file automatically generated for %d-argument constructors by
-//  gen_extclass.py
+//  gen_extclass.python
 
 #ifndef EXTENSION_CLASS_DWA052000_H_
 # define EXTENSION_CLASS_DWA052000_H_
@@ -28,33 +28,33 @@ def gen_extclass(args):
 # include <typeinfo>
 # include <boost/smart_ptr.hpp>
 
-namespace py {
+namespace python {
 
 // forward declarations
 template <long which, class operand> struct operators;
 template <class T> struct left_operand;
 template <class T> struct right_operand;
 
-enum WithoutDowncast { without_downcast };
+enum without_downcast_t { without_downcast };
 
 namespace detail {
 
 // forward declarations
-class ExtensionInstance;
-class ExtensionClassBase;
-template <class T> class InstanceHolder;
-template <class T, class U> class InstanceValueHolder;
-template <class Ptr, class T> class InstancePtrHolder;
+class extension_instance;
+class extension_class_base;
+template <class T> class instance_holder;
+template <class T, class U> class instance_value_holder;
+template <class ref, class T> class instance_ptr_holder;
 template <class Specified> struct operand_select;
   template <long> struct choose_op;
   template <long> struct choose_rop;
   template <long> struct choose_unary_op;
   template <long> struct define_operator;
 
-MetaClass<ExtensionInstance>* extension_meta_class();
-ExtensionInstance* get_extension_instance(PyObject* p);
-void report_missing_instance_data(ExtensionInstance*, Class<ExtensionInstance>*, const std::type_info&);
-void report_missing_ptr_data(ExtensionInstance*, Class<ExtensionInstance>*, const std::type_info&);
+meta_class<extension_instance>* extension_meta_class();
+extension_instance* get_extension_instance(PyObject* p);
+void report_missing_instance_data(extension_instance*, class_t<extension_instance>*, const std::type_info&);
+void report_missing_ptr_data(extension_instance*, class_t<extension_instance>*, const std::type_info&);
 void report_missing_class_object(const std::type_info&);
 void report_released_smart_pointer(const std::type_info&);
     
@@ -66,87 +66,87 @@ T* check_non_null(T* p)
     return p;
 }
 
-template <class T> class HeldInstance;
+template <class T> class held_instance;
 
 typedef void* (*ConversionFunction)(void*);
 
 struct BaseClassInfo
 {
-    BaseClassInfo(ExtensionClassBase* t, ConversionFunction f)
+    BaseClassInfo(extension_class_base* t, ConversionFunction f)
         :class_object(t), convert(f)
         {}
     
-    ExtensionClassBase* class_object;
+    extension_class_base* class_object;
     ConversionFunction convert;
 };
 
-typedef BaseClassInfo DerivedClassInfo;
+typedef BaseClassInfo derived_class_info;
 
 struct add_operator_base;
 
-class ExtensionClassBase : public Class<ExtensionInstance>
+class extension_class_base : public class_t<extension_instance>
 {
  public:
-    ExtensionClassBase(const char* name);
+    extension_class_base(const char* name);
     
  public:
     // the purpose of try_class_conversions() and its related functions 
     // is explained in extclass.cpp
-    void* try_class_conversions(InstanceHolderBase*) const;
-    void* try_base_class_conversions(InstanceHolderBase*) const;
-    void* try_derived_class_conversions(InstanceHolderBase*) const;
+    void* try_class_conversions(instance_holder_base*) const;
+    void* try_base_class_conversions(instance_holder_base*) const;
+    void* try_derived_class_conversions(instance_holder_base*) const;
 
     void set_attribute(const char* name, PyObject* x);
-    void set_attribute(const char* name, Ptr x);
+    void set_attribute(const char* name, ref x);
     
  private:
-    virtual void* extract_object_from_holder(InstanceHolderBase* v) const = 0;
+    virtual void* extract_object_from_holder(instance_holder_base* v) const = 0;
     virtual std::vector<BaseClassInfo> const& base_classes() const = 0;
-    virtual std::vector<DerivedClassInfo> const& derived_classes() const = 0;
+    virtual std::vector<derived_class_info> const& derived_classes() const = 0;
 
  protected:
     friend struct add_operator_base;
-    void add_method(PyPtr<Function> method, const char* name);
-    void add_method(Function* method, const char* name);
+    void add_method(reference<function> method, const char* name);
+    void add_method(function* method, const char* name);
     
-    void add_constructor_object(Function*);
-    void add_setter_method(Function*, const char* name);
-    void add_getter_method(Function*, const char* name);
+    void add_constructor_object(function*);
+    void add_setter_method(function*, const char* name);
+    void add_getter_method(function*, const char* name);
 };
 
 template <class T>
-class ClassRegistry
+class class_registry
 {
  public:
-    static ExtensionClassBase* class_object()
+    static extension_class_base* class_object()
         { return static_class_object; }
 
     // Register/unregister the Python class object corresponding to T
-    static void register_class(ExtensionClassBase*);
-    static void unregister_class(ExtensionClassBase*);
+    static void register_class(extension_class_base*);
+    static void unregister_class(extension_class_base*);
 
     // Establish C++ inheritance relationships
     static void register_base_class(BaseClassInfo const&);
-    static void register_derived_class(DerivedClassInfo const&);
+    static void register_derived_class(derived_class_info const&);
 
     // Query the C++ inheritance relationships
     static std::vector<BaseClassInfo> const& base_classes();
-    static std::vector<DerivedClassInfo> const& derived_classes();
+    static std::vector<derived_class_info> const& derived_classes();
  private:
-    static ExtensionClassBase* static_class_object;
+    static extension_class_base* static_class_object;
     static std::vector<BaseClassInfo> static_base_class_info;
-    static std::vector<DerivedClassInfo> static_derived_class_info;
+    static std::vector<derived_class_info> static_derived_class_info;
 };
 
-}} // namespace py::detail
+}} // namespace python::detail
 
-PY_BEGIN_CONVERSION_NAMESPACE
+BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
 
 // This class' only job is to define from_python and to_python converters for T
 // and U. T is the class the user really intends to wrap. U is a class derived
 // from T with some virtual function overriding boilerplate, or if there are no
-// virtual functions, U = HeldInstance<T>.
-template <class T, class U = py::detail::HeldInstance<T> >
+// virtual functions, U = held_instance<T>.
+template <class T, class U = python::detail::held_instance<T> >
 class PyExtensionClassConverters
 {
  public:
@@ -159,7 +159,7 @@ class PyExtensionClassConverters
     // pop up. Now, if T hasn't been wrapped as an extension class, the user
     // will see an error message about the lack of an eligible
     // py_extension_class_converters() function.
-    friend PyExtensionClassConverters py_extension_class_converters(py::Type<T>)
+    friend PyExtensionClassConverters py_extension_class_converters(python::type<T>)
     { 
         return PyExtensionClassConverters();
     }
@@ -177,118 +177,118 @@ class PyExtensionClassConverters
     // writes code which causes us to try to copy a T.
     PyObject* to_python(const T& x) const
     {
-        py::PyPtr<py::detail::ExtensionInstance> result(create_instance());
+        python::reference<python::detail::extension_instance> result(create_instance());
         result->add_implementation(
-            std::auto_ptr<py::detail::InstanceHolderBase>(
-                new py::detail::InstanceValueHolder<T,U>(result.get(), x)));
+            std::auto_ptr<python::detail::instance_holder_base>(
+                new python::detail::instance_value_holder<T,U>(result.get(), x)));
         return result.release();
     }
     
     // Convert to T*
-    friend T* from_python(PyObject* obj, py::Type<T*>)
+    friend T* from_python(PyObject* obj, python::type<T*>)
     {
-        // Downcast to an ExtensionInstance, then find the actual T
-        py::detail::ExtensionInstance* self = py::detail::get_extension_instance(obj);
-        typedef std::vector<py::detail::InstanceHolderBase*>::const_iterator Iterator;
-        for (Iterator p = self->wrapped_objects().begin();
+        // downcast to an extension_instance, then find the actual T
+        python::detail::extension_instance* self = python::detail::get_extension_instance(obj);
+        typedef std::vector<python::detail::instance_holder_base*>::const_iterator iterator;
+        for (iterator p = self->wrapped_objects().begin();
              p != self->wrapped_objects().end(); ++p)
         {
-            py::detail::InstanceHolder<T>* held = dynamic_cast<py::detail::InstanceHolder<T>*>(*p);
+            python::detail::instance_holder<T>* held = dynamic_cast<python::detail::instance_holder<T>*>(*p);
             if (held != 0)
                 return held->target();
 
             // see extclass.cpp for an explanation of try_class_conversions()
-            void* target = py::detail::ClassRegistry<T>::class_object()->try_class_conversions(*p);
+            void* target = python::detail::class_registry<T>::class_object()->try_class_conversions(*p);
             if(target) 
                 return static_cast<T*>(target);
         }
-        py::detail::report_missing_instance_data(self, py::detail::ClassRegistry<T>::class_object(), typeid(T));
-        throw py::ArgumentError();
+        python::detail::report_missing_instance_data(self, python::detail::class_registry<T>::class_object(), typeid(T));
+        throw python::argument_error();
     }
 
     // Convert to PtrType, where PtrType can be dereferenced to obtain a T.
     template <class PtrType>
-    static PtrType& ptr_from_python(PyObject* obj, py::Type<PtrType>)
+    static PtrType& ptr_from_python(PyObject* obj, python::type<PtrType>)
     {
-        // Downcast to an ExtensionInstance, then find the actual T
-        py::detail::ExtensionInstance* self = py::detail::get_extension_instance(obj);
-        typedef std::vector<py::detail::InstanceHolderBase*>::const_iterator Iterator;
-        for (Iterator p = self->wrapped_objects().begin();
+        // downcast to an extension_instance, then find the actual T
+        python::detail::extension_instance* self = python::detail::get_extension_instance(obj);
+        typedef std::vector<python::detail::instance_holder_base*>::const_iterator iterator;
+        for (iterator p = self->wrapped_objects().begin();
              p != self->wrapped_objects().end(); ++p)
         {
-            py::detail::InstancePtrHolder<PtrType, T>* held =
-                dynamic_cast<py::detail::InstancePtrHolder<PtrType, T>*>(*p);
+            python::detail::instance_ptr_holder<PtrType, T>* held =
+                dynamic_cast<python::detail::instance_ptr_holder<PtrType, T>*>(*p);
             if (held != 0)
                 return held->ptr();
         }
-        py::detail::report_missing_ptr_data(self, py::detail::ClassRegistry<T>::class_object(), typeid(T));
-        throw py::ArgumentError();
+        python::detail::report_missing_ptr_data(self, python::detail::class_registry<T>::class_object(), typeid(T));
+        throw python::argument_error();
     }
 
     template <class PtrType>
     static PyObject* ptr_to_python(PtrType x)
     {
-        py::PyPtr<py::detail::ExtensionInstance> result(create_instance());
+        python::reference<python::detail::extension_instance> result(create_instance());
         result->add_implementation(
-            std::auto_ptr<py::detail::InstanceHolderBase>(
-                new py::detail::InstancePtrHolder<PtrType,T>(x)));
+            std::auto_ptr<python::detail::instance_holder_base>(
+                new python::detail::instance_ptr_holder<PtrType,T>(x)));
         return result.release();
     }
 
-    static py::PyPtr<py::detail::ExtensionInstance> create_instance()
+    static python::reference<python::detail::extension_instance> create_instance()
     {
-        PyTypeObject* class_object = py::detail::ClassRegistry<T>::class_object();
+        PyTypeObject* class_object = python::detail::class_registry<T>::class_object();
         if (class_object == 0)
-            py::detail::report_missing_class_object(typeid(T));
+            python::detail::report_missing_class_object(typeid(T));
             
-        return py::PyPtr<py::detail::ExtensionInstance>(
-            new py::detail::ExtensionInstance(class_object));
+        return python::reference<python::detail::extension_instance>(
+            new python::detail::extension_instance(class_object));
     }
 
     // Convert to const T*
-    friend const T* from_python(PyObject* p, py::Type<const T*>)
-        { return from_python(p, py::Type<T*>()); }
+    friend const T* from_python(PyObject* p, python::type<const T*>)
+        { return from_python(p, python::type<T*>()); }
 
     // Convert to const T* const&
-    friend const T* from_python(PyObject* p, py::Type<const T*const&>)
-         { return from_python(p, py::Type<const T*>()); }
+    friend const T* from_python(PyObject* p, python::type<const T*const&>)
+         { return from_python(p, python::type<const T*>()); }
   
     // Convert to T* const&
-    friend T* from_python(PyObject* p, py::Type<T* const&>)
-         { return from_python(p, py::Type<T*>()); }
+    friend T* from_python(PyObject* p, python::type<T* const&>)
+         { return from_python(p, python::type<T*>()); }
  
     // Convert to T&
-    friend T& from_python(PyObject* p, py::Type<T&>)
-        { return *py::detail::check_non_null(from_python(p, py::Type<T*>())); }
+    friend T& from_python(PyObject* p, python::type<T&>)
+        { return *python::detail::check_non_null(from_python(p, python::type<T*>())); }
 
     // Convert to const T&
-    friend const T& from_python(PyObject* p, py::Type<const T&>)
-        { return from_python(p, py::Type<T&>()); }
+    friend const T& from_python(PyObject* p, python::type<const T&>)
+        { return from_python(p, python::type<T&>()); }
 
     // Convert to T
-    friend const T& from_python(PyObject* p, py::Type<T>)
-        { return from_python(p, py::Type<T&>()); }
+    friend const T& from_python(PyObject* p, python::type<T>)
+        { return from_python(p, python::type<T&>()); }
 
-    friend std::auto_ptr<T>& from_python(PyObject* p, py::Type<std::auto_ptr<T>&>)
-        { return ptr_from_python(p, py::Type<std::auto_ptr<T> >()); }
+    friend std::auto_ptr<T>& from_python(PyObject* p, python::type<std::auto_ptr<T>&>)
+        { return ptr_from_python(p, python::type<std::auto_ptr<T> >()); }
     
-    friend std::auto_ptr<T>& from_python(PyObject* p, py::Type<std::auto_ptr<T> >)
-        { return ptr_from_python(p, py::Type<std::auto_ptr<T> >()); }
+    friend std::auto_ptr<T>& from_python(PyObject* p, python::type<std::auto_ptr<T> >)
+        { return ptr_from_python(p, python::type<std::auto_ptr<T> >()); }
     
-    friend const std::auto_ptr<T>& from_python(PyObject* p, py::Type<const std::auto_ptr<T>&>)
-        { return ptr_from_python(p, py::Type<std::auto_ptr<T> >()); }
+    friend const std::auto_ptr<T>& from_python(PyObject* p, python::type<const std::auto_ptr<T>&>)
+        { return ptr_from_python(p, python::type<std::auto_ptr<T> >()); }
 
     friend PyObject* to_python(std::auto_ptr<T> x)
         { return ptr_to_python(x); }
 
-    friend boost::shared_ptr<T>& from_python(PyObject* p, py::Type<boost::shared_ptr<T>&>)
-        { return ptr_from_python(p, py::Type<boost::shared_ptr<T> >()); }
+    friend boost::shared_ptr<T>& from_python(PyObject* p, python::type<boost::shared_ptr<T>&>)
+        { return ptr_from_python(p, python::type<boost::shared_ptr<T> >()); }
     
-    friend boost::shared_ptr<T>& from_python(PyObject* p, py::Type<boost::shared_ptr<T> >)
-        { return ptr_from_python(p, py::Type<boost::shared_ptr<T> >()); }
+    friend boost::shared_ptr<T>& from_python(PyObject* p, python::type<boost::shared_ptr<T> >)
+        { return ptr_from_python(p, python::type<boost::shared_ptr<T> >()); }
     
-    friend const boost::shared_ptr<T>& from_python(PyObject* p, py::Type<const boost::shared_ptr<T>&>)
-        { return ptr_from_python(p, py::Type<boost::shared_ptr<T> >()); }
+    friend const boost::shared_ptr<T>& from_python(PyObject* p, python::type<const boost::shared_ptr<T>&>)
+        { return ptr_from_python(p, python::type<boost::shared_ptr<T> >()); }
 
     friend PyObject* to_python(boost::shared_ptr<T> x)
         { return ptr_to_python(x); }
@@ -301,31 +301,31 @@ class PyExtensionClassConverters
 template <class T>
 PyObject* to_python(const T& x)
 {
-    return py_extension_class_converters(py::Type<T>()).to_python(x);
+    return py_extension_class_converters(python::type<T>()).to_python(x);
 }
 
-PY_END_CONVERSION_NAMESPACE
+BOOST_PYTHON_END_CONVERSION_NAMESPACE
 
-namespace py {
+namespace python {
 
-PY_IMPORT_CONVERSION(PyExtensionClassConverters);
+BOOST_PYTHON_IMPORT_CONVERSION(PyExtensionClassConverters);
 
 namespace detail {
 
-template <class T> class InstanceHolder;
+template <class T> class instance_holder;
 
-class ReadOnlySetattrFunction : public Function
+class read_only_setattr_function : public function
 {
  public:
-    ReadOnlySetattrFunction(const char* name);
+    read_only_setattr_function(const char* name);
     PyObject* do_call(PyObject* args, PyObject* keywords) const;
     const char* description() const;
  private:
-    String m_name;
+    string m_name;
 };
 
   template <class From, class To>
-  struct DefineConversion
+  struct define_conversion
   {
       static void* upcast_ptr(void* v)
       {
@@ -339,7 +339,7 @@ class ReadOnlySetattrFunction : public Function
   };
 
 // An easy way to make an extension base class which wraps T. Note that Python
-// subclasses of this class will simply be Class<ExtensionInstance> objects.
+// subclasses of this class will simply be class_t<extension_instance> objects.
 //
 // U should be a class derived from T which overrides virtual functions with
 // boilerplate code to call back into Python. See extclass_demo.h for examples.
@@ -348,45 +348,45 @@ class ReadOnlySetattrFunction : public Function
 // Python which are called from C++ if you don't supply it. If you just want to
 // be able to use T in python without overriding member functions, you can omit
 // U.
-template <class T, class U = HeldInstance<T> >
-class ExtensionClass
+template <class T, class U = held_instance<T> >
+class extension_class
     : public PyExtensionClassConverters<T, U>, // This generates the to_python/from_python functions
-      public ExtensionClassBase
+      public extension_class_base
 {
  public:
-    typedef T WrappedType;
-    typedef U CallbackType;
+    typedef T wrapped_type;
+    typedef U callback_type;
     
     // Construct with a name that comes from typeid(T).name(). The name only
     // affects the objects of this class are represented through repr()
-    ExtensionClass();
+    extension_class();
     
     // Construct with the given name. The name only affects the objects of this
     // class are represented through repr()
-    ExtensionClass(const char* name);
+    extension_class(const char* name);
     
-    ~ExtensionClass();
+    ~extension_class();
 
     // define constructors
 """ % args
         + gen_function(
 """    template <%(class A%n%:, %)>
-    inline void def(Constructor<%(A%n%:, %)>)
-    // The following incantation builds a Signature1, Signature2,... object. It
+    inline void def(constructor<%(A%n%:, %)>)
+    // The following incantation builds a signature1, signature2,... object. It
     // should _all_ get optimized away.
     { add_constructor(
-        %(prepend(Type<A%n>::Id(),
-        %)        Signature0()%()%));
+        %(prepend(type<A%n>::id(),
+        %)        signature0()%()%));
     }
 """, args)
         +
 """
 
     // export homogeneous operators (type of both lhs and rhs is 'operator')
-    // usage:  foo_class.def(py::operators<(py::op_add | py::op_sub), Foo>());
+    // usage:  foo_class.def(python::operators<(python::op_add | python::op_sub), Foo>());
     
     // export homogeneous operators (type of both lhs and rhs is 'T const&')
-    // usage:  foo_class.def(py::operators<(py::op_add | py::op_sub)>());
+    // usage:  foo_class.def(python::operators<(python::op_add | python::op_sub)>());
     template <long which, class Operand>
     inline void def(operators<which,Operand>)
     {
@@ -395,12 +395,12 @@ class ExtensionClass
     }
 
     // export heterogeneous operators (type of lhs: 'left', of rhs: 'right')
-    // usage:  foo_class.def(py::operators<(py::op_add | py::op_sub), Foo>(),
-    //                       py::right_operand<int const&>());
+    // usage:  foo_class.def(python::operators<(python::op_add | python::op_sub), Foo>(),
+    //                       python::right_operand<int const&>());
 
     // export heterogeneous operators (type of lhs: 'T const&', of rhs: 'right')
-    // usage:  foo_class.def(py::operators<(py::op_add | py::op_sub)>(),
-    //                       py::right_operand<int const&>());
+    // usage:  foo_class.def(python::operators<(python::op_add | python::op_sub)>(),
+    //                       python::right_operand<int const&>());
     template <long which, class Left, class Right>
     inline void def(operators<which,Left>, right_operand<Right> r)
     {
@@ -410,13 +410,13 @@ class ExtensionClass
 
     // export heterogeneous reverse-argument operators 
     // (type of lhs: 'left', of rhs: 'right')
-    // usage:  foo_class.def(py::operators<(py::op_add | py::op_sub), Foo>(),
-    //                       py::left_operand<int const&>());
+    // usage:  foo_class.def(python::operators<(python::op_add | python::op_sub), Foo>(),
+    //                       python::left_operand<int const&>());
     
     // export heterogeneous reverse-argument operators 
     // (type of lhs: 'left', of rhs: 'T const&')
-    // usage:  foo_class.def(py::operators<(py::op_add | py::op_sub)>(),
-    //                       py::left_operand<int const&>());
+    // usage:  foo_class.def(python::operators<(python::op_add | python::op_sub)>(),
+    //                       python::left_operand<int const&>());
     template <long which, class Left, class Right>
     inline void def(operators<which,Right>, left_operand<Left> l)
     {
@@ -425,7 +425,7 @@ class ExtensionClass
     }
 
     // define a function that passes Python arguments and keywords
-    // to C++ verbatim (as a 'Tuple const&' and 'Dict const&' 
+    // to C++ verbatim (as a 'tuple const&' and 'dictionary const&' 
     // respectively). This is useful for manual argument passing.
     // It's also the only possibility to pass keyword arguments to C++.
     // Fn must have a signatur that is compatible to 
@@ -452,34 +452,34 @@ class ExtensionClass
     template <class Fn, class DefaultFn>
     inline void def(Fn fn, const char* name, DefaultFn default_fn)
     {
-        this->add_method(new_virtual_function(Type<T>(), fn, default_fn), name);
+        this->add_method(new_virtual_function(type<T>(), fn, default_fn), name);
     }
 
     // Provide a function which implements x.<name>, reading from the given
-    // member (pm) of the T instance
+    // member (pm) of the T obj
     template <class MemberType>
     inline void def_getter(MemberType T::*pm, const char* name)
     {
-        this->add_getter_method(new GetterFunction<T, MemberType>(pm), name);
+        this->add_getter_method(new getter_function<T, MemberType>(pm), name);
     }
     
     // Provide a function which implements assignment to x.<name>, writing to
-    // the given member (pm) of the T instance
+    // the given member (pm) of the T obj
     template <class MemberType>
     inline void def_setter(MemberType T::*pm, const char* name)
     {
-        this->add_setter_method(new SetterFunction<T, MemberType>(pm), name);
+        this->add_setter_method(new setter_function<T, MemberType>(pm), name);
     }
     
-    // Expose the given member (pm) of the T instance as a read-only attribute
+    // Expose the given member (pm) of the T obj as a read-only attribute
     template <class MemberType>
     inline void def_readonly(MemberType T::*pm, const char* name)
     {
-        this->add_setter_method(new ReadOnlySetattrFunction(name), name);
+        this->add_setter_method(new read_only_setattr_function(name), name);
         this->def_getter(pm, name);
     }
     
-    // Expose the given member (pm) of the T instance as a read/write attribute
+    // Expose the given member (pm) of the T obj as a read/write attribute
     template <class MemberType>
     inline void def_read_write(MemberType T::*pm, const char* name)
     {
@@ -493,43 +493,43 @@ class ExtensionClass
     // declare the given class a base class of this one and register 
     // up and down conversion functions
     template <class S, class V>
-    void declare_base(ExtensionClass<S, V>* base)
+    void declare_base(extension_class<S, V>* base)
     {
         // see extclass.cpp for an explanation of why we need to register
         // conversion functions
         BaseClassInfo baseInfo(base, 
-                            &DefineConversion<S, T>::downcast_ptr);
-        ClassRegistry<T>::register_base_class(baseInfo);
-        add_base(Ptr(as_object(base), Ptr::new_ref));
+                            &define_conversion<S, T>::downcast_ptr);
+        class_registry<T>::register_base_class(baseInfo);
+        add_base(ref(as_object(base), ref::increment_count));
         
-        DerivedClassInfo derivedInfo(this, 
-                            &DefineConversion<T, S>::upcast_ptr);
-        ClassRegistry<S>::register_derived_class(derivedInfo);
+        derived_class_info derivedInfo(this, 
+                            &define_conversion<T, S>::upcast_ptr);
+        class_registry<S>::register_derived_class(derivedInfo);
     }
         
     // declare the given class a base class of this one and register 
     // only up conversion function
     template <class S, class V>
-    void declare_base(ExtensionClass<S, V>* base, WithoutDowncast)
+    void declare_base(extension_class<S, V>* base, without_downcast_t)
     {
         // see extclass.cpp for an explanation of why we need to register
         // conversion functions
         BaseClassInfo baseInfo(base, 0);
-        ClassRegistry<T>::register_base_class(baseInfo);
-        add_base(Ptr(as_object(base), Ptr::new_ref));
+        class_registry<T>::register_base_class(baseInfo);
+        add_base(ref(as_object(base), ref::increment_count));
         
-        DerivedClassInfo derivedInfo(this, 
-                           &DefineConversion<T, S>::upcast_ptr);
-        ClassRegistry<S>::register_derived_class(derivedInfo);
+        derived_class_info derivedInfo(this, 
+                           &define_conversion<T, S>::upcast_ptr);
+        class_registry<S>::register_derived_class(derivedInfo);
     }
     
  private: // types
-    typedef InstanceValueHolder<T,U> Holder;
+    typedef instance_value_holder<T,U> holder;
 
- private: // ExtensionClassBase virtual function implementations
+ private: // extension_class_base virtual function implementations
     std::vector<BaseClassInfo> const& base_classes() const;
-    std::vector<DerivedClassInfo> const& derived_classes() const;
-    void* extract_object_from_holder(InstanceHolderBase* v) const;
+    std::vector<derived_class_info> const& derived_classes() const;
+    void* extract_object_from_holder(instance_holder_base* v) const;
 
  private: // Utility functions
     template <long which, class Operand>
@@ -604,40 +604,40 @@ class ExtensionClass
         choose_rop<(which & op_cmp)>::template args<Left,Right>::add(this);
     }
     
-    template <class Signature>
-    void add_constructor(Signature sig)
+    template <class signature>
+    void add_constructor(signature sig)
     {
-        this->add_constructor_object(InitFunction<Holder>::create(sig));
+        this->add_constructor_object(init_function<holder>::create(sig));
     }
 };
 
-// A simple wrapper over a T which allows us to use ExtensionClass<T> with a
-// single template parameter only. See ExtensionClass<T>, above.
+// A simple wrapper over a T which allows us to use extension_class<T> with a
+// single template parameter only. See extension_class<T>, above.
 template <class T>
-class HeldInstance : public T
+class held_instance : public T
 {
     // There are no member functions: we want to avoid inadvertently overriding
     // any virtual functions in T.
 public:"""
         + gen_functions("""%{
     template <%(class A%n%:, %)>%}
-    HeldInstance(PyObject*%(, A%n% a%n%)) : T(%(a%n%:, %)) {}""", args)
+    held_instance(PyObject*%(, A%n% a%n%)) : T(%(a%n%:, %)) {}""", args)
         + """
 };
 
-// Abstract base class for all instance holders. Base for template class
-// InstanceHolder<>, below.
-class InstanceHolderBase
+// Abstract base class for all obj holders. Base for template class
+// instance_holder<>, below.
+class instance_holder_base
 {
 public:
-    virtual ~InstanceHolderBase() {}
+    virtual ~instance_holder_base() {}
     virtual bool held_by_value() = 0;
 };
 
 // Abstract base class which holds a Held, somehow. Provides a uniform way to
 // get a pointer to the held object
 template <class Held>
-class InstanceHolder : public InstanceHolderBase
+class instance_holder : public instance_holder_base
 {
 public:
     virtual Held*target() = 0;
@@ -648,10 +648,10 @@ public:
 // corresponding constructor for arguments (PyObject*, A1...An). Wrapper is
 // neccessary to implement virtual function callbacks (there must be a
 // back-pointer to the actual Python object so that we can call any
-// overrides). HeldInstance (above) is used as a default Wrapper class when
+// overrides). held_instance (above) is used as a default Wrapper class when
 // there are no virtual functions.
 template <class Held, class Wrapper>
-class InstanceValueHolder : public InstanceHolder<Held>
+class instance_value_holder : public instance_holder<Held>
 {
 public:
     Held* target() { return &m_held; }
@@ -659,11 +659,11 @@ public:
 """
         + gen_functions("""%{
     template <%(class A%n%:, %)>%}
-    InstanceValueHolder(ExtensionInstance* p%(, A%n a%n%)) :
+    instance_value_holder(extension_instance* p%(, A%n a%n%)) :
         m_held(p%(, a%n%)) {}""", args)
         + """
 
- public: // implementation of InstanceHolderBase required interface
+ public: // implementation of instance_holder_base required interface
     bool held_by_value() { return true; }
 
  private:
@@ -674,59 +674,59 @@ public:
 // PtrType. By default, these are only generated for PtrType ==
 // std::auto_ptr<HeldType> and PtrType == boost::shared_ptr<HeldType>.
 template <class PtrType, class HeldType>
-class InstancePtrHolder : public InstanceHolder<HeldType>
+class instance_ptr_holder : public instance_holder<HeldType>
 {
  public:
     HeldType* target() { return &*m_ptr; }
     PtrType& ptr() { return m_ptr; }
 
-    InstancePtrHolder(PtrType ptr) : m_ptr(ptr) {}
+    instance_ptr_holder(PtrType ptr) : m_ptr(ptr) {}
     
- public: // implementation of InstanceHolderBase required interface
+ public: // implementation of instance_holder_base required interface
     bool held_by_value() { return false; }
  private:
     PtrType m_ptr;
 };
 
-class ExtensionInstance : public Instance
+class extension_instance : public instance
 {
  public:
-    ExtensionInstance(PyTypeObject* class_);
-    ~ExtensionInstance();
+    extension_instance(PyTypeObject* class_);
+    ~extension_instance();
     
-    void add_implementation(std::auto_ptr<InstanceHolderBase> holder);
+    void add_implementation(std::auto_ptr<instance_holder_base> holder);
 
-    typedef std::vector<InstanceHolderBase*> WrappedObjects;
-    const WrappedObjects& wrapped_objects() const
+    typedef std::vector<instance_holder_base*> held_objects;
+    const held_objects& wrapped_objects() const
         { return m_wrapped_objects; }
  private:
-    WrappedObjects m_wrapped_objects;
+    held_objects m_wrapped_objects;
 };
 
 //
 // Template function implementations
 //
 
-Tuple extension_class_coerce(Ptr l, Ptr r);
+tuple extension_class_coerce(ref l, ref r);
 
 template <class T, class U>
-ExtensionClass<T, U>::ExtensionClass()
-    : ExtensionClassBase(typeid(T).name())
+extension_class<T, U>::extension_class()
+    : extension_class_base(typeid(T).name())
 {
-    ClassRegistry<T>::register_class(this);
+    class_registry<T>::register_class(this);
 }
 
 template <class T, class U>
-ExtensionClass<T, U>::ExtensionClass(const char* name)
-    : ExtensionClassBase(name)
+extension_class<T, U>::extension_class(const char* name)
+    : extension_class_base(name)
 {
-    ClassRegistry<T>::register_class(this);
+    class_registry<T>::register_class(this);
 }
 
 template <class T, class U>
-void ExtensionClass<T, U>::def_standard_coerce()
+void extension_class<T, U>::def_standard_coerce()
 {
-    Ptr coerce_fct = dict().get_item(String("__coerce__"));
+    ref coerce_fct = dict().get_item(string("__coerce__"));
     
     if(coerce_fct.get() == 0) // not yet defined
         this->def(&extension_class_coerce, "__coerce__");
@@ -735,36 +735,36 @@ void ExtensionClass<T, U>::def_standard_coerce()
 template <class T, class U>
 inline
 std::vector<BaseClassInfo> const& 
-ExtensionClass<T, U>::base_classes() const
+extension_class<T, U>::base_classes() const
 {
-    return ClassRegistry<T>::base_classes();
+    return class_registry<T>::base_classes();
 }
 
 template <class T, class U>
 inline
-std::vector<DerivedClassInfo> const& 
-ExtensionClass<T, U>::derived_classes() const
+std::vector<derived_class_info> const& 
+extension_class<T, U>::derived_classes() const
 {
-    return ClassRegistry<T>::derived_classes();
+    return class_registry<T>::derived_classes();
 }
        
 template <class T, class U>
-void* ExtensionClass<T, U>::extract_object_from_holder(InstanceHolderBase* v) const
+void* extension_class<T, U>::extract_object_from_holder(instance_holder_base* v) const
 {
-    InstanceHolder<T>* held = dynamic_cast<InstanceHolder<T>*>(v);
+    instance_holder<T>* held = dynamic_cast<instance_holder<T>*>(v);
     if(held)
         return held->target();
     return 0;
 }
 
 template <class T, class U>
-ExtensionClass<T, U>::~ExtensionClass()
+extension_class<T, U>::~extension_class()
 {
-    ClassRegistry<T>::unregister_class(this);
+    class_registry<T>::unregister_class(this);
 }
 
 template <class T>
-inline void ClassRegistry<T>::register_class(ExtensionClassBase* p)
+inline void class_registry<T>::register_class(extension_class_base* p)
 {
     // You're not expected to create more than one of these!
     assert(static_class_object == 0);
@@ -772,7 +772,7 @@ inline void ClassRegistry<T>::register_class(ExtensionClassBase* p)
 }
 
 template <class T>
-inline void ClassRegistry<T>::unregister_class(ExtensionClassBase* p)
+inline void class_registry<T>::unregister_class(extension_class_base* p)
 {
     // The user should be destroying the same object they created.
     assert(static_class_object == p);
@@ -781,25 +781,25 @@ inline void ClassRegistry<T>::unregister_class(ExtensionClassBase* p)
 }
 
 template <class T>
-void ClassRegistry<T>::register_base_class(BaseClassInfo const& i)
+void class_registry<T>::register_base_class(BaseClassInfo const& i)
 {
     static_base_class_info.push_back(i);
 }
 
 template <class T>
-void ClassRegistry<T>::register_derived_class(DerivedClassInfo const& i)
+void class_registry<T>::register_derived_class(derived_class_info const& i)
 {
     static_derived_class_info.push_back(i);
 }
 
 template <class T>
-std::vector<BaseClassInfo> const& ClassRegistry<T>::base_classes()
+std::vector<BaseClassInfo> const& class_registry<T>::base_classes()
 {
     return static_base_class_info;
 }
 
 template <class T>
-std::vector<DerivedClassInfo> const& ClassRegistry<T>::derived_classes()
+std::vector<derived_class_info> const& class_registry<T>::derived_classes()
 {
     return static_derived_class_info;
 }
@@ -808,13 +808,13 @@ std::vector<DerivedClassInfo> const& ClassRegistry<T>::derived_classes()
 // Static data member declaration.
 //
 template <class T>
-ExtensionClassBase* ClassRegistry<T>::static_class_object;
+extension_class_base* class_registry<T>::static_class_object;
 template <class T>
-std::vector<BaseClassInfo> ClassRegistry<T>::static_base_class_info;
+std::vector<BaseClassInfo> class_registry<T>::static_base_class_info;
 template <class T>
-std::vector<DerivedClassInfo> ClassRegistry<T>::static_derived_class_info;
+std::vector<derived_class_info> class_registry<T>::static_derived_class_info;
 
-}} // namespace py::detail
+}} // namespace python::detail
 
 #endif // EXTENSION_CLASS_DWA052000_H_
 """)
diff --git a/gen_function.py b/gen_function.py
index b2b22ab8..bebbc818 100644
--- a/gen_function.py
+++ b/gen_function.py
@@ -72,9 +72,9 @@ def gen_function(template, n, *args, **keywords):
     ... %(        PyObject* a%n;
     ... %)        if (!PyArg_ParseTuple(args, const_cast<char*>("O%(O%)"), &self%(, &a%n%)))
     ...             return 0;
-    ...         T& target = from_python(self, Type<T&>());
+    ...         T& target = from_python(self, type<T&>());
     ...         %3to_python((target.*pmf)(%(
-    ...                 from_python(a%n, Type<A%n>())%:,%)
+    ...                 from_python(a%n, type<A%n>())%:,%)
     ...                 ));%4
     ...     }'''
     
@@ -84,7 +84,7 @@ def gen_function(template, n, *args, **keywords):
             PyObject* self;
             if (!PyArg_ParseTuple(args, const_cast<char*>("O"), &self))
                 return 0;
-            T& target = from_python(self, Type<T&>());
+            T& target = from_python(self, type<T&>());
             return to_python((target.*pmf)(
                     ));
         }
@@ -97,10 +97,10 @@ def gen_function(template, n, *args, **keywords):
             PyObject* a2;
             if (!PyArg_ParseTuple(args, const_cast<char*>("OOO"), &self, &a1, &a2))
                 return 0;
-            T& target = from_python(self, Type<T&>());
+            T& target = from_python(self, type<T&>());
             return to_python((target.*pmf)(
-                    from_python(a1, Type<A1>()),
-                    from_python(a2, Type<A2>())
+                    from_python(a1, type<A1>()),
+                    from_python(a2, type<A2>())
                     ));
         }
         
@@ -113,11 +113,11 @@ def gen_function(template, n, *args, **keywords):
             PyObject* a3;
             if (!PyArg_ParseTuple(args, const_cast<char*>("OOOO"), &self, &a1, &a2, &a3))
                 return 0;
-            T& target = from_python(self, Type<T&>());
+            T& target = from_python(self, type<T&>());
             to_python((target.*pmf)(
-                    from_python(a1, Type<A1>()),
-                    from_python(a2, Type<A2>()),
-                    from_python(a3, Type<A3>())
+                    from_python(a1, type<A1>()),
+                    from_python(a2, type<A2>()),
+                    from_python(a3, type<A3>())
                     ));
             return none();
         }
diff --git a/gen_init_function.py b/gen_init_function.py
index a96a7b68..9fedec2c 100644
--- a/gen_init_function.py
+++ b/gen_init_function.py
@@ -12,7 +12,7 @@ def gen_init_function(args):
 //  The author gratefully acknowleges the support of Dragon Systems, Inc., in
 //  producing this work.
 //
-//  This file was generated for %d-argument constructors by gen_init_function.py
+//  This file was generated for %d-argument constructors by gen_init_function.python
 
 #ifndef INIT_FUNCTION_DWA052000_H_
 # define INIT_FUNCTION_DWA052000_H_
@@ -22,7 +22,7 @@ def gen_init_function(args):
 # include "signatures.h"
 # include <typeinfo>
 
-namespace py {
+namespace python {
 
 namespace detail {
 
@@ -106,50 +106,50 @@ namespace detail {
       const_reference value;
   };
 
-class ExtensionInstance;
-class InstanceHolderBase;
+class extension_instance;
+class instance_holder_base;
 
-class Init;
+class init;
 """
-        + gen_functions('template <class T%(, class A%n%)> struct Init%x;\n', args)
+        + gen_functions('template <class T%(, class A%n%)> struct init%x;\n', args)
         + """
 template <class T>
-struct InitFunction
+struct init_function
 {
 """ + gen_functions("""%{
     template <%(class A%n%:, %)>
-%}    static Init* create(Signature%x%{<%(A%n%:, %)>%}) {
-        return new Init%x<T%(,
+%}    static init* create(signature%x%{<%(A%n%:, %)>%}) {
+        return new init%x<T%(,
                        detail::parameter_traits<A%n>::const_reference%)>;
     }
 """, args)+"""};
 
-class Init : public Function
+class init : public function
 {
-private: // override Function hook
+private: // override function hook
     PyObject* do_call(PyObject* args, PyObject* keywords) const;
 private:
-    virtual InstanceHolderBase* create_holder(ExtensionInstance* self, PyObject* tail_args, PyObject* keywords) const = 0;
+    virtual instance_holder_base* create_holder(extension_instance* self, PyObject* tail_args, PyObject* keywords) const = 0;
 };
 """ + gen_functions("""
 
 template <class T%(, class A%n%)>
-struct Init%x : Init
+struct init%x : init
 {
-    virtual InstanceHolderBase* create_holder(ExtensionInstance* self, PyObject* args, PyObject* /*keywords*/) const
+    virtual instance_holder_base* create_holder(extension_instance* self, PyObject* args, PyObject* /*keywords*/) const
     {
         %(PyObject* a%n;
         %)if (!PyArg_ParseTuple(args, const_cast<char*>("%(O%)")%(, &a%n%)))
-            throw ArgumentError();
+            throw argument_error();
         return new T(self%(,
-            py::detail::reference_parameter<A%n>(from_python(a%n, Type<A%n>()))%)
+            python::detail::reference_parameter<A%n>(from_python(a%n, type<A%n>()))%)
             );
     }
     const char* description() const
         { return typeid(void (*)(T&%(, A%n%%))).name(); }
 };""", args) + """
 
-}} // namespace py::detail
+}} // namespace python::detail
 
 #endif // INIT_FUNCTION_DWA052000_H_
 """)
diff --git a/gen_signatures.py b/gen_signatures.py
index 8d19ffe6..612f7a53 100644
--- a/gen_signatures.py
+++ b/gen_signatures.py
@@ -6,23 +6,23 @@ def gen_struct_signatures(args):
     for n in range(args, -1, -1):
         result = (
             result + gen_function("""%{template <%(class T%n%:, %)>
-%}struct Signature%x {};
+%}struct signature%x {};
 
 """, n)
 #            + ((n == args) and [""] or
 #               [gen_function("""
 #    template <class X>
-#    static inline Signature%1<X%(, T%n%)> prepend(Type<X>)
-#        { return Signature%1<X%(, T%n%)>(); }""",
+#    static inline signature%1<X%(, T%n%)> prepend(type<X>)
+#        { return signature%1<X%(, T%n%)>(); }""",
 #                         n, (str(n+1),))
 #                ]
 #               )[0]
 #            
 #            + ((n != 0) and [""] or
 #               ["""
-#    // This one terminates the chain. Prepending Void to the head of a Void
-#    // signature results in a Void signature again.
-#    static inline Signature0 prepend(Void) { return Signature0(); }"""]
+#    // This one terminates the chain. Prepending void_t to the head of a void_t
+#    // signature results in a void_t signature again.
+#    static inline signature0 prepend(void_t) { return signature0(); }"""]
 #               )[0]
 #            + """
 #};
@@ -31,8 +31,8 @@ def gen_struct_signatures(args):
  + ((n == args) and [""] or
             [gen_function(
 """template <%(class T%n%, %)class X>
-inline Signature%1<X%(, T%n%)> prepend(Type<X>, Signature%x%{<%(T%n%:, %)>%})
-    { return Signature%1<X%(, T%n%)>(); }
+inline signature%1<X%(, T%n%)> prepend(type<X>, signature%x%{<%(T%n%:, %)>%})
+    { return signature%1<X%(, T%n%)>(); }
 
 """, n, str(n+1))
              ]
@@ -50,62 +50,62 @@ def gen_signatures(args):
 //  The author gratefully acknowleges the support of Dragon Systems, Inc., in
 //  producing this work.
 //
-//  This file automatically generated by gen_signatures.py for %d arguments.
+//  This file automatically generated by gen_signatures.python for %d arguments.
 #ifndef SIGNATURES_DWA050900_H_
 # define SIGNATURES_DWA050900_H_
 
 # include "pyconfig.h"
 
-namespace py {
+namespace python {
 
 namespace detail {
 // A stand-in for the built-in void. This one can be passed to functions and
 // (under MSVC, which has a bug, be used as a default template type parameter).
-struct Void {};
+struct void_t {};
 }
 
 // An envelope in which type information can be delivered for the purposes
 // of selecting an overloaded from_python() function. This is needed to work
 // around MSVC's lack of partial specialiation/ordering. Where normally we'd
 // want to form a function call like void f<const T&>(), We instead pass
-// Type<const T&> as one of the function parameters to select a particular
+// type<const T&> as one of the function parameters to select a particular
 // overload.
 //
-// The Id typedef helps us deal with the lack of partial ordering by generating
-// unique types for constructor signatures. In general, Type<T>::Id is Type<T>,
-// but Type<Void>::Id is just Void.
+// The id typedef helps us deal with the lack of partial ordering by generating
+// unique types for constructor signatures. In general, type<T>::id is type<T>,
+// but type<void_t>::id is just void_t.
 template <class T>
-struct Type
+struct type
 {
-    typedef Type Id;
+    typedef type id;
 };
 
 template <>
-struct Type<py::detail::Void>
+struct type<python::detail::void_t>
 {
-    typedef py::detail::Void Id;
+    typedef python::detail::void_t id;
 };
 
 namespace detail {
 // These basically encapsulate a chain of types, , used to make the syntax of
-// add(Constructor<T1, ...>()) work. We need to produce a unique type for each number
-// of non-default parameters to Constructor<>.  Q: why not use a recursive
+// add(constructor<T1, ...>()) work. We need to produce a unique type for each number
+// of non-default parameters to constructor<>.  Q: why not use a recursive
 // formulation for infinite extensibility? A: MSVC6 seems to choke on constructs
 // that involve recursive template nesting.
 //
-// Signature chaining
+// signature chaining
 """ % args
         + gen_struct_signatures(args)
         + """
-// This one terminates the chain. Prepending Void to the head of a Void
-// signature results in a Void signature again.
-inline Signature0 prepend(Void, Signature0) { return Signature0(); }
+// This one terminates the chain. Prepending void_t to the head of a void_t
+// signature results in a void_t signature again.
+inline signature0 prepend(void_t, signature0) { return signature0(); }
 
 } // namespace detail
 """
         + gen_function("""
-template <%(class A%n% = detail::Void%:, %)>
-struct Constructor
+template <%(class A%n% = detail::void_t%:, %)>
+struct constructor
 {
 };
 """, args)
@@ -113,16 +113,16 @@ struct Constructor
 namespace detail {
 // Return value extraction:
 
-// This is just another little envelope for carrying a typedef (see Type,
-// above). I could have re-used Type, but that has a very specific purpose. I
+// This is just another little envelope for carrying a typedef (see type,
+// above). I could have re-used type, but that has a very specific purpose. I
 // thought this would be clearer.
 template <class T>
-struct ReturnValue { typedef T Type; };
+struct return_value_select { typedef T type; };
 
 // free functions"""
         + gen_functions("""
 template <class R%(, class A%n%)>
-ReturnValue<R> return_value(R (*)(%(A%n%:, %))) { return ReturnValue<R>(); }
+return_value_select<R> return_value(R (*)(%(A%n%:, %))) { return return_value_select<R>(); }
 """, args)
 
         +
@@ -132,16 +132,16 @@ ReturnValue<R> return_value(R (*)(%(A%n%:, %))) { return ReturnValue<R>(); }
 // member functions"""
         + gen_functions("""
 template <class R, class T%(, class A%n%)>
-ReturnValue<R> return_value(R (T::*)(%(A%n%:, %))) { return ReturnValue<R>(); }
+return_value_select<R> return_value(R (T::*)(%(A%n%:, %))) { return return_value_select<R>(); }
 """, args)
 
         + gen_functions("""
 template <class R, class T%(, class A%n%)>
-ReturnValue<R> return_value(R (T::*)(%(A%n%:, %)) const) { return ReturnValue<R>(); }
+return_value_select<R> return_value(R (T::*)(%(A%n%:, %)) const) { return return_value_select<R>(); }
 """, args)
 
         + """
-}} // namespace py::detail
+}} // namespace python::detail
 
 #endif
 """)
diff --git a/gen_singleton.py b/gen_singleton.py
index 36422966..203d6444 100644
--- a/gen_singleton.py
+++ b/gen_singleton.py
@@ -16,33 +16,33 @@ def gen_singleton(args):
 
 # include "pyconfig.h"
 
-namespace py { namespace detail {
+namespace python { namespace detail {
 
-struct Empty {};
-template <class Derived, class Base = Empty>
-struct Singleton : Base
+struct empty {};
+template <class Derived, class Base = empty>
+struct singleton : Base
 {
-    typedef Singleton SingletonBase; // Convenience type for derived class constructors
+    typedef singleton singleton_base; // Convenience type for derived class constructors
     
-    static Derived* singleton();
+    static Derived* instance();
 
     // Pass-through constructors
 """
         + gen_functions("""%{
     template <%(class A%n%:, %)>
-%}    Singleton(%(const A%n& a%n%:, %)) : Base(%(a%n%:, %)) {}
+%}    singleton(%(const A%n& a%n%:, %)) : Base(%(a%n%:, %)) {}
 """, args)
         + """
 };
 
 template <class Derived, class Base>
-Derived* Singleton<Derived,Base>::singleton()
+Derived* singleton<Derived,Base>::instance()
 {
     static Derived x;
     return &x;
 }
 
-}} // namespace py::detail
+}} // namespace python::detail
 
 #endif
 """)
diff --git a/inheritance.html b/inheritance.html
index e991065d..385fe812 100644
--- a/inheritance.html
+++ b/inheritance.html
@@ -41,7 +41,7 @@
         wrapped derived classes may be passed where values, pointers, or
         references to a base class are expected as arguments. The
         <code>declare_base</code> member function of
-        <code>ClassWrapper&lt;&gt;</code> is used to establish the relationship
+        <code>class_builder&lt;&gt;</code> is used to establish the relationship
         between base and derived classes:
 
 <blockquote>
@@ -80,13 +80,13 @@ void initmy_module()
 {
     try
     {
-       py::Module my_module("my_module");
+       python::module_builder my_module("my_module");
 
-       py::ClassWrapper&lt;Base&gt; base_class(my_module, "Base");
-       base_class.def(py::Constructor&lt;void&gt;());
+       python::class_builder&lt;Base&gt; base_class(my_module, "Base");
+       base_class.def(python::constructor&lt;void&gt;());
 
-       py::ClassWrapper&lt;Derived&gt; derived_class(my_module, "Derived");
-       derived_class.def(py::Constructor&lt;void&gt;());
+       python::class_builder&lt;Derived&gt; derived_class(my_module, "Derived");
+       derived_class.def(python::constructor&lt;void&gt;());
        <b>// Establish the inheritance relationship between Base and Derived
        derived_class.declare_base(base_class);</b>
 
@@ -96,7 +96,7 @@ void initmy_module()
     }
     catch(...)
     {
-       py::handle_exception();    // Deal with the exception for Python
+       python::handle_exception();    // Deal with the exception for Python
     }
 }
 </pre>
@@ -126,7 +126,7 @@ expected but where type information has been lost.</i><pre>
 <p>
   If for some reason your base class has no virtual functions but you still want
   to represent the inheritance relationship between base and derived classes,
-  pass the special symbol <code>py::without_downcast</code> as the 2nd parameter
+  pass the special symbol <code>python::without_downcast</code> as the 2nd parameter
   to <code>declare_base</code>:
 
 <blockquote>
@@ -135,12 +135,12 @@ struct Base2 {};
 struct Derived2 { int f(); };
 <hr>
    ...
-   py::ClassWrapper&lt;Base&gt; base2_class(my_module, "Base2");
-   base2_class.def(py::Constructor&lt;void&gt;());
+   python::class_builder&lt;Base&gt; base2_class(my_module, "Base2");
+   base2_class.def(python::constructor&lt;void&gt;());
 
-   py::ClassWrapper&lt;Derived2&gt; derived2_class(my_module, "Derived2");
-   derived2_class.def(py::Constructor&lt;void&gt;());
-   derived_class.declare_base(base_class, <b>py::without_downcast</b>);
+   python::class_builder&lt;Derived2&gt; derived2_class(my_module, "Derived2");
+   derived2_class.def(python::constructor&lt;void&gt;());
+   derived_class.declare_base(base_class, <b>python::without_downcast</b>);
 </pre>
 </blockquote>
 
diff --git a/init_function.cpp b/init_function.cpp
index defe7ee3..f29e914a 100644
--- a/init_function.cpp
+++ b/init_function.cpp
@@ -11,26 +11,26 @@
 #include "extclass.h"
 #include <utility>
 
-namespace py { namespace detail {
+namespace python { namespace detail {
 
-  PyObject* Init::do_call(PyObject* args_, PyObject* keywords) const
+  PyObject* init::do_call(PyObject* args_, PyObject* keywords) const
   {
-      Tuple args(Ptr(args_, Ptr::borrowed));
+      tuple args(ref(args_, ref::increment_count));
       if (args[0]->ob_type->ob_type != extension_meta_class())
       {
           PyErr_SetString(PyExc_TypeError, "argument 1 to __init__ must be an ExtensionInstance");
           return 0;
       }
 
-      ExtensionInstance *self = static_cast<ExtensionInstance*>(args[0].get());
+      extension_instance *self = static_cast<extension_instance*>(args[0].get());
 
-      Tuple ctor_args = args.slice(1, args.size());
+      tuple ctor_args = args.slice(1, args.size());
 
-      std::auto_ptr<InstanceHolderBase> result(
+      std::auto_ptr<instance_holder_base> result(
           create_holder(self, ctor_args.get(), keywords));
 
       self->add_implementation(result);
       return none();
   }
 
-}} // namespace py::detail
+}} // namespace python::detail
diff --git a/init_function.h b/init_function.h
index 70709d9c..5353031b 100644
--- a/init_function.h
+++ b/init_function.h
@@ -6,7 +6,7 @@
 //  The author gratefully acknowleges the support of Dragon Systems, Inc., in
 //  producing this work.
 //
-//  This file was generated for %d-argument constructors by gen_init_function.py
+//  This file was generated for %d-argument constructors by gen_init_function.python
 
 #ifndef INIT_FUNCTION_DWA052000_H_
 # define INIT_FUNCTION_DWA052000_H_
@@ -16,7 +16,7 @@
 # include "signatures.h"
 # include <typeinfo>
 
-namespace py {
+namespace python {
 
 namespace detail {
 
@@ -100,16 +100,16 @@ namespace detail {
       const_reference value;
   };
 
-class ExtensionInstance;
-class InstanceHolderBase;
+class extension_instance;
+class instance_holder_base;
 
-class Init;
-template <class T> struct Init0;
-template <class T, class A1> struct Init1;
-template <class T, class A1, class A2> struct Init2;
-template <class T, class A1, class A2, class A3> struct Init3;
-template <class T, class A1, class A2, class A3, class A4> struct Init4;
-template <class T, class A1, class A2, class A3, class A4, class A5> struct Init5;
+class init;
+template <class T> struct init0;
+template <class T, class A1> struct init1;
+template <class T, class A1, class A2> struct init2;
+template <class T, class A1, class A2, class A3> struct init3;
+template <class T, class A1, class A2, class A3, class A4> struct init4;
+template <class T, class A1, class A2, class A3, class A4, class A5> struct init5;
 template <class T, class A1, class A2, class A3, class A4, class A5, class A6> struct Init6;
 template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7> struct Init7;
 template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> struct Init8;
@@ -117,36 +117,36 @@ template <class T, class A1, class A2, class A3, class A4, class A5, class A6, c
 template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10> struct Init10;
 
 template <class T>
-struct InitFunction
+struct init_function
 {
-    static Init* create(Signature0) {
-        return new Init0<T>;
+    static init* create(signature0) {
+        return new init0<T>;
     }
 
     template <class A1>
-    static Init* create(Signature1<A1>) {
-        return new Init1<T,
+    static init* create(signature1<A1>) {
+        return new init1<T,
                        detail::parameter_traits<A1>::const_reference>;
     }
 
     template <class A1, class A2>
-    static Init* create(Signature2<A1, A2>) {
-        return new Init2<T,
+    static init* create(signature2<A1, A2>) {
+        return new init2<T,
                        detail::parameter_traits<A1>::const_reference,
                        detail::parameter_traits<A2>::const_reference>;
     }
 
     template <class A1, class A2, class A3>
-    static Init* create(Signature3<A1, A2, A3>) {
-        return new Init3<T,
+    static init* create(signature3<A1, A2, A3>) {
+        return new init3<T,
                        detail::parameter_traits<A1>::const_reference,
                        detail::parameter_traits<A2>::const_reference,
                        detail::parameter_traits<A3>::const_reference>;
     }
 
     template <class A1, class A2, class A3, class A4>
-    static Init* create(Signature4<A1, A2, A3, A4>) {
-        return new Init4<T,
+    static init* create(signature4<A1, A2, A3, A4>) {
+        return new init4<T,
                        detail::parameter_traits<A1>::const_reference,
                        detail::parameter_traits<A2>::const_reference,
                        detail::parameter_traits<A3>::const_reference,
@@ -154,8 +154,8 @@ struct InitFunction
     }
 
     template <class A1, class A2, class A3, class A4, class A5>
-    static Init* create(Signature5<A1, A2, A3, A4, A5>) {
-        return new Init5<T,
+    static init* create(signature5<A1, A2, A3, A4, A5>) {
+        return new init5<T,
                        detail::parameter_traits<A1>::const_reference,
                        detail::parameter_traits<A2>::const_reference,
                        detail::parameter_traits<A3>::const_reference,
@@ -164,7 +164,7 @@ struct InitFunction
     }
 
     template <class A1, class A2, class A3, class A4, class A5, class A6>
-    static Init* create(Signature6<A1, A2, A3, A4, A5, A6>) {
+    static init* create(Signature6<A1, A2, A3, A4, A5, A6>) {
         return new Init6<T,
                        detail::parameter_traits<A1>::const_reference,
                        detail::parameter_traits<A2>::const_reference,
@@ -175,7 +175,7 @@ struct InitFunction
     }
 
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-    static Init* create(Signature7<A1, A2, A3, A4, A5, A6, A7>) {
+    static init* create(Signature7<A1, A2, A3, A4, A5, A6, A7>) {
         return new Init7<T,
                        detail::parameter_traits<A1>::const_reference,
                        detail::parameter_traits<A2>::const_reference,
@@ -187,7 +187,7 @@ struct InitFunction
     }
 
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-    static Init* create(Signature8<A1, A2, A3, A4, A5, A6, A7, A8>) {
+    static init* create(Signature8<A1, A2, A3, A4, A5, A6, A7, A8>) {
         return new Init8<T,
                        detail::parameter_traits<A1>::const_reference,
                        detail::parameter_traits<A2>::const_reference,
@@ -200,7 +200,7 @@ struct InitFunction
     }
 
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-    static Init* create(Signature9<A1, A2, A3, A4, A5, A6, A7, A8, A9>) {
+    static init* create(Signature9<A1, A2, A3, A4, A5, A6, A7, A8, A9>) {
         return new Init9<T,
                        detail::parameter_traits<A1>::const_reference,
                        detail::parameter_traits<A2>::const_reference,
@@ -214,7 +214,7 @@ struct InitFunction
     }
 
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
-    static Init* create(Signature10<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>) {
+    static init* create(Signature10<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>) {
         return new Init10<T,
                        detail::parameter_traits<A1>::const_reference,
                        detail::parameter_traits<A2>::const_reference,
@@ -229,22 +229,22 @@ struct InitFunction
     }
 };
 
-class Init : public Function
+class init : public function
 {
-private: // override Function hook
+private: // override function hook
     PyObject* do_call(PyObject* args, PyObject* keywords) const;
 private:
-    virtual InstanceHolderBase* create_holder(ExtensionInstance* self, PyObject* tail_args, PyObject* keywords) const = 0;
+    virtual instance_holder_base* create_holder(extension_instance* self, PyObject* tail_args, PyObject* keywords) const = 0;
 };
 
 
 template <class T>
-struct Init0 : Init
+struct init0 : init
 {
-    virtual InstanceHolderBase* create_holder(ExtensionInstance* self, PyObject* args, PyObject* /*keywords*/) const
+    virtual instance_holder_base* create_holder(extension_instance* self, PyObject* args, PyObject* /*keywords*/) const
     {
         if (!PyArg_ParseTuple(args, const_cast<char*>("")))
-            throw ArgumentError();
+            throw argument_error();
         return new T(self
             );
     }
@@ -253,15 +253,15 @@ struct Init0 : Init
 };
 
 template <class T, class A1>
-struct Init1 : Init
+struct init1 : init
 {
-    virtual InstanceHolderBase* create_holder(ExtensionInstance* self, PyObject* args, PyObject* /*keywords*/) const
+    virtual instance_holder_base* create_holder(extension_instance* self, PyObject* args, PyObject* /*keywords*/) const
     {
         PyObject* a1;
         if (!PyArg_ParseTuple(args, const_cast<char*>("O"), &a1))
-            throw ArgumentError();
+            throw argument_error();
         return new T(self,
-            py::detail::reference_parameter<A1>(from_python(a1, Type<A1>()))
+            python::detail::reference_parameter<A1>(from_python(a1, type<A1>()))
             );
     }
     const char* description() const
@@ -269,17 +269,17 @@ struct Init1 : Init
 };
 
 template <class T, class A1, class A2>
-struct Init2 : Init
+struct init2 : init
 {
-    virtual InstanceHolderBase* create_holder(ExtensionInstance* self, PyObject* args, PyObject* /*keywords*/) const
+    virtual instance_holder_base* create_holder(extension_instance* self, PyObject* args, PyObject* /*keywords*/) const
     {
         PyObject* a1;
         PyObject* a2;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OO"), &a1, &a2))
-            throw ArgumentError();
+            throw argument_error();
         return new T(self,
-            py::detail::reference_parameter<A1>(from_python(a1, Type<A1>())),
-            py::detail::reference_parameter<A2>(from_python(a2, Type<A2>()))
+            python::detail::reference_parameter<A1>(from_python(a1, type<A1>())),
+            python::detail::reference_parameter<A2>(from_python(a2, type<A2>()))
             );
     }
     const char* description() const
@@ -287,19 +287,19 @@ struct Init2 : Init
 };
 
 template <class T, class A1, class A2, class A3>
-struct Init3 : Init
+struct init3 : init
 {
-    virtual InstanceHolderBase* create_holder(ExtensionInstance* self, PyObject* args, PyObject* /*keywords*/) const
+    virtual instance_holder_base* create_holder(extension_instance* self, PyObject* args, PyObject* /*keywords*/) const
     {
         PyObject* a1;
         PyObject* a2;
         PyObject* a3;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOO"), &a1, &a2, &a3))
-            throw ArgumentError();
+            throw argument_error();
         return new T(self,
-            py::detail::reference_parameter<A1>(from_python(a1, Type<A1>())),
-            py::detail::reference_parameter<A2>(from_python(a2, Type<A2>())),
-            py::detail::reference_parameter<A3>(from_python(a3, Type<A3>()))
+            python::detail::reference_parameter<A1>(from_python(a1, type<A1>())),
+            python::detail::reference_parameter<A2>(from_python(a2, type<A2>())),
+            python::detail::reference_parameter<A3>(from_python(a3, type<A3>()))
             );
     }
     const char* description() const
@@ -307,21 +307,21 @@ struct Init3 : Init
 };
 
 template <class T, class A1, class A2, class A3, class A4>
-struct Init4 : Init
+struct init4 : init
 {
-    virtual InstanceHolderBase* create_holder(ExtensionInstance* self, PyObject* args, PyObject* /*keywords*/) const
+    virtual instance_holder_base* create_holder(extension_instance* self, PyObject* args, PyObject* /*keywords*/) const
     {
         PyObject* a1;
         PyObject* a2;
         PyObject* a3;
         PyObject* a4;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOO"), &a1, &a2, &a3, &a4))
-            throw ArgumentError();
+            throw argument_error();
         return new T(self,
-            py::detail::reference_parameter<A1>(from_python(a1, Type<A1>())),
-            py::detail::reference_parameter<A2>(from_python(a2, Type<A2>())),
-            py::detail::reference_parameter<A3>(from_python(a3, Type<A3>())),
-            py::detail::reference_parameter<A4>(from_python(a4, Type<A4>()))
+            python::detail::reference_parameter<A1>(from_python(a1, type<A1>())),
+            python::detail::reference_parameter<A2>(from_python(a2, type<A2>())),
+            python::detail::reference_parameter<A3>(from_python(a3, type<A3>())),
+            python::detail::reference_parameter<A4>(from_python(a4, type<A4>()))
             );
     }
     const char* description() const
@@ -329,9 +329,9 @@ struct Init4 : Init
 };
 
 template <class T, class A1, class A2, class A3, class A4, class A5>
-struct Init5 : Init
+struct init5 : init
 {
-    virtual InstanceHolderBase* create_holder(ExtensionInstance* self, PyObject* args, PyObject* /*keywords*/) const
+    virtual instance_holder_base* create_holder(extension_instance* self, PyObject* args, PyObject* /*keywords*/) const
     {
         PyObject* a1;
         PyObject* a2;
@@ -339,13 +339,13 @@ struct Init5 : Init
         PyObject* a4;
         PyObject* a5;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOO"), &a1, &a2, &a3, &a4, &a5))
-            throw ArgumentError();
+            throw argument_error();
         return new T(self,
-            py::detail::reference_parameter<A1>(from_python(a1, Type<A1>())),
-            py::detail::reference_parameter<A2>(from_python(a2, Type<A2>())),
-            py::detail::reference_parameter<A3>(from_python(a3, Type<A3>())),
-            py::detail::reference_parameter<A4>(from_python(a4, Type<A4>())),
-            py::detail::reference_parameter<A5>(from_python(a5, Type<A5>()))
+            python::detail::reference_parameter<A1>(from_python(a1, type<A1>())),
+            python::detail::reference_parameter<A2>(from_python(a2, type<A2>())),
+            python::detail::reference_parameter<A3>(from_python(a3, type<A3>())),
+            python::detail::reference_parameter<A4>(from_python(a4, type<A4>())),
+            python::detail::reference_parameter<A5>(from_python(a5, type<A5>()))
             );
     }
     const char* description() const
@@ -353,9 +353,9 @@ struct Init5 : Init
 };
 
 template <class T, class A1, class A2, class A3, class A4, class A5, class A6>
-struct Init6 : Init
+struct Init6 : init
 {
-    virtual InstanceHolderBase* create_holder(ExtensionInstance* self, PyObject* args, PyObject* /*keywords*/) const
+    virtual instance_holder_base* create_holder(extension_instance* self, PyObject* args, PyObject* /*keywords*/) const
     {
         PyObject* a1;
         PyObject* a2;
@@ -364,14 +364,14 @@ struct Init6 : Init
         PyObject* a5;
         PyObject* a6;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOO"), &a1, &a2, &a3, &a4, &a5, &a6))
-            throw ArgumentError();
+            throw argument_error();
         return new T(self,
-            py::detail::reference_parameter<A1>(from_python(a1, Type<A1>())),
-            py::detail::reference_parameter<A2>(from_python(a2, Type<A2>())),
-            py::detail::reference_parameter<A3>(from_python(a3, Type<A3>())),
-            py::detail::reference_parameter<A4>(from_python(a4, Type<A4>())),
-            py::detail::reference_parameter<A5>(from_python(a5, Type<A5>())),
-            py::detail::reference_parameter<A6>(from_python(a6, Type<A6>()))
+            python::detail::reference_parameter<A1>(from_python(a1, type<A1>())),
+            python::detail::reference_parameter<A2>(from_python(a2, type<A2>())),
+            python::detail::reference_parameter<A3>(from_python(a3, type<A3>())),
+            python::detail::reference_parameter<A4>(from_python(a4, type<A4>())),
+            python::detail::reference_parameter<A5>(from_python(a5, type<A5>())),
+            python::detail::reference_parameter<A6>(from_python(a6, type<A6>()))
             );
     }
     const char* description() const
@@ -379,9 +379,9 @@ struct Init6 : Init
 };
 
 template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-struct Init7 : Init
+struct Init7 : init
 {
-    virtual InstanceHolderBase* create_holder(ExtensionInstance* self, PyObject* args, PyObject* /*keywords*/) const
+    virtual instance_holder_base* create_holder(extension_instance* self, PyObject* args, PyObject* /*keywords*/) const
     {
         PyObject* a1;
         PyObject* a2;
@@ -391,15 +391,15 @@ struct Init7 : Init
         PyObject* a6;
         PyObject* a7;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOO"), &a1, &a2, &a3, &a4, &a5, &a6, &a7))
-            throw ArgumentError();
+            throw argument_error();
         return new T(self,
-            py::detail::reference_parameter<A1>(from_python(a1, Type<A1>())),
-            py::detail::reference_parameter<A2>(from_python(a2, Type<A2>())),
-            py::detail::reference_parameter<A3>(from_python(a3, Type<A3>())),
-            py::detail::reference_parameter<A4>(from_python(a4, Type<A4>())),
-            py::detail::reference_parameter<A5>(from_python(a5, Type<A5>())),
-            py::detail::reference_parameter<A6>(from_python(a6, Type<A6>())),
-            py::detail::reference_parameter<A7>(from_python(a7, Type<A7>()))
+            python::detail::reference_parameter<A1>(from_python(a1, type<A1>())),
+            python::detail::reference_parameter<A2>(from_python(a2, type<A2>())),
+            python::detail::reference_parameter<A3>(from_python(a3, type<A3>())),
+            python::detail::reference_parameter<A4>(from_python(a4, type<A4>())),
+            python::detail::reference_parameter<A5>(from_python(a5, type<A5>())),
+            python::detail::reference_parameter<A6>(from_python(a6, type<A6>())),
+            python::detail::reference_parameter<A7>(from_python(a7, type<A7>()))
             );
     }
     const char* description() const
@@ -407,9 +407,9 @@ struct Init7 : Init
 };
 
 template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-struct Init8 : Init
+struct Init8 : init
 {
-    virtual InstanceHolderBase* create_holder(ExtensionInstance* self, PyObject* args, PyObject* /*keywords*/) const
+    virtual instance_holder_base* create_holder(extension_instance* self, PyObject* args, PyObject* /*keywords*/) const
     {
         PyObject* a1;
         PyObject* a2;
@@ -420,16 +420,16 @@ struct Init8 : Init
         PyObject* a7;
         PyObject* a8;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOO"), &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8))
-            throw ArgumentError();
+            throw argument_error();
         return new T(self,
-            py::detail::reference_parameter<A1>(from_python(a1, Type<A1>())),
-            py::detail::reference_parameter<A2>(from_python(a2, Type<A2>())),
-            py::detail::reference_parameter<A3>(from_python(a3, Type<A3>())),
-            py::detail::reference_parameter<A4>(from_python(a4, Type<A4>())),
-            py::detail::reference_parameter<A5>(from_python(a5, Type<A5>())),
-            py::detail::reference_parameter<A6>(from_python(a6, Type<A6>())),
-            py::detail::reference_parameter<A7>(from_python(a7, Type<A7>())),
-            py::detail::reference_parameter<A8>(from_python(a8, Type<A8>()))
+            python::detail::reference_parameter<A1>(from_python(a1, type<A1>())),
+            python::detail::reference_parameter<A2>(from_python(a2, type<A2>())),
+            python::detail::reference_parameter<A3>(from_python(a3, type<A3>())),
+            python::detail::reference_parameter<A4>(from_python(a4, type<A4>())),
+            python::detail::reference_parameter<A5>(from_python(a5, type<A5>())),
+            python::detail::reference_parameter<A6>(from_python(a6, type<A6>())),
+            python::detail::reference_parameter<A7>(from_python(a7, type<A7>())),
+            python::detail::reference_parameter<A8>(from_python(a8, type<A8>()))
             );
     }
     const char* description() const
@@ -437,9 +437,9 @@ struct Init8 : Init
 };
 
 template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-struct Init9 : Init
+struct Init9 : init
 {
-    virtual InstanceHolderBase* create_holder(ExtensionInstance* self, PyObject* args, PyObject* /*keywords*/) const
+    virtual instance_holder_base* create_holder(extension_instance* self, PyObject* args, PyObject* /*keywords*/) const
     {
         PyObject* a1;
         PyObject* a2;
@@ -451,17 +451,17 @@ struct Init9 : Init
         PyObject* a8;
         PyObject* a9;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOOO"), &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9))
-            throw ArgumentError();
+            throw argument_error();
         return new T(self,
-            py::detail::reference_parameter<A1>(from_python(a1, Type<A1>())),
-            py::detail::reference_parameter<A2>(from_python(a2, Type<A2>())),
-            py::detail::reference_parameter<A3>(from_python(a3, Type<A3>())),
-            py::detail::reference_parameter<A4>(from_python(a4, Type<A4>())),
-            py::detail::reference_parameter<A5>(from_python(a5, Type<A5>())),
-            py::detail::reference_parameter<A6>(from_python(a6, Type<A6>())),
-            py::detail::reference_parameter<A7>(from_python(a7, Type<A7>())),
-            py::detail::reference_parameter<A8>(from_python(a8, Type<A8>())),
-            py::detail::reference_parameter<A9>(from_python(a9, Type<A9>()))
+            python::detail::reference_parameter<A1>(from_python(a1, type<A1>())),
+            python::detail::reference_parameter<A2>(from_python(a2, type<A2>())),
+            python::detail::reference_parameter<A3>(from_python(a3, type<A3>())),
+            python::detail::reference_parameter<A4>(from_python(a4, type<A4>())),
+            python::detail::reference_parameter<A5>(from_python(a5, type<A5>())),
+            python::detail::reference_parameter<A6>(from_python(a6, type<A6>())),
+            python::detail::reference_parameter<A7>(from_python(a7, type<A7>())),
+            python::detail::reference_parameter<A8>(from_python(a8, type<A8>())),
+            python::detail::reference_parameter<A9>(from_python(a9, type<A9>()))
             );
     }
     const char* description() const
@@ -469,9 +469,9 @@ struct Init9 : Init
 };
 
 template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
-struct Init10 : Init
+struct Init10 : init
 {
-    virtual InstanceHolderBase* create_holder(ExtensionInstance* self, PyObject* args, PyObject* /*keywords*/) const
+    virtual instance_holder_base* create_holder(extension_instance* self, PyObject* args, PyObject* /*keywords*/) const
     {
         PyObject* a1;
         PyObject* a2;
@@ -484,24 +484,24 @@ struct Init10 : Init
         PyObject* a9;
         PyObject* a10;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOOOO"), &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9, &a10))
-            throw ArgumentError();
+            throw argument_error();
         return new T(self,
-            py::detail::reference_parameter<A1>(from_python(a1, Type<A1>())),
-            py::detail::reference_parameter<A2>(from_python(a2, Type<A2>())),
-            py::detail::reference_parameter<A3>(from_python(a3, Type<A3>())),
-            py::detail::reference_parameter<A4>(from_python(a4, Type<A4>())),
-            py::detail::reference_parameter<A5>(from_python(a5, Type<A5>())),
-            py::detail::reference_parameter<A6>(from_python(a6, Type<A6>())),
-            py::detail::reference_parameter<A7>(from_python(a7, Type<A7>())),
-            py::detail::reference_parameter<A8>(from_python(a8, Type<A8>())),
-            py::detail::reference_parameter<A9>(from_python(a9, Type<A9>())),
-            py::detail::reference_parameter<A10>(from_python(a10, Type<A10>()))
+            python::detail::reference_parameter<A1>(from_python(a1, type<A1>())),
+            python::detail::reference_parameter<A2>(from_python(a2, type<A2>())),
+            python::detail::reference_parameter<A3>(from_python(a3, type<A3>())),
+            python::detail::reference_parameter<A4>(from_python(a4, type<A4>())),
+            python::detail::reference_parameter<A5>(from_python(a5, type<A5>())),
+            python::detail::reference_parameter<A6>(from_python(a6, type<A6>())),
+            python::detail::reference_parameter<A7>(from_python(a7, type<A7>())),
+            python::detail::reference_parameter<A8>(from_python(a8, type<A8>())),
+            python::detail::reference_parameter<A9>(from_python(a9, type<A9>())),
+            python::detail::reference_parameter<A10>(from_python(a10, type<A10>()))
             );
     }
     const char* description() const
         { return typeid(void (*)(T&, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)).name(); }
 };
 
-}} // namespace py::detail
+}} // namespace python::detail
 
 #endif // INIT_FUNCTION_DWA052000_H_
diff --git a/module.cpp b/module.cpp
index c61fda43..8d0b3ddb 100644
--- a/module.cpp
+++ b/module.cpp
@@ -8,45 +8,45 @@
 
 #include "module.h"
 
-namespace py {
+namespace python {
 
 namespace {
-  Ptr name_holder;
+  ref name_holder;
 }
 
-String Module::name()
+string module_builder::name()
 {
-    // If this fails, you haven't created a Module object
+    // If this fails, you haven't created a module_builder object
     assert(name_holder.get() != 0);
-    return String(name_holder);
+    return string(name_holder);
 }
 
-Module::Module(const char* name)
+module_builder::module_builder(const char* name)
     : m_module(Py_InitModule(const_cast<char*>(name), initial_methods))
 {
-    // If this fails, you've created more than 1 Module object in your module    
+    // If this fails, you've created more than 1 module_builder object in your module    
     assert(name_holder.get() == 0);
-    name_holder = Ptr(PyObject_GetAttrString(m_module, const_cast<char*>("__name__")));
+    name_holder = ref(PyObject_GetAttrString(m_module, const_cast<char*>("__name__")));
 }
 
 void
-Module::add(detail::Function* x, const char* name)
+module_builder::add(detail::function* x, const char* name)
 {
-    PyPtr<detail::Function> f(x); // First take possession of the object.
-    detail::Function::add_to_namespace(f, name, PyModule_GetDict(m_module));
+    reference<detail::function> f(x); // First take possession of the object.
+    detail::function::add_to_namespace(f, name, PyModule_GetDict(m_module));
 }
 
-void Module::add(Ptr x, const char* name)
+void module_builder::add(ref x, const char* name)
 {
 	PyObject* dictionary = PyModule_GetDict(m_module);
     PyDict_SetItemString(dictionary, const_cast<char*>(name), x.get());
 }
 
-void Module::add(PyTypeObject* x, const char* name /*= 0*/)
+void module_builder::add(PyTypeObject* x, const char* name /*= 0*/)
 {
-    this->add(Ptr(as_object(x)), name ? name : x->tp_name);
+    this->add(ref(as_object(x)), name ? name : x->tp_name);
 }
 
-PyMethodDef Module::initial_methods[] = { { 0, 0, 0, 0 } };
+PyMethodDef module_builder::initial_methods[] = { { 0, 0, 0, 0 } };
 
 }
diff --git a/module.h b/module.h
index 64459e3f..601ef17d 100644
--- a/module.h
+++ b/module.h
@@ -14,20 +14,20 @@
 # include "objects.h"
 # include "functions.h"
 
-namespace py {
+namespace python {
 
-class Module
+class module_builder
 {
-    typedef PyObject * (*RawFunctionPtr)(py::Tuple const &, py::Dict const &);
+    typedef PyObject * (*raw_function_ptr)(python::tuple const &, python::dictionary const &);
     
  public:
-    // Create a module. REQUIRES: only one Module is created per module.
-    Module(const char* name);
+    // Create a module. REQUIRES: only one module_builder is created per module.
+    module_builder(const char* name);
 
     // Add elements to the module
-    void add(detail::Function* x, const char* name);
+    void add(detail::function* x, const char* name);
     void add(PyTypeObject* x, const char* name = 0);
-    void add(Ptr x, const char*name);
+    void add(ref x, const char*name);
 
     template <class Fn>
     void def_raw(Fn fn, const char* name)
@@ -41,7 +41,7 @@ class Module
         add(detail::new_wrapped_function(fn), name);
     }
 
-    static String name();
+    static string name();
     
  private:
     PyObject* m_module;
diff --git a/newtypes.cpp b/newtypes.cpp
index 0213b78e..2bb115b8 100644
--- a/newtypes.cpp
+++ b/newtypes.cpp
@@ -18,17 +18,17 @@
 #include "objects.h"
 #include <boost/type_traits.hpp>
 
-namespace py {
+namespace python {
 
 namespace {
 
-  using detail::TypeObjectBase;
+  using detail::type_object_base;
 
-  PyObject* call(PyObject* instance, PyObject* (TypeObjectBase::*f)(PyObject*) const)
+  PyObject* call(PyObject* obj, PyObject* (type_object_base::*f)(PyObject*) const)
   {
       try
       {
-          return (static_cast<TypeObjectBase*>(instance->ob_type)->*f)(instance);
+          return (static_cast<type_object_base*>(obj->ob_type)->*f)(obj);
       }
       catch(...)
       {
@@ -40,11 +40,11 @@ namespace {
   // Naming this differently allows us to use it for functions returning long on
   // compilers without partial ordering
   template <class R>
-  R int_call(PyObject* instance, R (TypeObjectBase::*f)(PyObject*) const)
+  R int_call(PyObject* obj, R (type_object_base::*f)(PyObject*) const)
   {
       try
       {
-          return (static_cast<TypeObjectBase*>(instance->ob_type)->*f)(instance);
+          return (static_cast<type_object_base*>(obj->ob_type)->*f)(obj);
       }
       catch(...)
       {
@@ -54,17 +54,17 @@ namespace {
   }
 
   // Implemented in terms of int_call, above
-  int call(PyObject* instance, int (TypeObjectBase::*f)(PyObject*) const)
+  int call(PyObject* obj, int (type_object_base::*f)(PyObject*) const)
   {
-      return int_call(instance, f);
+      return int_call(obj, f);
   }
 
   template <class A1>
-  PyObject* call(PyObject* instance, PyObject* (TypeObjectBase::*f)(PyObject*, A1) const, A1 a1)
+  PyObject* call(PyObject* obj, PyObject* (type_object_base::*f)(PyObject*, A1) const, A1 a1)
   {
       try
       {
-          return (static_cast<TypeObjectBase*>(instance->ob_type)->*f)(instance, a1);
+          return (static_cast<type_object_base*>(obj->ob_type)->*f)(obj, a1);
       }
       catch(...)
       {
@@ -74,11 +74,11 @@ namespace {
   }
 
   template <class A1>
-  int call(PyObject* instance, int (TypeObjectBase::*f)(PyObject*, A1) const, A1 a1)
+  int call(PyObject* obj, int (type_object_base::*f)(PyObject*, A1) const, A1 a1)
   {
       try
       {
-          return (static_cast<TypeObjectBase*>(instance->ob_type)->*f)(instance, a1);
+          return (static_cast<type_object_base*>(obj->ob_type)->*f)(obj, a1);
       }
       catch(...)
       {
@@ -88,11 +88,11 @@ namespace {
   }
 
   template <class A1, class A2>
-  PyObject* call(PyObject* instance, PyObject* (TypeObjectBase::*f)(PyObject*, A1, A2) const, A1 a1, A2 a2)
+  PyObject* call(PyObject* obj, PyObject* (type_object_base::*f)(PyObject*, A1, A2) const, A1 a1, A2 a2)
   {
       try
       {
-          return (static_cast<TypeObjectBase*>(instance->ob_type)->*f)(instance, a1, a2);
+          return (static_cast<type_object_base*>(obj->ob_type)->*f)(obj, a1, a2);
       }
       catch(...)
       {
@@ -102,11 +102,11 @@ namespace {
   }
 
   template <class A1, class A2>
-  int call(PyObject* instance, int (TypeObjectBase::*f)(PyObject*, A1, A2) const, A1 a1, A2 a2)
+  int call(PyObject* obj, int (type_object_base::*f)(PyObject*, A1, A2) const, A1 a1, A2 a2)
   {
       try
       {
-          return (static_cast<TypeObjectBase*>(instance->ob_type)->*f)(instance, a1, a2);
+          return (static_cast<type_object_base*>(obj->ob_type)->*f)(obj, a1, a2);
       }
       catch(...)
       {
@@ -116,11 +116,11 @@ namespace {
   }
 
   template <class A1, class A2, class A3>
-  int call(PyObject* instance, int (TypeObjectBase::*f)(PyObject*, A1, A2, A3) const, A1 a1, A2 a2, A3 a3)
+  int call(PyObject* obj, int (type_object_base::*f)(PyObject*, A1, A2, A3) const, A1 a1, A2 a2, A3 a3)
   {
       try
       {
-          return (static_cast<TypeObjectBase*>(instance->ob_type)->*f)(instance, a1, a2, a3);
+          return (static_cast<type_object_base*>(obj->ob_type)->*f)(obj, a1, a2, a3);
       }
       catch(...)
       {
@@ -129,12 +129,12 @@ namespace {
       }
   }
 
-  int call_length_function(PyObject* instance, int (TypeObjectBase::*f)(PyObject*) const)
+  int call_length_function(PyObject* obj, int (type_object_base::*f)(PyObject*) const)
   {
       try
       {
           const int outcome =
-              (static_cast<TypeObjectBase*>(instance->ob_type)->*f)(instance);
+              (static_cast<type_object_base*>(obj->ob_type)->*f)(obj);
 
           if (outcome < 0)
           {
@@ -154,37 +154,37 @@ namespace {
 
 extern "C" {
 
-static PyObject* do_instance_repr(PyObject* instance)
+static PyObject* do_instance_repr(PyObject* obj)
 {
-    return call(instance, &TypeObjectBase::instance_repr);
+    return call(obj, &type_object_base::instance_repr);
 }
 
-static int do_instance_compare(PyObject* instance, PyObject* other)
+static int do_instance_compare(PyObject* obj, PyObject* other)
 {
-    return call(instance, &TypeObjectBase::instance_compare, other);
+    return call(obj, &type_object_base::instance_compare, other);
 }
 
-static PyObject* do_instance_str(PyObject* instance)
+static PyObject* do_instance_str(PyObject* obj)
 {
-    return call(instance, &TypeObjectBase::instance_str);
+    return call(obj, &type_object_base::instance_str);
 }
 
-static long do_instance_hash(PyObject* instance)
+static long do_instance_hash(PyObject* obj)
 {
-    return int_call(instance, &TypeObjectBase::instance_hash);
+    return int_call(obj, &type_object_base::instance_hash);
 }
     
-static PyObject* do_instance_call(PyObject* instance, PyObject* args, PyObject* keywords)
+static PyObject* do_instance_call(PyObject* obj, PyObject* args, PyObject* keywords)
 {
-    return call(instance, &TypeObjectBase::instance_call, args, keywords);
+    return call(obj, &type_object_base::instance_call, args, keywords);
 }
 
-static void do_instance_dealloc(PyObject* instance)
+static void do_instance_dealloc(PyObject* obj)
 {
     try
     {
-        static_cast<TypeObjectBase*>(instance->ob_type)
-            ->instance_dealloc(instance);
+        static_cast<type_object_base*>(obj->ob_type)
+            ->instance_dealloc(obj);
     }
     catch(...)
     {
@@ -193,51 +193,51 @@ static void do_instance_dealloc(PyObject* instance)
     }
 }
 
-static PyObject* do_instance_getattr(PyObject* instance, char* name)
+static PyObject* do_instance_getattr(PyObject* obj, char* name)
 {
     const char* name_ = name;
-    return call(instance, &TypeObjectBase::instance_getattr, name_);
+    return call(obj, &type_object_base::instance_getattr, name_);
 }
 
-static int do_instance_setattr(PyObject* instance, char* name, PyObject* value)
+static int do_instance_setattr(PyObject* obj, char* name, PyObject* value)
 {
     const char* name_ = name;
-    return call(instance, &TypeObjectBase::instance_setattr, name_, value);
+    return call(obj, &type_object_base::instance_setattr, name_, value);
 }
 
-static int do_instance_mp_length(PyObject* instance)
+static int do_instance_mp_length(PyObject* obj)
 {
-    return call_length_function(instance, &TypeObjectBase::instance_mapping_length);
+    return call_length_function(obj, &type_object_base::instance_mapping_length);
 }
 
-static int do_instance_sq_length(PyObject* instance)
+static int do_instance_sq_length(PyObject* obj)
 {
-    return call_length_function(instance, &TypeObjectBase::instance_sequence_length);
+    return call_length_function(obj, &type_object_base::instance_sequence_length);
 }
 
-static PyObject* do_instance_mp_subscript(PyObject* instance, PyObject* index)
+static PyObject* do_instance_mp_subscript(PyObject* obj, PyObject* index)
 {
-    return call(instance, &TypeObjectBase::instance_mapping_subscript, index);
+    return call(obj, &type_object_base::instance_mapping_subscript, index);
 }
 
-static PyObject* do_instance_sq_item(PyObject* instance, int index)
+static PyObject* do_instance_sq_item(PyObject* obj, int index)
 {
     try
     {
-        const PyTypeObject* const type = instance->ob_type;
+        const PyTypeObject* const type = obj->ob_type;
         
         // This is an extension to standard class behavior. If sequence_length
         // is implemented and n >= sequence_length(), raise an IndexError. That
         // keeps users from having to worry about raising it themselves
         if (type->tp_as_sequence != 0 && type->tp_as_sequence->sq_length != 0
-            && index >= type->tp_as_sequence->sq_length(instance))
+            && index >= type->tp_as_sequence->sq_length(obj))
         {
             PyErr_SetString(PyExc_IndexError, type->tp_name);
             return 0;
         }
     
-        return static_cast<TypeObjectBase*>(instance->ob_type)
-            ->instance_sequence_item(instance, index);
+        return static_cast<type_object_base*>(obj->ob_type)
+            ->instance_sequence_item(obj, index);
     }
     catch(...)
     {
@@ -246,151 +246,151 @@ static PyObject* do_instance_sq_item(PyObject* instance, int index)
     }
 }
 
-static int do_instance_mp_ass_subscript(PyObject* instance, PyObject* index, PyObject* value)
+static int do_instance_mp_ass_subscript(PyObject* obj, PyObject* index, PyObject* value)
 {
-    return call(instance, &TypeObjectBase::instance_mapping_ass_subscript, index, value);
+    return call(obj, &type_object_base::instance_mapping_ass_subscript, index, value);
 }
 
-static int do_instance_sq_ass_item(PyObject* instance, int index, PyObject* value)
+static int do_instance_sq_ass_item(PyObject* obj, int index, PyObject* value)
 {
-    return call(instance, &TypeObjectBase::instance_sequence_ass_item, index, value);
+    return call(obj, &type_object_base::instance_sequence_ass_item, index, value);
 }
 
-static PyObject* do_instance_sq_concat(PyObject* instance, PyObject* other)
+static PyObject* do_instance_sq_concat(PyObject* obj, PyObject* other)
 {
-    return call(instance, &TypeObjectBase::instance_sequence_concat, other);
+    return call(obj, &type_object_base::instance_sequence_concat, other);
 }
 
-static PyObject* do_instance_sq_repeat(PyObject* instance, int n)
+static PyObject* do_instance_sq_repeat(PyObject* obj, int n)
 {
-    return call(instance, &TypeObjectBase::instance_sequence_repeat, n);
+    return call(obj, &type_object_base::instance_sequence_repeat, n);
 }
 
 static PyObject* do_instance_sq_slice(
-    PyObject* instance, int start, int finish)
+    PyObject* obj, int start, int finish)
 {
-    return call(instance, &TypeObjectBase::instance_sequence_slice, start, finish);
+    return call(obj, &type_object_base::instance_sequence_slice, start, finish);
 }
 
 static int do_instance_sq_ass_slice(
-    PyObject* instance, int start, int finish, PyObject* value)
+    PyObject* obj, int start, int finish, PyObject* value)
 {
-    return call(instance, &TypeObjectBase::instance_sequence_ass_slice, start, finish, value);
+    return call(obj, &type_object_base::instance_sequence_ass_slice, start, finish, value);
 }
 
-static PyObject* do_instance_nb_add(PyObject* instance, PyObject* other)
+static PyObject* do_instance_nb_add(PyObject* obj, PyObject* other)
 {
-    return call(instance, &TypeObjectBase::instance_number_add, other);
+    return call(obj, &type_object_base::instance_number_add, other);
 }
 
-static PyObject* do_instance_nb_subtract(PyObject* instance, PyObject* other)
+static PyObject* do_instance_nb_subtract(PyObject* obj, PyObject* other)
 {
-    return call(instance, &TypeObjectBase::instance_number_subtract, other);
+    return call(obj, &type_object_base::instance_number_subtract, other);
 }
 
-static PyObject* do_instance_nb_multiply(PyObject* instance, PyObject* other)
+static PyObject* do_instance_nb_multiply(PyObject* obj, PyObject* other)
 {
-    return call(instance, &TypeObjectBase::instance_number_multiply, other);
+    return call(obj, &type_object_base::instance_number_multiply, other);
 }
 
-static PyObject* do_instance_nb_divide(PyObject* instance, PyObject* other)
+static PyObject* do_instance_nb_divide(PyObject* obj, PyObject* other)
 {
-    return call(instance, &TypeObjectBase::instance_number_divide, other);
+    return call(obj, &type_object_base::instance_number_divide, other);
 }
 
-static PyObject* do_instance_nb_remainder(PyObject* instance, PyObject* other)
+static PyObject* do_instance_nb_remainder(PyObject* obj, PyObject* other)
 {
-    return call(instance, &TypeObjectBase::instance_number_remainder, other);
+    return call(obj, &type_object_base::instance_number_remainder, other);
 }
 
-static PyObject* do_instance_nb_divmod(PyObject* instance, PyObject* other)
+static PyObject* do_instance_nb_divmod(PyObject* obj, PyObject* other)
 {
-    return call(instance, &TypeObjectBase::instance_number_divmod, other);
+    return call(obj, &type_object_base::instance_number_divmod, other);
 }
 
-static PyObject* do_instance_nb_power(PyObject* instance, PyObject* exponent, PyObject* modulus)
+static PyObject* do_instance_nb_power(PyObject* obj, PyObject* exponent, PyObject* modulus)
 {
-    return call(instance, &TypeObjectBase::instance_number_power, exponent, modulus);
+    return call(obj, &type_object_base::instance_number_power, exponent, modulus);
 }
 
-static PyObject* do_instance_nb_negative(PyObject* instance)
+static PyObject* do_instance_nb_negative(PyObject* obj)
 {
-    return call(instance, &TypeObjectBase::instance_number_negative);
+    return call(obj, &type_object_base::instance_number_negative);
 }
 
-static PyObject* do_instance_nb_positive(PyObject* instance)
+static PyObject* do_instance_nb_positive(PyObject* obj)
 {
-    return call(instance, &TypeObjectBase::instance_number_positive);
+    return call(obj, &type_object_base::instance_number_positive);
 }
 
-static PyObject* do_instance_nb_absolute(PyObject* instance)
+static PyObject* do_instance_nb_absolute(PyObject* obj)
 {
-    return call(instance, &TypeObjectBase::instance_number_absolute);
+    return call(obj, &type_object_base::instance_number_absolute);
 }
 
-static int do_instance_nb_nonzero(PyObject* instance)
+static int do_instance_nb_nonzero(PyObject* obj)
 {
-    return call(instance, &TypeObjectBase::instance_number_nonzero);
+    return call(obj, &type_object_base::instance_number_nonzero);
 }
 
-static PyObject* do_instance_nb_invert(PyObject* instance)
+static PyObject* do_instance_nb_invert(PyObject* obj)
 {
-    return call(instance, &TypeObjectBase::instance_number_invert);
+    return call(obj, &type_object_base::instance_number_invert);
 }
 
     
-static PyObject* do_instance_nb_lshift(PyObject* instance, PyObject* other)
+static PyObject* do_instance_nb_lshift(PyObject* obj, PyObject* other)
 {
-    return call(instance, &TypeObjectBase::instance_number_lshift, other);
+    return call(obj, &type_object_base::instance_number_lshift, other);
 }
 
-static PyObject* do_instance_nb_rshift(PyObject* instance, PyObject* other)
+static PyObject* do_instance_nb_rshift(PyObject* obj, PyObject* other)
 {
-    return call(instance, &TypeObjectBase::instance_number_rshift, other);
+    return call(obj, &type_object_base::instance_number_rshift, other);
 }
 
-static PyObject* do_instance_nb_and(PyObject* instance, PyObject* other)
+static PyObject* do_instance_nb_and(PyObject* obj, PyObject* other)
 {
-    return call(instance, &TypeObjectBase::instance_number_and, other);
+    return call(obj, &type_object_base::instance_number_and, other);
 }
 
-static PyObject* do_instance_nb_xor(PyObject* instance, PyObject* other)
+static PyObject* do_instance_nb_xor(PyObject* obj, PyObject* other)
 {
-    return call(instance, &TypeObjectBase::instance_number_xor, other);
+    return call(obj, &type_object_base::instance_number_xor, other);
 }
 
-static PyObject* do_instance_nb_or(PyObject* instance, PyObject* other)
+static PyObject* do_instance_nb_or(PyObject* obj, PyObject* other)
 {
-    return call(instance, &TypeObjectBase::instance_number_or, other);
+    return call(obj, &type_object_base::instance_number_or, other);
 }
 
-static int do_instance_nb_coerce(PyObject**instance, PyObject**other)
+static int do_instance_nb_coerce(PyObject**obj, PyObject**other)
 {
-    return call(*instance, &TypeObjectBase::instance_number_coerce, instance, other);
+    return call(*obj, &type_object_base::instance_number_coerce, obj, other);
 }
-static PyObject* do_instance_nb_int(PyObject* instance)
+static PyObject* do_instance_nb_int(PyObject* obj)
 {
-    return call(instance, &TypeObjectBase::instance_number_int);
+    return call(obj, &type_object_base::instance_number_int);
 }
 
-static PyObject* do_instance_nb_long(PyObject* instance)
+static PyObject* do_instance_nb_long(PyObject* obj)
 {
-    return call(instance, &TypeObjectBase::instance_number_long);
+    return call(obj, &type_object_base::instance_number_long);
 }
 
-static PyObject* do_instance_nb_float(PyObject* instance)
+static PyObject* do_instance_nb_float(PyObject* obj)
 {
-    return call(instance, &TypeObjectBase::instance_number_float);
+    return call(obj, &type_object_base::instance_number_float);
 }
 
-static PyObject* do_instance_nb_oct(PyObject* instance)
+static PyObject* do_instance_nb_oct(PyObject* obj)
 {
-    return call(instance, &TypeObjectBase::instance_number_oct);
+    return call(obj, &type_object_base::instance_number_oct);
 }
 
-static PyObject* do_instance_nb_hex(PyObject* instance)
+static PyObject* do_instance_nb_hex(PyObject* obj)
 {
-    return call(instance, &TypeObjectBase::instance_number_hex);
+    return call(obj, &type_object_base::instance_number_hex);
 }
 
 } // extern "C"
@@ -399,11 +399,11 @@ namespace
 {
 
 #define ENABLE_GENERAL_CAPABILITY(field) \
-    case TypeObjectBase::field: \
+    case type_object_base::field: \
         dest->tp_##field = &do_instance_##field; \
         return true
 
-bool add_capability_general(TypeObjectBase::Capability capability, PyTypeObject* dest)
+bool add_capability_general(type_object_base::capability capability, PyTypeObject* dest)
 {
     assert(dest != 0);
     
@@ -436,13 +436,13 @@ void create_method_table_if_null(T*& table)
 }
 
 #define ENABLE_MAPPING_CAPABILITY(field) \
-    case TypeObjectBase::mapping_##field: \
+    case type_object_base::mapping_##field: \
         create_method_table_if_null(dest); \
         dest->mp_##field = &do_instance_mp_##field; \
         detail::shared_pod_manager::replace_if_equal(dest); \
         return true
 
-bool add_capability_mapping(TypeObjectBase::Capability capability, PyMappingMethods*& dest)
+bool add_capability_mapping(type_object_base::capability capability, PyMappingMethods*& dest)
 {
     switch(capability)
     {
@@ -455,13 +455,13 @@ bool add_capability_mapping(TypeObjectBase::Capability capability, PyMappingMeth
 }
 
 #define ENABLE_SEQUENCE_CAPABILITY(field) \
-    case TypeObjectBase::sequence_##field: \
+    case type_object_base::sequence_##field: \
         create_method_table_if_null(dest); \
         dest->sq_##field = &do_instance_sq_##field; \
         detail::shared_pod_manager::replace_if_equal(dest); \
         return true
 
-bool add_capability_sequence(TypeObjectBase::Capability capability, PySequenceMethods*& dest)
+bool add_capability_sequence(type_object_base::capability capability, PySequenceMethods*& dest)
 {
     switch(capability)
     {
@@ -478,13 +478,13 @@ bool add_capability_sequence(TypeObjectBase::Capability capability, PySequenceMe
 }
 
 #define ENABLE_NUMBER_CAPABILITY(field) \
-    case TypeObjectBase::number_##field: \
+    case type_object_base::number_##field: \
         create_method_table_if_null(dest); \
         dest->nb_##field = &do_instance_nb_##field; \
         detail::shared_pod_manager::replace_if_equal(dest); \
         return true
 
-bool add_capability_number(TypeObjectBase::Capability capability, PyNumberMethods*& dest)
+bool add_capability_number(type_object_base::capability capability, PyNumberMethods*& dest)
 {
     switch(capability)
     {
@@ -517,13 +517,13 @@ bool add_capability_number(TypeObjectBase::Capability capability, PyNumberMethod
 }
 
 #define ENABLE_BUFFER_CAPABILITY(field) \
-    case TypeObjectBase::buffer_##field: \
+    case type_object_base::buffer_##field: \
         create_method_table_if_null(dest); \
         dest->bf_##field = &do_instance_bf_##field; \
         detail::shared_pod_manager::replace_if_equal(dest); \
         return true
 
-bool add_capability_buffer(TypeObjectBase::Capability capability, PyBufferProcs*& dest)
+bool add_capability_buffer(type_object_base::capability capability, PyBufferProcs*& dest)
 {
     (void)dest; // suppress unused argument warning
     (void)capability; // likwise
@@ -543,7 +543,7 @@ bool add_capability_buffer(TypeObjectBase::Capability capability, PyBufferProcs*
 namespace detail  {
 
   void add_capability(
-      TypeObjectBase::Capability capability,
+      type_object_base::capability capability,
       PyTypeObject* dest_)
   {
     if(add_capability_general(capability, dest_))
@@ -562,7 +562,7 @@ namespace detail  {
   }
 } // namespace detail
 
-TypeObjectBase::~TypeObjectBase()
+type_object_base::~type_object_base()
 {
     detail::shared_pod_manager::dispose(tp_as_mapping);
     detail::shared_pod_manager::dispose(tp_as_sequence);
@@ -570,13 +570,13 @@ TypeObjectBase::~TypeObjectBase()
     detail::shared_pod_manager::dispose(tp_as_buffer);
 }
 
-void TypeObjectBase::enable(TypeObjectBase::Capability capability)
+void type_object_base::enable(type_object_base::capability capability)
 {
     detail::add_capability(capability, this);
 }
 
-TypeObjectBase::TypeObjectBase(PyTypeObject* t)
-    : PythonType(t)
+type_object_base::type_object_base(PyTypeObject* t)
+    : python_type(t)
 {
     this->tp_dealloc = do_instance_dealloc;
 }
@@ -636,14 +636,14 @@ namespace
 
 namespace detail
 {
-  struct shared_pod_manager::Compare
+  struct shared_pod_manager::compare
   {
       bool operator()(const std::pair<char*, std::size_t>& x1,
                       const std::pair<char*, std::size_t>& x2) const
       {
           const std::size_t n1 = x1.second;
           const std::size_t n2 = x2.second;
-          return n1 < n2 || n1 == n2 && PY_CSTD_::memcmp(x1.first, x2.first, n1) < 0;
+          return n1 < n2 || n1 == n2 && BOOST_CSTD_::memcmp(x1.first, x2.first, n1) < 0;
       }
   };
 
@@ -659,7 +659,7 @@ namespace detail
       char* pod;
   };
 
-  shared_pod_manager& shared_pod_manager::instance()
+  shared_pod_manager& shared_pod_manager::obj()
   {
       static shared_pod_manager spm;
       return spm;
@@ -674,17 +674,17 @@ namespace detail
       if(pod == 0)
           return 0;
 
-      const Holder element(static_cast<char*>(pod), size);
+      const holder element(static_cast<char*>(pod), size);
 
-      const Storage::iterator found
-          = std::lower_bound(m_storage.begin(), m_storage.end(), element, Compare());
+      const storage::iterator found
+          = std::lower_bound(m_storage.begin(), m_storage.end(), element, compare());
 
       if (found != m_storage.end() && pod == found->first)
       {
           // pod already in list => do nothing
           return pod;
       }
-      else if (found != m_storage.end() && !Compare()(element, *found))
+      else if (found != m_storage.end() && !compare()(element, *found))
       {
           // equal element in list => replace
           void* replacement = found->first;
@@ -748,7 +748,7 @@ namespace detail
       if(pod == 0)
           return;
 
-      const Storage::iterator found =
+      const storage::iterator found =
           std::find_if(m_storage.begin(), m_storage.end(), 
           identical(static_cast<char*>(pod)));
 
@@ -760,217 +760,217 @@ namespace detail
 } // namespace detail
 
 namespace {
-  struct ErrorType {
+  struct error_type {
       operator PyObject*() const { return 0; }
       operator int() const { return -1; }
   };
 
-  ErrorType unimplemented(const char* name)
+  error_type unimplemented(const char* name)
   {
       assert(!"Control should never reach here");
-      String s("Unimplemented ");
-      s += String(name);
+      string s("Unimplemented ");
+      s += string(name);
       PyErr_SetObject(PyExc_RuntimeError, s.get());
-      return ErrorType();
+      return error_type();
   }
 }
 
-PyObject* TypeObjectBase::instance_repr(PyObject*) const
+PyObject* type_object_base::instance_repr(PyObject*) const
 {
     return unimplemented("instance_repr");
 }
 
-int TypeObjectBase::instance_compare(PyObject*, PyObject*) const
+int type_object_base::instance_compare(PyObject*, PyObject*) const
 {
     return unimplemented("instance_compare");
 }
 
-PyObject* TypeObjectBase::instance_str(PyObject*) const
+PyObject* type_object_base::instance_str(PyObject*) const
 {
     return unimplemented("instance_str");
 }
 
-long TypeObjectBase::instance_hash(PyObject* /* instance */) const
+long type_object_base::instance_hash(PyObject* /* obj */) const
 {
     return unimplemented("instance_hash");
 }
 
-PyObject* TypeObjectBase::instance_call(PyObject* /*instance*/, PyObject* /*args*/, PyObject* /*kw*/) const
+PyObject* type_object_base::instance_call(PyObject* /*obj*/, PyObject* /*args*/, PyObject* /*kw*/) const
 {
     return unimplemented("instance_call");
 }
 
-PyObject* TypeObjectBase::instance_getattr(PyObject* /*instance*/, const char* /*name*/) const
+PyObject* type_object_base::instance_getattr(PyObject* /*obj*/, const char* /*name*/) const
 {
     return unimplemented("instance_getattr");
 }
 
-int TypeObjectBase::instance_setattr(PyObject* /*instance*/, const char* /*name*/, PyObject* /*value*/) const
+int type_object_base::instance_setattr(PyObject* /*obj*/, const char* /*name*/, PyObject* /*value*/) const
 {
     return unimplemented("instance_setattr");
 }
 
-int TypeObjectBase::instance_mapping_length(PyObject*) const
+int type_object_base::instance_mapping_length(PyObject*) const
 {
     return unimplemented("instance_mapping_length");
 }
 
-int TypeObjectBase::instance_sequence_length(PyObject*) const
+int type_object_base::instance_sequence_length(PyObject*) const
 {
     return unimplemented("instance_sequence_length");
 }
 
-PyObject* TypeObjectBase::instance_mapping_subscript(PyObject*, PyObject*) const
+PyObject* type_object_base::instance_mapping_subscript(PyObject*, PyObject*) const
 {
     return unimplemented("instance_mapping_subscript");
 }
 
-PyObject* TypeObjectBase::instance_sequence_item(PyObject*, int) const
+PyObject* type_object_base::instance_sequence_item(PyObject*, int) const
 {
     return unimplemented("instance_sequence_item");
 }
 
-int TypeObjectBase::instance_mapping_ass_subscript(PyObject*, PyObject*, PyObject*) const
+int type_object_base::instance_mapping_ass_subscript(PyObject*, PyObject*, PyObject*) const
 {
     return unimplemented("instance_mapping_ass_subscript");
 }
 
-int TypeObjectBase::instance_sequence_ass_item(PyObject*, int, PyObject*) const
+int type_object_base::instance_sequence_ass_item(PyObject*, int, PyObject*) const
 {
     return unimplemented("instance_sequence_ass_item");
 }
 
-PyObject* TypeObjectBase::instance_sequence_concat(PyObject*, PyObject*) const
+PyObject* type_object_base::instance_sequence_concat(PyObject*, PyObject*) const
 {
     return unimplemented("instance_sequence_concat");
 }
 
-PyObject* TypeObjectBase::instance_sequence_repeat(PyObject*, int) const
+PyObject* type_object_base::instance_sequence_repeat(PyObject*, int) const
 {
     return unimplemented("instance_sequence_repeat");
 }
 
-PyObject* TypeObjectBase::instance_sequence_slice(PyObject*, int, int) const
+PyObject* type_object_base::instance_sequence_slice(PyObject*, int, int) const
 {
     return unimplemented("instance_sequence_slice");
 }
 
-int TypeObjectBase::instance_sequence_ass_slice(PyObject*, int, int, PyObject*) const
+int type_object_base::instance_sequence_ass_slice(PyObject*, int, int, PyObject*) const
 {
     return unimplemented("instance_sequence_ass_slice");
 }
 
-PyObject* TypeObjectBase::instance_number_add(PyObject*, PyObject*) const
+PyObject* type_object_base::instance_number_add(PyObject*, PyObject*) const
 {
     return unimplemented("instance_number_add");
 }
 
-PyObject* TypeObjectBase::instance_number_subtract(PyObject*, PyObject*) const
+PyObject* type_object_base::instance_number_subtract(PyObject*, PyObject*) const
 {
     return unimplemented("instance_number_subtract");
 }
 
-PyObject* TypeObjectBase::instance_number_multiply(PyObject*, PyObject*) const
+PyObject* type_object_base::instance_number_multiply(PyObject*, PyObject*) const
 {
     return unimplemented("instance_number_multiply");
 }
 
-PyObject* TypeObjectBase::instance_number_divide(PyObject*, PyObject*) const
+PyObject* type_object_base::instance_number_divide(PyObject*, PyObject*) const
 {
     return unimplemented("instance_number_divide");
 }
 
-PyObject* TypeObjectBase::instance_number_remainder(PyObject*, PyObject*) const
+PyObject* type_object_base::instance_number_remainder(PyObject*, PyObject*) const
 {
     return unimplemented("instance_number_remainder");
 }
 
-PyObject* TypeObjectBase::instance_number_divmod(PyObject*, PyObject*) const
+PyObject* type_object_base::instance_number_divmod(PyObject*, PyObject*) const
 {
     return unimplemented("instance_number_divmod");
 }
 
-PyObject* TypeObjectBase::instance_number_power(PyObject*, PyObject*, PyObject*) const
+PyObject* type_object_base::instance_number_power(PyObject*, PyObject*, PyObject*) const
 {
     return unimplemented("instance_number_divmod");
 }
 
-PyObject* TypeObjectBase::instance_number_negative(PyObject*) const
+PyObject* type_object_base::instance_number_negative(PyObject*) const
 {
     return unimplemented("instance_number_negative");
 }
 
-PyObject* TypeObjectBase::instance_number_positive(PyObject*) const
+PyObject* type_object_base::instance_number_positive(PyObject*) const
 {
     return unimplemented("instance_number_positive");
 }
 
-PyObject* TypeObjectBase::instance_number_absolute(PyObject*) const
+PyObject* type_object_base::instance_number_absolute(PyObject*) const
 {
     return unimplemented("instance_number_absolute");
 }
 
-int TypeObjectBase::instance_number_nonzero(PyObject*) const
+int type_object_base::instance_number_nonzero(PyObject*) const
 {
     return unimplemented("instance_number_nonzero");
 }
 
-PyObject* TypeObjectBase::instance_number_invert(PyObject*) const
+PyObject* type_object_base::instance_number_invert(PyObject*) const
 {
     return unimplemented("instance_number_invert");
 }
 
-PyObject* TypeObjectBase::instance_number_lshift(PyObject*, PyObject*) const
+PyObject* type_object_base::instance_number_lshift(PyObject*, PyObject*) const
 {
     return unimplemented("instance_number_lshift");
 }
 
-PyObject* TypeObjectBase::instance_number_rshift(PyObject*, PyObject*) const
+PyObject* type_object_base::instance_number_rshift(PyObject*, PyObject*) const
 {
     return unimplemented("instance_number_rshift");
 }
 
-PyObject* TypeObjectBase::instance_number_and(PyObject*, PyObject*) const
+PyObject* type_object_base::instance_number_and(PyObject*, PyObject*) const
 {
     return unimplemented("instance_number_and");
 }
 
-PyObject* TypeObjectBase::instance_number_xor(PyObject*, PyObject*) const
+PyObject* type_object_base::instance_number_xor(PyObject*, PyObject*) const
 {
     return unimplemented("instance_number_xor");
 }
 
-PyObject* TypeObjectBase::instance_number_or(PyObject*, PyObject*) const
+PyObject* type_object_base::instance_number_or(PyObject*, PyObject*) const
 {
     return unimplemented("instance_number_or");
 }
 
-int TypeObjectBase::instance_number_coerce(PyObject*, PyObject**, PyObject**) const
+int type_object_base::instance_number_coerce(PyObject*, PyObject**, PyObject**) const
 {
     return unimplemented("instance_number_coerce");
 }
 
-PyObject* TypeObjectBase::instance_number_int(PyObject*) const
+PyObject* type_object_base::instance_number_int(PyObject*) const
 {
     return unimplemented("instance_number_int");
 }
 
-PyObject* TypeObjectBase::instance_number_long(PyObject*) const
+PyObject* type_object_base::instance_number_long(PyObject*) const
 {
     return unimplemented("instance_number_long");
 }
 
-PyObject* TypeObjectBase::instance_number_float(PyObject*) const
+PyObject* type_object_base::instance_number_float(PyObject*) const
 {
     return unimplemented("instance_number_float");
 }
 
-PyObject* TypeObjectBase::instance_number_oct(PyObject*) const
+PyObject* type_object_base::instance_number_oct(PyObject*) const
 {
     return unimplemented("instance_number_oct");
 }
 
-PyObject* TypeObjectBase::instance_number_hex(PyObject*) const
+PyObject* type_object_base::instance_number_hex(PyObject*) const
 {
     return unimplemented("instance_number_hex");
 }
@@ -980,10 +980,10 @@ PyObject* TypeObjectBase::instance_number_hex(PyObject*) const
 
 #ifdef TYPE_OBJECT_BASE_STANDALONE_TEST
 
-struct TestTypeObject : py::TypeObjectBase
+struct TestTypeObject : python::type_object_base
 {
     TestTypeObject()
-    : py::TypeObjectBase(Py_None->ob_type->ob_type)
+    : python::type_object_base(Py_None->ob_type->ob_type)
     {}
     
     void instance_dealloc(PyObject*) const {}
@@ -996,27 +996,27 @@ struct POD1
 
 int main()
 {
-    py::TypeObjectBase *o1, *o2, *o3;
+    python::type_object_base *o1, *o2, *o3;
     
 //    POD1 * pod1;
-//    py::detail::shared_pod_manager::create(pod1);
+//    python::detail::shared_pod_manager::create(pod1);
     
     o1 = new TestTypeObject;
     o2 = new TestTypeObject;
     o3 = new TestTypeObject;
     
-    assert(py::pod_instance_counter == 0);
+    assert(python::pod_instance_counter == 0);
     
-    o1->enable(py::TypeObjectBase::number_add);
-    o1->enable(py::TypeObjectBase::compare);
+    o1->enable(python::type_object_base::number_add);
+    o1->enable(python::type_object_base::compare);
 
-    o2->enable(py::TypeObjectBase::number_add);
-    o2->enable(py::TypeObjectBase::mapping_length);
+    o2->enable(python::type_object_base::number_add);
+    o2->enable(python::type_object_base::mapping_length);
     
-    o3->enable(py::TypeObjectBase::number_add);
-    o3->enable(py::TypeObjectBase::sequence_length);
+    o3->enable(python::type_object_base::number_add);
+    o3->enable(python::type_object_base::sequence_length);
 
-    assert(py::pod_instance_counter == 3);
+    assert(python::pod_instance_counter == 3);
     assert(o1->tp_as_number && !o1->tp_as_mapping && !o1->tp_as_sequence);
     assert(o2->tp_as_number && o2->tp_as_mapping && !o2->tp_as_sequence);
     assert(o3->tp_as_number && !o3->tp_as_mapping && o3->tp_as_sequence);
@@ -1025,39 +1025,39 @@ int main()
     assert((void*)o2->tp_as_number != o2->tp_as_mapping);
     assert((void*)o2->tp_as_mapping != o3->tp_as_sequence);
     
-    o1->enable(py::TypeObjectBase::number_subtract);
+    o1->enable(python::type_object_base::number_subtract);
     
-    assert(py::pod_instance_counter == 4);
+    assert(python::pod_instance_counter == 4);
     assert(o1->tp_as_number != o2->tp_as_number);
     assert(o2->tp_as_number == o3->tp_as_number);
     
-    o3->enable(py::TypeObjectBase::mapping_subscript);
+    o3->enable(python::type_object_base::mapping_subscript);
 
-    assert(py::pod_instance_counter == 5);
+    assert(python::pod_instance_counter == 5);
     assert(o3->tp_as_number && o3->tp_as_mapping && o3->tp_as_sequence);
     assert(o2->tp_as_mapping != o3->tp_as_mapping);
     
-    o2->enable(py::TypeObjectBase::mapping_subscript);
-    o3->enable(py::TypeObjectBase::mapping_length);
+    o2->enable(python::type_object_base::mapping_subscript);
+    o3->enable(python::type_object_base::mapping_length);
 
-    assert(py::pod_instance_counter == 4);
+    assert(python::pod_instance_counter == 4);
     assert(o2->tp_as_number && o2->tp_as_mapping && !o2->tp_as_sequence);
     assert(o3->tp_as_number && o3->tp_as_mapping && o3->tp_as_sequence);
     assert(o2->tp_as_mapping == o3->tp_as_mapping);
     
-    py::TypeObjectBase *o4 = new TestTypeObject;
+    python::type_object_base *o4 = new TestTypeObject;
 
-    assert(py::pod_instance_counter == 4);
+    assert(python::pod_instance_counter == 4);
 
-    o4->enable(py::TypeObjectBase::number_add);
+    o4->enable(python::type_object_base::number_add);
 
-    assert(py::pod_instance_counter == 4);
+    assert(python::pod_instance_counter == 4);
     assert(o4->tp_as_number && !o4->tp_as_mapping && !o4->tp_as_sequence);
     assert(o4->tp_as_number == o3->tp_as_number);
     
     delete o3;
 
-    assert(py::pod_instance_counter == 3);
+    assert(python::pod_instance_counter == 3);
     assert(o1->tp_as_number && !o1->tp_as_mapping && !o1->tp_as_sequence);
     assert(o2->tp_as_number && o2->tp_as_mapping && !o2->tp_as_sequence);
     assert(o4->tp_as_number && !o4->tp_as_mapping && !o4->tp_as_sequence);
@@ -1065,33 +1065,33 @@ int main()
     
     o3 =  new TestTypeObject;
     
-    assert(py::pod_instance_counter == 3);
+    assert(python::pod_instance_counter == 3);
 
-    o3->enable(py::TypeObjectBase::number_add);
-    o3->enable(py::TypeObjectBase::sequence_length);
+    o3->enable(python::type_object_base::number_add);
+    o3->enable(python::type_object_base::sequence_length);
 
-    assert(py::pod_instance_counter == 4);
+    assert(python::pod_instance_counter == 4);
     assert(o3->tp_as_number && !o3->tp_as_mapping && o3->tp_as_sequence);
     assert(o1->tp_as_number != o3->tp_as_number);
     assert(o2->tp_as_number == o3->tp_as_number);
     
     delete o1;
     
-    assert(py::pod_instance_counter == 3);
+    assert(python::pod_instance_counter == 3);
     
     delete o4;
     
-    assert(py::pod_instance_counter == 3);
+    assert(python::pod_instance_counter == 3);
     
     delete o3;
     
-    assert(py::pod_instance_counter == 2);
+    assert(python::pod_instance_counter == 2);
     
     delete o2;
     
-    assert(py::pod_instance_counter == 0);
+    assert(python::pod_instance_counter == 0);
     
-    assert(py::detail::shared_pod_manager::instance().m_storage.size() == 0);
+    assert(python::detail::shared_pod_manager::obj().m_storage.size() == 0);
 }
 
 #endif
diff --git a/newtypes.h b/newtypes.h
index cf24d7d7..b4df4176 100644
--- a/newtypes.h
+++ b/newtypes.h
@@ -11,40 +11,40 @@
 
 //  Usage:
 //  class X : public
-//          py::Callable<
-//          py::Getattrable <
-//          py::Setattrable<PythonObject, X> > >
+//          python::callable<
+//          python::getattrable <
+//          python::setattrable<python_object, X> > >
 //  {
 //  public:
-//      Ptr call(args, kw);
-//      Ptr getattr(args, kw);
-//      Ptr setattr(args, kw);
+//      ref call(args, kw);
+//      ref getattr(args, kw);
+//      ref setattr(args, kw);
 //  };
 
 # include "pyconfig.h"
-# include "signatures.h" // really just for Type<>
+# include "signatures.h" // really just for type<>
 # include "cast.h"
 # include "base_object.h"
 # include <typeinfo>
 # include <vector>
 # include <cassert>
 
-namespace py {
+namespace python {
 
-class String;
+class string;
 
 namespace detail {
 
-class InstanceHolderBase;
+class instance_holder_base;
 
-class TypeObjectBase : public PythonType
+class type_object_base : public python_type
 {
  public:
-    explicit TypeObjectBase(PyTypeObject* type_type);
-    virtual ~TypeObjectBase();
+    explicit type_object_base(PyTypeObject* type_type);
+    virtual ~type_object_base();
 
  public:
-    enum Capability {
+    enum capability {
         hash, call, str, getattr, setattr, compare, repr,
 
         mapping_length, mapping_subscript, mapping_ass_subscript,
@@ -60,19 +60,19 @@ class TypeObjectBase : public PythonType
         number_hex
     };
     
-    void enable(Capability);
+    void enable(capability);
     
     //
-    // Type behaviors
+    // type behaviors
     //
  public: // Callbacks for basic type functionality.
     virtual PyObject* instance_repr(PyObject*) const;
     virtual int instance_compare(PyObject*, PyObject* other) const;
     virtual PyObject* instance_str(PyObject*) const;
     virtual long instance_hash(PyObject*) const;
-    virtual PyObject* instance_call(PyObject* instance, PyObject* args, PyObject* kw) const;
-    virtual PyObject* instance_getattr(PyObject* instance, const char* name) const;
-    virtual int instance_setattr(PyObject* instance, const char* name, PyObject* value) const;
+    virtual PyObject* instance_call(PyObject* obj, PyObject* args, PyObject* kw) const;
+    virtual PyObject* instance_getattr(PyObject* obj, const char* name) const;
+    virtual int instance_setattr(PyObject* obj, const char* name, PyObject* value) const;
 
     // Dealloc is a special case, since every type needs a nonzero tp_dealloc slot.
     virtual void instance_dealloc(PyObject*) const = 0;
@@ -83,13 +83,13 @@ class TypeObjectBase : public PythonType
     virtual int instance_mapping_ass_subscript(PyObject*, PyObject*, PyObject*) const;
 
  public: // Callbacks for sequence methods
-    virtual int instance_sequence_length(PyObject* instance) const;
-    virtual PyObject* instance_sequence_concat(PyObject* instance, PyObject* other) const;
-    virtual PyObject* instance_sequence_repeat(PyObject* instance, int n) const;
-    virtual PyObject* instance_sequence_item(PyObject* instance, int n) const;
-    virtual PyObject* instance_sequence_slice(PyObject* instance, int start, int finish) const;
-    virtual int instance_sequence_ass_item(PyObject* instance, int n, PyObject* value) const;
-    virtual int instance_sequence_ass_slice(PyObject* instance, int start, int finish, PyObject* value) const;
+    virtual int instance_sequence_length(PyObject* obj) const;
+    virtual PyObject* instance_sequence_concat(PyObject* obj, PyObject* other) const;
+    virtual PyObject* instance_sequence_repeat(PyObject* obj, int n) const;
+    virtual PyObject* instance_sequence_item(PyObject* obj, int n) const;
+    virtual PyObject* instance_sequence_slice(PyObject* obj, int start, int finish) const;
+    virtual int instance_sequence_ass_item(PyObject* obj, int n, PyObject* value) const;
+    virtual int instance_sequence_ass_slice(PyObject* obj, int start, int finish, PyObject* value) const;
     
  public: // Callbacks for number methods
     virtual PyObject* instance_number_add(PyObject*, PyObject*) const;
@@ -118,22 +118,22 @@ class TypeObjectBase : public PythonType
 };
 
 template <class T>
-class TypeObject : public TypeObjectBase
+class type_object : public type_object_base
 {
  public:
-    typedef T Instance;
+    typedef T instance;
 
-    TypeObject(PyTypeObject* type_type, const char* name)
-        : TypeObjectBase(type_type)
+    type_object(PyTypeObject* type_type, const char* name)
+        : type_object_base(type_type)
     {
         assert(name != 0);
         this->tp_name = const_cast<char*>(name);
     }
 
-    TypeObject(PyTypeObject* type_type)
-        : TypeObjectBase(type_type)
+    type_object(PyTypeObject* type_type)
+        : type_object_base(type_type)
     {
-        this->tp_name = const_cast<char*>(typeid(Instance).name());
+        this->tp_name = const_cast<char*>(typeid(instance).name());
     }
 
  private: // Overridable behaviors.
@@ -142,193 +142,193 @@ class TypeObject : public TypeObjectBase
     // you have other constraints, you'll need to override this
     virtual void dealloc(T* p) const;
     
- private: // Implementation of TypeObjectBase hooks. Do not reimplement in derived classes.
+ private: // Implementation of type_object_base hooks. Do not reimplement in derived classes.
     void instance_dealloc(PyObject*) const;
 };
 
 //
-// Type objects
+// type objects
 //
 template <class Base>
-class Callable : public Base
+class callable : public Base
 {
  public:
-    typedef Callable Properties; // Convenience for derived class construction
-    typedef typename Base::Instance Instance;
-    Callable(PyTypeObject* type_type, const char* name);
-    Callable(PyTypeObject* type_type);
+    typedef callable properties; // Convenience for derived class construction
+    typedef typename Base::instance instance;
+    callable(PyTypeObject* type_type, const char* name);
+    callable(PyTypeObject* type_type);
  private:
-    PyObject* instance_call(PyObject* instance, PyObject* args, PyObject* kw) const;
+    PyObject* instance_call(PyObject* obj, PyObject* args, PyObject* kw) const;
 };
 
 template <class Base>
-class Getattrable : public Base
+class getattrable : public Base
 {
  public:
-    typedef Getattrable Properties; // Convenience for derived class construction
-    typedef typename Base::Instance Instance;
-    Getattrable(PyTypeObject* type_type, const char* name);
-    Getattrable(PyTypeObject* type_type);
+    typedef getattrable properties; // Convenience for derived class construction
+    typedef typename Base::instance instance;
+    getattrable(PyTypeObject* type_type, const char* name);
+    getattrable(PyTypeObject* type_type);
  private:
-    PyObject* instance_getattr(PyObject* instance, const char* name) const;
+    PyObject* instance_getattr(PyObject* obj, const char* name) const;
 };
 
 template <class Base>
-class Setattrable : public Base
+class setattrable : public Base
 {
  public:
-    typedef Setattrable Properties; // Convenience for derived class construction
-    typedef typename Base::Instance Instance;
-    Setattrable(PyTypeObject* type_type, const char* name);
-    Setattrable(PyTypeObject* type_type);
+    typedef setattrable properties; // Convenience for derived class construction
+    typedef typename Base::instance instance;
+    setattrable(PyTypeObject* type_type, const char* name);
+    setattrable(PyTypeObject* type_type);
  private:
-    int instance_setattr(PyObject* instance, const char* name, PyObject* value) const;
+    int instance_setattr(PyObject* obj, const char* name, PyObject* value) const;
 };
 
 template <class Base>
-class Reprable : public Base
+class reprable : public Base
 {
  public:
-    typedef Reprable Properties; // Convenience for derived class construction
-    typedef typename Base::Instance Instance;
-    Reprable(PyTypeObject* type_type, const char* name);
-    Reprable(PyTypeObject* type_type);
+    typedef reprable properties; // Convenience for derived class construction
+    typedef typename Base::instance instance;
+    reprable(PyTypeObject* type_type, const char* name);
+    reprable(PyTypeObject* type_type);
  private:
-    PyObject* instance_repr(PyObject* instance) const;
+    PyObject* instance_repr(PyObject* obj) const;
 };
 
 //
 // Member function definitions
 //
 
-// TypeObject<>
+// type_object<>
 template <class T>
-void TypeObject<T>::instance_dealloc(PyObject* instance) const
+void type_object<T>::instance_dealloc(PyObject* obj) const
 {
-    this->dealloc(Downcast<Instance>(instance).get());
+    this->dealloc(downcast<instance>(obj).get());
 }
 
 template <class T>
-void TypeObject<T>::dealloc(T* instance) const
+void type_object<T>::dealloc(T* obj) const
 {
-    delete instance;
+    delete obj;
 }
 
-// Callable
+// callable
 template <class Base>
-Callable<Base>::Callable(PyTypeObject* type_type, const char* name)
+callable<Base>::callable(PyTypeObject* type_type, const char* name)
     : Base(type_type, name)
 {
     this->enable(call);
 }
         
 template <class Base>
-Callable<Base>::Callable(PyTypeObject* type_type)
+callable<Base>::callable(PyTypeObject* type_type)
     : Base(type_type)
 {
     this->enable(call);
 }
         
 template <class Base>
-PyObject* Callable<Base>::instance_call(PyObject* instance, PyObject* args, PyObject* kw) const
+PyObject* callable<Base>::instance_call(PyObject* obj, PyObject* args, PyObject* kw) const
 {
-    return Downcast<Instance>(instance)->call(args, kw);
+    return downcast<instance>(obj)->call(args, kw);
 }
 
-// Getattrable
+// getattrable
 template <class Base>
-Getattrable<Base>::Getattrable(PyTypeObject* type_type, const char* name)
+getattrable<Base>::getattrable(PyTypeObject* type_type, const char* name)
     : Base(type_type, name)
 {
     this->enable(getattr);
 }
         
 template <class Base>
-Getattrable<Base>::Getattrable(PyTypeObject* type_type)
+getattrable<Base>::getattrable(PyTypeObject* type_type)
     : Base(type_type)
 {
     this->enable(getattr);
 }
         
 template <class Base>
-PyObject* Getattrable<Base>::instance_getattr(PyObject* instance, const char* name) const
+PyObject* getattrable<Base>::instance_getattr(PyObject* obj, const char* name) const
 {
-    return Downcast<Instance>(instance)->getattr(name);
+    return downcast<instance>(obj)->getattr(name);
 }
 
-// Setattrable
+// setattrable
 template <class Base>
-Setattrable<Base>::Setattrable(PyTypeObject* type_type, const char* name)
+setattrable<Base>::setattrable(PyTypeObject* type_type, const char* name)
     : Base(type_type, name)
 {
     this->enable(setattr);
 }
         
 template <class Base>
-Setattrable<Base>::Setattrable(PyTypeObject* type_type)
+setattrable<Base>::setattrable(PyTypeObject* type_type)
     : Base(type_type)
 {
     this->enable(setattr);
 }
         
 template <class Base>
-int Setattrable<Base>::instance_setattr(PyObject* instance, const char* name, PyObject* value) const
+int setattrable<Base>::instance_setattr(PyObject* obj, const char* name, PyObject* value) const
 {
-    return Downcast<Instance>(instance)->setattr(name, value);
+    return downcast<instance>(obj)->setattr(name, value);
 }
 
-// Reprable
+// reprable
 template <class Base>
-Reprable<Base>::Reprable(PyTypeObject* type_type, const char* name)
+reprable<Base>::reprable(PyTypeObject* type_type, const char* name)
     : Base(type_type, name)
 {
     this->enable(repr);
 }
         
 template <class Base>
-Reprable<Base>::Reprable(PyTypeObject* type_type)
+reprable<Base>::reprable(PyTypeObject* type_type)
     : Base(type_type)
 {
     this->enable(repr);
 }
         
 template <class Base>
-PyObject* Reprable<Base>::instance_repr(PyObject* instance) const
+PyObject* reprable<Base>::instance_repr(PyObject* obj) const
 {
-    return Downcast<Instance>(instance)->repr();
+    return downcast<instance>(obj)->repr();
 }
 
   class shared_pod_manager
   {
-      typedef std::pair<char*, std::size_t> Holder;
-      typedef std::vector<Holder> Storage;
+      typedef std::pair<char*, std::size_t> holder;
+      typedef std::vector<holder> storage;
         
    public:
-      static shared_pod_manager& instance();
+      static shared_pod_manager& obj();
       ~shared_pod_manager();
 
       template <class T>
       static void replace_if_equal(T*& t)
       {
-          t = reinterpret_cast<T*>(instance().replace_if_equal(t, sizeof(T)));
+          t = reinterpret_cast<T*>(obj().replace_if_equal(t, sizeof(T)));
       }
 
       template <class T>
       static void make_unique_copy(T*& t)
       {
-          t = reinterpret_cast<T*>(instance().make_unique_copy(t, sizeof(T)));
+          t = reinterpret_cast<T*>(obj().make_unique_copy(t, sizeof(T)));
       }
 
       template <class T>
       static void create(T*& t)
       {
-          t = reinterpret_cast<T*>(instance().create(sizeof(T)));
+          t = reinterpret_cast<T*>(obj().create(sizeof(T)));
       }
 
       template <class T>
       static void dispose(T* t)
       {
-          instance().dec_ref(t, sizeof(T));
+          obj().dec_ref(t, sizeof(T));
       }
 
    private:
@@ -338,26 +338,26 @@ PyObject* Reprable<Base>::instance_repr(PyObject* instance) const
       void dec_ref(void* pod, std::size_t size);
       void erase_from_list(void* pod);
         
-      struct Compare;
+      struct compare;
       struct identical;
 
    private:
-      shared_pod_manager() {} // singleton
+      shared_pod_manager() {} // instance
 
 #ifdef TYPE_OBJECT_BASE_STANDALONE_TEST
    public:
 #endif
-      Storage m_storage;
+      storage m_storage;
   };
 
 
-  void add_capability(TypeObjectBase::Capability capability, 
+  void add_capability(type_object_base::capability capability, 
                       PyTypeObject* dest);
 
 // This macro gets the length of an array as a compile-time constant, and will
 // fail to compile if the parameter is a pointer.
 # define PY_ARRAY_LENGTH(a) \
-        (sizeof(::py::detail::countof_validate(a, &(a))) ? sizeof(a) / sizeof((a)[0]) : 0)
+        (sizeof(::python::detail::countof_validate(a, &(a))) ? sizeof(a) / sizeof((a)[0]) : 0)
 
   template<typename T>
   inline void countof_validate(T* const, T* const*);
@@ -365,6 +365,6 @@ PyObject* Reprable<Base>::instance_repr(PyObject* instance) const
   template<typename T>
   inline int countof_validate(const void*, T);
 
-}} // namespace py::detail
+}} // namespace python::detail
 
 #endif // TYPES_DWA051800_H_
diff --git a/none.h b/none.h
index 37b4851c..d13877f5 100644
--- a/none.h
+++ b/none.h
@@ -12,10 +12,10 @@
 # include "pyconfig.h"
 # include "wrap_python.h"
 
-namespace py { namespace detail {
+namespace python { namespace detail {
 
 inline PyObject* none() { Py_INCREF(Py_None); return Py_None; }
     
-}} // namespace py::detail
+}} // namespace python::detail
 
 #endif // NONE_DWA_052000_H_
diff --git a/objects.cpp b/objects.cpp
index 141e9ed1..bf4dc46e 100644
--- a/objects.cpp
+++ b/objects.cpp
@@ -11,141 +11,141 @@
 #include "objects.h"
 #include "none.h"
 
-namespace py {
+namespace python {
 
 template <class T>
-T object_from_python(PyObject* p, Type<T>)
+T object_from_python(PyObject* p, type<T>)
 {
-    Ptr x(p, Ptr::new_ref);
+    ref x(p, ref::increment_count);
     if (!T::accepts(x))
     {
         PyErr_SetString(PyExc_TypeError, p->ob_type->tp_name);
-        throw ErrorAlreadySet();
+        throw error_already_set();
     }
     return T(x);
 }
 
-inline PyObject* object_to_python(const Object& x)
+inline PyObject* object_to_python(const object& x)
 {
     return x.reference().release();
 }
 
-Object::Object(Ptr p)
+object::object(ref p)
     : m_p(p) {}
     
 // Return a reference to the held object
-Ptr Object::reference() const
+ref object::reference() const
 {
     return m_p;
 }
 
 // Return a raw pointer to the held object
-PyObject* Object::get() const
+PyObject* object::get() const
 {
     return m_p.get();
 }
 
-} // namespace py
+} // namespace python
 
-PY_BEGIN_CONVERSION_NAMESPACE
+BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
 
-PyObject* to_python(const py::Tuple& x)
+PyObject* to_python(const python::tuple& x)
 {
     return object_to_python(x);
 }
 
-py::Tuple from_python(PyObject* p, py::Type<py::Tuple> type)
+python::tuple from_python(PyObject* p, python::type<python::tuple> type)
 {
-    return py::object_from_python(p, type);
+    return python::object_from_python(p, type);
 }
 
-PyObject* to_python(const py::List& x)
+PyObject* to_python(const python::list& x)
 {
     return object_to_python(x);
 }
 
-py::List from_python(PyObject* p, py::Type<py::List> type)
+python::list from_python(PyObject* p, python::type<python::list> type)
 {
-    return py::object_from_python(p, type);
+    return python::object_from_python(p, type);
 }
 
-PyObject* to_python(const py::Dict& x)
+PyObject* to_python(const python::dictionary& x)
 {
     return object_to_python(x);
 }
 
-py::Dict from_python(PyObject* p, py::Type<py::Dict> type)
+python::dictionary from_python(PyObject* p, python::type<python::dictionary> type)
 {
-    return py::object_from_python(p, type);
+    return python::object_from_python(p, type);
 }
 
-PyObject* to_python(const py::String& x)
+PyObject* to_python(const python::string& x)
 {
     return object_to_python(x);
 }
 
-py::String from_python(PyObject* p, py::Type<py::String> type)
+python::string from_python(PyObject* p, python::type<python::string> type)
 {
-    return py::object_from_python(p, type);
+    return python::object_from_python(p, type);
 }
 
-PY_END_CONVERSION_NAMESPACE
+BOOST_PYTHON_END_CONVERSION_NAMESPACE
 
-namespace py {
+namespace python {
 
-Tuple::Tuple(std::size_t n)
-    : Object(Ptr(PyTuple_New(n)))
+tuple::tuple(std::size_t n)
+    : object(ref(PyTuple_New(n)))
 {
     for (std::size_t i = 0; i < n; ++i)
         PyTuple_SET_ITEM(get(), i, detail::none());
 }
     
-Tuple::Tuple(Ptr p)
-    : Object(p)
+tuple::tuple(ref p)
+    : object(p)
 {
     assert(accepts(p));
     if (!accepts(p))
     {
         PyErr_SetString(PyExc_TypeError, p->ob_type->tp_name);
-        throw ErrorAlreadySet();
+        throw error_already_set();
     }
 }
 
-PyTypeObject* Tuple::type_object()
+PyTypeObject* tuple::type_obj()
 {
     return &PyTuple_Type;
 }
 
-bool Tuple::accepts(Ptr p)
+bool tuple::accepts(ref p)
 {
     return PyTuple_Check(p.get());
 }
 
-std::size_t Tuple::size() const
+std::size_t tuple::size() const
 {
     return PyTuple_Size(get());
 }
 
-Ptr Tuple::operator[](std::size_t pos) const
+ref tuple::operator[](std::size_t pos) const
 {
-    return Ptr(PyTuple_GetItem(get(), static_cast<int>(pos)),
-               Ptr::new_ref);
+    return ref(PyTuple_GetItem(get(), static_cast<int>(pos)),
+               ref::increment_count);
 }
 
-void Tuple::set_item(std::size_t pos, const Ptr& rhs)
+void tuple::set_item(std::size_t pos, const ref& rhs)
 {
     int failed = PyTuple_SetItem(
-        get(), static_cast<int>(pos), Ptr(rhs).release()); // A reference is stolen here.
+        get(), static_cast<int>(pos), ref(rhs).release()); // A reference is stolen here.
     (void)failed;
     assert(failed == 0);
 }
 
-Tuple Tuple::slice(int low, int high) const
+tuple tuple::slice(int low, int high) const
 {
-    return Tuple(Ptr(PyTuple_GetSlice(get(), low, high)));
+    return tuple(ref(PyTuple_GetSlice(get(), low, high)));
 }
 
-Tuple& Tuple::operator+=(const Tuple& rhs)
+tuple& tuple::operator+=(const tuple& rhs)
 {
     return *this = *this + rhs;
 }
@@ -153,44 +153,44 @@ Tuple& Tuple::operator+=(const Tuple& rhs)
 
 // Construct from an owned PyObject*.
 // Precondition: p must point to a python string.
-String::String(Ptr p)
-    : Object(p)
+string::string(ref p)
+    : object(p)
 {
     assert(accepts(p));
     if (!accepts(p))
     {
         PyErr_SetString(PyExc_TypeError, p->ob_type->tp_name);
-        throw ErrorAlreadySet();
+        throw error_already_set();
     }
 }
     
-String::String(const char* s)
-    : Object(Ptr(PyString_FromString(s))) {}
+string::string(const char* s)
+    : object(ref(PyString_FromString(s))) {}
 
-String::String(const char* s, std::size_t length)
-    : Object(Ptr(PyString_FromStringAndSize(s, length))) {}
+string::string(const char* s, std::size_t length)
+    : object(ref(PyString_FromStringAndSize(s, length))) {}
 
-String::String(const char* s, Interned)
-    : Object(Ptr(PyString_InternFromString(s))) {}
+string::string(const char* s, interned_t)
+    : object(ref(PyString_InternFromString(s))) {}
 
 #if 0
-String::String(const char* s, std::size_t length, Interned)
-    : Object(Ptr(PyString_InternFromStringAndSize(s, length))) {}
+string::string(const char* s, std::size_t length, interned_t)
+    : object(ref(PyString_InternFromStringAndSize(s, length))) {}
 #endif
 
-String::String(const String& rhs)
-    : Object(rhs.reference()) {}
+string::string(const string& rhs)
+    : object(rhs.reference()) {}
 
 // Get the type object for Strings
-PyTypeObject* String::type_object()
+PyTypeObject* string::type_obj()
 { return &PyString_Type; }
 
-// Return true if the given object is a python String
-bool String::accepts(Ptr o)
+// Return true if the given object is a python string
+bool string::accepts(ref o)
 { return PyString_Check(o.get()); }
 
 // Return the length of the string.
-std::size_t String::size() const
+std::size_t string::size() const
 {
     int size = PyString_GET_SIZE(get());
     assert(size >= 0);
@@ -200,134 +200,134 @@ std::size_t String::size() const
 // Returns a null-terminated representation of the contents of string.
 // The pointer refers to the internal buffer of string, not a copy.
 // The data must not be modified in any way. It must not be de-allocated. 
-const char* String::c_str() const
+const char* string::c_str() const
 { return PyString_AS_STRING(get()); }
 
-void String::intern()
+void string::intern()
 { // UNTESTED!!
-    *this = String(Ptr(PyString_InternFromString(c_str()), Ptr::borrowed));
+    *this = string(ref(PyString_InternFromString(c_str()), ref::increment_count));
 }
 
-String& String::operator*=(unsigned int repeat_count)
+string& string::operator*=(unsigned int repeat_count)
 {
-    *this = String(Ptr(PySequence_Repeat(get(), repeat_count)));
+    *this = string(ref(PySequence_Repeat(get(), repeat_count)));
     return *this;
 }
 
-Dict::Dict(Ptr p)
-    : Object(p)
+dictionary::dictionary(ref p)
+    : object(p)
 {
     assert(accepts(p));
     if (!accepts(p))
     {
         PyErr_SetString(PyExc_TypeError, p->ob_type->tp_name);
-        throw ErrorAlreadySet();
+        throw error_already_set();
     }
 }
 
-Dict::Dict()
-    : Object(Ptr(PyDict_New())) {}
+dictionary::dictionary()
+    : object(ref(PyDict_New())) {}
 
-PyTypeObject* Dict::type_object()
+PyTypeObject* dictionary::type_obj()
 { return &PyDict_Type; }
 
-bool Dict::accepts(Ptr p)
+bool dictionary::accepts(ref p)
 { return PyDict_Check(p.get()); }
 
-void Dict::clear()
+void dictionary::clear()
 { PyDict_Clear(get()); }
 
-const Ptr& Dict::Proxy::operator=(const Ptr& rhs)
+const ref& dictionary::proxy::operator=(const ref& rhs)
 {
     if (PyDict_SetItem(m_dict.get(), m_key.get(), rhs.get()) == -1)
-        throw ErrorAlreadySet();
+        throw error_already_set();
     return rhs;
 }
 
-Dict::Proxy::operator Ptr() const
+dictionary::proxy::operator ref() const
 {
-    return Ptr(m_dict->ob_type->tp_as_mapping->mp_subscript(m_dict.get(), m_key.get()),
-               Ptr::borrowed);
+    return ref(m_dict->ob_type->tp_as_mapping->mp_subscript(m_dict.get(), m_key.get()),
+               ref::increment_count);
 }
 
-Dict::Proxy::Proxy(const Ptr& dict, const Ptr& key)
+dictionary::proxy::proxy(const ref& dict, const ref& key)
     : m_dict(dict), m_key(key) {}
 
-Dict::Proxy Dict::operator[](Ptr key)
-{ return Proxy(reference(), key); }
+dictionary::proxy dictionary::operator[](ref key)
+{ return proxy(reference(), key); }
     
-Ptr Dict::operator[](Ptr key) const {
+ref dictionary::operator[](ref key) const {
     // An odd MSVC bug causes the ".operator Ptr()" to be needed
-    return Proxy(reference(), key).operator Ptr();
+    return proxy(reference(), key).operator ref();
 }
 
     
-Ptr Dict::get_item(const Ptr& key) const
+ref dictionary::get_item(const ref& key) const
 {
-    return get_item(key, Ptr());
+    return get_item(key, ref());
 }
 
-Ptr Dict::get_item(const Ptr& key, const Ptr& default_) const
+ref dictionary::get_item(const ref& key, const ref& default_) const
 {
     PyObject* value_or_null = PyDict_GetItem(get(), key.get());
     if (value_or_null == 0 && !PyErr_Occurred())
         return default_;
     else
-        return Ptr(value_or_null, Ptr::borrowed); // Will throw if there was another error
+        return ref(value_or_null, ref::increment_count); // Will throw if there was another error
 }
         
-void Dict::set_item(const Ptr& key, const Ptr& value)
+void dictionary::set_item(const ref& key, const ref& value)
 {
     if (PyDict_SetItem(get(), key.get(), value.get()) == -1)
-        throw ErrorAlreadySet();
+        throw error_already_set();
 }
 
-void Dict::erase(Ptr key) {
+void dictionary::erase(ref key) {
     if (PyDict_DelItem(get(), key.get()) == -1)
-        throw ErrorAlreadySet();
+        throw error_already_set();
 }
 
-List Dict::items() const { return List(Ptr(PyDict_Items(get()))); }
-List Dict::keys() const { return List(Ptr(PyDict_Keys(get()))); }
-List Dict::values() const { return List(Ptr(PyDict_Values(get()))); }
+list dictionary::items() const { return list(ref(PyDict_Items(get()))); }
+list dictionary::keys() const { return list(ref(PyDict_Keys(get()))); }
+list dictionary::values() const { return list(ref(PyDict_Values(get()))); }
 
-std::size_t Dict::size() const { return static_cast<std::size_t>(PyDict_Size(get())); }
+std::size_t dictionary::size() const { return static_cast<std::size_t>(PyDict_Size(get())); }
 
-String operator+(String x, String y)
+string operator+(string x, string y)
 {
     PyObject* io_string = x.reference().release();
     PyString_Concat(&io_string, y.get());
-    return String(Ptr(io_string));    
+    return string(ref(io_string));    
 }
 
-String& String::operator+=(const String& rhs)
+string& string::operator+=(const string& rhs)
 {
     return *this = *this + rhs;
 }
 
-String& String::operator+=(const char* y)
+string& string::operator+=(const char* y)
 {
-    return *this += String(y);
+    return *this += string(y);
 }
 
-String operator%(const String& format, const Tuple& args)
+string operator%(const string& format, const tuple& args)
 {
-    return String(Ptr(PyString_Format(format.get(), args.reference().get())));
+    return string(ref(PyString_Format(format.get(), args.reference().get())));
 }
 
-String operator+(String x, const char* y)
+string operator+(string x, const char* y)
 {
-    return x + String(y);
+    return x + string(y);
 }
 
-String operator+(const char* x, String y)
+string operator+(const char* x, string y)
 {
-    return String(x) + y;
+    return string(x) + y;
 }
 
-Tuple operator+(const Tuple& x, const Tuple& y)
+tuple operator+(const tuple& x, const tuple& y)
 {
-    Tuple result(x.size() + y.size());
+    tuple result(x.size() + y.size());
     for (std::size_t xi = 0; xi < x.size(); ++xi)
         result.set_item(xi, x[xi]);
     for (std::size_t yi = 0; yi < y.size(); ++yi)
@@ -336,148 +336,148 @@ Tuple operator+(const Tuple& x, const Tuple& y)
 }
 
 
-List::List(Ptr p)
-    : Object(p)
+list::list(ref p)
+    : object(p)
 {
     assert(accepts(p));
     if (!accepts(p))
     {
         PyErr_SetString(PyExc_TypeError, p->ob_type->tp_name);
-        throw ErrorAlreadySet();
+        throw error_already_set();
     }
 }
 
-List::List(std::size_t sz)
-    : Object(Ptr(PyList_New(sz)))
+list::list(std::size_t sz)
+    : object(ref(PyList_New(sz)))
 {
 }
 
-PyTypeObject* List::type_object()
+PyTypeObject* list::type_obj()
 {
     return &PyList_Type;
 }
 
-bool List::accepts(Ptr p)
+bool list::accepts(ref p)
 {
     return PyList_Check(p.get());
 }
 
-std::size_t List::size()
+std::size_t list::size()
 {
     return PyList_Size(get());
 }
 
-Ptr List::operator[](std::size_t pos) const
+ref list::operator[](std::size_t pos) const
 {
-    return Ptr(PyList_GetItem(get(), pos), Ptr::borrowed);
+    return ref(PyList_GetItem(get(), pos), ref::increment_count);
 }
 
-List::Proxy List::operator[](std::size_t pos)
+list::proxy list::operator[](std::size_t pos)
 {
-    return Proxy(reference(), pos);
+    return proxy(reference(), pos);
 }
 
-void List::insert(std::size_t index, const Ptr& item)
+void list::insert(std::size_t index, const ref& item)
 {
     if (PyList_Insert(get(), index, item.get()) == -1)
-        throw ErrorAlreadySet();
+        throw error_already_set();
 }
 
-void List::push_back(const Ptr& item)
+void list::push_back(const ref& item)
 {
     if (PyList_Append(get(), item.get()) == -1)
-        throw ErrorAlreadySet();
+        throw error_already_set();
 }
 
-void List::append(const Ptr& item)
+void list::append(const ref& item)
 {
     this->push_back(item);
 }
 
-List List::slice(int low, int high) const
+list list::slice(int low, int high) const
 {
-    return List(Ptr(PyList_GetSlice(get(), low, high)));
+    return list(ref(PyList_GetSlice(get(), low, high)));
 }
 
-List::SliceProxy List::slice(int low, int high)
+list::slice_proxy list::slice(int low, int high)
 {
-    return SliceProxy(reference(), low, high);
+    return slice_proxy(reference(), low, high);
 }
 
-void List::sort()
+void list::sort()
 {
     if (PyList_Sort(get()) == -1)
-        throw ErrorAlreadySet();
+        throw error_already_set();
 }
 
-void List::reverse()
+void list::reverse()
 {
     if (PyList_Reverse(get()) == -1)
-        throw ErrorAlreadySet();
+        throw error_already_set();
 }
 
-Tuple List::as_tuple() const
+tuple list::as_tuple() const
 {
-    return Tuple(Ptr(PyList_AsTuple(get())));
+    return tuple(ref(PyList_AsTuple(get())));
 }
 
-const Ptr& List::Proxy::operator=(const Ptr& rhs)
+const ref& list::proxy::operator=(const ref& rhs)
 {
     m_list.set_item(m_index, rhs);
     return rhs;
 }
 
-List::Proxy::operator Ptr() const
+list::proxy::operator ref() const
 {
-    return Ptr(PyList_GetItem(m_list.get(), m_index), Ptr::borrowed);
+    return ref(PyList_GetItem(m_list.get(), m_index), ref::increment_count);
 }
 
-Ptr List::get_item(std::size_t pos) const
+ref list::get_item(std::size_t pos) const
 {
-    return Ptr(PyList_GetItem(this->get(), pos), Ptr::borrowed);
+    return ref(PyList_GetItem(this->get(), pos), ref::increment_count);
 }
 
-void List::set_item(std::size_t pos, const Ptr& rhs)
+void list::set_item(std::size_t pos, const ref& rhs)
 {
     int result = PyList_SetItem(this->get(), pos, rhs.get());
     if (result == -1)
-        throw ErrorAlreadySet();
+        throw error_already_set();
     Py_INCREF(rhs.get());
 }
 
-List::Proxy::Proxy(const Ptr& list, std::size_t index)
+list::proxy::proxy(const ref& list, std::size_t index)
     : m_list(list), m_index(index)
 {
 }
 
-const List& List::SliceProxy::operator=(const List& rhs)
+const list& list::slice_proxy::operator=(const list& rhs)
 {
     if (PyList_SetSlice(m_list.get(), m_low, m_high, rhs.get()) == -1)
-        throw ErrorAlreadySet();
+        throw error_already_set();
     return rhs;
 }
 
-List::SliceProxy::operator Ptr() const
+list::slice_proxy::operator ref() const
 {
-    return Ptr(PyList_GetSlice(m_list.get(), m_low, m_high));
+    return ref(PyList_GetSlice(m_list.get(), m_low, m_high));
 }
 
-List::SliceProxy::operator List() const
+list::slice_proxy::operator list() const
 {
-    return List(this->operator Ptr());
+    return list(this->operator ref());
 }
 
-std::size_t List::SliceProxy::size()
+std::size_t list::slice_proxy::size()
 {
-    return this->operator List().size();
+    return this->operator list().size();
 }
 
-Ptr List::SliceProxy::operator[](std::size_t pos) const
+ref list::slice_proxy::operator[](std::size_t pos) const
 {
-    return this->operator List()[pos].operator Ptr();
+    return this->operator list()[pos].operator ref();
 }
 
-List::SliceProxy::SliceProxy(const Ptr& list, int low, int high)
+list::slice_proxy::slice_proxy(const ref& list, int low, int high)
     : m_list(list), m_low(low), m_high(high)
 {
 }
diff --git a/objects.h b/objects.h
index fd8716c9..0cc3214e 100644
--- a/objects.h
+++ b/objects.h
@@ -15,48 +15,48 @@
 # include "boost/operators.hpp"
 # include <utility>
 
-namespace py {
+namespace python {
 
-class Object
+class object
 {
  public:
-    explicit Object(Ptr p);
+    explicit object(ref p);
     
     // Return a reference to the held object
-    Ptr reference() const;
+    ref reference() const;
 
     // Return a raw pointer to the held object
     PyObject* get() const;
     
  private:
-    Ptr m_p;
+    ref m_p;
 };
 
-class Tuple : public Object
+class tuple : public object
 {
  public:
-    explicit Tuple(std::size_t n = 0);
-    explicit Tuple(Ptr p);
+    explicit tuple(std::size_t n = 0);
+    explicit tuple(ref p);
 
     template <class First, class Second>
-    Tuple(const std::pair<First,Second>& x)
-        : Object(Ptr(PyTuple_New(2)))
+    tuple(const std::pair<First,Second>& x)
+        : object(ref(PyTuple_New(2)))
     {
         set_item(0, x.first);
         set_item(1, x.second);
     }
     
     template <class First, class Second>
-    Tuple(const First& first, const Second& second)
-        : Object(Ptr(PyTuple_New(2)))
+    tuple(const First& first, const Second& second)
+        : object(ref(PyTuple_New(2)))
     {
         set_item(0, first);
         set_item(1, second);
     }
     
     template <class First, class Second, class Third>
-    Tuple(const First& first, const Second& second, const Third& third)
-        : Object(Ptr(PyTuple_New(3)))
+    tuple(const First& first, const Second& second, const Third& third)
+        : object(ref(PyTuple_New(3)))
     {
         set_item(0, first);
         set_item(1, second);
@@ -64,8 +64,8 @@ class Tuple : public Object
     }
     
     template <class First, class Second, class Third, class Fourth>
-    Tuple(const First& first, const Second& second, const Third& third, const Fourth& fourth)
-        : Object(Ptr(PyTuple_New(4)))
+    tuple(const First& first, const Second& second, const Third& third, const Fourth& fourth)
+        : object(ref(PyTuple_New(4)))
     {
         set_item(0, first);
         set_item(1, second);
@@ -73,10 +73,10 @@ class Tuple : public Object
         set_item(3, fourth);
     }
     
-    static PyTypeObject* type_object();
-    static bool accepts(Ptr p);
+    static PyTypeObject* type_obj();
+    static bool accepts(ref p);
     std::size_t size() const;
-    Ptr operator[](std::size_t pos) const;
+    ref operator[](std::size_t pos) const;
 
     template <class T>
     void set_item(std::size_t pos, const T& rhs)
@@ -84,76 +84,76 @@ class Tuple : public Object
         this->set_item(pos, make_ptr(rhs));
     }
     
-    void set_item(std::size_t pos, const Ptr& rhs);
+    void set_item(std::size_t pos, const ref& rhs);
     
-    Tuple slice(int low, int high) const;
+    tuple slice(int low, int high) const;
 
-    friend Tuple operator+(const Tuple&, const Tuple&);
-    Tuple& operator+=(const Tuple& rhs);
+    friend tuple operator+(const tuple&, const tuple&);
+    tuple& operator+=(const tuple& rhs);
 };
 
-class List : public Object
+class list : public object
 {
-    struct Proxy;
-    struct SliceProxy;
+    struct proxy;
+    struct slice_proxy;
  public:
-    explicit List(Ptr p);
-    explicit List(std::size_t sz = 0);
-    static PyTypeObject* type_object();
-    static bool accepts(Ptr p);
+    explicit list(ref p);
+    explicit list(std::size_t sz = 0);
+    static PyTypeObject* type_obj();
+    static bool accepts(ref p);
     std::size_t size();
-    Ptr operator[](std::size_t pos) const;
-    Proxy operator[](std::size_t pos);
-    Ptr get_item(std::size_t pos) const;
+    ref operator[](std::size_t pos) const;
+    proxy operator[](std::size_t pos);
+    ref get_item(std::size_t pos) const;
 
     template <class T>
     void set_item(std::size_t pos, const T& x)
         { this->set_item(pos, make_ptr(x)); }
-    void set_item(std::size_t pos, const Ptr& );
+    void set_item(std::size_t pos, const ref& );
     
-//    void set_item(std::size_t pos, const Object& );
+//    void set_item(std::size_t pos, const object& );
 
     template <class T>
     void insert(std::size_t index, const T& x)
         { this->insert(index, make_ptr(x)); }
-    void insert(std::size_t index, const Ptr& item);
+    void insert(std::size_t index, const ref& item);
 
     template <class T>
     void push_back(const T& item)
         { this->push_back(make_ptr(item)); }
-    void push_back(const Ptr& item);
+    void push_back(const ref& item);
     
     template <class T>
     void append(const T& item)
         { this->append(make_ptr(item)); }
-    void append(const Ptr& item);
+    void append(const ref& item);
     
-    List slice(int low, int high) const;
-    SliceProxy slice(int low, int high);
+    list slice(int low, int high) const;
+    slice_proxy slice(int low, int high);
     void sort();
     void reverse();
-    Tuple as_tuple() const;
+    tuple as_tuple() const;
 };
 
-class String
-    : public Object, public boost::multipliable2<String, unsigned int>
+class string
+    : public object, public boost::multipliable2<string, unsigned int>
 {
  public:
     // Construct from an owned PyObject*.
     // Precondition: p must point to a python string.
-    explicit String(Ptr p);
-    explicit String(const char* s);
-    String(const char* s, std::size_t length);
-    String(const String& rhs);
+    explicit string(ref p);
+    explicit string(const char* s);
+    string(const char* s, std::size_t length);
+    string(const string& rhs);
 
-    enum Interned { interned };
-    String(const char* s, Interned);
+    enum interned_t { interned };
+    string(const char* s, interned_t);
     
     // Get the type object for Strings
-    static PyTypeObject* type_object();
+    static PyTypeObject* type_obj();
 
-    // Return true if the given object is a python String
-    static bool accepts(Ptr o);
+    // Return true if the given object is a python string
+    static bool accepts(ref o);
 
     // Return the length of the string.
     std::size_t size() const;
@@ -163,172 +163,172 @@ class String
     // The data must not be modified in any way. It must not be de-allocated. 
     const char* c_str() const;
 
-    String& operator*=(unsigned int repeat_count);
-    String& operator+=(const String& rhs);
-    friend String operator+(String x, String y);
-    String& operator+=(const char* rhs);
-    friend String operator+(String x, const char* y);
-    friend String operator+(const char* x, String y);
+    string& operator*=(unsigned int repeat_count);
+    string& operator+=(const string& rhs);
+    friend string operator+(string x, string y);
+    string& operator+=(const char* rhs);
+    friend string operator+(string x, const char* y);
+    friend string operator+(const char* x, string y);
 
     void intern();
 
-    friend String operator%(const String& format, const Tuple& args);
+    friend string operator%(const string& format, const tuple& args);
 };
 
-class Dict : public Object
+class dictionary : public object
 {
  private:
-    struct Proxy;
+    struct proxy;
     
  public:
-    explicit Dict(Ptr p);
-    Dict();
+    explicit dictionary(ref p);
+    dictionary();
     void clear();
 
-    static PyTypeObject* type_object();
-    static bool accepts(Ptr p);
+    static PyTypeObject* type_obj();
+    static bool accepts(ref p);
     
  public:
     template <class Key>
-    Proxy operator[](const Key& key)
+    proxy operator[](const Key& key)
         { return this->operator[](make_ptr(key)); }
-    Proxy operator[](Ptr key);
+    proxy operator[](ref key);
     
     template <class Key>
-    Ptr operator[](const Key& key) const
+    ref operator[](const Key& key) const
         { return this->operator[](make_ptr(key)); }
-    Ptr operator[](Ptr key) const;
+    ref operator[](ref key) const;
 
     template <class Key>
-    Ptr get_item(const Key& key) const
+    ref get_item(const Key& key) const
         { return this->get_item(make_ptr(key)); }
-    Ptr get_item(const Ptr& key) const;
+    ref get_item(const ref& key) const;
     
     template <class Key, class Default>
-    Ptr get_item(const Key& key, const Default& default_) const
+    ref get_item(const Key& key, const Default& default_) const
         { return this->get_item(make_ptr(key), make_ptr(default_)); }
-    Ptr get_item(const Ptr& key, const Ptr& default_) const;
+    ref get_item(const ref& key, const ref& default_) const;
     
     template <class Key, class Value>
     void set_item(const Key& key, const Value& value)
         { this->set_item(make_ptr(key), make_ptr(value)); }
-    void set_item(const Ptr& key, const Ptr& value);
+    void set_item(const ref& key, const ref& value);
 
     template <class Key>
     void erase(const Key& key)
         { this->erase(make_ptr(key)); }
-    void erase(Ptr key);
+    void erase(ref key);
 
-//    Proxy operator[](const Object& key);
-//    Ptr operator[](const Object& key) const;
+//    proxy operator[](const object& key);
+//    ref operator[](const object& key) const;
 
-//    Ptr get_item(const Object& key, Ptr default_ = Ptr()) const;
-//    void set_item(const Object& key, const Ptr& value);
+//    ref get_item(const object& key, ref default_ = ref()) const;
+//    void set_item(const object& key, const ref& value);
         
-//    void erase(const Object& key);
+//    void erase(const object& key);
 
-    List items() const;
-    List keys() const;
-    List values() const;
+    list items() const;
+    list keys() const;
+    list values() const;
 
     std::size_t size() const;
     // TODO: iterator support
 };
 
-struct Dict::Proxy
+struct dictionary::proxy
 {
     template <class T>
-    const Ptr& operator=(const T& rhs)
+    const ref& operator=(const T& rhs)
         { return (*this) = make_ptr(rhs); }
-    const Ptr& operator=(const Ptr& rhs);
+    const ref& operator=(const ref& rhs);
 
-    operator Ptr() const;
+    operator ref() const;
  private:
-    friend class Dict;
-    Proxy(const Ptr& dict, const Ptr& key);
+    friend class dictionary;
+    proxy(const ref& dict, const ref& key);
 
     // This is needed to work around the very strange MSVC error report that the
     // return type of the built-in operator= differs from that of the ones
     // defined above. Couldn't hurt to make these un-assignable anyway, though.
-    const Ptr& operator=(const Proxy&); // Not actually implemented
+    const ref& operator=(const proxy&); // Not actually implemented
  private:
-    Ptr m_dict;
-    Ptr m_key;
+    ref m_dict;
+    ref m_key;
 };
 
-struct List::Proxy
+struct list::proxy
 {
     template <class T>
-    const Ptr& operator=(const T& rhs)
+    const ref& operator=(const T& rhs)
         { return (*this) = make_ptr(rhs); }
-    const Ptr& operator=(const Ptr& rhs);
+    const ref& operator=(const ref& rhs);
     
-    operator Ptr() const;
+    operator ref() const;
     
  private:
-    friend class List;
-    Proxy(const Ptr& list, std::size_t index);
+    friend class list;
+    proxy(const ref& list, std::size_t index);
     
     // This is needed to work around the very strange MSVC error report that the
     // return type of the built-in operator= differs from that of the ones
     // defined above. Couldn't hurt to make these un-assignable anyway, though.
-    const Ptr& operator=(const Proxy&); // Not actually implemented
+    const ref& operator=(const proxy&); // Not actually implemented
  private:
-    List m_list;
+    list m_list;
     std::size_t m_index;
 };
 
-struct List::SliceProxy
+struct list::slice_proxy
 {
-    const List& operator=(const List& rhs);
-    operator Ptr() const;
-    operator List() const;
+    const list& operator=(const list& rhs);
+    operator ref() const;
+    operator list() const;
     std::size_t size();
-    Ptr operator[](std::size_t pos) const;
+    ref operator[](std::size_t pos) const;
  private:
-    friend class List;
-    SliceProxy(const Ptr& list, int low, int high);
+    friend class list;
+    slice_proxy(const ref& list, int low, int high);
  private:
-    Ptr m_list;
+    ref m_list;
     int m_low, m_high;
 };
 
-} // namespace py
+} // namespace python
 
-PY_BEGIN_CONVERSION_NAMESPACE
+BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
 
-PyObject* to_python(const py::Tuple&);
-py::Tuple from_python(PyObject* p, py::Type<py::Tuple>);
+PyObject* to_python(const python::tuple&);
+python::tuple from_python(PyObject* p, python::type<python::tuple>);
 
-inline py::Tuple from_python(PyObject* p, py::Type<const py::Tuple&>)
+inline python::tuple from_python(PyObject* p, python::type<const python::tuple&>)
 {
-    return from_python(p, py::Type<py::Tuple>());
+    return from_python(p, python::type<python::tuple>());
 }
 
-PyObject* to_python(const py::List&);
-py::List from_python(PyObject* p, py::Type<py::List>);
+PyObject* to_python(const python::list&);
+python::list from_python(PyObject* p, python::type<python::list>);
 
-inline py::List from_python(PyObject* p, py::Type<const py::List&>)
+inline python::list from_python(PyObject* p, python::type<const python::list&>)
 {
-    return from_python(p, py::Type<py::List>());
+    return from_python(p, python::type<python::list>());
 }
 
-PyObject* to_python(const py::String&);
-py::String from_python(PyObject* p, py::Type<py::String>);
+PyObject* to_python(const python::string&);
+python::string from_python(PyObject* p, python::type<python::string>);
 
-inline py::String from_python(PyObject* p, py::Type<const py::String&>)
+inline python::string from_python(PyObject* p, python::type<const python::string&>)
 {
-    return from_python(p, py::Type<py::String>());
+    return from_python(p, python::type<python::string>());
 }
 
-PyObject* to_python(const py::Dict&);
-py::Dict from_python(PyObject* p, py::Type<py::Dict>);
+PyObject* to_python(const python::dictionary&);
+python::dictionary from_python(PyObject* p, python::type<python::dictionary>);
 
-inline py::Dict from_python(PyObject* p, py::Type<const py::Dict&>)
+inline python::dictionary from_python(PyObject* p, python::type<const python::dictionary&>)
 {
-    return from_python(p, py::Type<py::Dict>());
+    return from_python(p, python::type<python::dictionary>());
 }
 
-PY_END_CONVERSION_NAMESPACE
+BOOST_PYTHON_END_CONVERSION_NAMESPACE
 
 #endif // OBJECTS_DWA051100_H_
diff --git a/operators.h b/operators.h
index a4f55f70..ac7161aa 100644
--- a/operators.h
+++ b/operators.h
@@ -8,7 +8,7 @@
 # include <strstream>
 #endif
 
-namespace py {
+namespace python {
 
 namespace detail {
   struct auto_operand {};
@@ -39,7 +39,7 @@ enum operator_id
     op_cmp = 0x100000 
 };
 
-template <long which, class operand = py::detail::auto_operand>
+template <long which, class operand = python::detail::auto_operand>
 struct operators {};
 
 template <class T>
@@ -53,7 +53,7 @@ namespace detail
   template <class Specified>
   struct operand_select
   {
-      template <class WrappedType>
+      template <class wrapped_type>
       struct wrapped
       {
           typedef Specified type;
@@ -63,20 +63,20 @@ namespace detail
   template <>
   struct operand_select<auto_operand>
   {
-      template <class WrappedType>
+      template <class wrapped_type>
       struct wrapped
       {
-          typedef const WrappedType& type;
+          typedef const wrapped_type& type;
       };
   };
 
   template <long> struct define_operator;
 
-  // Base class which grants access to ExtensionClassBase::add_method() to its derived classes
+  // Base class which grants access to extension_class_base::add_method() to its derived classes
   struct add_operator_base
   {
    protected:
-      static inline void add_method(ExtensionClassBase* target, Function* method, const char* name)
+      static inline void add_method(extension_class_base* target, function* method, const char* name)
           { target->add_method(method, name); }
   };
 
@@ -89,7 +89,7 @@ namespace detail
 //  Usage:
 //      choose_op<(which & op_add)>::template args<left_t,right_t>::add(ext_class);
 // 
-// (see ExtensionClass<>::def_operators() for more examples).
+// (see extension_class<>::def_operators() for more examples).
 //
   template <long op_selector>
   struct choose_op
@@ -97,7 +97,7 @@ namespace detail
       template <class Left, class Right = Left>
       struct args : add_operator_base
       {
-          static inline void add(ExtensionClassBase* target)
+          static inline void add(extension_class_base* target)
           {
               typedef define_operator<op_selector> def_op;
               add_method(target,
@@ -115,7 +115,7 @@ namespace detail
       template <class Left, class Right = Left>
       struct args
       {
-          static inline void add(ExtensionClassBase*)
+          static inline void add(extension_class_base*)
           {
           }
 
@@ -128,7 +128,7 @@ namespace detail
       template <class Operand>
       struct args : add_operator_base
       {
-          static inline void add(ExtensionClassBase* target)
+          static inline void add(extension_class_base* target)
           {
               typedef define_operator<op_selector> def_op;
               add_method(target,
@@ -146,7 +146,7 @@ namespace detail
       template <class Operand>
       struct args
       {
-          static inline void add(ExtensionClassBase*)
+          static inline void add(extension_class_base*)
           {
           }
 
@@ -159,7 +159,7 @@ namespace detail
       template <class Left, class Right = Left>
       struct args : add_operator_base
       {
-          static inline void add(ExtensionClassBase* target)
+          static inline void add(extension_class_base* target)
           {
               typedef define_operator<op_selector> def_op;
               add_method(target,
@@ -177,7 +177,7 @@ namespace detail
       template <class Left, class Right = Left>
       struct args
       {
-          static inline void add(ExtensionClassBase*)
+          static inline void add(extension_class_base*)
           {
           }
 
@@ -189,15 +189,15 @@ namespace detail
   struct define_operator<op_##id>                                                       \
   {                                                                                     \
       template <class Left, class Right = Left>                                         \
-      struct operator_function : Function                                               \
+      struct operator_function : function                                               \
       {                                                                                 \
           PyObject* do_call(PyObject* arguments, PyObject* /* keywords */) const        \
           {                                                                             \
-              Tuple args(Ptr(arguments, Ptr::new_ref));                                 \
+              tuple args(ref(arguments, ref::increment_count));                                 \
                                                                                         \
-              return PY_CONVERSION::to_python(                                          \
-                  PY_CONVERSION::from_python(args[0].get(), py::Type<Left>()) oper      \
-                  PY_CONVERSION::from_python(args[1].get(), py::Type<Right>()));        \
+              return BOOST_PYTHON_CONVERSION::to_python(                                          \
+                  BOOST_PYTHON_CONVERSION::from_python(args[0].get(), python::type<Left>()) oper      \
+                  BOOST_PYTHON_CONVERSION::from_python(args[1].get(), python::type<Right>()));        \
           }                                                                             \
                                                                                         \
           const char* description() const                                               \
@@ -205,15 +205,15 @@ namespace detail
       };                                                                                \
                                                                                         \
       template <class Right, class Left>                                                \
-      struct roperator_function : Function                                              \
+      struct roperator_function : function                                              \
       {                                                                                 \
           PyObject* do_call(PyObject* arguments, PyObject* /* keywords */) const        \
           {                                                                             \
-              Tuple args(Ptr(arguments, Ptr::new_ref));                                 \
+              tuple args(ref(arguments, ref::increment_count));                                 \
                                                                                         \
-              return PY_CONVERSION::to_python(                                          \
-                  PY_CONVERSION::from_python(args[1].get(), py::Type<Left>()) oper      \
-                  PY_CONVERSION::from_python(args[0].get(), py::Type<Right>()));        \
+              return BOOST_PYTHON_CONVERSION::to_python(                                          \
+                  BOOST_PYTHON_CONVERSION::from_python(args[1].get(), python::type<Left>()) oper      \
+                  BOOST_PYTHON_CONVERSION::from_python(args[0].get(), python::type<Right>()));        \
           }                                                                             \
                                                                                         \
           const char* description() const                                               \
@@ -230,14 +230,14 @@ namespace detail
   struct define_operator<op_##id>                                                               \
   {                                                                                             \
       template <class operand>                                                                  \
-      struct operator_function : Function                                                       \
+      struct operator_function : function                                                       \
       {                                                                                         \
           PyObject* do_call(PyObject* arguments, PyObject* /* keywords */) const                \
           {                                                                                     \
-              Tuple args(Ptr(arguments, Ptr::new_ref));                                         \
+              tuple args(ref(arguments, ref::increment_count));                                         \
                                                                                                 \
-              return PY_CONVERSION::to_python(                                                  \
-                  oper(PY_CONVERSION::from_python(args[0].get(), py::Type<operand>())));        \
+              return BOOST_PYTHON_CONVERSION::to_python(                                                  \
+                  oper(BOOST_PYTHON_CONVERSION::from_python(args[0].get(), python::type<operand>())));        \
           }                                                                                     \
                                                                                                 \
           const char* description() const                                                       \
@@ -273,21 +273,21 @@ namespace detail
   struct define_operator<op_pow>
   {
       template <class Left, class Right = Left>
-      struct operator_function : Function
+      struct operator_function : function
       {
           PyObject* do_call(PyObject* arguments, PyObject* /* keywords */) const
           { 
-              Tuple args(Ptr(arguments, Ptr::new_ref));
+              tuple args(ref(arguments, ref::increment_count));
 
               if (args.size() == 3 && args[2]->ob_type != Py_None->ob_type)
               {
                   PyErr_SetString(PyExc_TypeError, "expected 2 arguments, got 3");
-                  throw ArgumentError();
+                  throw argument_error();
               }
 
-              return PY_CONVERSION::to_python(
-                  pow(PY_CONVERSION::from_python(args[0].get(), py::Type<Left>()),
-                   PY_CONVERSION::from_python(args[1].get(), py::Type<Right>()))); 
+              return BOOST_PYTHON_CONVERSION::to_python(
+                  pow(BOOST_PYTHON_CONVERSION::from_python(args[0].get(), python::type<Left>()),
+                   BOOST_PYTHON_CONVERSION::from_python(args[1].get(), python::type<Right>()))); 
           }
 
           const char* description() const
@@ -296,21 +296,21 @@ namespace detail
       };
 
       template <class Right, class Left>
-      struct roperator_function : Function
+      struct roperator_function : function
       {
           PyObject* do_call(PyObject* arguments, PyObject* /* keywords */) const
           { 
-              Tuple args(Ptr(arguments, Ptr::new_ref));
+              tuple args(ref(arguments, ref::increment_count));
 
               if (args.size() == 3 && args[2]->ob_type != Py_None->ob_type)
               {
                   PyErr_SetString(PyExc_TypeError, "bad operand type(s) for pow()");
-                  throw ArgumentError();
+                  throw argument_error();
               }
 
-              return PY_CONVERSION::to_python(
-                  pow(PY_CONVERSION::from_python(args[1].get(), py::Type<Left>()),
-                   PY_CONVERSION::from_python(args[0].get(), py::Type<Right>()))); 
+              return BOOST_PYTHON_CONVERSION::to_python(
+                  pow(BOOST_PYTHON_CONVERSION::from_python(args[1].get(), python::type<Left>()),
+                   BOOST_PYTHON_CONVERSION::from_python(args[0].get(), python::type<Right>()))); 
           }
 
           const char* description() const
@@ -326,21 +326,21 @@ namespace detail
   struct define_operator<op_divmod>
   {
       template <class Left, class Right = Left>
-      struct operator_function : Function
+      struct operator_function : function
       {
           PyObject* do_call(PyObject* arguments, PyObject* /* keywords */) const
           { 
-              Tuple args(Ptr(arguments, Ptr::new_ref));
+              tuple args(ref(arguments, ref::increment_count));
               PyObject * res = PyTuple_New(2);
 
               PyTuple_SET_ITEM(res, 0,
-                PY_CONVERSION::to_python(
-                   PY_CONVERSION::from_python(args[0].get(), py::Type<Left>()) /
-                   PY_CONVERSION::from_python(args[1].get(), py::Type<Right>()))); 
+                BOOST_PYTHON_CONVERSION::to_python(
+                   BOOST_PYTHON_CONVERSION::from_python(args[0].get(), python::type<Left>()) /
+                   BOOST_PYTHON_CONVERSION::from_python(args[1].get(), python::type<Right>()))); 
               PyTuple_SET_ITEM(res, 1,
-                PY_CONVERSION::to_python(
-                   PY_CONVERSION::from_python(args[0].get(), py::Type<Left>()) %
-                   PY_CONVERSION::from_python(args[1].get(), py::Type<Right>())));
+                BOOST_PYTHON_CONVERSION::to_python(
+                   BOOST_PYTHON_CONVERSION::from_python(args[0].get(), python::type<Left>()) %
+                   BOOST_PYTHON_CONVERSION::from_python(args[1].get(), python::type<Right>())));
 
               return res; 
           }
@@ -351,21 +351,21 @@ namespace detail
       };
 
       template <class Right, class Left>
-      struct roperator_function : Function
+      struct roperator_function : function
       {
           PyObject* do_call(PyObject* arguments, PyObject* /* keywords */) const
           { 
-              Tuple args(Ptr(arguments, Ptr::new_ref));
+              tuple args(ref(arguments, ref::increment_count));
               PyObject * res = PyTuple_New(2);
 
               PyTuple_SET_ITEM(res, 0,
-                PY_CONVERSION::to_python(
-                   PY_CONVERSION::from_python(args[1].get(), py::Type<Left>()) /
-                   PY_CONVERSION::from_python(args[0].get(), py::Type<Right>()))); 
+                BOOST_PYTHON_CONVERSION::to_python(
+                   BOOST_PYTHON_CONVERSION::from_python(args[1].get(), python::type<Left>()) /
+                   BOOST_PYTHON_CONVERSION::from_python(args[0].get(), python::type<Right>()))); 
               PyTuple_SET_ITEM(res, 1,
-                PY_CONVERSION::to_python(
-                   PY_CONVERSION::from_python(args[1].get(), py::Type<Left>()) %
-                   PY_CONVERSION::from_python(args[0].get(), py::Type<Right>())));
+                BOOST_PYTHON_CONVERSION::to_python(
+                   BOOST_PYTHON_CONVERSION::from_python(args[1].get(), python::type<Left>()) %
+                   BOOST_PYTHON_CONVERSION::from_python(args[0].get(), python::type<Right>())));
 
               return res; 
           }
@@ -383,18 +383,18 @@ namespace detail
   struct define_operator<op_cmp>
   {
       template <class Left, class Right = Left>
-      struct operator_function : Function
+      struct operator_function : function
       {
           PyObject* do_call(PyObject* arguments, PyObject* /* keywords */) const
           { 
-              Tuple args(Ptr(arguments, Ptr::new_ref));
+              tuple args(ref(arguments, ref::increment_count));
 
-              return PY_CONVERSION::to_python(
-                  (PY_CONVERSION::from_python(args[0].get(), py::Type<Left>()) <
-                   PY_CONVERSION::from_python(args[1].get(), py::Type<Right>())) ?
+              return BOOST_PYTHON_CONVERSION::to_python(
+                  (BOOST_PYTHON_CONVERSION::from_python(args[0].get(), python::type<Left>()) <
+                   BOOST_PYTHON_CONVERSION::from_python(args[1].get(), python::type<Right>())) ?
                        - 1 :
-                       (PY_CONVERSION::from_python(args[1].get(), py::Type<Right>()) <
-                       PY_CONVERSION::from_python(args[0].get(), py::Type<Left>())) ?
+                       (BOOST_PYTHON_CONVERSION::from_python(args[1].get(), python::type<Right>()) <
+                       BOOST_PYTHON_CONVERSION::from_python(args[0].get(), python::type<Left>())) ?
                            1 :
                            0) ; 
           }
@@ -405,18 +405,18 @@ namespace detail
       };
 
       template <class Right, class Left>
-      struct roperator_function : Function
+      struct roperator_function : function
       {
           PyObject* do_call(PyObject* arguments, PyObject* /* keywords */) const
           { 
-              Tuple args(Ptr(arguments, Ptr::new_ref));
+              tuple args(ref(arguments, ref::increment_count));
 
-              return PY_CONVERSION::to_python(
-                  (PY_CONVERSION::from_python(args[1].get(), py::Type<Left>()) <
-                   PY_CONVERSION::from_python(args[0].get(), py::Type<Right>())) ?
+              return BOOST_PYTHON_CONVERSION::to_python(
+                  (BOOST_PYTHON_CONVERSION::from_python(args[1].get(), python::type<Left>()) <
+                   BOOST_PYTHON_CONVERSION::from_python(args[0].get(), python::type<Right>())) ?
                        - 1 :
-                       (PY_CONVERSION::from_python(args[0].get(), py::Type<Right>()) <
-                       PY_CONVERSION::from_python(args[1].get(), py::Type<Left>())) ?
+                       (BOOST_PYTHON_CONVERSION::from_python(args[0].get(), python::type<Right>()) <
+                       BOOST_PYTHON_CONVERSION::from_python(args[1].get(), python::type<Left>())) ?
                            1 :
                            0) ; 
           }
@@ -434,24 +434,24 @@ namespace detail
   struct define_operator<op_str>
   {
       template <class operand>
-      struct operator_function : Function
+      struct operator_function : function
       {
           PyObject* do_call(PyObject* arguments, PyObject*) const
           { 
-              Tuple args(Ptr(arguments, Ptr::new_ref));
+              tuple args(ref(arguments, ref::increment_count));
 
 #if !defined(__GNUC__) || defined(__SGI_STL_PORT)
               std::ostringstream s;
-              s << PY_CONVERSION::from_python(args[0].get(), py::Type<operand>());
+              s << BOOST_PYTHON_CONVERSION::from_python(args[0].get(), python::type<operand>());
 #else
               std::ostrstream s;
-              s << PY_CONVERSION::from_python(args[0].get(), py::Type<operand>()) << char();
+              s << BOOST_PYTHON_CONVERSION::from_python(args[0].get(), python::type<operand>()) << char();
 #endif
 
 #if !defined(__GNUC__) || defined(__SGI_STL_PORT)
-              return PY_CONVERSION::to_python(s.str()); 
+              return BOOST_PYTHON_CONVERSION::to_python(s.str()); 
 #else
-              return PY_CONVERSION::to_python(const_cast<char const *>(s.str())); 
+              return BOOST_PYTHON_CONVERSION::to_python(const_cast<char const *>(s.str())); 
 #endif
           }
 
@@ -466,6 +466,6 @@ namespace detail
 
 } // namespace detail
 
-} // namespace py
+} // namespace python
 
 #endif /* OPERATORS_UK112000_H_ */
diff --git a/overloading.html b/overloading.html
index 66fff494..9d6ae681 100644
--- a/overloading.html
+++ b/overloading.html
@@ -33,15 +33,15 @@ void initoverload_demo()
 {
     try
     {
-        py::Module overload_demo("overload_demo");
+        python::module_builder overload_demo("overload_demo");
         // Overloaded functions at module scope
         overload_demo.def(f1, "f");
         overload_demo.def(f2, "f");
 
-        py::ClassWrapper&lt;X&gt; x_class(overload_demo, "X");
+        python::class_builder&lt;X&gt; x_class(overload_demo, "X");
         // Overloaded constructors
-        x_class.def(py::Constructor&lt;&gt;());
-        x_class.def(py::Constructor&lt;int&gt;());
+        x_class.def(python::constructor&lt;&gt;());
+        x_class.def(python::constructor&lt;int&gt;());
 
         // Overloaded member functions
         x_class.def((int (X::*)() const)&amp;X::value, "value");
diff --git a/overriding.html b/overriding.html
index b013a055..0b2668fe 100644
--- a/overriding.html
+++ b/overriding.html
@@ -46,7 +46,7 @@ class world
 
   <li><a name="derived_3">An</a> implementation of each virtual function you may wish to override in
   Python which uses
-  <code>py::Callback&lt<i>return-type</i>&gt;::call_method()</code> to call the
+  <code>python::callback&lt<i>return-type</i>&gt;::call_method()</code> to call the
   Python override.
 
   <li><a name="derived_4">For</a> each non-pure virtual function meant to be overridable from Python, a
@@ -65,7 +65,7 @@ struct world_callback : world
           m_self(self) {}
 
     const char* get() const // <a href="#derived_3">3</a>
-        { return py::Callback&lt;const char*&gt;::call_method(m_self, "get"); }
+        { return python::callback&lt;const char*&gt;::call_method(m_self, "get"); }
 
     static const char* <a name= "default_implementation">default_get</a>(const hello::world& self) const // <a href="#derived_4">4</a>
         { return self.world::get(); }
@@ -76,14 +76,14 @@ struct world_callback : world
 
 <p>
   Finally, we add <code>world_callback</code> to the <code>
-  ClassWrapper&lt;&gt;</code> declaration in our module initialization
+  class_builder&lt;&gt;</code> declaration in our module initialization
   function, and when we define the function, we must tell py_cpp about the default
   implementation:
 
 <blockquote><pre>
 // Create the <a name=
 "world_class">Python type object</a> for our extension class
-py::ClassWrapper&lt;hello::world<strong>,world_callback&gt;</strong> world_class(hello, "world");
+python::class_builder&lt;hello::world<strong>,world_callback&gt;</strong> world_class(hello, "world");
 // Add a virtual member function
 world_class.def(&amp;world::get, "get", &amp;<b>world_callback::default_get</b>);
 </pre></blockquote>
@@ -116,7 +116,7 @@ world_class.def(&amp;world::get, "get", &amp;<b>world_callback::default_get</b>)
       to deal with than a virtual function with a default implementation. First
       of all, you obviously don't need to <a href="#default_implementation">
       supply a default implementation</a>. Secondly, you don't need to call
-      <code>def()</code> on the <code>ExtensionClass&lt;&gt;</code> instance
+      <code>def()</code> on the <code>extension_class&lt;&gt;</code> instance
       for the virtual function. In fact, you wouldn't <em>want</em> to: if the
       corresponding attribute on the Python class stays undefined, you'll get
       an <code>AttributeError</code> in Python when you try to call the
@@ -128,7 +128,7 @@ struct baz {
 };
 
 struct baz_callback {
-    int pure(int x) { py::Callback&lt;int&gt;::call_method(m_self, "pure", x); }
+    int pure(int x) { python::callback&lt;int&gt;::call_method(m_self, "pure", x); }
 };
 
 extern "C"
@@ -139,13 +139,13 @@ initfoobar()
 {
     try
     {
-       py::Module foobar("foobar");
-       py::ClassWrapper&lt;baz,baz_callback&gt; baz_class("baz");
+       python::module_builder foobar("foobar");
+       python::class_builder&lt;baz,baz_callback&gt; baz_class("baz");
        baz_class.def(&amp;baz::pure, "pure");
     }
     catch(...)
     {
-       py::handle_exception();    // Deal with the exception for Python
+       python::handle_exception();    // Deal with the exception for Python
     }
 }
 </pre>
diff --git a/pointers.html b/pointers.html
index 61e07e7e..c2fbdade 100644
--- a/pointers.html
+++ b/pointers.html
@@ -61,11 +61,11 @@ wrapped <code>T</code>, you may want to provide an automatic
 thin wrappers. You can do this simply as follows:
 
 <blockquote><pre>
-PY_BEGIN_CONVERSION_NAMESPACE // this is a gcc 2.95.2 bug workaround
+BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE // this is a gcc 2.95.2 bug workaround
   PyObject* to_python(const Foo* p) {
      return to_python(*p); // convert const Foo* in terms of const Foo&
   }
-PY_END_CONVERSION_NAMESPACE
+BOOST_PYTHON_END_CONVERSION_NAMESPACE
 </pre></blockquote>
 
 <h4>If you can't (afford to) copy the referent, or the pointer is non-const</h4>
@@ -78,17 +78,17 @@ can not control the lifetime of the referent, so it may be destroyed by your C++
 code before the last Python reference to it disappears:
 
 <blockquote><pre>
-PY_BEGIN_CONVERSION_NAMESPACE // this is a gcc 2.95.2 bug workaround
+BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE // this is a gcc 2.95.2 bug workaround
   PyObject* to_python(Foo* p)
   {
-      return py::PyExtensionClassConverters<Foo>::ptr_to_python(p);
+      return python::PyExtensionClassConverters<Foo>::ptr_to_python(p);
   }
 
   PyObject* to_python(const Foo* p)
   {
       return to_python(const_cast<Foo*>(p));
   }
-PY_END_CONVERSION_NAMESPACE
+BOOST_PYTHON_END_CONVERSION_NAMESPACE
 </pre></blockquote>
 
 This will cause the Foo* to be treated as though it were an owning smart
@@ -117,9 +117,9 @@ typedef unsigned ErrorCode;
 const char* f(int* in_out_x); // original function
  ...
 #include &lt;py_cpp/objects.h&gt;
-const py::Tuple f_wrapper(int in_x) { 
+const python::tuple f_wrapper(int in_x) { 
   const char* s = f(in_x); 
-  return py::Tuple(s, in_x);
+  return python::tuple(s, in_x);
 }
   ...
 my_module.def(f_wrapper, "f");
diff --git a/py.cpp b/py.cpp
index 91c0f995..1662b91f 100644
--- a/py.cpp
+++ b/py.cpp
@@ -13,7 +13,7 @@
 # include <boost/cast.hpp>
 #endif
 
-namespace py {
+namespace python {
 
 // IMPORTANT: this function may only be called from within a catch block!
 void handle_exception()
@@ -26,7 +26,7 @@ void handle_exception()
         // Codewarrior doesn't suffer from this problem.
         throw;
     }
-    catch(const py::ErrorAlreadySet&)
+    catch(const python::error_already_set&)
     {
         // The python error reporting has already been handled.
     }
@@ -44,37 +44,37 @@ void handle_exception()
     }
 }
 
-} // namespace py
+} // namespace python
 
-PY_BEGIN_CONVERSION_NAMESPACE
+BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
 
-long from_python(PyObject* p, py::Type<long>)
+long from_python(PyObject* p, python::type<long>)
 {
     // Why am I clearing the error here before trying to convert? I know there's a reason...
     long result;
     {
         result = PyInt_AsLong(p);
         if (PyErr_Occurred())
-            throw py::ArgumentError();
+            throw python::argument_error();
     }
     return result;
 }
 
-double from_python(PyObject* p, py::Type<double>)
+double from_python(PyObject* p, python::type<double>)
 {
     double result;
     {
         result = PyFloat_AsDouble(p);
         if (PyErr_Occurred())
-            throw py::ArgumentError();
+            throw python::argument_error();
     }
     return result;
 }
 
 template <class T>
-T integer_from_python(PyObject* p, py::Type<T>)
+T integer_from_python(PyObject* p, python::type<T>)
 {
-    const long long_result = from_python(p, py::Type<long>());
+    const long long_result = from_python(p, python::type<long>());
 
 #ifndef BOOST_NO_LIMITS
     try
@@ -94,7 +94,7 @@ T integer_from_python(PyObject* p, py::Type<T>)
         const char message[] = "%ld out of range for %s";
         sprintf(buffer, message, long_result, typeid(T).name());
         PyErr_SetString(PyExc_ValueError, buffer);
-        throw py::ArgumentError();
+        throw python::argument_error();
     }
 #if defined(__MWERKS__) && __MWERKS__ <= 0x2400
     return 0; // Not smart enough to know that the catch clause always rethrows
@@ -119,13 +119,13 @@ PyObject* integer_to_python(T value)
     {
         const char message[] = "value out of range for Python int";
         PyErr_SetString(PyExc_ValueError, message);
-        throw py::ErrorAlreadySet();
+        throw python::error_already_set();
     }
     
     return to_python(value_as_long);
 }
 
-int from_python(PyObject* p, py::Type<int> type)
+int from_python(PyObject* p, python::type<int> type)
 {
     return integer_from_python(p, type);
 }
@@ -135,19 +135,19 @@ PyObject* to_python(unsigned int i)
 	return integer_to_python(i);
 }
 
-unsigned int from_python(PyObject* p, py::Type<unsigned int> type)
+unsigned int from_python(PyObject* p, python::type<unsigned int> type)
 {
     return integer_from_python(p, type);
 }
 
-short from_python(PyObject* p, py::Type<short> type)
+short from_python(PyObject* p, python::type<short> type)
 {
     return integer_from_python(p, type);
 }
 
-float from_python(PyObject* p, py::Type<float>)
+float from_python(PyObject* p, python::type<float>)
 {
-    return static_cast<float>(from_python(p, py::Type<double>()));
+    return static_cast<float>(from_python(p, python::type<double>()));
 }
 
 PyObject* to_python(unsigned short i)
@@ -155,7 +155,7 @@ PyObject* to_python(unsigned short i)
 	return integer_to_python(i);
 }
 
-unsigned short from_python(PyObject* p, py::Type<unsigned short> type)
+unsigned short from_python(PyObject* p, python::type<unsigned short> type)
 {
     return integer_from_python(p, type);
 }
@@ -165,7 +165,7 @@ PyObject* to_python(unsigned char i)
 	return integer_to_python(i);
 }
 
-unsigned char from_python(PyObject* p, py::Type<unsigned char> type)
+unsigned char from_python(PyObject* p, python::type<unsigned char> type)
 {
     return integer_from_python(p, type);
 }
@@ -175,7 +175,7 @@ PyObject* to_python(signed char i)
 	return integer_to_python(i);
 }
 
-signed char from_python(PyObject* p, py::Type<signed char> type)
+signed char from_python(PyObject* p, python::type<signed char> type)
 {
     return integer_from_python(p, type);
 }
@@ -185,24 +185,24 @@ PyObject* to_python(unsigned long x)
     return integer_to_python(x);
 }
 
-unsigned long from_python(PyObject* p, py::Type<unsigned long> type)
+unsigned long from_python(PyObject* p, python::type<unsigned long> type)
 {
     return integer_from_python(p, type);
 }
 
-void from_python(PyObject* p, py::Type<void>)
+void from_python(PyObject* p, python::type<void>)
 {
     if (p != Py_None) {
         PyErr_SetString(PyExc_TypeError, "expected argument of type None");
-        throw py::ArgumentError();
+        throw python::argument_error();
     }
 }
 
-const char* from_python(PyObject* p, py::Type<const char*>)
+const char* from_python(PyObject* p, python::type<const char*>)
 {
     const char* s = PyString_AsString(p);
     if (!s)
-        throw py::ArgumentError();
+        throw python::argument_error();
     return s;
 }
 
@@ -211,20 +211,20 @@ PyObject* to_python(const std::string& s)
 	return PyString_FromString(s.c_str());
 }
 
-std::string from_python(PyObject* p, py::Type<std::string>)
+std::string from_python(PyObject* p, python::type<std::string>)
 {
-    return std::string(from_python(p, py::Type<const char*>()));
+    return std::string(from_python(p, python::type<const char*>()));
 }
 
-bool from_python(PyObject* p, py::Type<bool>)
+bool from_python(PyObject* p, python::type<bool>)
 {
-    int value = from_python(p, py::Type<int>());
+    int value = from_python(p, python::type<int>());
     if (value == 0)
         return false;
     return true;
 }
 
-#ifdef PY_MSVC6_OR_EARLIER
+#ifdef BOOST_MSVC6_OR_EARLIER
 // An optimizer bug prevents these from being inlined.
 PyObject* to_python(double d)
 {
@@ -235,7 +235,7 @@ PyObject* to_python(float f)
 {
     return PyFloat_FromDouble(f);
 }
-#endif // PY_MSVC6_OR_EARLIER
+#endif // BOOST_MSVC6_OR_EARLIER
 
-PY_END_CONVERSION_NAMESPACE
+BOOST_PYTHON_END_CONVERSION_NAMESPACE
 
diff --git a/py.h b/py.h
index 785c02f7..e1cf6cb8 100644
--- a/py.h
+++ b/py.h
@@ -17,23 +17,23 @@
 # include "errors.h"
 # include <string>
 
-PY_BEGIN_CONVERSION_NAMESPACE // this is a gcc 2.95.2 bug workaround
+BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE // this is a gcc 2.95.2 bug workaround
 
 // This can be instantiated on an enum to provide the to_python/from_python
 // conversions, provided the values can fit in a long.
 template <class EnumType>
 class py_enum_as_int_converters
 {
-    friend EnumType from_python(PyObject* x, py::Type<EnumType>)
+    friend EnumType from_python(PyObject* x, python::type<EnumType>)
     {
         return static_cast<EnumType>(
-            from_python(x, py::Type<long>()));
+            from_python(x, python::type<long>()));
     }
 
-    friend EnumType from_python(PyObject* x, py::Type<const EnumType&>)
+    friend EnumType from_python(PyObject* x, python::type<const EnumType&>)
     {
         return static_cast<EnumType>(
-            from_python(x, py::Type<long>()));
+            from_python(x, python::type<long>()));
     }
 
     friend PyObject* to_python(EnumType x)
@@ -41,13 +41,13 @@ class py_enum_as_int_converters
         return to_python(static_cast<long>(x));
     }
 };
-PY_END_CONVERSION_NAMESPACE
+BOOST_PYTHON_END_CONVERSION_NAMESPACE
 
-namespace py {
+namespace python {
 template <class EnumType> class enum_as_int_converters
-    : public PY_CONVERSION::py_enum_as_int_converters<EnumType> {};
+    : public BOOST_PYTHON_CONVERSION::py_enum_as_int_converters<EnumType> {};
 
-template <class P, class T> class WrappedPointer;
+template <class P, class T> class wrapped_pointer;
 
 //#pragma warn_possunwant off
 inline void decref_impl(PyObject* p) { Py_DECREF(p); }
@@ -70,80 +70,80 @@ inline void xdecref(T* p)
 	xdecref_impl(reinterpret_cast<PyObject*>(p_base));
 }
 
-} // namespace py
+} // namespace python
 
-PY_BEGIN_CONVERSION_NAMESPACE
+BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
 //
 // Converters
 //
 PyObject* to_python(long);
-long from_python(PyObject* p, py::Type<long>);
-long from_python(PyObject* p, py::Type<const long&>);
+long from_python(PyObject* p, python::type<long>);
+long from_python(PyObject* p, python::type<const long&>);
 
 PyObject* to_python(unsigned long);
-unsigned long from_python(PyObject* p, py::Type<unsigned long>);
-unsigned long from_python(PyObject* p, py::Type<const unsigned long&>);
+unsigned long from_python(PyObject* p, python::type<unsigned long>);
+unsigned long from_python(PyObject* p, python::type<const unsigned long&>);
 
 PyObject* to_python(int);
-int from_python(PyObject*, py::Type<int>);
-int from_python(PyObject*, py::Type<const int&>);
+int from_python(PyObject*, python::type<int>);
+int from_python(PyObject*, python::type<const int&>);
     
 PyObject* to_python(unsigned int);
-unsigned int from_python(PyObject*, py::Type<unsigned int>);
-unsigned int from_python(PyObject*, py::Type<const unsigned int&>);
+unsigned int from_python(PyObject*, python::type<unsigned int>);
+unsigned int from_python(PyObject*, python::type<const unsigned int&>);
 
 PyObject* to_python(short);
-short from_python(PyObject*, py::Type<short>);
-short from_python(PyObject*, py::Type<const short&>);
+short from_python(PyObject*, python::type<short>);
+short from_python(PyObject*, python::type<const short&>);
     
 PyObject* to_python(unsigned short);
-unsigned short from_python(PyObject*, py::Type<unsigned short>);
-unsigned short from_python(PyObject*, py::Type<const unsigned short&>);
+unsigned short from_python(PyObject*, python::type<unsigned short>);
+unsigned short from_python(PyObject*, python::type<const unsigned short&>);
 
 PyObject* to_python(signed char);
-signed char from_python(PyObject*, py::Type<signed char>);
-signed char from_python(PyObject*, py::Type<const signed char&>);
+signed char from_python(PyObject*, python::type<signed char>);
+signed char from_python(PyObject*, python::type<const signed char&>);
 
 PyObject* to_python(unsigned char);
-unsigned char from_python(PyObject*, py::Type<unsigned char>);
-unsigned char from_python(PyObject*, py::Type<const unsigned char&>);
+unsigned char from_python(PyObject*, python::type<unsigned char>);
+unsigned char from_python(PyObject*, python::type<const unsigned char&>);
 
 PyObject* to_python(float);
-float from_python(PyObject*, py::Type<float>);
-float from_python(PyObject*, py::Type<const float&>);
+float from_python(PyObject*, python::type<float>);
+float from_python(PyObject*, python::type<const float&>);
     
 PyObject* to_python(double);
-double from_python(PyObject*, py::Type<double>);
-double from_python(PyObject*, py::Type<const double&>);
+double from_python(PyObject*, python::type<double>);
+double from_python(PyObject*, python::type<const double&>);
     
 PyObject* to_python(bool);
-bool from_python(PyObject*, py::Type<bool>);
-bool from_python(PyObject*, py::Type<const bool&>);
+bool from_python(PyObject*, python::type<bool>);
+bool from_python(PyObject*, python::type<const bool&>);
 
 PyObject* to_python(void);
-void from_python(PyObject*, py::Type<void>);
+void from_python(PyObject*, python::type<void>);
 
 PyObject* to_python(const char* s);
-const char* from_python(PyObject*, py::Type<const char*>);
+const char* from_python(PyObject*, python::type<const char*>);
 
 PyObject* to_python(const std::string& s);
-std::string from_python(PyObject*, py::Type<std::string>);
-std::string from_python(PyObject*, py::Type<const std::string&>);
+std::string from_python(PyObject*, python::type<std::string>);
+std::string from_python(PyObject*, python::type<const std::string&>);
 
 // For when your C++ function really wants to pass/return a PyObject*
 PyObject* to_python(PyObject*);
-PyObject* from_python(PyObject*, py::Type<PyObject*>);
+PyObject* from_python(PyObject*, python::type<PyObject*>);
 
 // Some standard conversions to/from smart pointer types. You can add your own
 // from these examples.  These are not generated using the friend technique from
-// WrappedPointer because:
+// wrapped_pointer because:
 //
 //      1. We want to be able to extend conversion to/from WrappedPointers using
 //      arbitrary smart pointer types.
 //
 //      2. It helps with compilation independence. This way, code which creates
 //      wrappers for functions accepting and returning smart_ptr<T> does not
-//      have to have already seen the invocation of WrappedType<T>.
+//      have to have already seen the invocation of wrapped_type<T>.
 //
 
 // Unfortunately, MSVC6 is so incredibly lame that we have to rely on the friend
@@ -151,15 +151,15 @@ PyObject* from_python(PyObject*, py::Type<PyObject*>);
 // types. This means that you need to write a non-templated function for each
 // specific smart_ptr<T> which you want to convert from_python. For example,
 //
-// namespace py {
+// namespace python {
 // #ifdef MUST_SUPPORT_MSVC
 //
-// MyPtr<Foo> from_python(PyObject*p, Type<MyPtr<Foo> >)
-//     { return smart_ptr_from_python(p, Type<MyPtr<Foo> >(), Type<Foo>());}
+// MyPtr<Foo> from_python(PyObject*p, type<MyPtr<Foo> >)
+//     { return smart_ptr_from_python(p, type<MyPtr<Foo> >(), type<Foo>());}
 // }
 // 
-// MyPtr<Bar> from_python(PyObject*p, Type<MyPtr<Bar> >)
-//     { return smart_ptr_from_python(p, Type<MyPtr<Bar> >(), Type<Bar>());}
+// MyPtr<Bar> from_python(PyObject*p, type<MyPtr<Bar> >)
+//     { return smart_ptr_from_python(p, type<MyPtr<Bar> >(), type<Bar>());}
 // 
 // ... // definitions for MyPtr<Baz>, MyPtr<Mumble>, etc.
 //
@@ -167,19 +167,19 @@ PyObject* from_python(PyObject*, py::Type<PyObject*>);
 //
 // // Just once for all MyPtr<T>
 // template <class T>
-// MyPtr<T> from_python(PyObject*p, Type<MyPtr<T> >)
+// MyPtr<T> from_python(PyObject*p, type<MyPtr<T> >)
 // {
-//    return smart_ptr_from_python(p, Type<MyPtr<T> >(), Type<T>());
+//    return smart_ptr_from_python(p, type<MyPtr<T> >(), type<T>());
 // }
 //
 // #endif
 // }
 
-#if !defined(PY_MSVC6_OR_EARLIER)
+#if !defined(BOOST_MSVC6_OR_EARLIER)
 template <class T>
-boost::shared_ptr<T> from_python(PyObject*p, py::Type<boost::shared_ptr<T> >)
+boost::shared_ptr<T> from_python(PyObject*p, python::type<boost::shared_ptr<T> >)
 {
-    return smart_ptr_from_python(p, py::Type<boost::shared_ptr<T> >(), py::Type<T>());
+    return smart_ptr_from_python(p, python::type<boost::shared_ptr<T> >(), python::type<T>());
 }
 #endif
 
@@ -187,13 +187,13 @@ boost::shared_ptr<T> from_python(PyObject*p, py::Type<boost::shared_ptr<T> >)
 template <class T>
 PyObject* to_python(std::auto_ptr<T> p)
 {
-    return new py::WrappedPointer<std::auto_ptr<T>, T>(p);
+    return new python::wrapped_pointer<std::auto_ptr<T>, T>(p);
 }
 
 template <class T>
 PyObject* to_python(boost::shared_ptr<T> p)
 {
-    return new py::WrappedPointer<boost::shared_ptr<T>, T>(p);
+    return new python::wrapped_pointer<boost::shared_ptr<T>, T>(p);
 }
 #endif
 
@@ -201,7 +201,7 @@ PyObject* to_python(boost::shared_ptr<T> p)
 // inline implementations
 //
 
-#ifndef PY_MSVC6_OR_EARLIER
+#ifndef BOOST_MSVC6_OR_EARLIER
 inline PyObject* to_python(double d)
 {
     return PyFloat_FromDouble(d);
@@ -211,7 +211,7 @@ inline PyObject* to_python(float f)
 {
     return PyFloat_FromDouble(f);
 }
-#endif // PY_MSVC6_OR_EARLIER
+#endif // BOOST_MSVC6_OR_EARLIER
 
 inline PyObject* to_python(long l)
 {
@@ -235,7 +235,7 @@ inline PyObject* to_python(bool b)
 
 inline PyObject* to_python(void)
 {
-    return py::detail::none();
+    return python::detail::none();
 }
 
 inline PyObject* to_python(const char* s)
@@ -243,9 +243,9 @@ inline PyObject* to_python(const char* s)
 	return PyString_FromString(s);
 }
 
-inline std::string from_python(PyObject* p, py::Type<const std::string&>)
+inline std::string from_python(PyObject* p, python::type<const std::string&>)
 {
-    return from_python(p, py::Type<std::string>());
+    return from_python(p, python::type<std::string>());
 }
 
 inline PyObject* to_python(PyObject* p)
@@ -254,72 +254,72 @@ inline PyObject* to_python(PyObject* p)
     return p;
 }
 
-inline PyObject* from_python(PyObject* p, py::Type<PyObject*>)
+inline PyObject* from_python(PyObject* p, python::type<PyObject*>)
 {
     return p;
 }
 
-inline const char* from_python(PyObject* p, py::Type<const char* const&>)
+inline const char* from_python(PyObject* p, python::type<const char* const&>)
 {
-    return from_python(p, py::Type<const char*>());
+    return from_python(p, python::type<const char*>());
 }
 
-inline double from_python(PyObject* p, py::Type<const double&>)
+inline double from_python(PyObject* p, python::type<const double&>)
 {
-    return from_python(p, py::Type<double>());
+    return from_python(p, python::type<double>());
 }
 
-inline float from_python(PyObject* p, py::Type<const float&>)
+inline float from_python(PyObject* p, python::type<const float&>)
 {
-    return from_python(p, py::Type<float>());
+    return from_python(p, python::type<float>());
 }
 
-inline int from_python(PyObject* p, py::Type<const int&>)
+inline int from_python(PyObject* p, python::type<const int&>)
 {
-    return from_python(p, py::Type<int>());
+    return from_python(p, python::type<int>());
 }
 
-inline short from_python(PyObject* p, py::Type<const short&>)
+inline short from_python(PyObject* p, python::type<const short&>)
 {
-    return from_python(p, py::Type<short>());
+    return from_python(p, python::type<short>());
 }
 
-inline long from_python(PyObject* p, py::Type<const long&>)
+inline long from_python(PyObject* p, python::type<const long&>)
 {
-    return from_python(p, py::Type<long>());
+    return from_python(p, python::type<long>());
 }
 
-inline bool from_python(PyObject* p, py::Type<const bool&>)
+inline bool from_python(PyObject* p, python::type<const bool&>)
 {
-    return from_python(p, py::Type<bool>());
+    return from_python(p, python::type<bool>());
 }
 
-inline unsigned int from_python(PyObject* p, py::Type<const unsigned int&>)
+inline unsigned int from_python(PyObject* p, python::type<const unsigned int&>)
 {
-    return from_python(p, py::Type<unsigned int>());
+    return from_python(p, python::type<unsigned int>());
 }
 
-inline unsigned short from_python(PyObject* p, py::Type<const unsigned short&>)
+inline unsigned short from_python(PyObject* p, python::type<const unsigned short&>)
 {
-    return from_python(p, py::Type<unsigned short>());
+    return from_python(p, python::type<unsigned short>());
 }
 
-inline signed char from_python(PyObject* p, py::Type<const signed char&>)
+inline signed char from_python(PyObject* p, python::type<const signed char&>)
 {
-    return from_python(p, py::Type<signed char>());
+    return from_python(p, python::type<signed char>());
 }
 
-inline unsigned char from_python(PyObject* p, py::Type<const unsigned char&>)
+inline unsigned char from_python(PyObject* p, python::type<const unsigned char&>)
 {
-    return from_python(p, py::Type<unsigned char>());
+    return from_python(p, python::type<unsigned char>());
 }
 
-inline unsigned long from_python(PyObject* p, py::Type<const unsigned long&>)
+inline unsigned long from_python(PyObject* p, python::type<const unsigned long&>)
 {
-    return from_python(p, py::Type<unsigned long>());
+    return from_python(p, python::type<unsigned long>());
 }
 
 
-PY_END_CONVERSION_NAMESPACE
+BOOST_PYTHON_END_CONVERSION_NAMESPACE
 
 #endif // METHOD_DWA122899_H_
diff --git a/py_cpp.html b/py_cpp.html
index 22495875..f38b61cb 100644
--- a/py_cpp.html
+++ b/py_cpp.html
@@ -77,9 +77,9 @@
       href="overloading.html">function overloading</a> and wrote the support for
       <a href="inheritance.html#implicit_conversion">reflecting C++ inheritance
       relationships</a>. He has helped to improve error-reporting from both
-      Python and C++, and has designed an extremely easy-to-use approach to 
-      export <a href="special.html#numeric">numeric operators</a> including
-      the possibility to avoid explicit coercion by means of overloading.
+      Python and C++, and has designed an extremely easy-to-use way of 
+      exposing <a href="special.html#numeric">numeric operators</a>, including
+      a way to avoid explicit coercion by means of overloading.
 
       <li>The members of the boost mailing list and the Python community supplied
       invaluable early feedback. In particular, Ron Clarke, Mark Evans, Anton
@@ -118,7 +118,7 @@
       <li>Advanced Topics
 
         <ol>
-          <li>ClassWrapper&lt;&gt;
+          <li>class_builder&lt;&gt;
 
           <li><a href="enums.html">enums</a>
 
diff --git a/pyconfig.h b/pyconfig.h
index a8c48244..746806ad 100644
--- a/pyconfig.h
+++ b/pyconfig.h
@@ -14,21 +14,20 @@
 
 # ifdef BOOST_NO_OPERATORS_IN_NAMESPACE
    // A gcc bug forces some symbols into the global namespace
-#  define PY_BEGIN_CONVERSION_NAMESPACE
-#  define PY_END_CONVERSION_NAMESPACE
-#  define PY_CONVERSION
-#  define PY_IMPORT_CONVERSION(x) using ::x
+#  define BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
+#  define BOOST_PYTHON_END_CONVERSION_NAMESPACE
+#  define BOOST_PYTHON_CONVERSION
+#  define BOOST_PYTHON_IMPORT_CONVERSION(x) using ::x
 # else
-#  define PY_BEGIN_CONVERSION_NAMESPACE namespace py {
-#  define PY_END_CONVERSION_NAMESPACE }
-#  define PY_CONVERSION py
-#  define PY_IMPORT_CONVERSION(x) void never_defined() // so we can follow the macro with a ';'
+#  define BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE namespace python {
+#  define BOOST_PYTHON_END_CONVERSION_NAMESPACE }
+#  define BOOST_PYTHON_CONVERSION python
+#  define BOOST_PYTHON_IMPORT_CONVERSION(x) void never_defined() // so we can follow the macro with a ';'
 # endif
 
 # if defined(BOOST_MSVC)
-#  define PY_COMPILER_IS_MSVC 1
 #  if _MSC_VER <= 1200
-#   define PY_MSVC6_OR_EARLIER 1
+#   define BOOST_MSVC6_OR_EARLIER 1
 #  endif
 
 # pragma warning (disable : 4786)
@@ -39,19 +38,19 @@
 // EDG-based compilers (e.g. alpha), which incorrectly warn that the result of
 // offsetof() is not an integer constant expression.
 # if defined(__DECCXX_VER) && __DECCXX_VER <= 60290024
-#  define PY_OFFSETOF(s_name, s_member) \
+#  define BOOST_OFFSETOF(s_name, s_member) \
         ((size_t)__INTADDR__(&(((s_name *)0)->s_member)))
 # else
-#  define PY_OFFSETOF(s_name, s_member) \
+#  define BOOST_OFFSETOF(s_name, s_member) \
         offsetof(s_name, s_member)
 # endif
 
 // The STLport puts all of the standard 'C' library names in std (as far as the
 // user is concerned), but without it you need a fix if you're using MSVC.
-# if defined(PY_MSVC6_OR_EARLIER) && !defined(__STLPORT)
-#  define PY_CSTD_
+# if defined(BOOST_MSVC6_OR_EARLIER) && !defined(__STLPORT)
+#  define BOOST_CSTD_
 # else
-#  define PY_CSTD_ std
+#  define BOOST_CSTD_ std
 # endif
 
 #endif // CONFIG_DWA052200_H_
diff --git a/pyptr.h b/pyptr.h
index 7dde02ac..bc7f73ef 100644
--- a/pyptr.h
+++ b/pyptr.h
@@ -18,82 +18,82 @@
 # include "errors.h"
 # include "py.h"
 
-PY_BEGIN_CONVERSION_NAMESPACE
+BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
 
 template <class T, class Value, class Base>
-struct PyPtrConversions : Base
+struct py_ptr_conversions : Base
 {
-    inline friend T from_python(PyObject* x, py::Type<const T&>)
-        { return T(py::Downcast<Value>(x).get(), T::new_ref); }
+    inline friend T from_python(PyObject* x, python::type<const T&>)
+        { return T(python::downcast<Value>(x).get(), T::increment_count); }
 
-    inline friend T from_python(PyObject* x, py::Type<T>)
-        { return T(py::Downcast<Value>(x).get(), T::new_ref); }
+    inline friend T from_python(PyObject* x, python::type<T>)
+        { return T(python::downcast<Value>(x).get(), T::increment_count); }
     
     inline friend PyObject* to_python(T x)
-        { return py::as_object(x.release()); }
+        { return python::as_object(x.release()); }
     
 };
 
-PY_END_CONVERSION_NAMESPACE
+BOOST_PYTHON_END_CONVERSION_NAMESPACE
 
-namespace py {
+namespace python {
 
-PY_IMPORT_CONVERSION(PyPtrConversions);
+BOOST_PYTHON_IMPORT_CONVERSION(py_ptr_conversions);
 
 template <class T>
-class PyPtr
-	: public PyPtrConversions<PyPtr<T>, T,
-       boost::dereferenceable<PyPtr<T>, T*> > // supplies op->
+class reference
+	: public py_ptr_conversions<reference<T>, T,
+       boost::dereferenceable<reference<T>, T*> > // supplies op->
 {
 public:
     typedef T value_type;
     
-	PyPtr(const PyPtr& rhs)
+	reference(const reference& rhs)
 		: m_p(rhs.m_p)
 	{
 		Py_XINCREF(object());
 	}
 
-#if !defined(PY_MSVC6_OR_EARLIER)
+#if !defined(BOOST_MSVC6_OR_EARLIER)
 	template <class T2>
-	PyPtr(const PyPtr<T2>& rhs)
+	reference(const reference<T2>& rhs)
 		: m_p(rhs.object())
 	{
 		Py_XINCREF(object());
 	}
 #endif
 
-	PyPtr() : m_p(0) {}
+	reference() : m_p(0) {}
     
     // These are two ways of spelling the same thing, that we need to increment
     // the reference count on the pointer when we're initialized.
-	enum NewRef { new_ref, borrowed = new_ref };
+	enum increment_count_t { increment_count };
 
-    enum AllowNull { null_ok };
+    enum allow_null { null_ok };
     
     template <class T2>
-    explicit PyPtr(T2* x)
+    explicit reference(T2* x)
         : m_p(expect_non_null(x)) {}
 
     template <class T2>
-    PyPtr(T2* x, NewRef)
+    reference(T2* x, increment_count_t)
         : m_p(expect_non_null(x)) { Py_INCREF(object()); }
 	
     template <class T2>
-    PyPtr(T2* x, AllowNull)
+    reference(T2* x, allow_null)
         : m_p(x) {}
 
     template <class T2>
-    PyPtr(T2* x, AllowNull, NewRef)
+    reference(T2* x, allow_null, increment_count_t)
         : m_p(x) { Py_XINCREF(object()); }
 	
     template <class T2>
-    PyPtr(T2* x, NewRef, AllowNull)
+    reference(T2* x, increment_count_t, allow_null)
         : m_p(x) { Py_XINCREF(object()); }
 	
-#if !defined(PY_MSVC6_OR_EARLIER)
+#if !defined(BOOST_MSVC6_OR_EARLIER)
 	template <class T2>
-	PyPtr& operator=(const PyPtr<T2>& rhs)
+	reference& operator=(const reference<T2>& rhs)
 	{
 		Py_XDECREF(object());
 		m_p = rhs.m_p;
@@ -102,7 +102,7 @@ public:
 	}
 #endif
 
-	PyPtr& operator=(const PyPtr& rhs)
+	reference& operator=(const reference& rhs)
 	{
 		Py_XINCREF(static_cast<PyObject*>(rhs.m_p));
 		Py_XDECREF(object());
@@ -110,7 +110,7 @@ public:
 		return *this;
 	}
     
-	~PyPtr()
+	~reference()
 	{
 		Py_XDECREF(m_p);
 	}
@@ -134,19 +134,19 @@ public:
         { Py_XDECREF(m_p); m_p = expect_non_null(x);}
 
     template <class T2>
-    void reset(T2* x, NewRef)
+    void reset(T2* x, increment_count_t)
         { Py_XDECREF(m_p); m_p = expect_non_null(x); Py_INCREF(object()); }
 	
     template <class T2>
-    void reset(T2* x, AllowNull)
+    void reset(T2* x, allow_null)
         { Py_XDECREF(m_p); m_p = x;}
 
     template <class T2>
-    void reset(T2* x, AllowNull, NewRef)
+    void reset(T2* x, allow_null, increment_count_t)
         { Py_XDECREF(m_p); m_p = x; Py_XINCREF(object()); }
 	
     template <class T2>
-    void reset(T2* x, NewRef, AllowNull)
+    void reset(T2* x, increment_count_t, allow_null)
         { Py_XDECREF(m_p); m_p = x; Py_XINCREF(object()); }
 	
 #if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
@@ -160,12 +160,12 @@ private:
 	T* m_p;
 };
 
-typedef PyPtr<PyObject> Ptr;
+typedef reference<PyObject> ref;
 
 template <class T>
-Ptr make_ptr(const T& x)
+ref make_ptr(const T& x)
 {
-    return Ptr(to_python(x));
+    return ref(to_python(x));
 }
 
 }
diff --git a/signatures.h b/signatures.h
index 1d12b9c3..d03787cb 100644
--- a/signatures.h
+++ b/signatures.h
@@ -6,50 +6,50 @@
 //  The author gratefully acknowleges the support of Dragon Systems, Inc., in
 //  producing this work.
 //
-//  This file automatically generated by gen_signatures.py for 10 arguments.
+//  This file automatically generated by gen_signatures.python for 10 arguments.
 #ifndef SIGNATURES_DWA050900_H_
 # define SIGNATURES_DWA050900_H_
 
 # include "pyconfig.h"
 
-namespace py {
+namespace python {
 
 namespace detail {
 // A stand-in for the built-in void. This one can be passed to functions and
 // (under MSVC, which has a bug, be used as a default template type parameter).
-struct Void {};
+struct void_t {};
 }
 
 // An envelope in which type information can be delivered for the purposes
 // of selecting an overloaded from_python() function. This is needed to work
 // around MSVC's lack of partial specialiation/ordering. Where normally we'd
 // want to form a function call like void f<const T&>(), We instead pass
-// Type<const T&> as one of the function parameters to select a particular
+// type<const T&> as one of the function parameters to select a particular
 // overload.
 //
-// The Id typedef helps us deal with the lack of partial ordering by generating
-// unique types for constructor signatures. In general, Type<T>::Id is Type<T>,
-// but Type<Void>::Id is just Void.
+// The id typedef helps us deal with the lack of partial ordering by generating
+// unique types for constructor signatures. In general, type<T>::id is type<T>,
+// but type<void_t>::id is just void_t.
 template <class T>
-struct Type
+struct type
 {
-    typedef Type Id;
+    typedef type id;
 };
 
 template <>
-struct Type<py::detail::Void>
+struct type<python::detail::void_t>
 {
-    typedef py::detail::Void Id;
+    typedef python::detail::void_t id;
 };
 
 namespace detail {
 // These basically encapsulate a chain of types, , used to make the syntax of
-// add(Constructor<T1, ...>()) work. We need to produce a unique type for each number
-// of non-default parameters to Constructor<>.  Q: why not use a recursive
+// add(constructor<T1, ...>()) work. We need to produce a unique type for each number
+// of non-default parameters to constructor<>.  Q: why not use a recursive
 // formulation for infinite extensibility? A: MSVC6 seems to choke on constructs
 // that involve recursive template nesting.
 //
-// Signature chaining
+// signature chaining
 template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10>
 struct Signature10 {};
 
@@ -57,195 +57,195 @@ template <class T1, class T2, class T3, class T4, class T5, class T6, class T7,
 struct Signature9 {};
 
 template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class X>
-inline Signature10<X, T1, T2, T3, T4, T5, T6, T7, T8, T9> prepend(Type<X>, Signature9<T1, T2, T3, T4, T5, T6, T7, T8, T9>)
+inline Signature10<X, T1, T2, T3, T4, T5, T6, T7, T8, T9> prepend(type<X>, Signature9<T1, T2, T3, T4, T5, T6, T7, T8, T9>)
     { return Signature10<X, T1, T2, T3, T4, T5, T6, T7, T8, T9>(); }
 
 template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
 struct Signature8 {};
 
 template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class X>
-inline Signature9<X, T1, T2, T3, T4, T5, T6, T7, T8> prepend(Type<X>, Signature8<T1, T2, T3, T4, T5, T6, T7, T8>)
+inline Signature9<X, T1, T2, T3, T4, T5, T6, T7, T8> prepend(type<X>, Signature8<T1, T2, T3, T4, T5, T6, T7, T8>)
     { return Signature9<X, T1, T2, T3, T4, T5, T6, T7, T8>(); }
 
 template <class T1, class T2, class T3, class T4, class T5, class T6, class T7>
 struct Signature7 {};
 
 template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class X>
-inline Signature8<X, T1, T2, T3, T4, T5, T6, T7> prepend(Type<X>, Signature7<T1, T2, T3, T4, T5, T6, T7>)
+inline Signature8<X, T1, T2, T3, T4, T5, T6, T7> prepend(type<X>, Signature7<T1, T2, T3, T4, T5, T6, T7>)
     { return Signature8<X, T1, T2, T3, T4, T5, T6, T7>(); }
 
 template <class T1, class T2, class T3, class T4, class T5, class T6>
 struct Signature6 {};
 
 template <class T1, class T2, class T3, class T4, class T5, class T6, class X>
-inline Signature7<X, T1, T2, T3, T4, T5, T6> prepend(Type<X>, Signature6<T1, T2, T3, T4, T5, T6>)
+inline Signature7<X, T1, T2, T3, T4, T5, T6> prepend(type<X>, Signature6<T1, T2, T3, T4, T5, T6>)
     { return Signature7<X, T1, T2, T3, T4, T5, T6>(); }
 
 template <class T1, class T2, class T3, class T4, class T5>
-struct Signature5 {};
+struct signature5 {};
 
 template <class T1, class T2, class T3, class T4, class T5, class X>
-inline Signature6<X, T1, T2, T3, T4, T5> prepend(Type<X>, Signature5<T1, T2, T3, T4, T5>)
+inline Signature6<X, T1, T2, T3, T4, T5> prepend(type<X>, signature5<T1, T2, T3, T4, T5>)
     { return Signature6<X, T1, T2, T3, T4, T5>(); }
 
 template <class T1, class T2, class T3, class T4>
-struct Signature4 {};
+struct signature4 {};
 
 template <class T1, class T2, class T3, class T4, class X>
-inline Signature5<X, T1, T2, T3, T4> prepend(Type<X>, Signature4<T1, T2, T3, T4>)
-    { return Signature5<X, T1, T2, T3, T4>(); }
+inline signature5<X, T1, T2, T3, T4> prepend(type<X>, signature4<T1, T2, T3, T4>)
+    { return signature5<X, T1, T2, T3, T4>(); }
 
 template <class T1, class T2, class T3>
-struct Signature3 {};
+struct signature3 {};
 
 template <class T1, class T2, class T3, class X>
-inline Signature4<X, T1, T2, T3> prepend(Type<X>, Signature3<T1, T2, T3>)
-    { return Signature4<X, T1, T2, T3>(); }
+inline signature4<X, T1, T2, T3> prepend(type<X>, signature3<T1, T2, T3>)
+    { return signature4<X, T1, T2, T3>(); }
 
 template <class T1, class T2>
-struct Signature2 {};
+struct signature2 {};
 
 template <class T1, class T2, class X>
-inline Signature3<X, T1, T2> prepend(Type<X>, Signature2<T1, T2>)
-    { return Signature3<X, T1, T2>(); }
+inline signature3<X, T1, T2> prepend(type<X>, signature2<T1, T2>)
+    { return signature3<X, T1, T2>(); }
 
 template <class T1>
-struct Signature1 {};
+struct signature1 {};
 
 template <class T1, class X>
-inline Signature2<X, T1> prepend(Type<X>, Signature1<T1>)
-    { return Signature2<X, T1>(); }
+inline signature2<X, T1> prepend(type<X>, signature1<T1>)
+    { return signature2<X, T1>(); }
 
-struct Signature0 {};
+struct signature0 {};
 
 template <class X>
-inline Signature1<X> prepend(Type<X>, Signature0)
-    { return Signature1<X>(); }
+inline signature1<X> prepend(type<X>, signature0)
+    { return signature1<X>(); }
 
 
-// This one terminates the chain. Prepending Void to the head of a Void
-// signature results in a Void signature again.
-inline Signature0 prepend(Void, Signature0) { return Signature0(); }
+// This one terminates the chain. Prepending void_t to the head of a void_t
+// signature results in a void_t signature again.
+inline signature0 prepend(void_t, signature0) { return signature0(); }
 
 } // namespace detail
 
-template <class A1 = detail::Void, class A2 = detail::Void, class A3 = detail::Void, class A4 = detail::Void, class A5 = detail::Void, class A6 = detail::Void, class A7 = detail::Void, class A8 = detail::Void, class A9 = detail::Void, class A10 = detail::Void>
-struct Constructor
+template <class A1 = detail::void_t, class A2 = detail::void_t, class A3 = detail::void_t, class A4 = detail::void_t, class A5 = detail::void_t, class A6 = detail::void_t, class A7 = detail::void_t, class A8 = detail::void_t, class A9 = detail::void_t, class A10 = detail::void_t>
+struct constructor
 {
 };
 
 namespace detail {
 // Return value extraction:
 
-// This is just another little envelope for carrying a typedef (see Type,
-// above). I could have re-used Type, but that has a very specific purpose. I
+// This is just another little envelope for carrying a typedef (see type,
+// above). I could have re-used type, but that has a very specific purpose. I
 // thought this would be clearer.
 template <class T>
-struct ReturnValue { typedef T Type; };
+struct return_value_select { typedef T type; };
 
 // free functions
 template <class R>
-ReturnValue<R> return_value(R (*)()) { return ReturnValue<R>(); }
+return_value_select<R> return_value(R (*)()) { return return_value_select<R>(); }
 
 template <class R, class A1>
-ReturnValue<R> return_value(R (*)(A1)) { return ReturnValue<R>(); }
+return_value_select<R> return_value(R (*)(A1)) { return return_value_select<R>(); }
 
 template <class R, class A1, class A2>
-ReturnValue<R> return_value(R (*)(A1, A2)) { return ReturnValue<R>(); }
+return_value_select<R> return_value(R (*)(A1, A2)) { return return_value_select<R>(); }
 
 template <class R, class A1, class A2, class A3>
-ReturnValue<R> return_value(R (*)(A1, A2, A3)) { return ReturnValue<R>(); }
+return_value_select<R> return_value(R (*)(A1, A2, A3)) { return return_value_select<R>(); }
 
 template <class R, class A1, class A2, class A3, class A4>
-ReturnValue<R> return_value(R (*)(A1, A2, A3, A4)) { return ReturnValue<R>(); }
+return_value_select<R> return_value(R (*)(A1, A2, A3, A4)) { return return_value_select<R>(); }
 
 template <class R, class A1, class A2, class A3, class A4, class A5>
-ReturnValue<R> return_value(R (*)(A1, A2, A3, A4, A5)) { return ReturnValue<R>(); }
+return_value_select<R> return_value(R (*)(A1, A2, A3, A4, A5)) { return return_value_select<R>(); }
 
 template <class R, class A1, class A2, class A3, class A4, class A5, class A6>
-ReturnValue<R> return_value(R (*)(A1, A2, A3, A4, A5, A6)) { return ReturnValue<R>(); }
+return_value_select<R> return_value(R (*)(A1, A2, A3, A4, A5, A6)) { return return_value_select<R>(); }
 
 template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-ReturnValue<R> return_value(R (*)(A1, A2, A3, A4, A5, A6, A7)) { return ReturnValue<R>(); }
+return_value_select<R> return_value(R (*)(A1, A2, A3, A4, A5, A6, A7)) { return return_value_select<R>(); }
 
 template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-ReturnValue<R> return_value(R (*)(A1, A2, A3, A4, A5, A6, A7, A8)) { return ReturnValue<R>(); }
+return_value_select<R> return_value(R (*)(A1, A2, A3, A4, A5, A6, A7, A8)) { return return_value_select<R>(); }
 
 template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-ReturnValue<R> return_value(R (*)(A1, A2, A3, A4, A5, A6, A7, A8, A9)) { return ReturnValue<R>(); }
+return_value_select<R> return_value(R (*)(A1, A2, A3, A4, A5, A6, A7, A8, A9)) { return return_value_select<R>(); }
 
 template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
-ReturnValue<R> return_value(R (*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)) { return ReturnValue<R>(); }
+return_value_select<R> return_value(R (*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)) { return return_value_select<R>(); }
 
 // TODO(?): handle 'const void'
 
 // member functions
 template <class R, class T>
-ReturnValue<R> return_value(R (T::*)()) { return ReturnValue<R>(); }
+return_value_select<R> return_value(R (T::*)()) { return return_value_select<R>(); }
 
 template <class R, class T, class A1>
-ReturnValue<R> return_value(R (T::*)(A1)) { return ReturnValue<R>(); }
+return_value_select<R> return_value(R (T::*)(A1)) { return return_value_select<R>(); }
 
 template <class R, class T, class A1, class A2>
-ReturnValue<R> return_value(R (T::*)(A1, A2)) { return ReturnValue<R>(); }
+return_value_select<R> return_value(R (T::*)(A1, A2)) { return return_value_select<R>(); }
 
 template <class R, class T, class A1, class A2, class A3>
-ReturnValue<R> return_value(R (T::*)(A1, A2, A3)) { return ReturnValue<R>(); }
+return_value_select<R> return_value(R (T::*)(A1, A2, A3)) { return return_value_select<R>(); }
 
 template <class R, class T, class A1, class A2, class A3, class A4>
-ReturnValue<R> return_value(R (T::*)(A1, A2, A3, A4)) { return ReturnValue<R>(); }
+return_value_select<R> return_value(R (T::*)(A1, A2, A3, A4)) { return return_value_select<R>(); }
 
 template <class R, class T, class A1, class A2, class A3, class A4, class A5>
-ReturnValue<R> return_value(R (T::*)(A1, A2, A3, A4, A5)) { return ReturnValue<R>(); }
+return_value_select<R> return_value(R (T::*)(A1, A2, A3, A4, A5)) { return return_value_select<R>(); }
 
 template <class R, class T, class A1, class A2, class A3, class A4, class A5, class A6>
-ReturnValue<R> return_value(R (T::*)(A1, A2, A3, A4, A5, A6)) { return ReturnValue<R>(); }
+return_value_select<R> return_value(R (T::*)(A1, A2, A3, A4, A5, A6)) { return return_value_select<R>(); }
 
 template <class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-ReturnValue<R> return_value(R (T::*)(A1, A2, A3, A4, A5, A6, A7)) { return ReturnValue<R>(); }
+return_value_select<R> return_value(R (T::*)(A1, A2, A3, A4, A5, A6, A7)) { return return_value_select<R>(); }
 
 template <class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-ReturnValue<R> return_value(R (T::*)(A1, A2, A3, A4, A5, A6, A7, A8)) { return ReturnValue<R>(); }
+return_value_select<R> return_value(R (T::*)(A1, A2, A3, A4, A5, A6, A7, A8)) { return return_value_select<R>(); }
 
 template <class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-ReturnValue<R> return_value(R (T::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9)) { return ReturnValue<R>(); }
+return_value_select<R> return_value(R (T::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9)) { return return_value_select<R>(); }
 
 template <class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
-ReturnValue<R> return_value(R (T::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)) { return ReturnValue<R>(); }
+return_value_select<R> return_value(R (T::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)) { return return_value_select<R>(); }
 
 template <class R, class T>
-ReturnValue<R> return_value(R (T::*)() const) { return ReturnValue<R>(); }
+return_value_select<R> return_value(R (T::*)() const) { return return_value_select<R>(); }
 
 template <class R, class T, class A1>
-ReturnValue<R> return_value(R (T::*)(A1) const) { return ReturnValue<R>(); }
+return_value_select<R> return_value(R (T::*)(A1) const) { return return_value_select<R>(); }
 
 template <class R, class T, class A1, class A2>
-ReturnValue<R> return_value(R (T::*)(A1, A2) const) { return ReturnValue<R>(); }
+return_value_select<R> return_value(R (T::*)(A1, A2) const) { return return_value_select<R>(); }
 
 template <class R, class T, class A1, class A2, class A3>
-ReturnValue<R> return_value(R (T::*)(A1, A2, A3) const) { return ReturnValue<R>(); }
+return_value_select<R> return_value(R (T::*)(A1, A2, A3) const) { return return_value_select<R>(); }
 
 template <class R, class T, class A1, class A2, class A3, class A4>
-ReturnValue<R> return_value(R (T::*)(A1, A2, A3, A4) const) { return ReturnValue<R>(); }
+return_value_select<R> return_value(R (T::*)(A1, A2, A3, A4) const) { return return_value_select<R>(); }
 
 template <class R, class T, class A1, class A2, class A3, class A4, class A5>
-ReturnValue<R> return_value(R (T::*)(A1, A2, A3, A4, A5) const) { return ReturnValue<R>(); }
+return_value_select<R> return_value(R (T::*)(A1, A2, A3, A4, A5) const) { return return_value_select<R>(); }
 
 template <class R, class T, class A1, class A2, class A3, class A4, class A5, class A6>
-ReturnValue<R> return_value(R (T::*)(A1, A2, A3, A4, A5, A6) const) { return ReturnValue<R>(); }
+return_value_select<R> return_value(R (T::*)(A1, A2, A3, A4, A5, A6) const) { return return_value_select<R>(); }
 
 template <class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-ReturnValue<R> return_value(R (T::*)(A1, A2, A3, A4, A5, A6, A7) const) { return ReturnValue<R>(); }
+return_value_select<R> return_value(R (T::*)(A1, A2, A3, A4, A5, A6, A7) const) { return return_value_select<R>(); }
 
 template <class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-ReturnValue<R> return_value(R (T::*)(A1, A2, A3, A4, A5, A6, A7, A8) const) { return ReturnValue<R>(); }
+return_value_select<R> return_value(R (T::*)(A1, A2, A3, A4, A5, A6, A7, A8) const) { return return_value_select<R>(); }
 
 template <class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-ReturnValue<R> return_value(R (T::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9) const) { return ReturnValue<R>(); }
+return_value_select<R> return_value(R (T::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9) const) { return return_value_select<R>(); }
 
 template <class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
-ReturnValue<R> return_value(R (T::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) const) { return ReturnValue<R>(); }
+return_value_select<R> return_value(R (T::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) const) { return return_value_select<R>(); }
 
-}} // namespace py::detail
+}} // namespace python::detail
 
 #endif
diff --git a/singleton.h b/singleton.h
index 2dc8051d..ccbcc1e6 100644
--- a/singleton.h
+++ b/singleton.h
@@ -11,58 +11,58 @@
 
 # include "pyconfig.h"
 
-namespace py { namespace detail {
+namespace python { namespace detail {
 
-struct Empty {};
-template <class Derived, class Base = Empty>
-struct Singleton : Base
+struct empty {};
+template <class Derived, class Base = empty>
+struct singleton : Base
 {
-    typedef Singleton SingletonBase; // Convenience type for derived class constructors
+    typedef singleton singleton_base; // Convenience type for derived class constructors
     
-    static Derived* singleton();
+    static Derived* instance();
 
     // Pass-through constructors
-    Singleton() : Base() {}
+    singleton() : Base() {}
 
     template <class A1>
-    Singleton(const A1& a1) : Base(a1) {}
+    singleton(const A1& a1) : Base(a1) {}
 
     template <class A1, class A2>
-    Singleton(const A1& a1, const A2& a2) : Base(a1, a2) {}
+    singleton(const A1& a1, const A2& a2) : Base(a1, a2) {}
 
     template <class A1, class A2, class A3>
-    Singleton(const A1& a1, const A2& a2, const A3& a3) : Base(a1, a2, a3) {}
+    singleton(const A1& a1, const A2& a2, const A3& a3) : Base(a1, a2, a3) {}
 
     template <class A1, class A2, class A3, class A4>
-    Singleton(const A1& a1, const A2& a2, const A3& a3, const A4& a4) : Base(a1, a2, a3, a4) {}
+    singleton(const A1& a1, const A2& a2, const A3& a3, const A4& a4) : Base(a1, a2, a3, a4) {}
 
     template <class A1, class A2, class A3, class A4, class A5>
-    Singleton(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5) : Base(a1, a2, a3, a4, a5) {}
+    singleton(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5) : Base(a1, a2, a3, a4, a5) {}
 
     template <class A1, class A2, class A3, class A4, class A5, class A6>
-    Singleton(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6) : Base(a1, a2, a3, a4, a5, a6) {}
+    singleton(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6) : Base(a1, a2, a3, a4, a5, a6) {}
 
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-    Singleton(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7) : Base(a1, a2, a3, a4, a5, a6, a7) {}
+    singleton(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7) : Base(a1, a2, a3, a4, a5, a6, a7) {}
 
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-    Singleton(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8) : Base(a1, a2, a3, a4, a5, a6, a7, a8) {}
+    singleton(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8) : Base(a1, a2, a3, a4, a5, a6, a7, a8) {}
 
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-    Singleton(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9) : Base(a1, a2, a3, a4, a5, a6, a7, a8, a9) {}
+    singleton(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9) : Base(a1, a2, a3, a4, a5, a6, a7, a8, a9) {}
 
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
-    Singleton(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9, const A10& a10) : Base(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {}
+    singleton(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9, const A10& a10) : Base(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {}
 
 };
 
 template <class Derived, class Base>
-Derived* Singleton<Derived,Base>::singleton()
+Derived* singleton<Derived,Base>::instance()
 {
     static Derived x;
     return &x;
 }
 
-}} // namespace py::detail
+}} // namespace python::detail
 
 #endif
diff --git a/special.html b/special.html
index fbdd301a..76c521cc 100644
--- a/special.html
+++ b/special.html
@@ -52,7 +52,9 @@ Python provides a number of special operatos for basic customization of a class:
 <p>
 </dl>
 
-If we have a suitable C++ function that supports any of these features, we can export it like any other function, using its Python special name. For example, suppose that class <code>Foo</code> provides a string conversion function:
+If we have a suitable C++ function that supports any of these features, we can
+export it like any other function, using its Python special name. For example,
+suppose that class <code>Foo</code> provides a string conversion function:
 
 <pre>
     std::string to_string(Foo const &amp; f)
@@ -66,17 +68,23 @@ If we have a suitable C++ function that supports any of these features, we can e
 This function would be wrapped like this:
 
 <pre>
-    py::ClassWrapper&lt:Foo&gt; foo_class(my_module, "Foo");
+    python::class_builder&lt:Foo&gt; foo_class(my_module, "Foo");
     foo_class.def(&amp;to_string, "__str__");
 </pre>
 
-Note that py_cpp also supports <em>automatic wrapping</em> in case of __str__ and __cmp__. This is explained in the <a href="#numeric">next section</a> and the <a href="#numeric_table">table of numeric operators</a>. 
+Note that py_cpp also supports <em>automatic wrapping</em> in case of __str__
+and __cmp__. This is explained in the <a href="#numeric">next section</a> and
+the <a href="#numeric_table">table of numeric operators</a>.
 
 <a name="numeric">
 <h2>Numeric Operators</h2>
 </a>
 
-There are two fundamental ways to define numeric operators within py_cpp: manual wrapping (as is done with <a href="#general">general operators</a>) and automatic wrapping. Lets start with the second possibility. Suppose, C++ defines a class <code>Int</code> (which might represent an infinite-precision integer) which support addition, so that we can write (in C++):
+There are two fundamental ways to define numeric operators within py_cpp: manual
+wrapping (as is done with <a href="#general">general operators</a>) and
+automatic wrapping. Lets start with the second possibility. Suppose, C++ defines
+a class <code>Int</code> (which might represent an infinite-precision integer)
+which support addition, so that we can write (in C++):
 
 <pre>
     Int a, b, c;
@@ -87,24 +95,30 @@ There are two fundamental ways to define numeric operators within py_cpp: manual
 To enable the same functionality in Python, we first wrap the <code>Int</code> class as usual:
 
 <pre>
-    py::ClassWrapper&lt;Int&gt; int_class(my_module, "Int");
-    int_class.def(py::Constructor&lt;&gt;());
+    python::class_builder&lt;Int&gt; int_class(my_module, "Int");
+    int_class.def(python::constructor&lt;&gt;());
     ...
 </pre>
 
 Then we export the addition operator like this:
 
 <pre>
-    int_class.def(py::operators&lt;py::op_add&gt;());
+    int_class.def(python::operators&lt;python::op_add&gt;());
 </pre>
 
-Since Int also supports subtraction, multiplication, adn division, we want to export those also. This can be done in a single command by 'or'ing the operator identifiers together (a complete list of these identifiers and the corresponding operators can be found in the <a href="#numeric_table">table</a>):
+Since Int also supports subtraction, multiplication, adn division, we want to
+export those also. This can be done in a single command by 'or'ing the operator
+identifiers together (a complete list of these identifiers and the corresponding
+operators can be found in the <a href="#numeric_table">table</a>):
 
 <pre>
-    int_class.def(py::operators&lt;(py::op_sub | py::op_mul | py::op_div)&gt;());
+    int_class.def(python::operators&lt;(python::op_sub | python::op_mul | python::op_div)&gt;());
 </pre>
 
-Note that the or-expression must be enclosed in parentheses. This form of operator definition will wrap homogeneous operators, i.e. operators whose left and right operand have the same type. Now, suppose that our C++ library also supports addition of Ints and plain integers:
+Note that the or-expression must be enclosed in parentheses. This form of
+operator definition will wrap homogeneous operators, i.e. operators whose left
+and right operand have the same type. Now, suppose that our C++ library also
+supports addition of Ints and plain integers:
 
 <pre>
     Int a, b;
@@ -114,37 +128,56 @@ Note that the or-expression must be enclosed in parentheses. This form of operat
     a = i + b;
 </pre>
 
-To wrap these heterogeneous operators (left and right hand side have different types), we need a possibility to specify a different type for one of the operands. This is done using the <code>right_operand</code> and <code>left_operand</code> templates:
+To wrap these heterogeneous operators (left and right hand side have different
+types), we need a possibility to specify a different type for one of the
+operands. This is done using the <code>right_operand</code> and
+<code>left_operand</code> templates:
 
 <pre>
-    int_class.def(py::operators&lt;py::op_add&gt;(), py::right_operand&lt;int&gt;());
-    int_class.def(py::operators&lt;py::op_add&gt;(), py::left_operand&lt;int&gt;());
+    int_class.def(python::operators&lt;python::op_add&gt;(), python::right_operand&lt;int&gt;());
+    int_class.def(python::operators&lt;python::op_add&gt;(), python::left_operand&lt;int&gt;());
 </pre>
 
-Py_cpp uses overloading to register several variants of the same operation (more on this in the context of <a href="#coercion">coercion</a>). Again, several operators can be exported at once:
+Py_cpp uses overloading to register several variants of the same operation (more
+on this in the context of <a href="#coercion">coercion</a>). Again, several
+operators can be exported at once:
 
 <pre>
-    int_class.def(py::operators&lt;(py::op_sub | py::op_mul | py::op_div)&gt;(),
-                       py::right_operand&lt;int&gt;());
-    int_class.def(py::operators&lt;(py::op_sub | py::op_mul | py::op_div)&gt;(), 
-                       py::left_operand&lt;int&gt;());
+    int_class.def(python::operators&lt;(python::op_sub | python::op_mul | python::op_div)&gt;(),
+                       python::right_operand&lt;int&gt;());
+    int_class.def(python::operators&lt;(python::op_sub | python::op_mul | python::op_div)&gt;(), 
+                       python::left_operand&lt;int&gt;());
 </pre>
 
 
-The type of the operand not mentioned is taken from the class object. In our example, the class object is <code>int_class</code>, and thus the other operand's type is `<code>Int const &amp;</code>'. You can override this default by explicitly specifying a type in the <code>operators</code> template:
+The type of the operand not mentioned is taken from the class object. In our
+example, the class object is <code>int_class</code>, and thus the other
+operand's type is `<code>Int const &amp;</code>'. You can override this default
+by explicitly specifying a type in the <code>operators</code> template:
 
 <pre>
-    int_class.def(py::operators&lt;py::op_add, Int&gt;(), py::right_operand&lt;int&gt;());
+    int_class.def(python::operators&lt;python::op_add, Int&gt;(), python::right_operand&lt;int&gt;());
 </pre>
 
 Here, `<code>Int</code>' would be used instead of `<code>Int const &amp;</code>'. 
+
 <p>
-Note that automatic wrapping doesn't need any specific form of <code>operator+()</code> (or one of the other operators), but rather wraps the <em>expression</em> `<code>left + right</code>'. That is, this mechanism can be used for any definition of <code>operator+()</code>, such as a free function `<code>Int operator+(Int, Int)</code>' or a member function `<code>Int Int::operator+(Int)</code>'.
+Note that automatic wrapping doesn't need any specific form of
+<code>operator+()</code> (or one of the other operators), but rather wraps the
+<em>expression</em> `<code>left + right</code>'. That is, this mechanism can be
+used for any definition of <code>operator+()</code>, such as a free function
+`<code>Int operator+(Int, Int)</code>' or a member function `<code>Int
+Int::operator+(Int)</code>'.
+
 <p>
-For the Python operators <code>pow()</code> and <code>abs()</code>, there is no corresponding C++ operator. Instead, automatic wrapping attempts to wrap C++ functions of the same name. This only works if those functions are known in namespace <code>py::detail</code>. Thus it might be necessary to add a using declaration prior to wrapping:
+For the Python operators <code>pow()</code> and <code>abs()</code>, there is no
+corresponding C++ operator. Instead, automatic wrapping attempts to wrap C++
+functions of the same name. This only works if those functions are known in
+namespace <code>python::detail</code>. Thus it might be necessary to add a using
+declaration prior to wrapping:
 
 <pre>
-    namespace py { 
+    namespace python { 
       namespace detail {
         using my_namespace::pow;
         using my_namespace::abs;
@@ -153,7 +186,10 @@ For the Python operators <code>pow()</code> and <code>abs()</code>, there is no
 
 
 <p>
-In some cases, automatic wrapping of operators is not possible or not desirable. Suppose, for example, that the modulo operation for Ints is defined by a set of functions <code>mod()</code> (for automatic wrapping, we would need <code>operator%()</code>):
+In some cases, automatic wrapping of operators is not possible or not
+desirable. Suppose, for example, that the modulo operation for Ints is defined
+by a set of functions <code>mod()</code> (for automatic wrapping, we would need
+<code>operator%()</code>):
 
 <pre>
     Int mod(Int const &amp; left, Int const &amp; right);
@@ -168,7 +204,9 @@ In order to create the Python operator "__mod__" from these functions, we have t
     int_class.def((Int (*)(Int const &amp;, int))&amp;mod, "__mod__");
 </pre>
 
-The third form (with <code>int</code> as left operand) cannot be wrapped this way. We must first create a function <code>rmod()</code> with the operands reversed:
+The third form (with <code>int</code> as left operand) cannot be wrapped this
+way. We must first create a function <code>rmod()</code> with the operands
+reversed:
 
 <pre>
     Int rmod(Int const &amp; right, int left)
@@ -186,41 +224,70 @@ This function must be wrapped under the name "__rmod__":
 A list of the possible operator names is also found in the <a href="#numeric_table">table</a>.
 Special treatment is necessary to export the <a href="#ternary_pow">ternary pow</a> operator.
 <p>
-Automatic and manual wrapping can be mixed arbitrarily. Note that you cannot overload the same operator for a given extension class on both `<code>int</code>' and `<code>float</code>', because Python implicitly converts these types into each other. Thus, the overloaded variant found first (be it `<code>int</code>' or `<code>float</code>') will be used for either of the two types.
+Automatic and manual wrapping can be mixed arbitrarily. Note that you cannot
+overload the same operator for a given extension class on both
+`<code>int</code>' and `<code>float</code>', because Python implicitly converts
+these types into each other. Thus, the overloaded variant found first (be it
+`<code>int</code>' or `<code>float</code>') will be used for either of the two
+types.
 
 <a name="coercion">
 <h4>Coercion</h4></a>
 
-Plain Python can only execute operators with identical types on the left and right hand side. If it encounters an expression where the types of the left and right operand differ, it tries to coerce these type to a common type before invoking the actual operator. Implementing good coercion functions can be difficult if many type combinations must be supported.
+Plain Python can only execute operators with identical types on the left and
+right hand side. If it encounters an expression where the types of the left and
+right operand differ, it tries to coerce these type to a common type before
+invoking the actual operator. Implementing good coercion functions can be
+difficult if many type combinations must be supported.
 <p>
-In contrast, py_cpp provides <em><a href="overloading.html">overloading</a></em>. By means of overloading, operator calling can be simplyfied drastically: you just register operators for all desired type combinations, and py_cpp automatically ensures that the correct function is called in each case. User defined coercion functions are <em>not necessary</em>. To enable operator overloading, py_cpp provides a standard coercion which is <em>implicitly registered</em> whenever automatic operator wrapping is used. 
+In contrast, py_cpp provides <em><a
+href="overloading.html">overloading</a></em>. By means of overloading, operator
+calling can be simplyfied drastically: you just register operators for all
+desired type combinations, and py_cpp automatically ensures that the correct
+function is called in each case. User defined coercion functions are <em>not
+necessary</em>. To enable operator overloading, py_cpp provides a standard
+coercion which is <em>implicitly registered</em> whenever automatic operator
+wrapping is used.
 <p>
-If you wrap all operator functions manually, but still want to use operator overloading, you have to register the standard coercion function explicitly:
+If you wrap all operator functions manually, but still want to use operator
+overloading, you have to register the standard coercion function explicitly:
 
 <pre>
     // this is not necessary if automatic operator wrapping is used
     int_class.def_standard_coerce();
 </pre>
 
-In case you encounter a situation where you absolutely need a customized coercion, you can overload the "__coerce__" operator itself. The signature of a coercion function must look like this:
+In case you encounter a situation where you absolutely need a customized
+coercion, you can overload the "__coerce__" operator itself. The signature of a
+coercion function must look like this:
 
 <pre>
-    py::Tuple custom_coerce(PyObject * left, PyObject * right);
+    python::tuple custom_coerce(PyObject * left, PyObject * right);
 </pre>
 
-The resulting <code>Tuple</code> must contain two elements which represent the values of <code>left</code> and <code>right</code> converted to the same type. Such a function is wrapped as usual:
+The resulting <code>tuple</code> must contain two elements which represent the
+values of <code>left</code> and <code>right</code> converted to the same
+type. Such a function is wrapped as usual:
 
 <pre>
     some_class.def(&amp;custom_coerce, "__coerce__");
 </pre>
 
-Note that the custom coercion function is only used if it is defined <em>before</em> any automatic operator wrapping on the given class or a call to `<code>some_class.def_standard_coerce()</code>'.
+Note that the custom coercion function is only used if it is defined
+<em>before</em> any automatic operator wrapping on the given class or a call to
+`<code>some_class.def_standard_coerce()</code>'.
 
 
 <a name="ternary_pow">
 <h4>The Ternary <code>pow()</code> Operator</h4></a>
 
-In addition to the usual binary <code>pow()</code>-operator (meaning <code>x^y</code>), Python also provides a ternary variant that implements <code>(x^y) % z</code> (presumably using a more efficient algorithm than concatenation of power and modulo operators). Automatic operator wrapping can only be used with the binary variant. Ternary <code>pow()</code> must always be wrapped manually. For a homgeneous ternary <code>pow()</code>, this is done as usual:
+In addition to the usual binary <code>pow()</code>-operator (meaning
+<code>x^y</code>), Python also provides a ternary variant that implements
+<code>(x^y) % z</code> (presumably using a more efficient algorithm than
+concatenation of power and modulo operators). Automatic operator wrapping can
+only be used with the binary variant. Ternary <code>pow()</code> must always be
+wrapped manually. For a homgeneous ternary <code>pow()</code>, this is done as
+usual:
 
 <pre>
     Int power(Int const &amp; first, Int const &amp; second, Int const &amp; module);
@@ -229,7 +296,8 @@ In addition to the usual binary <code>pow()</code>-operator (meaning <code>x^y</
     int_class.def((ternary_function1)&amp;power,  "__pow__");
 </pre>
 
-In case you want to support this function with non-uniform argument types, wrapping is a little more involved. Suppose, you have to wrap:
+In case you want to support this function with non-uniform argument types,
+wrapping is a little more involved. Suppose, you have to wrap:
 
 <pre>
     Int power(Int const &amp; first, int second, int module);
@@ -244,7 +312,10 @@ The first variant can be wrapped as usual:
     int_class.def((ternary_function2)&amp;power,  "__pow__");
 </pre>
 
-In the second variant, however, <code>Int</code> appears only as second argument, and in the last one it is the third argument. Therefor we must first provide functions where the argumant order is changed so that <code>Int</code> appears in first place:
+In the second variant, however, <code>Int</code> appears only as second
+argument, and in the last one it is the third argument. Therefor we must first
+provide functions where the argumant order is changed so that <code>Int</code>
+appears in first place:
 
 <pre>
     Int rpower(Int const &amp; second, int first, int module)
@@ -286,16 +357,16 @@ Note that "__rrpow__" is an extension not present in plain Python.
               <b>C++ Operator Id</b>
             <td align=center>
               <b>C++ Expression Used For Automatic Wrapping</b><br>
-              with <code>cpp_left = from_python(left, Type&lt;Left&gt;())</code>,<br>
-               <code>cpp_right = from_python(right, Type&lt;Right&gt;())</code>,<br>
-               and <code>cpp_oper = from_python(oper, Type&lt;Oper&gt;())</code>
+              with <code>cpp_left = from_python(left, type&lt;Left&gt;())</code>,<br>
+               <code>cpp_right = from_python(right, type&lt;Right&gt;())</code>,<br>
+               and <code>cpp_oper = from_python(oper, type&lt;Oper&gt;())</code>
           <tr>
             <td>
               <code>__add__, __radd__</code>
             <td>
               <code>left + right</code>
             <td>
-              <code>py::op_add</code>
+              <code>python::op_add</code>
             <td>
               <code>cpp_left + cpp_right</code>
           <tr>
@@ -304,7 +375,7 @@ Note that "__rrpow__" is an extension not present in plain Python.
             <td>
               <code>left - right</code>
             <td>
-              <code>py::op_sub</code>
+              <code>python::op_sub</code>
             <td>
               <code>cpp_left - cpp_right</code>
           <tr>
@@ -313,7 +384,7 @@ Note that "__rrpow__" is an extension not present in plain Python.
             <td>
               <code>left * right</code>
             <td>
-              <code>py::op_mul</code>
+              <code>python::op_mul</code>
             <td>
               <code>cpp_left * cpp_right</code>
           <tr>
@@ -322,7 +393,7 @@ Note that "__rrpow__" is an extension not present in plain Python.
             <td>
               <code>left / right</code>
             <td>
-              <code>py::op_div</code>
+              <code>python::op_div</code>
             <td>
               <code>cpp_left / cpp_right</code>
           <tr>
@@ -331,7 +402,7 @@ Note that "__rrpow__" is an extension not present in plain Python.
             <td>
               <code>left % right</code>
             <td>
-              <code>py::op_mod</code>
+              <code>python::op_mod</code>
             <td>
               <code>cpp_left % cpp_right</code>
           <tr>
@@ -340,7 +411,7 @@ Note that "__rrpow__" is an extension not present in plain Python.
             <td>
               <code>(quotient, remainder) <br>= divmod(left, right)</code>
             <td>
-              <code>py::op_divmod</code>
+              <code>python::op_divmod</code>
             <td>
               <code>cpp_left / cpp_right&nbsp;</code> and 
               <code>&nbsp;cpp_left % cpp_right</code>
@@ -351,7 +422,7 @@ Note that "__rrpow__" is an extension not present in plain Python.
               <code>pow(left, right)</code><br>
               (binary power)
             <td>
-              <code>py::op_pow</code>
+              <code>python::op_pow</code>
             <td>
               <code>pow(cpp_left, cpp_right)</code>
           <tr>
@@ -368,7 +439,7 @@ Note that "__rrpow__" is an extension not present in plain Python.
             <td>
               <code>left &lt;&lt; right</code>
             <td>
-              <code>py::op_lshift</code>
+              <code>python::op_lshift</code>
             <td>
               <code>cpp_left &lt;&lt; cpp_right</code>
           <tr>
@@ -377,7 +448,7 @@ Note that "__rrpow__" is an extension not present in plain Python.
             <td>
               <code>left &gt;&gt; right</code>
             <td>
-              <code>py::op_rshift</code>
+              <code>python::op_rshift</code>
             <td>
               <code>cpp_left &gt;&gt; cpp_right</code>
           <tr>
@@ -386,7 +457,7 @@ Note that "__rrpow__" is an extension not present in plain Python.
             <td>
               <code>left &amp; right</code>
             <td>
-              <code>py::op_and</code>
+              <code>python::op_and</code>
             <td>
               <code>cpp_left &amp; cpp_right</code>
           <tr>
@@ -395,7 +466,7 @@ Note that "__rrpow__" is an extension not present in plain Python.
             <td>
               <code>left ^ right</code>
             <td>
-              <code>py::op_xor</code>
+              <code>python::op_xor</code>
             <td>
               <code>cpp_left ^ cpp_right</code>
           <tr>
@@ -404,7 +475,7 @@ Note that "__rrpow__" is an extension not present in plain Python.
             <td>
               <code>left | right</code>
             <td>
-              <code>py::op_or</code>
+              <code>python::op_or</code>
             <td>
               <code>cpp_left | cpp_right</code>
           <tr>
@@ -418,7 +489,7 @@ Note that "__rrpow__" is an extension not present in plain Python.
               <code>left &gt;= right</code><br>
               <code>left == right</code>
             <td>
-              <code>py::op_cmp</code>
+              <code>python::op_cmp</code>
             <td>
               <code>cpp_left &lt; cpp_right&nbsp</code> and <code>&nbsp;cpp_right &lt; cpp_left</code>
           <tr>
@@ -427,7 +498,7 @@ Note that "__rrpow__" is an extension not present in plain Python.
             <td>
               <code>-oper&nbsp</code> (unary negation)
             <td>
-              <code>py::op_neg</code>
+              <code>python::op_neg</code>
             <td>
               <code>-cpp_oper</code>
           <tr>
@@ -436,7 +507,7 @@ Note that "__rrpow__" is an extension not present in plain Python.
             <td>
               <code>+oper&nbsp</code> (identity)
             <td>
-              <code>py::op_pos</code>
+              <code>python::op_pos</code>
             <td>
               <code>+cpp_oper</code>
           <tr>
@@ -445,7 +516,7 @@ Note that "__rrpow__" is an extension not present in plain Python.
             <td>
               <code>abs(oper)&nbsp</code> (absolute value)
             <td>
-              <code>py::op_abs</code>
+              <code>python::op_abs</code>
             <td>
               <code>abs(cpp_oper)</code>
           <tr>
@@ -454,7 +525,7 @@ Note that "__rrpow__" is an extension not present in plain Python.
             <td>
               <code>~oper&nbsp</code> (bitwise inversion)
             <td>
-              <code>py::op_invert</code>
+              <code>python::op_invert</code>
             <td>
               <code>~cpp_oper</code>
           <tr>
@@ -463,7 +534,7 @@ Note that "__rrpow__" is an extension not present in plain Python.
             <td>
               <code>int(oper)&nbsp</code> (integer conversion)
             <td>
-              <code>py::op_int</code>
+              <code>python::op_int</code>
             <td>
               <code>long(cpp_oper)</code>
           <tr>
@@ -472,7 +543,7 @@ Note that "__rrpow__" is an extension not present in plain Python.
             <td>
               <code>long(oper)&nbsp</code><br> (infinite precision integer conversion)
             <td>
-              <code>py::op_long</code>
+              <code>python::op_long</code>
             <td>
               <code>PyLong_FromLong(cpp_oper)</code>
           <tr>
@@ -481,7 +552,7 @@ Note that "__rrpow__" is an extension not present in plain Python.
             <td>
               <code>float(oper)&nbsp</code> (float conversion)
             <td>
-              <code>py::op_float</code>
+              <code>python::op_float</code>
             <td>
               <code>double(cpp_oper)</code>
           <tr>
@@ -504,7 +575,7 @@ Note that "__rrpow__" is an extension not present in plain Python.
             <td>
               <code>str(oper)&nbsp</code> (string conversion)
             <td>
-              <code>py::op_str</code>
+              <code>python::op_str</code>
             <td>
               <code>std::ostringstream s; s &lt;&lt; oper;</code>
           <tr>
@@ -521,11 +592,31 @@ Note that "__rrpow__" is an extension not present in plain Python.
 <h2>Sequence and Mapping Operators</h2>
 </a>
 
-Sequence and mapping operators let wrapped objects behave in accordance to Python's iteration and access protocols. These protocols differ considerably from the ones found in C++. For example, Python's typically iteration idiom looks like &nbsp;"<code>for i in S:</code>"&nbsp;, while in C++ one uses &nbsp;"<code>for(iterator i = S.begin(); i != S.end(); ++i)</code>". One could try to wrap C++ iterators in order to carry the C++ idiom into Python. However, this does not work very well because (1) it leads to non-uniform Python code (wrapped types must be used in a different way than Python built-in types) and (2) iterators are often implemented as plain C++ pointers which cannot be wrapped easily because py_cpp is designed to handle objects only. 
+Sequence and mapping operators let wrapped objects behave in accordance to
+Python's iteration and access protocols. These protocols differ considerably
+from the ones found in C++. For example, Python's typically iteration idiom
+looks like &nbsp;"<code>for i in S:</code>"&nbsp;, while in C++ one uses
+&nbsp;"<code>for(iterator i = S.begin(); i != S.end(); ++i)</code>". One could
+try to wrap C++ iterators in order to carry the C++ idiom into Python. However,
+this does not work very well because (1) it leads to non-uniform Python code
+(wrapped types must be used in a different way than Python built-in types) and
+(2) iterators are often implemented as plain C++ pointers which cannot be
+wrapped easily because py_cpp is designed to handle objects only.
+
 <p>
-Thus, it is a good idea to provide sequence and mapping operators for your wrapped containers. These operators have to be wrapped manually because there are no corresponding C++ operators that could be used for automatic wrapping. The Python documentation lists the relevant <a href="http://www.pythonlabs.com/pub/www.python.org/doc/current/ref/sequence-types.html">container operators</a>. In particular, expose __getitem__, __setitem__ and remember to throw the <code>PyExc_IndexError</code> when the index is out-of-range in order to enable the &nbsp;"<code>for i in S:</code>"&nbsp; idiom.
+Thus, it is a good idea to provide sequence and mapping operators for your
+wrapped containers. These operators have to be wrapped manually because there
+are no corresponding C++ operators that could be used for automatic
+wrapping. The Python documentation lists the relevant <a
+href="http://www.pythonlabs.com/pub/www.python.org/doc/current/ref/sequence-types.html">container
+operators</a>. In particular, expose __getitem__, __setitem__ and remember to
+throw the <code>PyExc_IndexError</code> when the index is out-of-range in order
+to enable the &nbsp;"<code>for i in S:</code>"&nbsp; idiom.
+
 <p>
-Here is an example. Suppose you, we want to wrap a <code>std::map&lt;std::size_t,std::string&gt;</code>. This is done as follows as follows:
+Here is an example. Suppose you, we want to wrap a
+<code>std::map&lt;std::size_t,std::string&gt;</code>. This is done as follows as
+follows:
 
       <blockquote>
 <pre>
@@ -540,8 +631,8 @@ void throw_key_error_if_end(
 {
     if (p == m.end())
     {
-        PyErr_SetObject(PyExc_KeyError, py::converters::to_python(key));
-        throw py::ErrorAlreadySet();
+        PyErr_SetObject(PyExc_KeyError, python::converters::to_python(key));
+        throw python::error_already_set();
     }
 }
 
@@ -570,8 +661,8 @@ void StringMapPythonClass::del_item(StringMap&amp; self, std::size_t key)
     self.erase(p);
 }
 
-ClassWrapper&lt;StringMap&gt; string_map(my_module, "StringMap");
-string_map.def(py::Constructor&lt;&gt;());
+class_builder&lt;StringMap&gt; string_map(my_module, "StringMap");
+string_map.def(python::constructor&lt;&gt;());
 string_map.def(&amp;StringMap::size, "__len__");
 string_map.def(get_item, "__getitem__");
 string_map.def(set_item, "__setitem__");
@@ -658,8 +749,8 @@ three
          Py_cpp uses the special <code>
         __xxxattr__<em>&lt;name&gt;</em>__</code> functionality described above
         to allow direct access to data members through the following special
-        functions on <code>ClassWrapper&lt;&gt;</code> and <code>
-        ExtensionClass&lt;&gt;</code>:
+        functions on <code>class_builder&lt;&gt;</code> and <code>
+        extension_class&lt;&gt;</code>:
       <ul>
         <li>
           <code>def_getter(<em>pointer-to-member</em>, <em>name</em>)</code> //
@@ -680,7 +771,7 @@ three
         behavior. For example, when <code>def_getter()</code> is used, the
         default functionality for <code>setattr()</code> and <code>
         delattr()</code> remains in effect, operating on items in the extension
-        instance's name-space (i.e., its <code>__dict__</code>). For that
+        obj's name-space (i.e., its <code>__dict__</code>). For that
         reason, you'll usually want to stick with <code>def_readonly</code> and
         <code>def_read_write</code>.
       <p>
@@ -695,9 +786,9 @@ long second(const Pil&amp; x) { return x.second; }
 my_module.def(first, "first");
 my_module.def(second, "second");
 
-ClassWrapper&lt;Pil&gt; pair_int_long(my_module, "Pair");
-pair_int_long.def(py::Constructor&lt;&gt;());
-pair_int_long.def(py::Constructor&lt;int,long&gt;());
+class_builder&lt;Pil&gt; pair_int_long(my_module, "Pair");
+pair_int_long.def(python::constructor&lt;&gt;());
+pair_int_long.def(python::constructor&lt;int,long&gt;());
 pair_int_long.def_read_write(&amp;Pil::first, "first");
 pair_int_long.def_read_write(&amp;Pil::second, "second");
 </pre>
@@ -717,7 +808,7 @@ pair_int_long.def_read_write(&amp;Pil::second, "second");
 &gt;&gt;&gt; x.second = 8
 &gt;&gt;&gt; x.second
 8
-&gt;&gt;&gt; second(x) # Prove that we're not just changing the instance __dict__
+&gt;&gt;&gt; second(x) # Prove that we're not just changing the obj __dict__
 8
 </pre>
       </blockquote>
diff --git a/subclass.cpp b/subclass.cpp
index 3219ec4e..ee28fd72 100644
--- a/subclass.cpp
+++ b/subclass.cpp
@@ -14,22 +14,22 @@
 #include <cstring>
 #include "module.h"
 
-namespace py {
+namespace python {
 
 namespace detail {
-  void enable_named_method(py::detail::ClassBase* type_object, const char* name);
+  void enable_named_method(python::detail::class_base* type_obj, const char* name);
 }
 
 namespace {
   // Add the name of the module currently being loaded to the name_space with the
   // key "__module__". If no module is being loaded, or if name_space already has
   // a key "__module", has no effect. This is not really a useful public
-  // interface; it's just used for Class<>::Class() below.
-  void add_current_module_name(Dict&);
+  // interface; it's just used for class_t<>::class_t() below.
+  void add_current_module_name(dictionary&);
 
   bool is_prefix(const char* s1, const char* s2);
   bool is_special_name(const char* name);
-  void enable_special_methods(py::detail::ClassBase* derived, const Tuple& bases, const Dict& name_space);
+  void enable_special_methods(python::detail::class_base* derived, const tuple& bases, const dictionary& name_space);
 
   void report_ignored_exception(PyObject* source)
   {
@@ -65,53 +65,53 @@ namespace {
       return PyObject_GetAttrString(klass, const_cast<char*>("__name__"));
   }
 
-  Ptr global_class_reduce()
+  ref global_class_reduce()
   {
-      static Ptr result(detail::new_wrapped_function(class_reduce));
+      static ref result(detail::new_wrapped_function(class_reduce));
       return result;
   }
   
 
-  Tuple instance_reduce(PyObject* instance)
+  tuple instance_reduce(PyObject* obj)
   {
-      Ptr instance_class(PyObject_GetAttrString(instance, const_cast<char*>("__class__")));
+      ref instance_class(PyObject_GetAttrString(obj, const_cast<char*>("__class__")));
 
-      Ptr getinitargs(PyObject_GetAttrString(instance, const_cast<char*>("__getinitargs__")),
-                      Ptr::null_ok);
+      ref getinitargs(PyObject_GetAttrString(obj, const_cast<char*>("__getinitargs__")),
+                      ref::null_ok);
       PyErr_Clear();
-      Ptr initargs;
+      ref initargs;
       if (getinitargs.get() != 0)
       {
-          initargs = Ptr(PyEval_CallObject(getinitargs.get(), NULL));
-          initargs = Ptr(PySequence_Tuple(initargs.get()));
+          initargs = ref(PyEval_CallObject(getinitargs.get(), NULL));
+          initargs = ref(PySequence_Tuple(initargs.get()));
       }
       else
       {
-          initargs = Ptr(PyTuple_New(0));
+          initargs = ref(PyTuple_New(0));
       }
 
-      Ptr getstate(PyObject_GetAttrString(instance, const_cast<char*>("__getstate__")),
-                   Ptr::null_ok);
+      ref getstate(PyObject_GetAttrString(obj, const_cast<char*>("__getstate__")),
+                   ref::null_ok);
       PyErr_Clear();
       if (getstate.get() != 0)
       {
-          Ptr state = Ptr(PyEval_CallObject(getstate.get(), NULL));
-          return Tuple(instance_class, initargs, state);
+          ref state = ref(PyEval_CallObject(getstate.get(), NULL));
+          return tuple(instance_class, initargs, state);
       }
 
-      Ptr state(PyObject_GetAttrString(instance, const_cast<char*>("__dict__")), Ptr::null_ok);
+      ref state(PyObject_GetAttrString(obj, const_cast<char*>("__dict__")), ref::null_ok);
       PyErr_Clear();
-      if (state.get() != 0 && Dict(state).size() > 0)
+      if (state.get() != 0 && dictionary(state).size() > 0)
       {
-          return Tuple(instance_class, initargs, state);
+          return tuple(instance_class, initargs, state);
       }
 
-      return Tuple(instance_class, initargs);
+      return tuple(instance_class, initargs);
   }
 
-  Ptr global_instance_reduce()
+  ref global_instance_reduce()
   {
-      static Ptr result(detail::new_wrapped_function(instance_reduce));
+      static ref result(detail::new_wrapped_function(instance_reduce));
       return result;
   }
 }
@@ -119,17 +119,17 @@ namespace {
 
 namespace detail {
 
-  ClassBase::ClassBase(PyTypeObject* meta_class, String name, Tuple bases, const Dict& name_space)
-      : TypeObjectBase(meta_class),
+  class_base::class_base(PyTypeObject* meta_class_obj, string name, tuple bases, const dictionary& name_space)
+      : type_object_base(meta_class_obj),
         m_name(name),
         m_bases(bases),
         m_name_space(name_space)
   {
       this->tp_name = const_cast<char*>(name.c_str());
-      enable(TypeObjectBase::getattr);
-      enable(TypeObjectBase::setattr);
+      enable(type_object_base::getattr);
+      enable(type_object_base::setattr);
       add_current_module_name(m_name_space);
-      static const py::String docstr("__doc__", py::String::interned);
+      static const python::string docstr("__doc__", python::string::interned);
       if (PyDict_GetItem(m_name_space.get(), docstr.get())== 0)
       {
           PyDict_SetItem(m_name_space.get(), docstr.get(), Py_None);
@@ -137,32 +137,32 @@ namespace detail {
       enable_special_methods(this, bases, name_space);
   }
 
-  void ClassBase::add_base(Ptr base)
+  void class_base::add_base(ref base)
   {
-      Tuple new_bases(m_bases.size() + 1);
+      tuple new_bases(m_bases.size() + 1);
       for (std::size_t i = 0; i < m_bases.size(); ++i)
           new_bases.set_item(i, m_bases[i]);
       new_bases.set_item(m_bases.size(), base);
       m_bases = new_bases;
   }
 
-  PyObject* ClassBase::getattr(const char* name)
+  PyObject* class_base::getattr(const char* name)
   {
-      if (!PY_CSTD_::strcmp(name, "__dict__"))
+      if (!BOOST_CSTD_::strcmp(name, "__dict__"))
       {
           PyObject* result = m_name_space.get();
           Py_INCREF(result);
           return result;
       }
       
-      if (!PY_CSTD_::strcmp(name, "__bases__"))
+      if (!BOOST_CSTD_::strcmp(name, "__bases__"))
       {
           PyObject* result = m_bases.get();
           Py_INCREF(result);
           return result;
       }
       
-      if (!PY_CSTD_::strcmp(name, "__name__"))
+      if (!BOOST_CSTD_::strcmp(name, "__name__"))
       {
           PyObject* result = m_name.get();
           Py_INCREF(result);
@@ -170,17 +170,17 @@ namespace detail {
       }
 
       // pickle support courtesy of "Ralf W. Grosse-Kunstleve" <rwgk@cci.lbl.gov>
-      if (!PY_CSTD_::strcmp(name, "__safe_for_unpickling__"))
+      if (!BOOST_CSTD_::strcmp(name, "__safe_for_unpickling__"))
       {
           return PyInt_FromLong(1);
       }
-      if (!PY_CSTD_::strcmp(name, "__reduce__"))
+      if (!BOOST_CSTD_::strcmp(name, "__reduce__"))
       {
-          Ptr target(as_object(this), Ptr::new_ref);
-          return new BoundFunction(target, global_class_reduce());
+          ref target(as_object(this), ref::increment_count);
+          return new bound_function(target, global_class_reduce());
       }
       
-      Ptr local_attribute = m_name_space.get_item(String(name).reference());
+      ref local_attribute = m_name_space.get_item(string(name).reference());
     
       if (local_attribute.get())
           return local_attribute.release();
@@ -203,7 +203,7 @@ namespace detail {
               // Unwind the actual underlying function from unbound Python class
               // methods in case of multiple inheritance from real Python
               // classes. Python stubbornly insists that the first argument to a
-              // method must be a true Python Instance object otherwise. Do not
+              // method must be a true Python instance object otherwise. Do not
               // unwrap bound methods; that would interfere with intended semantics.
               if (PyMethod_Check(base_attribute)
                   && reinterpret_cast<PyMethodObject*>(base_attribute)->im_self == 0)
@@ -224,27 +224,27 @@ namespace detail {
   }
 
   // Mostly copied wholesale from Python's classobject.c
-  PyObject* ClassBase::repr() const
+  PyObject* class_base::repr() const
   {
       PyObject *mod = PyDict_GetItemString(
           m_name_space.get(), const_cast<char*>("__module__"));
       unsigned long address = reinterpret_cast<unsigned long>(this);
-      String result = (mod == NULL || !PyString_Check(mod))
-                ? String("<extension class %s at %lx>") % Tuple(m_name, address)
-                : String("<extension class %s.%s at %lx>") % Tuple(Ptr(mod, Ptr::borrowed), m_name, address);
+      string result = (mod == NULL || !PyString_Check(mod))
+                ? string("<extension class %s at %lx>") % tuple(m_name, address)
+                : string("<extension class %s.%s at %lx>") % tuple(ref(mod, ref::increment_count), m_name, address);
       return result.reference().release();
   }
 
 
-  int ClassBase::setattr(const char* name, PyObject* value)
+  int class_base::setattr(const char* name, PyObject* value)
   {
       if (is_special_name(name)
-          && PY_CSTD_::strcmp(name, "__doc__") != 0
-          && PY_CSTD_::strcmp(name, "__name__") != 0)
+          && BOOST_CSTD_::strcmp(name, "__doc__") != 0
+          && BOOST_CSTD_::strcmp(name, "__name__") != 0)
       {
-          py::String message("Special attribute names other than '__doc__' and '__name__' are read-only, in particular: ");
+          python::string message("Special attribute names other than '__doc__' and '__name__' are read-only, in particular: ");
           PyErr_SetObject(PyExc_TypeError, (message + name).get());
-          throw ErrorAlreadySet();
+          throw error_already_set();
       }
       
       if (PyCallable_Check(value))
@@ -254,11 +254,11 @@ namespace detail {
           m_name_space.reference().get(), const_cast<char*>(name), value);
   }
 
-  bool ClassBase::initialize_instance(Instance* instance, PyObject* args, PyObject* keywords)
+  bool class_base::initialize_instance(instance* obj, PyObject* args, PyObject* keywords)
   {
-      // Getting the init function off the instance should result in a
+      // Getting the init function off the obj should result in a
       // bound method.
-      PyObject* const init_function = instance->getattr("__init__", false);
+      PyObject* const init_function = obj->getattr("__init__", false);
         
       if (init_function == 0)
       {
@@ -272,18 +272,18 @@ namespace detail {
       else
       {
           // Manage the reference to the bound function
-          Ptr init_function_holder(init_function);
+          ref init_function_holder(init_function);
         
-        // Declare a Ptr to manage the result of calling __init__ (which should be None).
-          Ptr init_result(
+        // Declare a ref to manage the result of calling __init__ (which should be None).
+          ref init_result(
               PyEval_CallObjectWithKeywords(init_function, args, keywords));
       }
       return true;
   }
 
-  void ClassBase::instance_dealloc(PyObject* instance) const
+  void class_base::instance_dealloc(PyObject* obj) const
   {
-      Py_INCREF(instance); // This allows a __del__ function to revive the instance
+      Py_INCREF(obj); // This allows a __del__ function to revive the obj
       
       PyObject* exc_type;
       PyObject* exc_value;
@@ -293,17 +293,17 @@ namespace detail {
       // This scope ensures that the reference held by del_function doesn't release
       // the last reference and delete the object recursively (infinitely).
       {
-          Ptr del_function;
+          ref del_function;
           try {
-              Instance* const target = py::Downcast<py::Instance>(instance);
-              del_function = Ptr(target->getattr("__del__", false), Ptr::null_ok);
+              instance* const target = python::downcast<python::instance>(obj);
+              del_function = ref(target->getattr("__del__", false), ref::null_ok);
           }
           catch(...) {
           }
 
           if (del_function.get() != 0)
           {
-              Ptr result(PyEval_CallObject(del_function.get(), (PyObject *)NULL), Ptr::null_ok);
+              ref result(PyEval_CallObject(del_function.get(), (PyObject *)NULL), ref::null_ok);
               
               if (result.get() == NULL)
                   report_ignored_exception(del_function.get());
@@ -311,25 +311,25 @@ namespace detail {
       }
       PyErr_Restore(exc_type, exc_value, exc_traceback);
       
-      if (--instance->ob_refcnt <= 0)
-          delete_instance(instance);
+      if (--obj->ob_refcnt <= 0)
+          delete_instance(obj);
   }
 
 
 }
 
-Instance::Instance(PyTypeObject* class_)
-    : py::detail::BaseObject<PyObject>(class_)
+instance::instance(PyTypeObject* class_)
+    : python::detail::base_object<PyObject>(class_)
 {
 }
 
-Instance::~Instance()
+instance::~instance()
 {
 }
 
-PyObject* Instance::getattr(const char* name, bool use_special_function)
+PyObject* instance::getattr(const char* name, bool use_special_function)
 {
-    if (!PY_CSTD_::strcmp(name, "__dict__"))
+    if (!BOOST_CSTD_::strcmp(name, "__dict__"))
     {
         if (PyEval_GetRestricted()) {
             PyErr_SetString(PyExc_RuntimeError,
@@ -340,18 +340,18 @@ PyObject* Instance::getattr(const char* name, bool use_special_function)
         return m_name_space.get();
     }
     
-    if (!PY_CSTD_::strcmp(name, "__class__"))
+    if (!BOOST_CSTD_::strcmp(name, "__class__"))
     {
         Py_INCREF(this->ob_type);
         return as_object(this->ob_type);
     }
 
-    if (!PY_CSTD_::strcmp(name, "__reduce__"))
+    if (!BOOST_CSTD_::strcmp(name, "__reduce__"))
     {
-      return new detail::BoundFunction(Ptr(this, Ptr::new_ref), global_instance_reduce());
+      return new detail::bound_function(ref(this, ref::increment_count), global_instance_reduce());
     }
     
-    Ptr local_attribute = m_name_space.get_item(String(name).reference());
+    ref local_attribute = m_name_space.get_item(string(name).reference());
     
     if (local_attribute.get())
         return local_attribute.release();
@@ -365,11 +365,11 @@ PyObject* Instance::getattr(const char* name, bool use_special_function)
         return 0;
     }
 
-    Ptr class_attribute;
+    ref class_attribute;
     if (function != 0)
     {
         // This will throw if the attribute wasn't found
-        class_attribute = Ptr(function);
+        class_attribute = ref(function);
     }
     else
     {
@@ -379,7 +379,7 @@ PyObject* Instance::getattr(const char* name, bool use_special_function)
         // First we try the special method that comes from concatenating
         // "__getattr__" and <name> and 2 trailing underscores. This is an
         // extension to regular Python class functionality.
-        const String specific_getattr_name(detail::getattr_string() + name + "__");
+        const string specific_getattr_name(detail::getattr_string() + name + "__");
         PyObject* getattr_method = PyObject_GetAttr(
             as_object(this->ob_type), specific_getattr_name.get());
 
@@ -405,7 +405,7 @@ PyObject* Instance::getattr(const char* name, bool use_special_function)
         }
 
         // Take ownership of the method
-        Ptr owner(getattr_method);
+        ref owner(getattr_method);
         
         // Call it to get the attribute.
         return PyEval_CallFunction(getattr_method, arg_format, this, name);
@@ -418,15 +418,15 @@ PyObject* Instance::getattr(const char* name, bool use_special_function)
     }
     else
     {
-        return detail::BoundFunction::create(Ptr(this, Ptr::borrowed), class_attribute);
+        return detail::bound_function::create(ref(this, ref::increment_count), class_attribute);
     }
 }
 
-// Instance::setattr_dict
+// instance::setattr_dict
 //
 //  Implements setattr() functionality for the "__dict__" attribute
 //
-int Instance::setattr_dict(PyObject* value)
+int instance::setattr_dict(PyObject* value)
 {
     if (PyEval_GetRestricted())
     {
@@ -441,35 +441,35 @@ int Instance::setattr_dict(PyObject* value)
                         "__dict__ must be set to a dictionary");
         return -1;
     }
-    m_name_space = Dict(Ptr(value, Ptr::borrowed));
+    m_name_space = dictionary(ref(value, ref::increment_count));
     return 0;
 }
 
-// Instance::setattr -
+// instance::setattr -
 //
-//  Implements the setattr() and delattr() functionality for our own Instance
+//  Implements the setattr() and delattr() functionality for our own instance
 //  objects, using the standard Python interface: if value == 0, we are deleting
 //  the attribute, and returns 0 unless an error occurred.
-int Instance::setattr(const char* name, PyObject* value)
+int instance::setattr(const char* name, PyObject* value)
 {
-    if (PY_CSTD_::strcmp(name, "__class__") == 0)
+    if (BOOST_CSTD_::strcmp(name, "__class__") == 0)
     {
         PyErr_SetString(PyExc_TypeError, "__class__ attribute is read-only");
-        throw ErrorAlreadySet();
+        throw error_already_set();
     }
     
-    if (PY_CSTD_::strcmp(name, "__dict__") == 0)
+    if (BOOST_CSTD_::strcmp(name, "__dict__") == 0)
         return setattr_dict(value);
     
     // Try to find an appropriate "specific" setter or getter method, either
     // __setattr__<name>__(value) or __delattr__<name>__(). This is an extension
     // to regular Python class functionality.
-    const String& base_name = value ? detail::setattr_string() : detail::delattr_string();
-    const String specific_method_name(base_name + name + "__");
+    const string& base_name = value ? detail::setattr_string() : detail::delattr_string();
+    const string specific_method_name(base_name + name + "__");
     
-    Ptr special_method(
+    ref special_method(
         PyObject_GetAttr(as_object(this->ob_type), specific_method_name.get()),
-        Ptr::null_ok);
+        ref::null_ok);
 
     PyObject* result_object = 0;
     if (special_method.get() != 0)
@@ -486,7 +486,7 @@ int Instance::setattr(const char* name, PyObject* value)
         PyErr_Clear();
         special_method.reset(
             PyObject_GetAttr(as_object(this->ob_type), base_name.get()),
-            Ptr::null_ok);
+            ref::null_ok);
         
         if (special_method.get() != 0)
         {
@@ -501,7 +501,7 @@ int Instance::setattr(const char* name, PyObject* value)
     // If we found an appropriate special method, handle the return value.
     if (special_method.get() != 0)
     {
-        Ptr manage_result(result_object);
+        ref manage_result(result_object);
         return 0;
     }
     
@@ -525,239 +525,239 @@ int Instance::setattr(const char* name, PyObject* value)
     }
 }
 
-PyObject* Instance::call(PyObject* args, PyObject* keywords)
+PyObject* instance::call(PyObject* args, PyObject* keywords)
 {
     return PyEval_CallObjectWithKeywords(
-        Ptr(getattr("__call__")).get(), // take possession of the result from getattr()
+        ref(getattr("__call__")).get(), // take possession of the result from getattr()
         args, keywords);
 }
 
-PyObject* Instance::repr()
+PyObject* instance::repr()
 {
-    return Callback<PyObject*>::call_method(this, "__repr__");
+    return callback<PyObject*>::call_method(this, "__repr__");
 }
 
-int Instance::compare(PyObject* other)
+int instance::compare(PyObject* other)
 {
-    return Callback<int>::call_method(this, "__cmp__", other);
+    return callback<int>::call_method(this, "__cmp__", other);
 }
 
-PyObject* Instance::str()
+PyObject* instance::str()
 {
-    return Callback<PyObject*>::call_method(this, "__str__");
+    return callback<PyObject*>::call_method(this, "__str__");
 }
 
-long Instance::hash()
+long instance::hash()
 {
-    return Callback<long>::call_method(this, "__hash__");
+    return callback<long>::call_method(this, "__hash__");
 }
 
-int Instance::length()
+int instance::length()
 {
-    return Callback<int>::call_method(this, "__len__");
+    return callback<int>::call_method(this, "__len__");
 }
 
-PyObject* Instance::get_subscript(PyObject* key)
+PyObject* instance::get_subscript(PyObject* key)
 {
-    return Callback<PyObject*>::call_method(this, "__getitem__", key);
+    return callback<PyObject*>::call_method(this, "__getitem__", key);
 }
 
-void Instance::set_subscript(PyObject* key, PyObject* value)
+void instance::set_subscript(PyObject* key, PyObject* value)
 {
     if (value == 0)
-        Callback<void>::call_method(this, "__delitem__", key);
+        callback<void>::call_method(this, "__delitem__", key);
     else
-        Callback<void>::call_method(this, "__setitem__", key, value);
+        callback<void>::call_method(this, "__setitem__", key, value);
 }
 
-PyObject* Instance::get_slice(int start, int finish)
+PyObject* instance::get_slice(int start, int finish)
 {
-    return Callback<PyObject*>::call_method(this, "__getslice__", start, finish);
+    return callback<PyObject*>::call_method(this, "__getslice__", start, finish);
 }
 
-void Instance::set_slice(int start, int finish, PyObject* value)
+void instance::set_slice(int start, int finish, PyObject* value)
 {
     if (value == 0)
-        Callback<void>::call_method(this, "__delslice__", start, finish);
+        callback<void>::call_method(this, "__delslice__", start, finish);
     else
-        Callback<void>::call_method(this, "__setslice__", start, finish, value);
+        callback<void>::call_method(this, "__setslice__", start, finish, value);
 }
 
-PyObject* Instance::add(PyObject* other)
+PyObject* instance::add(PyObject* other)
 {
-    return Callback<PyObject*>::call_method(this, "__add__", other);
+    return callback<PyObject*>::call_method(this, "__add__", other);
 }
 
-PyObject* Instance::subtract(PyObject* other)
+PyObject* instance::subtract(PyObject* other)
 {
-    return Callback<PyObject*>::call_method(this, "__sub__", other);
+    return callback<PyObject*>::call_method(this, "__sub__", other);
 }
 
-PyObject* Instance::multiply(PyObject* other)
+PyObject* instance::multiply(PyObject* other)
 {
-    return Callback<PyObject*>::call_method(this, "__mul__", other);
+    return callback<PyObject*>::call_method(this, "__mul__", other);
 }
 
-PyObject* Instance::divide(PyObject* other)
+PyObject* instance::divide(PyObject* other)
 {
-    return Callback<PyObject*>::call_method(this, "__div__", other);
+    return callback<PyObject*>::call_method(this, "__div__", other);
 }
 
-PyObject* Instance::remainder(PyObject* other)
+PyObject* instance::remainder(PyObject* other)
 {
-    return Callback<PyObject*>::call_method(this, "__mod__", other);
+    return callback<PyObject*>::call_method(this, "__mod__", other);
 }
 
-PyObject* Instance::divmod(PyObject* other)
+PyObject* instance::divmod(PyObject* other)
 {
-    return Callback<PyObject*>::call_method(this, "__divmod__", other);
+    return callback<PyObject*>::call_method(this, "__divmod__", other);
 }
 
-PyObject* Instance::power(PyObject* exponent, PyObject* modulus)
+PyObject* instance::power(PyObject* exponent, PyObject* modulus)
 {
     if (as_object(modulus->ob_type) == Py_None)
-        return Callback<PyObject*>::call_method(this, "__pow__", exponent);
+        return callback<PyObject*>::call_method(this, "__pow__", exponent);
     else
-        return Callback<PyObject*>::call_method(this, "__pow__", exponent, modulus);
+        return callback<PyObject*>::call_method(this, "__pow__", exponent, modulus);
 }
 
-PyObject* Instance::negative()
+PyObject* instance::negative()
 {
-    return Callback<PyObject*>::call_method(this, "__neg__");
+    return callback<PyObject*>::call_method(this, "__neg__");
 }
 
-PyObject* Instance::positive()
+PyObject* instance::positive()
 {
-    return Callback<PyObject*>::call_method(this, "__pos__");
+    return callback<PyObject*>::call_method(this, "__pos__");
 }
 
-PyObject* Instance::absolute()
+PyObject* instance::absolute()
 {
-    return Callback<PyObject*>::call_method(this, "__abs__");
+    return callback<PyObject*>::call_method(this, "__abs__");
 }
 
-int Instance::nonzero()
+int instance::nonzero()
 {
-    return Callback<bool>::call_method(this, "__nonzero__");
+    return callback<bool>::call_method(this, "__nonzero__");
 }
 
-PyObject* Instance::invert()
+PyObject* instance::invert()
 {
-    return Callback<PyObject*>::call_method(this, "__invert__");
+    return callback<PyObject*>::call_method(this, "__invert__");
 }
 
-PyObject* Instance::lshift(PyObject* other)
+PyObject* instance::lshift(PyObject* other)
 {
-    return Callback<PyObject*>::call_method(this, "__lshift__", other);
+    return callback<PyObject*>::call_method(this, "__lshift__", other);
 }
 
-PyObject* Instance::rshift(PyObject* other)
+PyObject* instance::rshift(PyObject* other)
 {
-    return Callback<PyObject*>::call_method(this, "__rshift__", other);
+    return callback<PyObject*>::call_method(this, "__rshift__", other);
 }
 
-PyObject* Instance::do_and(PyObject* other)
+PyObject* instance::do_and(PyObject* other)
 {
-    return Callback<PyObject*>::call_method(this, "__and__", other);
+    return callback<PyObject*>::call_method(this, "__and__", other);
 }
 
-PyObject* Instance::do_xor(PyObject* other)
+PyObject* instance::do_xor(PyObject* other)
 {
-    return Callback<PyObject*>::call_method(this, "__xor__", other);
+    return callback<PyObject*>::call_method(this, "__xor__", other);
 }
 
-PyObject* Instance::do_or(PyObject* other)
+PyObject* instance::do_or(PyObject* other)
 {
-    return Callback<PyObject*>::call_method(this, "__or__", other);
+    return callback<PyObject*>::call_method(this, "__or__", other);
 }
 
-int Instance::coerce(PyObject** x, PyObject** y)
+int instance::coerce(PyObject** x, PyObject** y)
 {
     assert(this == *x);
     
     // Coerce must return a tuple
-    Tuple result(Callback<Tuple>::call_method(this, "__coerce__", *y));
+    tuple result(callback<tuple>::call_method(this, "__coerce__", *y));
     
     *x = result[0].release();
     *y = result[1].release();
     return 0;
 }
 
-PyObject* Instance::as_int()
+PyObject* instance::as_int()
 {
-    return Callback<PyObject*>::call_method(this, "__int__");
+    return callback<PyObject*>::call_method(this, "__int__");
 }
 
-PyObject* Instance::as_long()
+PyObject* instance::as_long()
 {
-    return Callback<PyObject*>::call_method(this, "__long__");
+    return callback<PyObject*>::call_method(this, "__long__");
 }
 
-PyObject* Instance::as_float()
+PyObject* instance::as_float()
 {
-    return Callback<PyObject*>::call_method(this, "__float__");
+    return callback<PyObject*>::call_method(this, "__float__");
 }
 
-PyObject* Instance::oct()
+PyObject* instance::oct()
 {
-    return Callback<PyObject*>::call_method(this, "__oct__");
+    return callback<PyObject*>::call_method(this, "__oct__");
 }
 
-PyObject* Instance::hex()
+PyObject* instance::hex()
 {
-    return Callback<PyObject*>::call_method(this, "__hex__");
+    return callback<PyObject*>::call_method(this, "__hex__");
 }
 
 namespace {
-  struct NamedCapability
+  struct named_capability
   {
       const char* name;
-      detail::TypeObjectBase::Capability capability;
+      detail::type_object_base::capability capability;
   };
 
-  const NamedCapability enablers[] =
+  const named_capability enablers[] =
   {
-      { "__hash__", detail::TypeObjectBase::hash },
-      { "__cmp__", detail::TypeObjectBase::compare },
-      { "__repr__", detail::TypeObjectBase::repr },
-      { "__str__", detail::TypeObjectBase::str },
-      { "__call__", detail::TypeObjectBase::call },
-      { "__getattr__", detail::TypeObjectBase::getattr },
-      { "__setattr__", detail::TypeObjectBase::setattr },
-      { "__len__", detail::TypeObjectBase::mapping_length },
-      { "__len__", detail::TypeObjectBase::sequence_length },
-      { "__getitem__", detail::TypeObjectBase::mapping_subscript },
-      { "__getitem__", detail::TypeObjectBase::sequence_item },
-      { "__setitem__", detail::TypeObjectBase::mapping_ass_subscript },
-      { "__setitem__", detail::TypeObjectBase::sequence_ass_item },
-      { "__delitem__", detail::TypeObjectBase::mapping_ass_subscript },
-      { "__delitem__", detail::TypeObjectBase::sequence_ass_item },
-      { "__getslice__", detail::TypeObjectBase::sequence_slice },
-      { "__setslice__", detail::TypeObjectBase::sequence_ass_slice },
-      { "__delslice__", detail::TypeObjectBase::sequence_ass_slice },
-      { "__add__", detail::TypeObjectBase::number_add },
-      { "__sub__", detail::TypeObjectBase::number_subtract },
-      { "__mul__", detail::TypeObjectBase::number_multiply },
-      { "__div__", detail::TypeObjectBase::number_divide },
-      { "__mod__", detail::TypeObjectBase::number_remainder },
-      { "__divmod__", detail::TypeObjectBase::number_divmod },
-      { "__pow__", detail::TypeObjectBase::number_power },
-      { "__neg__", detail::TypeObjectBase::number_negative },
-      { "__pos__", detail::TypeObjectBase::number_positive },
-      { "__abs__", detail::TypeObjectBase::number_absolute },
-      { "__nonzero__", detail::TypeObjectBase::number_nonzero },
-      { "__invert__", detail::TypeObjectBase::number_invert },
-      { "__lshift__", detail::TypeObjectBase::number_lshift },
-      { "__rshift__", detail::TypeObjectBase::number_rshift },
-      { "__and__", detail::TypeObjectBase::number_and },
-      { "__xor__", detail::TypeObjectBase::number_xor },
-      { "__or__", detail::TypeObjectBase::number_or },
-      { "__coerce__", detail::TypeObjectBase::number_coerce },
-      { "__int__", detail::TypeObjectBase::number_int },
-      { "__long__", detail::TypeObjectBase::number_long },
-      { "__float__", detail::TypeObjectBase::number_float },
-      { "__oct__", detail::TypeObjectBase::number_oct },
-      { "__hex__", detail::TypeObjectBase::number_hex }
+      { "__hash__", detail::type_object_base::hash },
+      { "__cmp__", detail::type_object_base::compare },
+      { "__repr__", detail::type_object_base::repr },
+      { "__str__", detail::type_object_base::str },
+      { "__call__", detail::type_object_base::call },
+      { "__getattr__", detail::type_object_base::getattr },
+      { "__setattr__", detail::type_object_base::setattr },
+      { "__len__", detail::type_object_base::mapping_length },
+      { "__len__", detail::type_object_base::sequence_length },
+      { "__getitem__", detail::type_object_base::mapping_subscript },
+      { "__getitem__", detail::type_object_base::sequence_item },
+      { "__setitem__", detail::type_object_base::mapping_ass_subscript },
+      { "__setitem__", detail::type_object_base::sequence_ass_item },
+      { "__delitem__", detail::type_object_base::mapping_ass_subscript },
+      { "__delitem__", detail::type_object_base::sequence_ass_item },
+      { "__getslice__", detail::type_object_base::sequence_slice },
+      { "__setslice__", detail::type_object_base::sequence_ass_slice },
+      { "__delslice__", detail::type_object_base::sequence_ass_slice },
+      { "__add__", detail::type_object_base::number_add },
+      { "__sub__", detail::type_object_base::number_subtract },
+      { "__mul__", detail::type_object_base::number_multiply },
+      { "__div__", detail::type_object_base::number_divide },
+      { "__mod__", detail::type_object_base::number_remainder },
+      { "__divmod__", detail::type_object_base::number_divmod },
+      { "__pow__", detail::type_object_base::number_power },
+      { "__neg__", detail::type_object_base::number_negative },
+      { "__pos__", detail::type_object_base::number_positive },
+      { "__abs__", detail::type_object_base::number_absolute },
+      { "__nonzero__", detail::type_object_base::number_nonzero },
+      { "__invert__", detail::type_object_base::number_invert },
+      { "__lshift__", detail::type_object_base::number_lshift },
+      { "__rshift__", detail::type_object_base::number_rshift },
+      { "__and__", detail::type_object_base::number_and },
+      { "__xor__", detail::type_object_base::number_xor },
+      { "__or__", detail::type_object_base::number_or },
+      { "__coerce__", detail::type_object_base::number_coerce },
+      { "__int__", detail::type_object_base::number_int },
+      { "__long__", detail::type_object_base::number_long },
+      { "__float__", detail::type_object_base::number_float },
+      { "__oct__", detail::type_object_base::number_oct },
+      { "__hex__", detail::type_object_base::number_hex }
   };
 
   bool is_prefix(const char* s1, const char* s2)
@@ -772,14 +772,14 @@ namespace {
     if (name[0] != '_' || name[1] != '_' || name[2] == 0 || name[3] == 0)
         return false;
 
-    std::size_t name_length = PY_CSTD_::strlen(name);
+    std::size_t name_length = BOOST_CSTD_::strlen(name);
     return name[name_length - 1] == '_' && name[name_length - 2] == '_';
   }
 }
 
 namespace detail {
   // Enable the special handler for methods of the given name, if any.
-  void enable_named_method(py::detail::ClassBase* type_object, const char* name)
+  void enable_named_method(python::detail::class_base* type_obj, const char* name)
   {
       const std::size_t num_enablers = sizeof(enablers) / sizeof(enablers[0]);
 
@@ -793,7 +793,7 @@ namespace detail {
       {
           if (is_prefix(enablers[i].name + 2, name + 2))
           {
-              type_object->enable(enablers[i].capability);
+              type_obj->enable(enablers[i].capability);
           }
       }
   }
@@ -801,7 +801,7 @@ namespace detail {
 
 namespace {
   // Enable any special methods which are enabled in the base class.
-  void enable_special_methods(py::detail::ClassBase* derived, const Tuple& bases, const Dict& name_space)
+  void enable_special_methods(python::detail::class_base* derived, const tuple& bases, const dictionary& name_space)
   {
       for (std::size_t i = 0; i < bases.size(); ++i)
       {
@@ -809,19 +809,19 @@ namespace {
 
           for (std::size_t n = 0; n < PY_ARRAY_LENGTH(enablers); ++n)
           {
-              Ptr attribute(
+              ref attribute(
                   PyObject_GetAttrString(base, const_cast<char*>(enablers[n].name)),
-                  Ptr::null_ok);
+                  ref::null_ok);
               PyErr_Clear();
               if (attribute.get() != 0 && PyCallable_Check(attribute.get()))
                   detail::add_capability(enablers[n].capability, derived);
           }
       }
 
-      List keys(name_space.keys());
+      list keys(name_space.keys());
       for (std::size_t j = 0, len = keys.size(); j < len; ++j)
       {
-          String name_obj(keys.get_item(j));
+          string name_obj(keys.get_item(j));
           const char* name = name_obj.c_str();
 
           if (!is_special_name(name))
@@ -837,16 +837,16 @@ namespace {
       }
   }
 
-  void add_current_module_name(Dict& name_space)
+  void add_current_module_name(dictionary& name_space)
   {
-      static String module_key("__module__", String::interned);
-      name_space.set_item(module_key, Module::name());
+      static string module_key("__module__", string::interned);
+      name_space.set_item(module_key, module_builder::name());
   }
 }
 
-void adjust_slice_indices(PyObject* instance, int& start, int& finish)
+void adjust_slice_indices(PyObject* obj, int& start, int& finish)
 {
-    int length = Callback<int>::call_method(instance, "__len__");
+    int length = callback<int>::call_method(obj, "__len__");
     
     // This is standard Python class behavior.
     if (start < 0)
@@ -862,23 +862,23 @@ void adjust_slice_indices(PyObject* instance, int& start, int& finish)
 }
 
 namespace detail {
-const String& setattr_string()
+const string& setattr_string()
 {
-    static String x("__setattr__", String::interned);
+    static string x("__setattr__", string::interned);
     return x;
 }
 
-const String& getattr_string()
+const string& getattr_string()
 {
-    static String x("__getattr__", String::interned);
+    static string x("__getattr__", string::interned);
     return x;
 }
 
-const String& delattr_string()
+const string& delattr_string()
 {
-    static String x("__delattr__", String::interned);
+    static string x("__delattr__", string::interned);
     return x;
 }
 }
 
-} // namespace py
+} // namespace python
diff --git a/subclass.h b/subclass.h
index a7eba973..a7679a95 100644
--- a/subclass.h
+++ b/subclass.h
@@ -17,15 +17,15 @@
 # include "py.h"
 # include "callback.h"
 
-namespace py {
+namespace python {
 
-// A simple type which acts something like a built-in Python class instance.
-class Instance
-    : public py::detail::PythonObject
+// A simple type which acts something like a built-in Python class obj.
+class instance
+    : public python::detail::python_object
 {
  public:
-    Instance(PyTypeObject* class_);
-    ~Instance();
+    instance(PyTypeObject* class_);
+    ~instance();
 
     // Standard Python functions.
     PyObject* repr();
@@ -71,60 +71,60 @@ class Instance
     PyObject* hex();
 
  private: // noncopyable, without the size bloat
-    Instance(const Instance&);
-    void operator=(const Instance&);
+    instance(const instance&);
+    void operator=(const instance&);
 
  private: // helper functions
     int setattr_dict(PyObject* value);
     
  private:
-    Dict m_name_space;
+    dictionary m_name_space;
 };
 
-template <class T> class MetaClass;
+template <class T> class meta_class;
 
 namespace detail {
-  class ClassBase : public TypeObjectBase
+  class class_base : public type_object_base
   {
    public:
-      ClassBase(PyTypeObject* meta_class, String name, Tuple bases, const Dict& name_space);
-      Tuple bases() const;
-      String name() const;
-      Dict& dict();
+      class_base(PyTypeObject* meta_class_obj, string name, tuple bases, const dictionary& name_space);
+      tuple bases() const;
+      string name() const;
+      dictionary& dict();
       
       // Standard Python functions.
       PyObject* getattr(const char* name);
       int setattr(const char* name, PyObject* value);
       PyObject* repr() const;
-      void add_base(Ptr base);
+      void add_base(ref base);
 
    protected:
-      bool initialize_instance(Instance* instance, PyObject* args, PyObject* keywords);
+      bool initialize_instance(instance* obj, PyObject* args, PyObject* keywords);
 
    private: // virtual functions
-      // Subclasses should override this to delete the particular instance type
+      // Subclasses should override this to delete the particular obj type
       virtual void delete_instance(PyObject*) const = 0;
 
-   private: // py::TypeObjectBase required interface implementation
+   private: // python::type_object_base required interface implementation
       void instance_dealloc(PyObject*) const; // subclasses should not override this
       
    private:
-      String m_name;
-      Tuple m_bases;
-      Dict m_name_space;
+      string m_name;
+      tuple m_bases;
+      dictionary m_name_space;
   };
 
-  void enable_named_method(ClassBase* type_object, const char* name);
+  void enable_named_method(class_base* type_obj, const char* name);
 }
 
-// A type which acts a lot like a built-in Python class. T is the instance type,
-// so Class<Instance> is a very simple "class-alike".
+// A type which acts a lot like a built-in Python class. T is the obj type,
+// so class_t<instance> is a very simple "class-alike".
 template <class T>
-class Class
-    : public py::detail::ClassBase
+class class_t
+    : public python::detail::class_base
 {
  public:
-    Class(MetaClass<T>* meta_class, String name, Tuple bases, const Dict& name_space);
+    class_t(meta_class<T>* meta_class_obj, string name, tuple bases, const dictionary& name_space);
     
     // Standard Python functions.
     PyObject* call(PyObject* args, PyObject* keywords);
@@ -140,8 +140,8 @@ class Class
 
  private: // Implement sequence methods on instances
     int instance_sequence_length(PyObject*) const;
-    PyObject* instance_sequence_item(PyObject* instance, int n) const;
-    int instance_sequence_ass_item(PyObject* instance, int n, PyObject* value) const;
+    PyObject* instance_sequence_item(PyObject* obj, int n) const;
+    int instance_sequence_ass_item(PyObject* obj, int n, PyObject* value) const;
     PyObject* instance_sequence_slice(PyObject*, int start, int finish) const;
     int instance_sequence_ass_slice(PyObject*, int start, int finish, PyObject* value) const;
 
@@ -171,40 +171,40 @@ class Class
     PyObject* instance_number_hex(PyObject*) const;
     
  private: // Miscellaneous "special" methods
-    PyObject* instance_call(PyObject* instance, PyObject* args, PyObject* keywords) const;
-    PyObject* instance_getattr(PyObject* instance, const char* name) const;
-    int instance_setattr(PyObject* instance, const char* name, PyObject* value) const;
+    PyObject* instance_call(PyObject* obj, PyObject* args, PyObject* keywords) const;
+    PyObject* instance_getattr(PyObject* obj, const char* name) const;
+    int instance_setattr(PyObject* obj, const char* name, PyObject* value) const;
 
- private: // Implementation of py::detail::ClassBase required interface
+ private: // Implementation of python::detail::class_base required interface
     void delete_instance(PyObject*) const;
     
  private: // noncopyable, without the size bloat
-    Class(const Class<T>&);
-    void operator=(const Class&);
+    class_t(const class_t<T>&);
+    void operator=(const class_t&);
 };
 
-// The type of a Class<T> object.
+// The type of a class_t<T> object.
 template <class T>
-class MetaClass
-    : public py::detail::Reprable<
-                py::detail::Callable<
-                   py::detail::Getattrable<
-                      py::detail::Setattrable<
-                         py::detail::TypeObject<Class<T> > > > > >,
+class meta_class
+    : public python::detail::reprable<
+                python::detail::callable<
+                   python::detail::getattrable<
+                      python::detail::setattrable<
+                         python::detail::type_object<class_t<T> > > > > >,
       boost::noncopyable
 {
  public:
-    MetaClass();
+    meta_class();
 
     // Standard Python functions.
     PyObject* call(PyObject* args, PyObject* keywords);
     
-    struct TypeObject
-        : py::detail::Singleton<TypeObject,
-             py::detail::Callable<
-                py::detail::TypeObject<MetaClass> > >
+    struct type_object
+        : python::detail::singleton<type_object,
+             python::detail::callable<
+                python::detail::type_object<meta_class> > >
     {
-        TypeObject() : SingletonBase(&PyType_Type) {}
+        type_object() : singleton_base(&PyType_Type) {}
     };
 };
 
@@ -212,27 +212,27 @@ class MetaClass
 // Member function implementations.
 //
 template <class T>
-MetaClass<T>::MetaClass()
-    : Properties(TypeObject::singleton())
+meta_class<T>::meta_class()
+    : properties(type_object::instance())
 {
 } 
 
 template <class T>
-Class<T>::Class(MetaClass<T>* meta_class, String name, Tuple bases, const Dict& name_space)
-    : py::detail::ClassBase(meta_class, name, bases, name_space)
+class_t<T>::class_t(meta_class<T>* meta_class_obj, string name, tuple bases, const dictionary& name_space)
+    : python::detail::class_base(meta_class_obj, name, bases, name_space)
 {
 }
 
 template <class T>
-void Class<T>::delete_instance(PyObject* instance) const
+void class_t<T>::delete_instance(PyObject* obj) const
 {
-    delete Downcast<T>(instance);
+    delete downcast<T>(obj);
 }
 
 template <class T>
-PyObject* Class<T>::call(PyObject* args, PyObject* keywords)
+PyObject* class_t<T>::call(PyObject* args, PyObject* keywords)
 {
-    PyPtr<T> result(new T(this));
+    reference<T> result(new T(this));
     if (!this->initialize_instance(result.get(), args, keywords))
         return 0;
     else
@@ -240,257 +240,257 @@ PyObject* Class<T>::call(PyObject* args, PyObject* keywords)
 }
 
 template <class T>
-PyObject* Class<T>::instance_repr(PyObject* instance) const
+PyObject* class_t<T>::instance_repr(PyObject* obj) const
 {
-    return Downcast<T>(instance)->repr();
+    return downcast<T>(obj)->repr();
 }
 
 template <class T>
-int Class<T>::instance_compare(PyObject* instance, PyObject* other) const
+int class_t<T>::instance_compare(PyObject* obj, PyObject* other) const
 {
-    return Downcast<T>(instance)->compare(other);
+    return downcast<T>(obj)->compare(other);
 }
 
 template <class T>
-PyObject* Class<T>::instance_str(PyObject* instance) const
+PyObject* class_t<T>::instance_str(PyObject* obj) const
 {
-    return Downcast<T>(instance)->str();
+    return downcast<T>(obj)->str();
 }
 
 template <class T>
-long Class<T>::instance_hash(PyObject* instance) const
+long class_t<T>::instance_hash(PyObject* obj) const
 {
-    return Downcast<T>(instance)->hash();
+    return downcast<T>(obj)->hash();
 }
 
 template <class T>
-int Class<T>::instance_mapping_length(PyObject* instance) const
+int class_t<T>::instance_mapping_length(PyObject* obj) const
 {
-    return Downcast<T>(instance)->length();
+    return downcast<T>(obj)->length();
 }
 
 template <class T>
-int Class<T>::instance_sequence_length(PyObject* instance) const
+int class_t<T>::instance_sequence_length(PyObject* obj) const
 {
-    return Downcast<T>(instance)->length();
+    return downcast<T>(obj)->length();
 }
 
 template <class T>
-PyObject* Class<T>::instance_mapping_subscript(PyObject* instance, PyObject* key) const
+PyObject* class_t<T>::instance_mapping_subscript(PyObject* obj, PyObject* key) const
 {
-    return Downcast<T>(instance)->get_subscript(key);
+    return downcast<T>(obj)->get_subscript(key);
 }
 
 template <class T>
-PyObject* Class<T>::instance_sequence_item(PyObject* instance, int n) const
+PyObject* class_t<T>::instance_sequence_item(PyObject* obj, int n) const
 {
-    Ptr key(to_python(n));
-    return Downcast<T>(instance)->get_subscript(key.get());
+    ref key(to_python(n));
+    return downcast<T>(obj)->get_subscript(key.get());
 }
 
 template <class T>
-int Class<T>::instance_sequence_ass_item(PyObject* instance, int n, PyObject* value) const
+int class_t<T>::instance_sequence_ass_item(PyObject* obj, int n, PyObject* value) const
 {
-    Ptr key(to_python(n));
-    Downcast<T>(instance)->set_subscript(key.get(), value);
+    ref key(to_python(n));
+    downcast<T>(obj)->set_subscript(key.get(), value);
     return 0;
 }
 
 template <class T>
-int Class<T>::instance_mapping_ass_subscript(PyObject* instance, PyObject* key, PyObject* value) const
+int class_t<T>::instance_mapping_ass_subscript(PyObject* obj, PyObject* key, PyObject* value) const
 {
-    Downcast<T>(instance)->set_subscript(key, value);
+    downcast<T>(obj)->set_subscript(key, value);
     return 0;
 }
 
-void adjust_slice_indices(PyObject* instance, int& start, int& finish);
+void adjust_slice_indices(PyObject* obj, int& start, int& finish);
 
 template <class T>
-PyObject* Class<T>::instance_sequence_slice(PyObject* instance, int start, int finish) const
+PyObject* class_t<T>::instance_sequence_slice(PyObject* obj, int start, int finish) const
 {
-    adjust_slice_indices(instance, start, finish);    
-    return Downcast<T>(instance)->get_slice(start, finish);
+    adjust_slice_indices(obj, start, finish);    
+    return downcast<T>(obj)->get_slice(start, finish);
 }
 
 template <class T>
-int Class<T>::instance_sequence_ass_slice(PyObject* instance, int start, int finish, PyObject* value) const
+int class_t<T>::instance_sequence_ass_slice(PyObject* obj, int start, int finish, PyObject* value) const
 {
-    adjust_slice_indices(instance, start, finish);
-    Downcast<T>(instance)->set_slice(start, finish, value);
+    adjust_slice_indices(obj, start, finish);
+    downcast<T>(obj)->set_slice(start, finish, value);
     return 0;
 }
 
 template <class T>
-PyObject* Class<T>::instance_call(PyObject* instance, PyObject* args, PyObject* keywords) const
+PyObject* class_t<T>::instance_call(PyObject* obj, PyObject* args, PyObject* keywords) const
 {
-    return Downcast<T>(instance)->call(args, keywords);
+    return downcast<T>(obj)->call(args, keywords);
 }
 
 template <class T>
-PyObject* Class<T>::instance_getattr(PyObject* instance, const char* name) const
+PyObject* class_t<T>::instance_getattr(PyObject* obj, const char* name) const
 {
-    return Downcast<T>(instance)->getattr(name);
+    return downcast<T>(obj)->getattr(name);
 }
 
 
 template <class T>
-int Class<T>::instance_setattr(PyObject* instance, const char* name, PyObject* value) const
+int class_t<T>::instance_setattr(PyObject* obj, const char* name, PyObject* value) const
 {
-    return Downcast<T>(instance)->setattr(name, value);
+    return downcast<T>(obj)->setattr(name, value);
 }
 
 template <class T>
-PyObject* Class<T>::instance_number_add(PyObject* instance, PyObject* other) const
+PyObject* class_t<T>::instance_number_add(PyObject* obj, PyObject* other) const
 {
-    return Downcast<T>(instance)->add(other);
+    return downcast<T>(obj)->add(other);
 }
 
 template <class T>
-PyObject* Class<T>::instance_number_subtract(PyObject* instance, PyObject* other) const
+PyObject* class_t<T>::instance_number_subtract(PyObject* obj, PyObject* other) const
 {
-    return Downcast<T>(instance)->subtract(other);
+    return downcast<T>(obj)->subtract(other);
 }
 
 template <class T>
-PyObject* Class<T>::instance_number_multiply(PyObject* instance, PyObject* other) const
+PyObject* class_t<T>::instance_number_multiply(PyObject* obj, PyObject* other) const
 {
-    return Downcast<T>(instance)->multiply(other);
+    return downcast<T>(obj)->multiply(other);
 }
 
 template <class T>
-PyObject* Class<T>::instance_number_divide(PyObject* instance, PyObject* other) const
+PyObject* class_t<T>::instance_number_divide(PyObject* obj, PyObject* other) const
 {
-    return Downcast<T>(instance)->divide(other);
+    return downcast<T>(obj)->divide(other);
 }
 
 template <class T>
-PyObject* Class<T>::instance_number_remainder(PyObject* instance, PyObject* other) const
+PyObject* class_t<T>::instance_number_remainder(PyObject* obj, PyObject* other) const
 {
-    return Downcast<T>(instance)->remainder(other);
+    return downcast<T>(obj)->remainder(other);
 }
 
 template <class T>
-PyObject* Class<T>::instance_number_divmod(PyObject* instance, PyObject* other) const
+PyObject* class_t<T>::instance_number_divmod(PyObject* obj, PyObject* other) const
 {
-    return Downcast<T>(instance)->divmod(other);
+    return downcast<T>(obj)->divmod(other);
 }
 
 template <class T>
-PyObject* Class<T>::instance_number_power(PyObject* instance, PyObject* exponent, PyObject* modulus) const
+PyObject* class_t<T>::instance_number_power(PyObject* obj, PyObject* exponent, PyObject* modulus) const
 {
-    return Downcast<T>(instance)->power(exponent, modulus);
+    return downcast<T>(obj)->power(exponent, modulus);
 }
 
 template <class T>
-PyObject* Class<T>::instance_number_negative(PyObject* instance) const
+PyObject* class_t<T>::instance_number_negative(PyObject* obj) const
 {
-    return Downcast<T>(instance)->negative();
+    return downcast<T>(obj)->negative();
 }
 
 template <class T>
-PyObject* Class<T>::instance_number_positive(PyObject* instance) const
+PyObject* class_t<T>::instance_number_positive(PyObject* obj) const
 {
-    return Downcast<T>(instance)->positive();
+    return downcast<T>(obj)->positive();
 }
 
 template <class T>
-PyObject* Class<T>::instance_number_absolute(PyObject* instance) const
+PyObject* class_t<T>::instance_number_absolute(PyObject* obj) const
 {
-    return Downcast<T>(instance)->absolute();
+    return downcast<T>(obj)->absolute();
 }
 
 template <class T>
-int Class<T>::instance_number_nonzero(PyObject* instance) const
+int class_t<T>::instance_number_nonzero(PyObject* obj) const
 {
-    return Downcast<T>(instance)->nonzero();
+    return downcast<T>(obj)->nonzero();
 }
 
 template <class T>
-PyObject* Class<T>::instance_number_invert(PyObject* instance) const
+PyObject* class_t<T>::instance_number_invert(PyObject* obj) const
 {
-    return Downcast<T>(instance)->invert();
+    return downcast<T>(obj)->invert();
 }
 
 template <class T>
-PyObject* Class<T>::instance_number_lshift(PyObject* instance, PyObject* other) const
+PyObject* class_t<T>::instance_number_lshift(PyObject* obj, PyObject* other) const
 {
-    return Downcast<T>(instance)->lshift(other);
+    return downcast<T>(obj)->lshift(other);
 }
 
 template <class T>
-PyObject* Class<T>::instance_number_rshift(PyObject* instance, PyObject* other) const
+PyObject* class_t<T>::instance_number_rshift(PyObject* obj, PyObject* other) const
 {
-    return Downcast<T>(instance)->rshift(other);
+    return downcast<T>(obj)->rshift(other);
 }
 
 template <class T>
-PyObject* Class<T>::instance_number_and(PyObject* instance, PyObject* other) const
+PyObject* class_t<T>::instance_number_and(PyObject* obj, PyObject* other) const
 {
-    return Downcast<T>(instance)->do_and(other);
+    return downcast<T>(obj)->do_and(other);
 }
 
 template <class T>
-PyObject* Class<T>::instance_number_xor(PyObject* instance, PyObject* other) const
+PyObject* class_t<T>::instance_number_xor(PyObject* obj, PyObject* other) const
 {
-    return Downcast<T>(instance)->do_xor(other);
+    return downcast<T>(obj)->do_xor(other);
 }
 
 template <class T>
-PyObject* Class<T>::instance_number_or(PyObject* instance, PyObject* other) const
+PyObject* class_t<T>::instance_number_or(PyObject* obj, PyObject* other) const
 {
-    return Downcast<T>(instance)->do_or(other);
+    return downcast<T>(obj)->do_or(other);
 }
 
 template <class T>
-int Class<T>::instance_number_coerce(PyObject* instance, PyObject** x, PyObject** y) const
+int class_t<T>::instance_number_coerce(PyObject* obj, PyObject** x, PyObject** y) const
 {
-    return Downcast<T>(instance)->coerce(x, y);
+    return downcast<T>(obj)->coerce(x, y);
 }
 
 template <class T>
-PyObject* Class<T>::instance_number_int(PyObject* instance) const
+PyObject* class_t<T>::instance_number_int(PyObject* obj) const
 {
-    return Downcast<T>(instance)->as_int();
+    return downcast<T>(obj)->as_int();
 }
 
 template <class T>
-PyObject* Class<T>::instance_number_long(PyObject* instance) const
+PyObject* class_t<T>::instance_number_long(PyObject* obj) const
 {
-    return Downcast<T>(instance)->as_long();
+    return downcast<T>(obj)->as_long();
 }
 
 template <class T>
-PyObject* Class<T>::instance_number_float(PyObject* instance) const
+PyObject* class_t<T>::instance_number_float(PyObject* obj) const
 {
-    return Downcast<T>(instance)->as_float();
+    return downcast<T>(obj)->as_float();
 }
 
 template <class T>
-PyObject* Class<T>::instance_number_oct(PyObject* instance) const
+PyObject* class_t<T>::instance_number_oct(PyObject* obj) const
 {
-    return Downcast<T>(instance)->oct();
+    return downcast<T>(obj)->oct();
 }
 
 template <class T>
-PyObject* Class<T>::instance_number_hex(PyObject* instance) const
+PyObject* class_t<T>::instance_number_hex(PyObject* obj) const
 {
-    return Downcast<T>(instance)->hex();
+    return downcast<T>(obj)->hex();
 }
 
 namespace detail {
-  inline Dict& ClassBase::dict()
+  inline dictionary& class_base::dict()
   {
       return m_name_space;
   }
 
-  inline Tuple ClassBase::bases() const
+  inline tuple class_base::bases() const
   {
       return m_bases;
   }
 }
 
 template <class T>
-PyObject* MetaClass<T>::call(PyObject* args, PyObject* /*keywords*/)
+PyObject* meta_class<T>::call(PyObject* args, PyObject* /*keywords*/)
 {
     PyObject* name;
     PyObject* bases;
@@ -505,23 +505,23 @@ PyObject* MetaClass<T>::call(PyObject* args, PyObject* /*keywords*/)
     }
     
     return as_object(
-        new Class<T>(this, String(Ptr(name, Ptr::borrowed)),
-                  Tuple(Ptr(bases, Ptr::borrowed)),
-                  Dict(Ptr(name_space, Ptr::borrowed)))
+        new class_t<T>(this, string(ref(name, ref::increment_count)),
+                  tuple(ref(bases, ref::increment_count)),
+                  dictionary(ref(name_space, ref::increment_count)))
         );
 }
 
 namespace detail {
-  const String& setattr_string();
-  const String& getattr_string();
-  const String& delattr_string();
+  const string& setattr_string();
+  const string& getattr_string();
+  const string& delattr_string();
 
-  inline String ClassBase::name() const
+  inline string class_base::name() const
   {
       return m_name;
   }
 }
 
 
-} // namespace py
+} // namespace python
 #endif
diff --git a/test_extclass.py b/test_extclass.py
index afe7d0f8..578197f1 100644
--- a/test_extclass.py
+++ b/test_extclass.py
@@ -166,7 +166,7 @@ But objects not derived from Bar cannot:
     TypeError: extension class 'Baz' is not convertible into 'Bar'.
 
 The clone function on Baz returns a smart pointer; we wrap it into an
-ExtensionInstance and  make it look just like any other Baz instance.
+extension_instance and  make it look just like any other Baz obj.
 
     >>> baz_clone = baz.clone()
     >>> baz_clone.pass_bar(mi).first()
@@ -403,7 +403,7 @@ delete non-existent attribute:
     del m.foobar
     Traceback (innermost last):
       File "<stdin>", line 1, in ?
-    AttributeError: delete non-existing instance attribute
+    AttributeError: delete non-existing obj attribute
     
 Testing __getattr__ and __getattr__<name>:
   
diff --git a/under-the-hood.html b/under-the-hood.html
index d36fcbfd..7acbf37d 100644
--- a/under-the-hood.html
+++ b/under-the-hood.html
@@ -11,10 +11,10 @@
       A Peek Under the Hood
     </h1>
     <p>
-      <code> ExtensionClass&lt;T&gt;</code> is a subclass of <code>
+      <code> extension_class&lt;T&gt;</code> is a subclass of <code>
       PyTypeObject</code>, the <code> struct</code> which Python's 'C' API uses
-      to describe a type. <a href="example1.html#world_class">An instance of
-      the <code>ExtensionClass&lt;&gt;</code></a> becomes the Python type
+      to describe a type. <a href="example1.html#world_class">An obj of
+      the <code>extension_class&lt;&gt;</code></a> becomes the Python type
       object corresponding to <code>hello::world</code>. When we <a href= 
       "example1.html#add_world_class">add it to the module</a> it goes into the
       module's dictionary to be looked up under the name "world".
@@ -26,10 +26,10 @@
       overloaded functions <code>PyObject*
       to_python(</code><em>S</em><code>)</code> and <em>
       S'</em><code>from_python(PyObject*,
-      Type&lt;</code><em>S</em><code>&gt;)</code> which convert between any C++
+      type&lt;</code><em>S</em><code>&gt;)</code> which convert between any C++
       type <em>S</em> and a <code>PyObject*</code>, the type which represents a
       reference to any Python object in its 'C' API. The <a href= 
-      "example1.html#world_class"><code>ExtensionClass&lt;T&gt;</code></a>
+      "example1.html#world_class"><code>extension_class&lt;T&gt;</code></a>
       template defines a whole raft of these conversions (for <code>T, T*,
       T&amp;, std::auto_ptr&lt;T&gt;</code>, etc.), using the same inline
       friend function technique employed by <a href= 
@@ -38,15 +38,15 @@
     <p>
       Because the <code>to_python</code> and <code>from_python</code> functions
       for a user-defined class are defined by <code>
-      ExtensionClass&lt;T&gt;</code>, it is important that an instantiation of
-      <code> ExtensionClass&lt;T&gt;</code> is visible to any code which wraps
+      extension_class&lt;T&gt;</code>, it is important that an instantiation of
+      <code> extension_class&lt;T&gt;</code> is visible to any code which wraps
       a C++ function with a <code>T, T*, const T&amp;</code>, etc. parameter or
       return value. In particular, you may want to create all of the classes at
       the top of your module's init function, then <code>def</code> the member
       functions later to avoid problems with inter-class dependencies.
     <p>
-      Previous: <a href="overriding.html">Function Overloading</a>
-      Next: <a href="building.html">Building a Module with Py_cpp</a>
+      Previous: <a href="overriding.html">function Overloading</a>
+      Next: <a href="building.html">Building a module_builder with Py_cpp</a>
       Up: <a href="py_cpp.html">Top</a>
     <p>
       &copy; Copyright David Abrahams 2000. Permission to copy, use, modify,