diff --git a/bindings/python/ns3module_helpers.cc b/bindings/python/ns3module_helpers.cc
index 92c3cefb3..9951ef80d 100644
--- a/bindings/python/ns3module_helpers.cc
+++ b/bindings/python/ns3module_helpers.cc
@@ -2,7 +2,7 @@
 #include "ns3/ref-count-base.h"
 
 
-namespace ns3{
+namespace ns3 {
 
 void PythonCompleteConstruct (Ptr<Object> object, TypeId typeId, const AttributeList &attributes)
 {
@@ -17,320 +17,320 @@ void PythonCompleteConstruct (Ptr<Object> object, TypeId typeId, const Attribute
 class PythonEventImpl : public ns3::EventImpl
 {
 private:
-    PyObject *m_callback;
-    PyObject *m_args;
+  PyObject *m_callback;
+  PyObject *m_args;
 public:
-    PythonEventImpl (PyObject *callback, PyObject *args)
-    {
-        m_callback = callback;
-        Py_INCREF(m_callback);
-        m_args = args;
-        Py_INCREF(m_args);
-    }
-    virtual ~PythonEventImpl ()
-    {
-        PyGILState_STATE __py_gil_state;
-        __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
+  PythonEventImpl (PyObject *callback, PyObject *args)
+  {
+    m_callback = callback;
+    Py_INCREF (m_callback);
+    m_args = args;
+    Py_INCREF (m_args);
+  }
+  virtual ~PythonEventImpl ()
+  {
+    PyGILState_STATE __py_gil_state;
+    __py_gil_state = (PyEval_ThreadsInitialized () ? PyGILState_Ensure () : (PyGILState_STATE) 0);
 
-        Py_DECREF(m_callback);
-        Py_DECREF(m_args);
+    Py_DECREF (m_callback);
+    Py_DECREF (m_args);
 
-        if (PyEval_ThreadsInitialized())
-            PyGILState_Release(__py_gil_state);
-    }
-    virtual void Notify ()
-    {
-        PyGILState_STATE __py_gil_state;
-        __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);
-        
-        PyObject *retval = PyObject_CallObject(m_callback, m_args);
-        if (retval) {
-            if (retval != Py_None) {
-                PyErr_SetString(PyExc_TypeError, "event callback should return None");
-                PyErr_Print();
-            }
-            Py_DECREF(retval);
-        } else {
-             PyErr_Print();
-        }
+    if (PyEval_ThreadsInitialized ())
+      PyGILState_Release (__py_gil_state);
+  }
+  virtual void Notify ()
+  {
+    PyGILState_STATE __py_gil_state;
+    __py_gil_state = (PyEval_ThreadsInitialized () ? PyGILState_Ensure () : (PyGILState_STATE) 0);
 
-        if (PyEval_ThreadsInitialized())
-            PyGILState_Release(__py_gil_state);
-    }
+    PyObject *retval = PyObject_CallObject (m_callback, m_args);
+    if (retval) {
+        if (retval != Py_None) {
+            PyErr_SetString (PyExc_TypeError, "event callback should return None");
+            PyErr_Print ();
+          }
+        Py_DECREF (retval);
+      } else {
+        PyErr_Print ();
+      }
+
+    if (PyEval_ThreadsInitialized ())
+      PyGILState_Release (__py_gil_state);
+  }
 };
 
 
 PyObject *
-_wrap_Simulator_Schedule(PyNs3Simulator *PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs,
-                         PyObject **return_exception)
+_wrap_Simulator_Schedule (PyNs3Simulator *PYBINDGEN_UNUSED (dummy), PyObject *args, PyObject *kwargs,
+                          PyObject **return_exception)
 {
-    PyObject *exc_type, *traceback;
-    PyObject *py_time;
-    PyObject *py_callback;
-    PyObject *user_args;
-    ns3::Ptr<PythonEventImpl> py_event_impl;
-    PyNs3EventId *py_EventId;
+  PyObject *exc_type, *traceback;
+  PyObject *py_time;
+  PyObject *py_callback;
+  PyObject *user_args;
+  ns3::Ptr<PythonEventImpl> py_event_impl;
+  PyNs3EventId *py_EventId;
 
-    if (kwargs && PyObject_Length(kwargs) > 0) {
-        PyErr_SetString(PyExc_TypeError, "keyword arguments not supported");
-        goto error;
+  if (kwargs && PyObject_Length (kwargs) > 0) {
+      PyErr_SetString (PyExc_TypeError, "keyword arguments not supported");
+      goto error;
     }
 
-    if (PyTuple_GET_SIZE(args) < 2) {
-        PyErr_SetString(PyExc_TypeError, "ns3.Simulator.Schedule needs at least 2 arguments");
-        goto error;
+  if (PyTuple_GET_SIZE (args) < 2) {
+      PyErr_SetString (PyExc_TypeError, "ns3.Simulator.Schedule needs at least 2 arguments");
+      goto error;
     }
-    py_time = PyTuple_GET_ITEM(args, 0);
-    py_callback = PyTuple_GET_ITEM(args, 1);
+  py_time = PyTuple_GET_ITEM (args, 0);
+  py_callback = PyTuple_GET_ITEM (args, 1);
 
-    if (!PyObject_IsInstance(py_time, (PyObject*) &PyNs3Time_Type)) {
-        PyErr_SetString(PyExc_TypeError, "Parameter 1 should be a ns3.Time instance");
-        goto error;
+  if (!PyObject_IsInstance (py_time, (PyObject*) &PyNs3Time_Type)) {
+      PyErr_SetString (PyExc_TypeError, "Parameter 1 should be a ns3.Time instance");
+      goto error;
     }
-    if (!PyCallable_Check(py_callback)) {
-        PyErr_SetString(PyExc_TypeError, "Parameter 2 should be callable");
-        goto error;
+  if (!PyCallable_Check (py_callback)) {
+      PyErr_SetString (PyExc_TypeError, "Parameter 2 should be callable");
+      goto error;
     }
-    user_args = PyTuple_GetSlice(args, 2, PyTuple_GET_SIZE(args));
-    py_event_impl = ns3::Create<PythonEventImpl>(py_callback, user_args);
-    Py_DECREF(user_args);
+  user_args = PyTuple_GetSlice (args, 2, PyTuple_GET_SIZE (args));
+  py_event_impl = ns3::Create<PythonEventImpl>(py_callback, user_args);
+  Py_DECREF (user_args);
 
-    py_EventId = PyObject_New(PyNs3EventId, &PyNs3EventId_Type);
-    py_EventId->obj = new ns3::EventId(
-       ns3::Simulator::Schedule(*((PyNs3Time *) py_time)->obj, py_event_impl));
-    return (PyObject *) py_EventId;
+  py_EventId = PyObject_New (PyNs3EventId, &PyNs3EventId_Type);
+  py_EventId->obj = new ns3::EventId (
+    ns3::Simulator::Schedule (*((PyNs3Time *) py_time)->obj, py_event_impl));
+  return (PyObject *) py_EventId;
 
 error:
-    PyErr_Fetch(&exc_type, return_exception, &traceback);
-    Py_XDECREF(exc_type);
-    Py_XDECREF(traceback);
-    return NULL;
+  PyErr_Fetch (&exc_type, return_exception, &traceback);
+  Py_XDECREF (exc_type);
+  Py_XDECREF (traceback);
+  return NULL;
 }
 
 
 PyObject *
-_wrap_Simulator_ScheduleNow(PyNs3Simulator *PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs,
-                            PyObject **return_exception)
+_wrap_Simulator_ScheduleNow (PyNs3Simulator *PYBINDGEN_UNUSED (dummy), PyObject *args, PyObject *kwargs,
+                             PyObject **return_exception)
 {
-    PyObject *exc_type, *traceback;
-    PyObject *py_callback;
-    PyObject *user_args;
-    ns3::Ptr<PythonEventImpl> py_event_impl;
-    PyNs3EventId *py_EventId;
+  PyObject *exc_type, *traceback;
+  PyObject *py_callback;
+  PyObject *user_args;
+  ns3::Ptr<PythonEventImpl> py_event_impl;
+  PyNs3EventId *py_EventId;
 
-    if (kwargs && PyObject_Length(kwargs) > 0) {
-        PyErr_SetString(PyExc_TypeError, "keyword arguments not supported");
-        goto error;
+  if (kwargs && PyObject_Length (kwargs) > 0) {
+      PyErr_SetString (PyExc_TypeError, "keyword arguments not supported");
+      goto error;
     }
 
-    if (PyTuple_GET_SIZE(args) < 1) {
-        PyErr_SetString(PyExc_TypeError, "ns3.Simulator.Schedule needs at least 1 argument");
-        goto error;
+  if (PyTuple_GET_SIZE (args) < 1) {
+      PyErr_SetString (PyExc_TypeError, "ns3.Simulator.Schedule needs at least 1 argument");
+      goto error;
     }
-    py_callback = PyTuple_GET_ITEM(args, 0);
+  py_callback = PyTuple_GET_ITEM (args, 0);
 
-    if (!PyCallable_Check(py_callback)) {
-        PyErr_SetString(PyExc_TypeError, "Parameter 2 should be callable");
-        goto error;
+  if (!PyCallable_Check (py_callback)) {
+      PyErr_SetString (PyExc_TypeError, "Parameter 2 should be callable");
+      goto error;
     }
-    user_args = PyTuple_GetSlice(args, 1, PyTuple_GET_SIZE(args));
-    py_event_impl = ns3::Create<PythonEventImpl>(py_callback, user_args);
-    Py_DECREF(user_args);
+  user_args = PyTuple_GetSlice (args, 1, PyTuple_GET_SIZE (args));
+  py_event_impl = ns3::Create<PythonEventImpl>(py_callback, user_args);
+  Py_DECREF (user_args);
 
-    py_EventId = PyObject_New(PyNs3EventId, &PyNs3EventId_Type);
-    py_EventId->obj = new ns3::EventId(ns3::Simulator::ScheduleNow(py_event_impl));
-    return (PyObject *) py_EventId;
+  py_EventId = PyObject_New (PyNs3EventId, &PyNs3EventId_Type);
+  py_EventId->obj = new ns3::EventId (ns3::Simulator::ScheduleNow (py_event_impl));
+  return (PyObject *) py_EventId;
 
 error:
-    PyErr_Fetch(&exc_type, return_exception, &traceback);
-    Py_XDECREF(exc_type);
-    Py_XDECREF(traceback);
-    return NULL;
+  PyErr_Fetch (&exc_type, return_exception, &traceback);
+  Py_XDECREF (exc_type);
+  Py_XDECREF (traceback);
+  return NULL;
 }
 
 
 PyObject *
-_wrap_Simulator_ScheduleDestroy(PyNs3Simulator *PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs,
-                                PyObject **return_exception)
+_wrap_Simulator_ScheduleDestroy (PyNs3Simulator *PYBINDGEN_UNUSED (dummy), PyObject *args, PyObject *kwargs,
+                                 PyObject **return_exception)
 {
-    PyObject *exc_type, *traceback;
-    PyObject *py_callback;
-    PyObject *user_args;
-    ns3::Ptr<PythonEventImpl> py_event_impl;
-    PyNs3EventId *py_EventId;
+  PyObject *exc_type, *traceback;
+  PyObject *py_callback;
+  PyObject *user_args;
+  ns3::Ptr<PythonEventImpl> py_event_impl;
+  PyNs3EventId *py_EventId;
 
-    if (kwargs && PyObject_Length(kwargs) > 0) {
-        PyErr_SetString(PyExc_TypeError, "keyword arguments not supported");
-        goto error;
+  if (kwargs && PyObject_Length (kwargs) > 0) {
+      PyErr_SetString (PyExc_TypeError, "keyword arguments not supported");
+      goto error;
     }
 
-    if (PyTuple_GET_SIZE(args) < 1) {
-        PyErr_SetString(PyExc_TypeError, "ns3.Simulator.Schedule needs at least 1 argument");
-        goto error;
+  if (PyTuple_GET_SIZE (args) < 1) {
+      PyErr_SetString (PyExc_TypeError, "ns3.Simulator.Schedule needs at least 1 argument");
+      goto error;
     }
-    py_callback = PyTuple_GET_ITEM(args, 0);
+  py_callback = PyTuple_GET_ITEM (args, 0);
 
-    if (!PyCallable_Check(py_callback)) {
-        PyErr_SetString(PyExc_TypeError, "Parameter 2 should be callable");
-        goto error;
+  if (!PyCallable_Check (py_callback)) {
+      PyErr_SetString (PyExc_TypeError, "Parameter 2 should be callable");
+      goto error;
     }
-    user_args = PyTuple_GetSlice(args, 1, PyTuple_GET_SIZE(args));
-    py_event_impl = ns3::Create<PythonEventImpl>(py_callback, user_args);
-    Py_DECREF(user_args);
+  user_args = PyTuple_GetSlice (args, 1, PyTuple_GET_SIZE (args));
+  py_event_impl = ns3::Create<PythonEventImpl>(py_callback, user_args);
+  Py_DECREF (user_args);
 
-    py_EventId = PyObject_New(PyNs3EventId, &PyNs3EventId_Type);
-    py_EventId->obj = new ns3::EventId(ns3::Simulator::ScheduleDestroy(py_event_impl));
-    return (PyObject *) py_EventId;
+  py_EventId = PyObject_New (PyNs3EventId, &PyNs3EventId_Type);
+  py_EventId->obj = new ns3::EventId (ns3::Simulator::ScheduleDestroy (py_event_impl));
+  return (PyObject *) py_EventId;
 
 error:
-    PyErr_Fetch(&exc_type, return_exception, &traceback);
-    Py_XDECREF(exc_type);
-    Py_XDECREF(traceback);
-    return NULL;
+  PyErr_Fetch (&exc_type, return_exception, &traceback);
+  Py_XDECREF (exc_type);
+  Py_XDECREF (traceback);
+  return NULL;
 }
 
 
 PyObject *
-_wrap_TypeId_LookupByNameFailSafe(PyNs3TypeId *PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs,
-                                  PyObject **return_exception)
+_wrap_TypeId_LookupByNameFailSafe (PyNs3TypeId *PYBINDGEN_UNUSED (dummy), PyObject *args, PyObject *kwargs,
+                                   PyObject **return_exception)
 {
-    bool ok;
-    const char *name;
-    Py_ssize_t name_len;
-    ns3::TypeId tid;
-    PyNs3TypeId *py_tid;
-    const char *keywords[] = {"name", NULL};
-    
-    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "s#", (char **) keywords, &name, &name_len)) {
-        PyObject *exc_type, *traceback;
-        PyErr_Fetch(&exc_type, return_exception, &traceback);
-        Py_XDECREF(exc_type);
-        Py_XDECREF(traceback);
-        return NULL;
+  bool ok;
+  const char *name;
+  Py_ssize_t name_len;
+  ns3::TypeId tid;
+  PyNs3TypeId *py_tid;
+  const char *keywords[] = {"name", NULL};
+
+  if (!PyArg_ParseTupleAndKeywords (args, kwargs, (char *) "s#", (char **) keywords, &name, &name_len)) {
+      PyObject *exc_type, *traceback;
+      PyErr_Fetch (&exc_type, return_exception, &traceback);
+      Py_XDECREF (exc_type);
+      Py_XDECREF (traceback);
+      return NULL;
     }
-    ok = ns3::TypeId::LookupByNameFailSafe(std::string(name, name_len), &tid);
-    if (!ok)
+  ok = ns3::TypeId::LookupByNameFailSafe (std::string (name, name_len), &tid);
+  if (!ok)
     {
-        PyErr_Format(PyExc_KeyError, "The ns3 type with name `%s' is not registered", name);
-        return NULL;
+      PyErr_Format (PyExc_KeyError, "The ns3 type with name `%s' is not registered", name);
+      return NULL;
     }
 
-    py_tid = PyObject_New(PyNs3TypeId, &PyNs3TypeId_Type);
-    py_tid->obj = new ns3::TypeId (tid);
-    PyNs3TypeId_wrapper_registry[(void *) py_tid->obj] = (PyObject *) py_tid;    
-    
-    return (PyObject *) py_tid;
+  py_tid = PyObject_New (PyNs3TypeId, &PyNs3TypeId_Type);
+  py_tid->obj = new ns3::TypeId (tid);
+  PyNs3TypeId_wrapper_registry[(void *) py_tid->obj] = (PyObject *) py_tid;
+
+  return (PyObject *) py_tid;
 }
 
 
 class CommandLinePythonValueSetter : public ns3::RefCountBase
 {
-    PyObject *m_namespace;
-    std::string m_variable;
+  PyObject *m_namespace;
+  std::string m_variable;
 public:
-    CommandLinePythonValueSetter (PyObject *ns, std::string const &variable) {
-        Py_INCREF(ns);
-        m_namespace = ns;
-        m_variable = variable;
-    }
-    bool Parse (std::string value) {
-        PyObject *pyvalue = PyString_FromStringAndSize (value.data(), value.size());
-        PyObject_SetAttrString (m_namespace, (char *) m_variable.c_str(), pyvalue);
-        if (PyErr_Occurred()) {
-            PyErr_Print();
-            return false;
-        }
-        return true;
-    }
-    virtual ~CommandLinePythonValueSetter () {
-        Py_DECREF (m_namespace);
-        m_namespace = NULL;
-    }
-    
+  CommandLinePythonValueSetter (PyObject *ns, std::string const &variable) {
+    Py_INCREF (ns);
+    m_namespace = ns;
+    m_variable = variable;
+  }
+  bool Parse (std::string value) {
+    PyObject *pyvalue = PyString_FromStringAndSize (value.data (), value.size ());
+    PyObject_SetAttrString (m_namespace, (char *) m_variable.c_str (), pyvalue);
+    if (PyErr_Occurred ()) {
+        PyErr_Print ();
+        return false;
+      }
+    return true;
+  }
+  virtual ~CommandLinePythonValueSetter () {
+    Py_DECREF (m_namespace);
+    m_namespace = NULL;
+  }
+
 };
 
 PyObject *
-_wrap_CommandLine_AddValue(PyNs3CommandLine *self, PyObject *args, PyObject *kwargs,
-                           PyObject **return_exception)
+_wrap_CommandLine_AddValue (PyNs3CommandLine *self, PyObject *args, PyObject *kwargs,
+                            PyObject **return_exception)
 {
-    const char *name, *help, *variable = NULL;
-    PyObject *py_namespace = NULL;
-    const char *keywords[] = {"name", "help", "variable", "namespace", NULL};
-    
-    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "ss|sO", (char **) keywords, &name, &help, &variable, &py_namespace)) {
-        PyObject *exc_type, *traceback;
-        PyErr_Fetch(&exc_type, return_exception, &traceback);
-        Py_XDECREF(exc_type);
-        Py_XDECREF(traceback);
-        return NULL;
-    }
-    
-    if (variable == NULL) {
-        variable = name;
-    }
-    if (py_namespace == NULL) {
-        py_namespace = (PyObject *) self;
+  const char *name, *help, *variable = NULL;
+  PyObject *py_namespace = NULL;
+  const char *keywords[] = {"name", "help", "variable", "namespace", NULL};
+
+  if (!PyArg_ParseTupleAndKeywords (args, kwargs, (char *) "ss|sO", (char **) keywords, &name, &help, &variable, &py_namespace)) {
+      PyObject *exc_type, *traceback;
+      PyErr_Fetch (&exc_type, return_exception, &traceback);
+      Py_XDECREF (exc_type);
+      Py_XDECREF (traceback);
+      return NULL;
     }
 
-    ns3::Ptr<CommandLinePythonValueSetter> setter = ns3::Create<CommandLinePythonValueSetter> (py_namespace, variable);
-    self->obj->AddValue (name, help, ns3::MakeCallback (&CommandLinePythonValueSetter::Parse, setter));
+  if (variable == NULL) {
+      variable = name;
+    }
+  if (py_namespace == NULL) {
+      py_namespace = (PyObject *) self;
+    }
 
-    Py_INCREF(Py_None);
-    return Py_None;
+  ns3::Ptr<CommandLinePythonValueSetter> setter = ns3::Create<CommandLinePythonValueSetter> (py_namespace, variable);
+  self->obj->AddValue (name, help, ns3::MakeCallback (&CommandLinePythonValueSetter::Parse, setter));
+
+  Py_INCREF (Py_None);
+  return Py_None;
 }
 
 
 PyObject *
-_wrap_Simulator_Run(PyNs3Simulator *PYBINDGEN_UNUSED(dummy), PyObject *args, PyObject *kwargs,
-                    PyObject **return_exception)
+_wrap_Simulator_Run (PyNs3Simulator *PYBINDGEN_UNUSED (dummy), PyObject *args, PyObject *kwargs,
+                     PyObject **return_exception)
 {
-    const char *keywords[] = {"signal_check_frequency", NULL};
-    int signal_check_frequency;
+  const char *keywords[] = {"signal_check_frequency", NULL};
+  int signal_check_frequency;
 
-    ns3::Ptr<ns3::DefaultSimulatorImpl> defaultSim =
-        ns3::DynamicCast<ns3::DefaultSimulatorImpl> (ns3::Simulator::GetImplementation ());
-    if (defaultSim) {
-        signal_check_frequency = 100;
+  ns3::Ptr<ns3::DefaultSimulatorImpl> defaultSim =
+    ns3::DynamicCast<ns3::DefaultSimulatorImpl> (ns3::Simulator::GetImplementation ());
+  if (defaultSim) {
+      signal_check_frequency = 100;
     } else {
-        signal_check_frequency = -1;
-    }
-    
-    if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "|i", (char **) keywords, &signal_check_frequency)) {
-        PyObject *exc_type, *traceback;
-        PyErr_Fetch(&exc_type, return_exception, &traceback);
-        Py_XDECREF(exc_type);
-        Py_XDECREF(traceback);
-        return NULL;
+      signal_check_frequency = -1;
     }
 
-    PyThreadState *py_thread_state = NULL;
+  if (!PyArg_ParseTupleAndKeywords (args, kwargs, (char *) "|i", (char **) keywords, &signal_check_frequency)) {
+      PyObject *exc_type, *traceback;
+      PyErr_Fetch (&exc_type, return_exception, &traceback);
+      Py_XDECREF (exc_type);
+      Py_XDECREF (traceback);
+      return NULL;
+    }
 
-    if (signal_check_frequency == -1)
+  PyThreadState *py_thread_state = NULL;
+
+  if (signal_check_frequency == -1)
     {
-        if (PyEval_ThreadsInitialized ())
-            py_thread_state = PyEval_SaveThread();
-        ns3::Simulator::Run();
-        if (py_thread_state)
-            PyEval_RestoreThread(py_thread_state);
+      if (PyEval_ThreadsInitialized ())
+        py_thread_state = PyEval_SaveThread ();
+      ns3::Simulator::Run ();
+      if (py_thread_state)
+        PyEval_RestoreThread (py_thread_state);
     } else {
-        while (!ns3::Simulator::IsFinished())
-        {        
-            if (PyEval_ThreadsInitialized())
-                py_thread_state = PyEval_SaveThread();
+      while (!ns3::Simulator::IsFinished ())
+        {
+          if (PyEval_ThreadsInitialized ())
+            py_thread_state = PyEval_SaveThread ();
 
-            for (int n = signal_check_frequency; n > 0 && !ns3::Simulator::IsFinished(); --n)
-            {        
-                ns3::Simulator::RunOneEvent();
+          for (int n = signal_check_frequency; n > 0 && !ns3::Simulator::IsFinished (); --n)
+            {
+              ns3::Simulator::RunOneEvent ();
             }
-            
-            if (py_thread_state)
-                PyEval_RestoreThread(py_thread_state);
-            PyErr_CheckSignals();
-            if (PyErr_Occurred())
-                return NULL;
+
+          if (py_thread_state)
+            PyEval_RestoreThread (py_thread_state);
+          PyErr_CheckSignals ();
+          if (PyErr_Occurred ())
+            return NULL;
         }
     }
-    Py_INCREF(Py_None);
-    return Py_None;
+  Py_INCREF (Py_None);
+  return Py_None;
 }