Freestyle Python API improvements - part 8.

* Proper handling of keyword arguments was implemented in Operators and ContextFunctions,
as well as in methods of Interface0D, Interface1D, Iterator, their subclasses, Noise and
IntegrationType.

* Operators' methods and functions in the ContextFunctions module were renamed from
CamelCase to lower cases + underscores.  Style modules were updated accordingly.

* Additional code clean-up was also made.

17 files changed, 702 insertions, 688 deletions

diff --git a/source/blender/freestyle/intern/python/BPy_ContextFunctions.cpp b/source/blender/freestyle/intern/python/BPy_ContextFunctions.cpp
index e96df3fe762..af5085dc548 100644
--- a/source/blender/freestyle/intern/python/BPy_ContextFunctions.cpp
+++ b/source/blender/freestyle/intern/python/BPy_ContextFunctions.cpp
@@ -37,13 +37,13 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-  
+
 ///////////////////////////////////////////////////////////////////////////////////////////
 
 //------------------------ MODULE FUNCTIONS ----------------------------------
 
-static char ContextFunctions_GetTimeStampCF___doc__[] =
-".. function:: GetTimeStampCF()\n"
+static char ContextFunctions_get_time_stamp___doc__[] =
+".. function:: get_time_stamp()\n"
 "\n"
 "   Returns the system time stamp.\n"
 "\n"
@@ -51,13 +51,13 @@ static char ContextFunctions_GetTimeStampCF___doc__[] =
 "   :rtype: int\n";
 
 static PyObject *
-ContextFunctions_GetTimeStampCF( PyObject* self )
+ContextFunctions_get_time_stamp(PyObject* self)
 {
-  return PyLong_FromLong( ContextFunctions::GetTimeStampCF() );
+	return PyLong_FromLong(ContextFunctions::GetTimeStampCF());
 }
 
-static char ContextFunctions_GetCanvasWidthCF___doc__[] =
-".. method:: GetCanvasWidthCF()\n"
+static char ContextFunctions_get_canvas_width___doc__[] =
+".. method:: get_canvas_width()\n"
 "\n"
 "   Returns the canvas width.\n"
 "\n"
@@ -65,13 +65,13 @@ static char ContextFunctions_GetCanvasWidthCF___doc__[] =
 "   :rtype: int\n";
 
 static PyObject *
-ContextFunctions_GetCanvasWidthCF( PyObject* self )
+ContextFunctions_get_canvas_width(PyObject* self)
 {
-  return PyLong_FromLong( ContextFunctions::GetCanvasWidthCF() );
+	return PyLong_FromLong(ContextFunctions::GetCanvasWidthCF());
 }
 
-static char ContextFunctions_GetCanvasHeightCF___doc__[] =
-".. method:: GetCanvasHeightCF()\n"
+static char ContextFunctions_get_canvas_height___doc__[] =
+".. method:: get_canvas_height()\n"
 "\n"
 "   Returns the canvas height.\n"
 "\n"
@@ -79,49 +79,48 @@ static char ContextFunctions_GetCanvasHeightCF___doc__[] =
 "   :rtype: int\n";
 
 static PyObject *
-ContextFunctions_GetCanvasHeightCF( PyObject* self )
+ContextFunctions_get_canvas_height(PyObject* self)
 {
-  return PyLong_FromLong( ContextFunctions::GetCanvasHeightCF() );
+	return PyLong_FromLong(ContextFunctions::GetCanvasHeightCF());
 }
 
-static char ContextFunctions_LoadMapCF___doc__[] =
-".. function:: LoadMapCF(iFileName, iMapName, iNbLevels=4, iSigma=1.0)\n"
+static char ContextFunctions_load_map___doc__[] =
+".. function:: load_map(file_name, map_name, num_levels=4, sigma=1.0)\n"
 "\n"
 "   Loads an image map for further reading.\n"
 "\n"
-"   :arg iFileName: The name of the image file.\n"
-"   :type iFileName: str\n"
-"   :arg iMapName: The name that will be used to access this image.\n"
-"   :type iMapName: str\n"
-"   :arg iNbLevels: The number of levels in the map pyramid\n"
-"      (default = 4).  If iNbLevels == 0, the complete pyramid is\n"
+"   :arg file_name: The name of the image file.\n"
+"   :type file_name: str\n"
+"   :arg map_name: The name that will be used to access this image.\n"
+"   :type map_name: str\n"
+"   :arg num_levels: The number of levels in the map pyramid\n"
+"      (default = 4).  If num_levels == 0, the complete pyramid is\n"
 "      built.\n"
-"   :type iNbLevels: int\n"
-"   :arg iSigma: The sigma value of the gaussian function.\n"
-"   :type iSigma: float\n";
+"   :type num_levels: int\n"
+"   :arg sigma: The sigma value of the gaussian function.\n"
+"   :type sigma: float\n";
 
 static PyObject *
-ContextFunctions_LoadMapCF( PyObject *self, PyObject *args )
+ContextFunctions_load_map(PyObject *self, PyObject *args, PyObject *kwds)
 {
-  char *fileName, *mapName;
-  unsigned nbLevels;
-  float sigma;
-
-  if( !PyArg_ParseTuple(args, "ssIf", &fileName, &mapName, &nbLevels, &sigma) )
-    return NULL;
-
-  ContextFunctions::LoadMapCF(fileName, mapName, nbLevels, sigma);
-
-  Py_RETURN_NONE;
+	static const char *kwlist[] = {"file_name", "map_name", "num_levels", "sigma", NULL};
+	char *fileName, *mapName;
+	unsigned nbLevels = 4;
+	float sigma = 1.0;
+
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "ss|If", (char **)kwlist, &fileName, &mapName, &nbLevels, &sigma))
+		return NULL;
+	ContextFunctions::LoadMapCF(fileName, mapName, nbLevels, sigma);
+	Py_RETURN_NONE;
 }
 
-static char ContextFunctions_ReadMapPixelCF___doc__[] =
-".. function:: ReadMapPixelCF(iMapName, level, x, y)\n"
+static char ContextFunctions_read_map_pixel___doc__[] =
+".. function:: read_map_pixel(map_name, level, x, y)\n"
 "\n"
 "   Reads a pixel in a user-defined map.\n"
 "\n"
-"   :arg iMapName: The name of the map.\n"
-"   :type iMapName: str\n"
+"   :arg map_name: The name of the map.\n"
+"   :type map_name: str\n"
 "   :arg level: The level of the pyramid in which we wish to read the\n"
 "      pixel.\n"
 "   :type level: int\n"
@@ -135,22 +134,20 @@ static char ContextFunctions_ReadMapPixelCF___doc__[] =
 "   :rtype: float\n";
 
 static PyObject *
-ContextFunctions_ReadMapPixelCF( PyObject *self, PyObject *args )
+ContextFunctions_read_map_pixel(PyObject *self, PyObject *args, PyObject *kwds)
 {
-  char *mapName;
-  int level;
-  unsigned x, y;
-
-  if( !PyArg_ParseTuple(args, "siII", &mapName, &level, &x, &y) )
-    return NULL;
-
-  float f = ContextFunctions::ReadMapPixelCF(mapName, level, x, y);
-
-  return PyFloat_FromDouble( f );
+	static const char *kwlist[] = {"map_name", "level", "x", "y", NULL};
+	char *mapName;
+	int level;
+	unsigned x, y;
+
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "siII", (char **)kwlist, &mapName, &level, &x, &y))
+		return NULL;
+	return PyFloat_FromDouble(ContextFunctions::ReadMapPixelCF(mapName, level, x, y));
 }
 
-static char ContextFunctions_ReadCompleteViewMapPixelCF___doc__[] =
-".. function:: ReadCompleteViewMapPixelCF(level, x, y)\n"
+static char ContextFunctions_read_complete_view_map_pixel___doc__[] =
+".. function:: read_complete_view_map_pixel(level, x, y)\n"
 "\n"
 "   Reads a pixel in the complete view map.\n"
 "\n"
@@ -167,27 +164,25 @@ static char ContextFunctions_ReadCompleteViewMapPixelCF___doc__[] =
 "   :rtype: float\n";
 
 static PyObject *
-ContextFunctions_ReadCompleteViewMapPixelCF( PyObject *self, PyObject *args )
+ContextFunctions_read_complete_view_map_pixel(PyObject *self, PyObject *args, PyObject *kwds)
 {
-  int level;
-  unsigned x, y;
+	static const char *kwlist[] = {"level", "x", "y", NULL};
+	int level;
+	unsigned x, y;
 
-  if( !PyArg_ParseTuple(args, "iII", &level, &x, &y) )
-    return NULL;
-
-  float f = ContextFunctions::ReadCompleteViewMapPixelCF(level, x, y);
-
-  return PyFloat_FromDouble( f );
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "iII", (char **)kwlist, &level, &x, &y))
+		return NULL;
+	return PyFloat_FromDouble(ContextFunctions::ReadCompleteViewMapPixelCF(level, x, y));
 }
 
-static char ContextFunctions_ReadDirectionalViewMapPixelCF___doc__[] =
-".. function:: ReadDirectionalViewMapPixelCF(iOrientation, level, x, y)\n"
+static char ContextFunctions_read_directional_view_map_pixel___doc__[] =
+".. function:: read_directional_view_map_pixel(orientation, level, x, y)\n"
 "\n"
 "   Reads a pixel in one of the oriented view map images.\n"
 "\n"
-"   :arg iOrientation: The number telling which orientation we want to\n"
+"   :arg orientation: The number telling which orientation we want to\n"
 "      check.\n"
-"   :type iOrientation: int\n"
+"   :type orientation: int\n"
 "   :arg level: The level of the pyramid in which we wish to read the\n"
 "      pixel.\n"
 "   :type level: int\n"
@@ -201,21 +196,19 @@ static char ContextFunctions_ReadDirectionalViewMapPixelCF___doc__[] =
 "   :rtype: float\n";
 
 static PyObject *
-ContextFunctions_ReadDirectionalViewMapPixelCF( PyObject *self, PyObject *args )
+ContextFunctions_read_directional_view_map_pixel(PyObject *self, PyObject *args, PyObject *kwds)
 {
-  int orientation, level;
-  unsigned x, y;
-
-  if( !PyArg_ParseTuple(args, "iiII", &orientation, &level, &x, &y) )
-    return NULL;
-
-  float f = ContextFunctions::ReadDirectionalViewMapPixelCF(orientation, level, x, y);
+	static const char *kwlist[] = {"orientation", "level", "x", "y", NULL};
+	int orientation, level;
+	unsigned x, y;
 
-  return PyFloat_FromDouble( f );
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "iiII", (char **)kwlist, &orientation, &level, &x, &y))
+		return NULL;
+	return PyFloat_FromDouble(ContextFunctions::ReadDirectionalViewMapPixelCF(orientation, level, x, y));
 }
 
-static char ContextFunctions_GetSelectedFEdgeCF___doc__[] =
-".. function:: GetSelectedFEdgeCF()\n"
+static char ContextFunctions_get_selected_fedge___doc__[] =
+".. function:: get_selected_fedge()\n"
 "\n"
 "   Returns the selected FEdge.\n"
 "\n"
@@ -223,13 +216,12 @@ static char ContextFunctions_GetSelectedFEdgeCF___doc__[] =
 "   :rtype: :class:`FEdge`\n";
 
 static PyObject *
-ContextFunctions_GetSelectedFEdgeCF( PyObject *self )
+ContextFunctions_get_selected_fedge(PyObject *self)
 {
-  FEdge *fe = ContextFunctions::GetSelectedFEdgeCF();
-  if( fe )
-    return Any_BPy_FEdge_from_FEdge( *fe );
-
-  Py_RETURN_NONE;
+	FEdge *fe = ContextFunctions::GetSelectedFEdgeCF();
+	if (fe)
+		return Any_BPy_FEdge_from_FEdge(*fe);
+	Py_RETURN_NONE;
 }
 
 /*-----------------------ContextFunctions module docstring-------------------------------*/
@@ -239,14 +231,14 @@ static char module_docstring[] = "The Blender Freestyle.ContextFunctions submodu
 /*-----------------------ContextFunctions module functions definitions-------------------*/
 
 static PyMethodDef module_functions[] = {
-  {"GetTimeStampCF", (PyCFunction)ContextFunctions_GetTimeStampCF, METH_NOARGS, ContextFunctions_GetTimeStampCF___doc__},
-  {"GetCanvasWidthCF", (PyCFunction)ContextFunctions_GetCanvasWidthCF, METH_NOARGS, ContextFunctions_GetCanvasWidthCF___doc__},
-  {"GetCanvasHeightCF", (PyCFunction)ContextFunctions_GetCanvasHeightCF, METH_NOARGS, ContextFunctions_GetCanvasHeightCF___doc__},
-  {"LoadMapCF", (PyCFunction)ContextFunctions_LoadMapCF, METH_VARARGS, ContextFunctions_LoadMapCF___doc__},
-  {"ReadMapPixelCF", (PyCFunction)ContextFunctions_ReadMapPixelCF, METH_VARARGS, ContextFunctions_ReadMapPixelCF___doc__},
-  {"ReadCompleteViewMapPixelCF", (PyCFunction)ContextFunctions_ReadCompleteViewMapPixelCF, METH_VARARGS, ContextFunctions_ReadCompleteViewMapPixelCF___doc__},
-  {"ReadDirectionalViewMapPixelCF", (PyCFunction)ContextFunctions_ReadDirectionalViewMapPixelCF, METH_VARARGS, ContextFunctions_ReadDirectionalViewMapPixelCF___doc__},
-  {"GetSelectedFEdgeCF", (PyCFunction)ContextFunctions_GetSelectedFEdgeCF, METH_NOARGS, ContextFunctions_GetSelectedFEdgeCF___doc__},
+  {"get_time_stamp", (PyCFunction)ContextFunctions_get_time_stamp, METH_NOARGS, ContextFunctions_get_time_stamp___doc__},
+  {"get_canvas_width", (PyCFunction)ContextFunctions_get_canvas_width, METH_NOARGS, ContextFunctions_get_canvas_width___doc__},
+  {"get_canvas_height", (PyCFunction)ContextFunctions_get_canvas_height, METH_NOARGS, ContextFunctions_get_canvas_height___doc__},
+  {"load_map", (PyCFunction)ContextFunctions_load_map, METH_VARARGS | METH_KEYWORDS, ContextFunctions_load_map___doc__},
+  {"read_map_pixel", (PyCFunction)ContextFunctions_read_map_pixel, METH_VARARGS | METH_KEYWORDS, ContextFunctions_read_map_pixel___doc__},
+  {"read_complete_view_map_pixel", (PyCFunction)ContextFunctions_read_complete_view_map_pixel, METH_VARARGS | METH_KEYWORDS, ContextFunctions_read_complete_view_map_pixel___doc__},
+  {"read_directional_view_map_pixel", (PyCFunction)ContextFunctions_read_directional_view_map_pixel, METH_VARARGS | METH_KEYWORDS, ContextFunctions_read_directional_view_map_pixel___doc__},
+  {"get_selected_fedge", (PyCFunction)ContextFunctions_get_selected_fedge, METH_NOARGS, ContextFunctions_get_selected_fedge___doc__},
   {NULL, NULL, 0, NULL}
 };
 
@@ -262,28 +254,20 @@ static PyModuleDef module_definition = {
 
 //------------------- MODULE INITIALIZATION --------------------------------
 
-int ContextFunctions_Init( PyObject *module )
-{	
-  PyObject *m, *d, *f;
-
-  if( module == NULL )
-    return -1;
+int ContextFunctions_Init(PyObject *module)
+{
+	PyObject *m;
 
-  m = PyModule_Create(&module_definition);
-  if (m == NULL)
-    return -1;
-  Py_INCREF(m);
-  PyModule_AddObject(module, "ContextFunctions", m);
+	if (module == NULL)
+		return -1;
 
-  // from ContextFunctions import *
-  d = PyModule_GetDict(m);
-  for (PyMethodDef *p = module_functions; p->ml_name; p++) {
-	f = PyDict_GetItemString(d, p->ml_name);
-	Py_INCREF(f);
-	PyModule_AddObject(module, p->ml_name, f);
-  }
+	m = PyModule_Create(&module_definition);
+	if (m == NULL)
+		return -1;
+	Py_INCREF(m);
+	PyModule_AddObject(module, "ContextFunctions", m);
 
-  return 0;
+	return 0;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////
diff --git a/source/blender/freestyle/intern/python/BPy_FrsNoise.cpp b/source/blender/freestyle/intern/python/BPy_FrsNoise.cpp
index b559eabb046..b6e90a4b440 100644
--- a/source/blender/freestyle/intern/python/BPy_FrsNoise.cpp
+++ b/source/blender/freestyle/intern/python/BPy_FrsNoise.cpp
@@ -41,22 +41,22 @@ extern "C" {
 ///////////////////////////////////////////////////////////////////////////////////////////
 
 //-------------------MODULE INITIALIZATION--------------------------------
-int FrsNoise_Init( PyObject *module )
+int FrsNoise_Init(PyObject *module)
 {
-	if( module == NULL )
+	if (module == NULL)
 		return -1;
 
-	if( PyType_Ready( &FrsNoise_Type ) < 0 )
+	if (PyType_Ready(&FrsNoise_Type) < 0)
 		return -1;
-
-	Py_INCREF( &FrsNoise_Type );
+	Py_INCREF(&FrsNoise_Type);
 	PyModule_AddObject(module, "Noise", (PyObject *)&FrsNoise_Type);
+
 	return 0;
 }
 
 //------------------------INSTANCE METHODS ----------------------------------
 
-static char FrsNoise___doc__[] =
+PyDoc_STRVAR(FrsNoise_doc,
 "Class to provide Perlin noise functionalities.\n"
 "\n"
 ".. method:: __init__(seed = -1)\n"
@@ -66,30 +66,31 @@ static char FrsNoise___doc__[] =
 "   otherwise, time is used as a seed.\n"
 "\n"
 "   :arg seed: Seed for random number generation.\n"
-"   :type seed: int\n";
+"   :type seed: int");
 
-static int FrsNoise___init__(BPy_FrsNoise *self, PyObject *args, PyObject *kwds)
+static int FrsNoise_init(BPy_FrsNoise *self, PyObject *args, PyObject *kwds)
 {
+	static const char *kwlist[] = {"seed", NULL};
 	long seed = -1;
-	if(!( PyArg_ParseTuple(args, "|l", &seed) ))
+
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "|l", (char **)kwlist, &seed))
 		return -1;
 	self->n = new Noise(seed);
 	return 0;
 }
 
-static void FrsNoise___dealloc__(BPy_FrsNoise* self)
+static void FrsNoise_dealloc(BPy_FrsNoise* self)
 {
 	delete self->n;
-    Py_TYPE(self)->tp_free((PyObject*)self);
+	Py_TYPE(self)->tp_free((PyObject*)self);
 }
 
-
-static PyObject * FrsNoise___repr__(BPy_FrsNoise* self)
+static PyObject * FrsNoise_repr(BPy_FrsNoise* self)
 {
-    return PyUnicode_FromFormat("Noise - address: %p", self->n );
+	return PyUnicode_FromFormat("Noise - address: %p", self->n);
 }
 
-static char FrsNoise_turbulence1___doc__[] =
+PyDoc_STRVAR(FrsNoise_turbulence1_doc,
 ".. method:: turbulence1(v, freq, amp, oct=4)\n"
 "\n"
 "   Returns a noise value for a 1D element.\n"
@@ -103,19 +104,20 @@ static char FrsNoise_turbulence1___doc__[] =
 "   :arg oct: Number of octaves.\n"
 "   :type oct: int\n"
 "   :return: A noise value.\n"
-"   :rtype: float\n";
+"   :rtype: float");
 
-static PyObject * FrsNoise_turbulence1( BPy_FrsNoise *self , PyObject *args) {
+static PyObject * FrsNoise_turbulence1(BPy_FrsNoise *self , PyObject *args, PyObject *kwds)
+{
+	static const char *kwlist[] = {"v", "freq", "amp", "oct", NULL};
 	float f1, f2, f3;
 	unsigned int i = 4;
 
-	if(!( PyArg_ParseTuple(args, "fff|I", &f1, &f2, &f3, &i) ))
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "fff|I", (char **)kwlist, &f1, &f2, &f3, &i))
 		return NULL;
-
-	return PyFloat_FromDouble( self->n->turbulence1(f1, f2, f3, i) );
+	return PyFloat_FromDouble(self->n->turbulence1(f1, f2, f3, i));
 }
 
-static char FrsNoise_turbulence2___doc__[] =
+PyDoc_STRVAR(FrsNoise_turbulence2_doc,
 ".. method:: turbulence2(v, freq, amp, oct=4)\n"
 "\n"
 "   Returns a noise value for a 2D element.\n"
@@ -129,26 +131,28 @@ static char FrsNoise_turbulence2___doc__[] =
 "   :arg oct: Number of octaves.\n"
 "   :type oct: int\n"
 "   :return: A noise value.\n"
-"   :rtype: float\n";
+"   :rtype: float");
 
-static PyObject * FrsNoise_turbulence2( BPy_FrsNoise *self , PyObject *args) {
+static PyObject * FrsNoise_turbulence2(BPy_FrsNoise *self , PyObject *args, PyObject *kwds)
+{
+	static const char *kwlist[] = {"v", "freq", "amp", "oct", NULL};
 	PyObject *obj1;
 	float f2, f3;
 	unsigned int i = 4;
 
-	if(!( PyArg_ParseTuple(args, "Off|I", &obj1, &f2, &f3, &i) ))
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "Off|I", (char **)kwlist, &obj1, &f2, &f3, &i))
 		return NULL;
 	Vec2f *v = Vec2f_ptr_from_PyObject(obj1);
-	if( !v ) {
+	if (!v) {
 		PyErr_SetString(PyExc_TypeError, "argument 1 must be a 2D vector (either a list of 2 elements or Vector)");
 		return NULL;
 	}
 	float t = self->n->turbulence2(*v, f2, f3, i);
 	delete v;
-	return PyFloat_FromDouble( t );
+	return PyFloat_FromDouble(t);
 }
 
-static char FrsNoise_turbulence3___doc__[] =
+PyDoc_STRVAR(FrsNoise_turbulence3_doc,
 ".. method:: turbulence3(v, freq, amp, oct=4)\n"
 "\n"
 "   Returns a noise value for a 3D element.\n"
@@ -162,26 +166,28 @@ static char FrsNoise_turbulence3___doc__[] =
 "   :arg oct: Number of octaves.\n"
 "   :type oct: int\n"
 "   :return: A noise value.\n"
-"   :rtype: float\n";
+"   :rtype: float");
 
-static PyObject * FrsNoise_turbulence3( BPy_FrsNoise *self , PyObject *args) {
+static PyObject * FrsNoise_turbulence3(BPy_FrsNoise *self , PyObject *args, PyObject *kwds)
+{
+	static const char *kwlist[] = {"v", "freq", "amp", "oct", NULL};
 	PyObject *obj1;
 	float f2, f3;
 	unsigned int i = 4;
 
-	if(!( PyArg_ParseTuple(args, "Off|I", &obj1, &f2, &f3, &i) ))
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "Off|I", (char **)kwlist, &obj1, &f2, &f3, &i))
 		return NULL;
 	Vec3f *v = Vec3f_ptr_from_PyObject(obj1);
-	if( !v ) {
+	if (!v) {
 		PyErr_SetString(PyExc_TypeError, "argument 1 must be a 3D vector (either a list of 3 elements or Vector)");
 		return NULL;
 	}
 	float t = self->n->turbulence3(*v, f2, f3, i);
 	delete v;
-	return PyFloat_FromDouble( t );
+	return PyFloat_FromDouble(t);
 }
 
-static char FrsNoise_smoothNoise1___doc__[] =
+PyDoc_STRVAR(FrsNoise_smoothNoise1_doc,
 ".. method:: smoothNoise1(v)\n"
 "\n"
 "   Returns a smooth noise value for a 1D element.\n"
@@ -189,18 +195,19 @@ static char FrsNoise_smoothNoise1___doc__[] =
 "   :arg v: One-dimensional sample point.\n"
 "   :type v: float\n"
 "   :return: A smooth noise value.\n"
-"   :rtype: float\n";
+"   :rtype: float");
 
-static PyObject * FrsNoise_smoothNoise1( BPy_FrsNoise *self , PyObject *args) {
+static PyObject * FrsNoise_smoothNoise1(BPy_FrsNoise *self , PyObject *args, PyObject *kwds)
+{
+	static const char *kwlist[] = {"v", NULL};
 	float f;
 
-	if(!( PyArg_ParseTuple(args, "f", &f) ))
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "f", (char **)kwlist, &f))
 		return NULL;
-
-	return PyFloat_FromDouble( self->n->smoothNoise1(f) );
+	return PyFloat_FromDouble(self->n->smoothNoise1(f));
 }
 
-static char FrsNoise_smoothNoise2___doc__[] =
+PyDoc_STRVAR(FrsNoise_smoothNoise2_doc,
 ".. method:: smoothNoise2(v)\n"
 "\n"
 "   Returns a smooth noise value for a 2D element.\n"
@@ -208,24 +215,26 @@ static char FrsNoise_smoothNoise2___doc__[] =
 "   :arg v: Two-dimensional sample point.\n"
 "   :type v: :class:`mathutils.Vector`, list or tuple of 2 real numbers\n"
 "   :return: A smooth noise value.\n"
-"   :rtype: float\n";
+"   :rtype: float");
 
-static PyObject * FrsNoise_smoothNoise2( BPy_FrsNoise *self , PyObject *args) {
+static PyObject * FrsNoise_smoothNoise2(BPy_FrsNoise *self , PyObject *args, PyObject *kwds)
+{
+	static const char *kwlist[] = {"v", NULL};
 	PyObject *obj;
 
-	if(!( PyArg_ParseTuple(args, "O", &obj) ))
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O", (char **)kwlist, &obj))
 		return NULL;
 	Vec2f *v = Vec2f_ptr_from_PyObject(obj);
-	if( !v ) {
+	if (!v) {
 		PyErr_SetString(PyExc_TypeError, "argument 1 must be a 2D vector (either a list of 2 elements or Vector)");
 		return NULL;
 	}
 	float t = self->n->smoothNoise2(*v);
 	delete v;
-	return PyFloat_FromDouble( t );
+	return PyFloat_FromDouble(t);
 }
 
-static char FrsNoise_smoothNoise3___doc__[] =
+PyDoc_STRVAR(FrsNoise_smoothNoise3_doc,
 ".. method:: smoothNoise3(v)\n"
 "\n"
 "   Returns a smooth noise value for a 3D element.\n"
@@ -233,31 +242,32 @@ static char FrsNoise_smoothNoise3___doc__[] =
 "   :arg v: Three-dimensional sample point.\n"
 "   :type v: :class:`mathutils.Vector`, list or tuple of 3 real numbers\n"
 "   :return: A smooth noise value.\n"
-"   :rtype: float\n";
+"   :rtype: float");
 
-static PyObject * FrsNoise_smoothNoise3( BPy_FrsNoise *self , PyObject *args) {
+static PyObject * FrsNoise_smoothNoise3(BPy_FrsNoise *self , PyObject *args, PyObject *kwds)
+{
+	static const char *kwlist[] = {"v", NULL};
 	PyObject *obj;
 
-	if(!( PyArg_ParseTuple(args, "O", &obj) ))
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O", (char **)kwlist, &obj))
 		return NULL;
 	Vec3f *v = Vec3f_ptr_from_PyObject(obj);
-	if( !v ) {
+	if (!v) {
 		PyErr_SetString(PyExc_TypeError, "argument 1 must be a 3D vector (either a list of 3 elements or Vector)");
 		return NULL;
 	}
 	float t = self->n->smoothNoise3(*v);
 	delete v;
-	return PyFloat_FromDouble( t );
+	return PyFloat_FromDouble(t);
 }
 
-/*----------------------FrsNoise instance definitions ----------------------------*/
 static PyMethodDef BPy_FrsNoise_methods[] = {
-	{"turbulence1", ( PyCFunction ) FrsNoise_turbulence1, METH_VARARGS, FrsNoise_turbulence1___doc__},
-	{"turbulence2", ( PyCFunction ) FrsNoise_turbulence2, METH_VARARGS, FrsNoise_turbulence2___doc__},
-	{"turbulence3", ( PyCFunction ) FrsNoise_turbulence3, METH_VARARGS, FrsNoise_turbulence3___doc__},
-	{"smoothNoise1", ( PyCFunction ) FrsNoise_smoothNoise1, METH_VARARGS, FrsNoise_smoothNoise1___doc__},
-	{"smoothNoise2", ( PyCFunction ) FrsNoise_smoothNoise2, METH_VARARGS, FrsNoise_smoothNoise2___doc__},
-	{"smoothNoise3", ( PyCFunction ) FrsNoise_smoothNoise3, METH_VARARGS, FrsNoise_smoothNoise3___doc__},
+	{"turbulence1", (PyCFunction)FrsNoise_turbulence1, METH_VARARGS | METH_KEYWORDS, FrsNoise_turbulence1_doc},
+	{"turbulence2", (PyCFunction)FrsNoise_turbulence2, METH_VARARGS | METH_KEYWORDS, FrsNoise_turbulence2_doc},
+	{"turbulence3", (PyCFunction)FrsNoise_turbulence3, METH_VARARGS | METH_KEYWORDS, FrsNoise_turbulence3_doc},
+	{"smoothNoise1", (PyCFunction)FrsNoise_smoothNoise1, METH_VARARGS | METH_KEYWORDS, FrsNoise_smoothNoise1_doc},
+	{"smoothNoise2", (PyCFunction)FrsNoise_smoothNoise2, METH_VARARGS | METH_KEYWORDS, FrsNoise_smoothNoise2_doc},
+	{"smoothNoise3", (PyCFunction)FrsNoise_smoothNoise3, METH_VARARGS | METH_KEYWORDS, FrsNoise_smoothNoise3_doc},
 	{NULL, NULL, 0, NULL}
 };
 
@@ -268,12 +278,12 @@ PyTypeObject FrsNoise_Type = {
 	"Noise",                        /* tp_name */
 	sizeof(BPy_FrsNoise),           /* tp_basicsize */
 	0,                              /* tp_itemsize */
-	(destructor)FrsNoise___dealloc__, /* tp_dealloc */
+	(destructor)FrsNoise_dealloc,   /* tp_dealloc */
 	0,                              /* tp_print */
 	0,                              /* tp_getattr */
 	0,                              /* tp_setattr */
 	0,                              /* tp_reserved */
-	(reprfunc)FrsNoise___repr__,    /* tp_repr */
+	(reprfunc)FrsNoise_repr,        /* tp_repr */
 	0,                              /* tp_as_number */
 	0,                              /* tp_as_sequence */
 	0,                              /* tp_as_mapping */
@@ -284,7 +294,7 @@ PyTypeObject FrsNoise_Type = {
 	0,                              /* tp_setattro */
 	0,                              /* tp_as_buffer */
 	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
-	FrsNoise___doc__,               /* tp_doc */
+	FrsNoise_doc,                   /* tp_doc */
 	0,                              /* tp_traverse */
 	0,                              /* tp_clear */
 	0,                              /* tp_richcompare */
@@ -299,7 +309,7 @@ PyTypeObject FrsNoise_Type = {
 	0,                              /* tp_descr_get */
 	0,                              /* tp_descr_set */
 	0,                              /* tp_dictoffset */
-	(initproc)FrsNoise___init__,    /* tp_init */
+	(initproc)FrsNoise_init,        /* tp_init */
 	0,                              /* tp_alloc */
 	PyType_GenericNew,              /* tp_new */
 };
diff --git a/source/blender/freestyle/intern/python/BPy_IntegrationType.cpp b/source/blender/freestyle/intern/python/BPy_IntegrationType.cpp
index b56a5f96894..8b447129eca 100644
--- a/source/blender/freestyle/intern/python/BPy_IntegrationType.cpp
+++ b/source/blender/freestyle/intern/python/BPy_IntegrationType.cpp
@@ -46,14 +46,14 @@ extern "C" {
 //------------------------ MODULE FUNCTIONS ----------------------------------
 
 PyDoc_STRVAR(Integrator_integrate_doc,
-".. function:: integrate(fun, it, it_end, integration_type)\n"
+".. function:: integrate(func, it, it_end, integration_type)\n"
 "\n"
 "   Returns a single value from a set of values evaluated at each 0D\n"
 "   element of this 1D element.\n"
 "\n"
-"   :arg fun: The UnaryFunction0D used to compute a value at each\n"
+"   :arg func: The UnaryFunction0D used to compute a value at each\n"
 "      Interface0D.\n"
-"   :type fun: :class:`UnaryFunction0D`\n"
+"   :type func: :class:`UnaryFunction0D`\n"
 "   :arg it: The Interface0DIterator used to iterate over the 0D\n"
 "      elements of this 1D element. The integration will occur over\n"
 "      the 0D elements starting from the one pointed by it.\n"
@@ -65,41 +65,23 @@ PyDoc_STRVAR(Integrator_integrate_doc,
 "      single value from a set of values.\n"
 "   :type integration_type: :class:`IntegrationType`\n"
 "   :return: The single value obtained for the 1D element.  The return\n"
-"      value type is float if fun is of the :class:`UnaryFunction0DDouble`\n"
-"      or :class:`UnaryFunction0DFloat` type, and int if fun is of the\n"
+"      value type is float if func is of the :class:`UnaryFunction0DDouble`\n"
+"      or :class:`UnaryFunction0DFloat` type, and int if func is of the\n"
 "      :class:`UnaryFunction0DUnsigned` type.\n"
 "   :rtype: int or float");
 
-static PyObject * Integrator_integrate(PyObject *self, PyObject *args)
+static PyObject * Integrator_integrate(PyObject *self, PyObject *args, PyObject *kwds)
 {
+	static const char *kwlist[] = {"func", "it", "it_end", "integration_type", NULL};
 	PyObject *obj1, *obj4 = 0;
 	BPy_Interface0DIterator *obj2, *obj3;
 
-#if 1
-	if (!PyArg_ParseTuple(args, "O!O!O!|O!", &UnaryFunction0D_Type, &obj1,
-		&Interface0DIterator_Type, &obj2, &Interface0DIterator_Type, &obj3,
-		&IntegrationType_Type, &obj4))
-		return NULL;
-#else
-	if (!PyArg_ParseTuple(args, "OOO|O", &obj1, &obj2, &obj3, &obj4))
-		return NULL;
-	if (!BPy_UnaryFunction0D_Check(obj1)) {
-		PyErr_SetString(PyExc_TypeError, "argument 1 must be a UnaryFunction0D object");
-		return NULL;
-	}
-	if (!BPy_Interface0DIterator_Check(obj2)) {
-		PyErr_SetString(PyExc_TypeError, "argument 2 must be a Interface0DIterator object");
-		return NULL;
-	}
-	if (!BPy_Interface0DIterator_Check(obj3)) {
-		PyErr_SetString(PyExc_TypeError, "argument 3 must be a Interface0DIterator object");
-		return NULL;
-	}
-	if (obj4 && !BPy_IntegrationType_Check(obj4)) {
-		PyErr_SetString(PyExc_TypeError, "argument 4 must be a IntegrationType object");
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!O!O!|O!", (char **)kwlist,
+	                                 &UnaryFunction0D_Type, &obj1, &Interface0DIterator_Type, &obj2,
+	                                 &Interface0DIterator_Type, &obj3, &IntegrationType_Type, &obj4))
+	{
 		return NULL;
 	}
-#endif
 
 	Interface0DIterator it(*(obj2->if0D_it)), it_end(*(obj3->if0D_it));
 	IntegrationType t = (obj4) ? IntegrationType_from_BPy_IntegrationType(obj4) : MEAN;
@@ -108,20 +90,20 @@ static PyObject * Integrator_integrate(PyObject *self, PyObject *args)
 		UnaryFunction0D<double> *fun = ((BPy_UnaryFunction0DDouble *)obj1)->uf0D_double;
 		double res = integrate(*fun, it, it_end, t);
 		return PyFloat_FromDouble(res);
-
-	} else if (BPy_UnaryFunction0DFloat_Check(obj1)) {
+	}
+	else if (BPy_UnaryFunction0DFloat_Check(obj1)) {
 		UnaryFunction0D<float> *fun = ((BPy_UnaryFunction0DFloat *)obj1)->uf0D_float;
 		float res = integrate(*fun, it, it_end, t);
 		return PyFloat_FromDouble(res);
-
-	} else if (BPy_UnaryFunction0DUnsigned_Check(obj1)) {
+	}
+	else if (BPy_UnaryFunction0DUnsigned_Check(obj1)) {
 		UnaryFunction0D<unsigned int> *fun = ((BPy_UnaryFunction0DUnsigned *)obj1)->uf0D_unsigned;
 		unsigned int res = integrate(*fun, it, it_end, t);
 		return PyLong_FromLong(res);
-
-	} else {
-		string msg("unsupported function type: " + string(obj1->ob_type->tp_name));
-		PyErr_SetString(PyExc_TypeError, msg.c_str());
+	}
+	else {
+		string class_name(Py_TYPE(obj1)->tp_name);
+		PyErr_SetString(PyExc_TypeError, ("unsupported function type: " + class_name).c_str());
 		return NULL;
 	}
 }
@@ -133,7 +115,7 @@ PyDoc_STRVAR(module_docstring, "The Blender Freestyle.Integrator submodule\n\n")
 /*-----------------------Integrator module functions definitions---------------------------*/
 
 static PyMethodDef module_functions[] = {
-	{"integrate", (PyCFunction) Integrator_integrate, METH_VARARGS, Integrator_integrate_doc},
+	{"integrate", (PyCFunction) Integrator_integrate, METH_VARARGS | METH_KEYWORDS, Integrator_integrate_doc},
 	{NULL, NULL, 0, NULL}
 };
 
diff --git a/source/blender/freestyle/intern/python/BPy_Interface0D.cpp b/source/blender/freestyle/intern/python/BPy_Interface0D.cpp
index 5b7fdfbbd4a..bbfe99ebbf0 100644
--- a/source/blender/freestyle/intern/python/BPy_Interface0D.cpp
+++ b/source/blender/freestyle/intern/python/BPy_Interface0D.cpp
@@ -57,32 +57,32 @@ int Interface0D_Init(PyObject *module)
 		return -1;
 	Py_INCREF(&Interface0D_Type);
 	PyModule_AddObject(module, "Interface0D", (PyObject *)&Interface0D_Type);
-	
+
 	if (PyType_Ready(&CurvePoint_Type) < 0)
 		return -1;
 	Py_INCREF(&CurvePoint_Type);
 	PyModule_AddObject(module, "CurvePoint", (PyObject *)&CurvePoint_Type);
-	
+
 	if (PyType_Ready(&SVertex_Type) < 0)
 		return -1;
 	Py_INCREF(&SVertex_Type);
 	PyModule_AddObject(module, "SVertex", (PyObject *)&SVertex_Type);	
-	
+
 	if (PyType_Ready(&ViewVertex_Type) < 0)
 		return -1;
 	Py_INCREF(&ViewVertex_Type);
 	PyModule_AddObject(module, "ViewVertex", (PyObject *)&ViewVertex_Type);
-	
+
 	if (PyType_Ready(&StrokeVertex_Type) < 0)
 		return -1;
 	Py_INCREF(&StrokeVertex_Type);
 	PyModule_AddObject(module, "StrokeVertex", (PyObject *)&StrokeVertex_Type);
-	
+
 	if (PyType_Ready(&NonTVertex_Type) < 0)
 		return -1;
 	Py_INCREF(&NonTVertex_Type);
 	PyModule_AddObject(module, "NonTVertex", (PyObject *)&NonTVertex_Type);
-	
+
 	if (PyType_Ready(&TVertex_Type) < 0)
 		return -1;
 	Py_INCREF(&TVertex_Type);
@@ -137,11 +137,12 @@ PyDoc_STRVAR(Interface0D_get_fedge_doc,
 "   :return: The FEdge lying between the two 0D elements.\n"
 "   :rtype: :class:`FEdge`");
 
-static PyObject *Interface0D_get_fedge(BPy_Interface0D *self, PyObject *args)
+static PyObject *Interface0D_get_fedge(BPy_Interface0D *self, PyObject *args, PyObject *kwds)
 {
+	static const char *kwlist[] = {"inter", NULL};
 	PyObject *py_if0D;
 
-	if (!PyArg_ParseTuple(args, "O!", &Interface0D_Type, &py_if0D))
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!", (char **)kwlist, &Interface0D_Type, &py_if0D))
 		return NULL;
 	FEdge *fe = self->if0D->getFEdge(*(((BPy_Interface0D *)py_if0D)->if0D));
 	if (PyErr_Occurred())
@@ -152,7 +153,7 @@ static PyObject *Interface0D_get_fedge(BPy_Interface0D *self, PyObject *args)
 }
 
 static PyMethodDef BPy_Interface0D_methods[] = {
-	{"get_fedge", (PyCFunction)Interface0D_get_fedge, METH_VARARGS, Interface0D_get_fedge_doc},
+	{"get_fedge", (PyCFunction)Interface0D_get_fedge, METH_VARARGS | METH_KEYWORDS, Interface0D_get_fedge_doc},
 	{NULL, NULL, 0, NULL}
 };
 
diff --git a/source/blender/freestyle/intern/python/BPy_Interface1D.cpp b/source/blender/freestyle/intern/python/BPy_Interface1D.cpp
index 4a66ca14021..e990f10f946 100644
--- a/source/blender/freestyle/intern/python/BPy_Interface1D.cpp
+++ b/source/blender/freestyle/intern/python/BPy_Interface1D.cpp
@@ -180,11 +180,12 @@ PyDoc_STRVAR(Interface1D_points_begin_doc,
 "   :return: An Interface0DIterator pointing to the first point.\n"
 "   :rtype: :class:`Interface0DIterator`");
 
-static PyObject * Interface1D_points_begin(BPy_Interface1D *self, PyObject *args)
+static PyObject * Interface1D_points_begin(BPy_Interface1D *self, PyObject *args, PyObject *kwds)
 {
-	float f = 0;
+	static const char *kwlist[] = {"t", NULL};
+	float f = 0.0f;
 
-	if(!(PyArg_ParseTuple(args, "|f", &f)))
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "|f", (char **)kwlist, &f))
 		return NULL;
 	Interface0DIterator if0D_it(self->if1D->pointsBegin(f));
 	return BPy_Interface0DIterator_from_Interface0DIterator(if0D_it, 0);
@@ -204,11 +205,12 @@ PyDoc_STRVAR(Interface1D_points_end_doc,
 "   :return: An Interface0DIterator pointing after the last point.\n"
 "   :rtype: :class:`Interface0DIterator`");
 
-static PyObject * Interface1D_points_end(BPy_Interface1D *self, PyObject *args)
+static PyObject * Interface1D_points_end(BPy_Interface1D *self, PyObject *args, PyObject *kwds)
 {
-	float f = 0;
+	static const char *kwlist[] = {"t", NULL};
+	float f = 0.0f;
 
-	if (!PyArg_ParseTuple(args, "|f", &f))
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "|f", (char **)kwlist, &f))
 		return NULL;
 	Interface0DIterator if0D_it(self->if1D->pointsEnd(f));
 	return BPy_Interface0DIterator_from_Interface0DIterator(if0D_it, 1);
@@ -217,8 +219,8 @@ static PyObject * Interface1D_points_end(BPy_Interface1D *self, PyObject *args)
 static PyMethodDef BPy_Interface1D_methods[] = {
 	{"vertices_begin", (PyCFunction)Interface1D_vertices_begin, METH_NOARGS, Interface1D_vertices_begin_doc},
 	{"vertices_end", (PyCFunction)Interface1D_vertices_end, METH_NOARGS, Interface1D_vertices_end_doc},
-	{"points_begin", (PyCFunction)Interface1D_points_begin, METH_VARARGS, Interface1D_points_begin_doc},
-	{"points_end", (PyCFunction)Interface1D_points_end, METH_VARARGS, Interface1D_points_end_doc},
+	{"points_begin", (PyCFunction)Interface1D_points_begin, METH_VARARGS | METH_KEYWORDS, Interface1D_points_begin_doc},
+	{"points_end", (PyCFunction)Interface1D_points_end, METH_VARARGS | METH_KEYWORDS, Interface1D_points_end_doc},
 	{NULL, NULL, 0, NULL}
 };
 
diff --git a/source/blender/freestyle/intern/python/BPy_Operators.cpp b/source/blender/freestyle/intern/python/BPy_Operators.cpp
index 333b6cc1107..29498b1f480 100644
--- a/source/blender/freestyle/intern/python/BPy_Operators.cpp
+++ b/source/blender/freestyle/intern/python/BPy_Operators.cpp
@@ -48,62 +48,61 @@ extern "C" {
 ///////////////////////////////////////////////////////////////////////////////////////////
 
 //-------------------MODULE INITIALIZATION--------------------------------
-int Operators_Init( PyObject *module )
-{	
-	if( module == NULL )
+int Operators_Init(PyObject *module)
+{
+	if (module == NULL)
 		return -1;
 
-	if( PyType_Ready( &Operators_Type ) < 0 )
+	if (PyType_Ready(&Operators_Type) < 0)
 		return -1;
+	Py_INCREF(&Operators_Type);
+	PyModule_AddObject(module, "Operators", (PyObject *)&Operators_Type);
 
-	Py_INCREF( &Operators_Type );
-	PyModule_AddObject(module, "Operators", (PyObject *)&Operators_Type);	
 	return 0;
 }
 
 //------------------------INSTANCE METHODS ----------------------------------
 
-static char Operators___doc__[] =
+PyDoc_STRVAR(Operators_doc,
 "Class defining the operators used in a style module.  There are five\n"
 "types of operators: Selection, chaining, splitting, sorting and\n"
 "creation.  All these operators are user controlled through functors,\n"
-"predicates and shaders that are taken as arguments.\n";
+"predicates and shaders that are taken as arguments.");
 
-static void Operators___dealloc__(BPy_Operators* self)
+static void Operators_dealloc(BPy_Operators* self)
 {
-    Py_TYPE(self)->tp_free((PyObject*)self);
+	Py_TYPE(self)->tp_free((PyObject*)self);
 }
 
-static char Operators_select___doc__[] =
+PyDoc_STRVAR(Operators_select_doc,
 ".. staticmethod:: select(pred)\n"
 "\n"
 "   Selects the ViewEdges of the ViewMap verifying a specified\n"
 "   condition.\n"
 "\n"
 "   :arg pred: The predicate expressing this condition.\n"
-"   :type pred: UnaryPredicate1D\n";
+"   :type pred: UnaryPredicate1D");
 
-static PyObject * Operators_select(BPy_Operators* self, PyObject *args)
+static PyObject *Operators_select(BPy_Operators* self, PyObject *args, PyObject *kwds)
 {
+	static const char *kwlist[] = {"pred", NULL};
 	PyObject *obj = 0;
 
-	if ( !PyArg_ParseTuple(args, "O!", &UnaryPredicate1D_Type, &obj) )
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!", (char **)kwlist, &UnaryPredicate1D_Type, &obj))
 		return NULL;
-	if ( !((BPy_UnaryPredicate1D *) obj)->up1D ) {
+	if (!((BPy_UnaryPredicate1D *)obj)->up1D) {
 		PyErr_SetString(PyExc_TypeError, "Operators.select(): 1st argument: invalid UnaryPredicate1D object");
 		return NULL;
 	}
-
-	if (Operators::select(*( ((BPy_UnaryPredicate1D *) obj)->up1D )) < 0) {
+	if (Operators::select(*(((BPy_UnaryPredicate1D *)obj)->up1D)) < 0) {
 		if (!PyErr_Occurred())
 			PyErr_SetString(PyExc_RuntimeError, "Operators.select() failed");
 		return NULL;
 	}
-
 	Py_RETURN_NONE;
 }
 
-static char Operators_chain___doc__[] =
+PyDoc_STRVAR(Operators_chain_doc,
 ".. staticmethod:: chain(it, pred, modifier)\n"
 "\n"
 "   Builds a set of chains from the current set of ViewEdges.  Each\n"
@@ -141,57 +140,56 @@ static char Operators_chain___doc__[] =
 "   :type it: :class:`ViewEdgeIterator`\n"
 "   :arg pred: The predicate on the ViewEdge that expresses the\n"
 "      stopping condition.\n"
-"   :type pred: :class:`UnaryPredicate1D`\n";
+"   :type pred: :class:`UnaryPredicate1D`");
 
-// CHANGE: first parameter is a chaining iterator, not just a view
-
-static PyObject * Operators_chain(BPy_Operators* self, PyObject *args)
+static PyObject *Operators_chain(BPy_Operators* self, PyObject *args, PyObject *kwds)
 {
+	static const char *kwlist[] = {"it", "pred", "modifier", NULL};
 	PyObject *obj1 = 0, *obj2 = 0, *obj3 = 0;
 
-	if ( !PyArg_ParseTuple(args, "O!O!|O!", &ChainingIterator_Type, &obj1,
-										    &UnaryPredicate1D_Type, &obj2,
-										    &UnaryFunction1DVoid_Type, &obj3) )
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!O!|O!", (char **)kwlist,
+	                                 &ChainingIterator_Type, &obj1,
+	                                 &UnaryPredicate1D_Type, &obj2,
+	                                 &UnaryFunction1DVoid_Type, &obj3))
+	{
 		return NULL;
-	if ( !((BPy_ChainingIterator *) obj1)->c_it ) {
+	}
+	if (!((BPy_ChainingIterator *)obj1)->c_it) {
 		PyErr_SetString(PyExc_TypeError, "Operators.chain(): 1st argument: invalid ChainingIterator object");
 		return NULL;
 	}
-	if ( !((BPy_UnaryPredicate1D *) obj2)->up1D ) {
+	if (!((BPy_UnaryPredicate1D *)obj2)->up1D) {
 		PyErr_SetString(PyExc_TypeError, "Operators.chain(): 2nd argument: invalid UnaryPredicate1D object");
 		return NULL;
 	}
-
-	if( !obj3 ) {
-		
-		if (Operators::chain( 	*( ((BPy_ChainingIterator *) obj1)->c_it ),
-								*( ((BPy_UnaryPredicate1D *) obj2)->up1D )  ) < 0) {
+	if (!obj3) {
+		if (Operators::chain(*(((BPy_ChainingIterator *)obj1)->c_it),
+		                     *(((BPy_UnaryPredicate1D *)obj2)->up1D)) < 0)
+		{
 			if (!PyErr_Occurred())
 				PyErr_SetString(PyExc_RuntimeError, "Operators.chain() failed");
 			return NULL;
 		}
-							
-	} else {
-		
-		if ( !((BPy_UnaryFunction1DVoid *) obj3)->uf1D_void ) {
+	}
+	else {
+		if (!((BPy_UnaryFunction1DVoid *)obj3)->uf1D_void) {
 			PyErr_SetString(PyExc_TypeError, "Operators.chain(): 3rd argument: invalid UnaryFunction1DVoid object");
 			return NULL;
 		}
-		if (Operators::chain( 	*( ((BPy_ChainingIterator *) obj1)->c_it ),
-								*( ((BPy_UnaryPredicate1D *) obj2)->up1D ),
-								*( ((BPy_UnaryFunction1DVoid *) obj3)->uf1D_void )  ) < 0) {
+		if (Operators::chain(*(((BPy_ChainingIterator *)obj1)->c_it),
+		                     *(((BPy_UnaryPredicate1D *)obj2)->up1D),
+		                     *(((BPy_UnaryFunction1DVoid *)obj3)->uf1D_void)) < 0)
+		{
 			if (!PyErr_Occurred())
 				PyErr_SetString(PyExc_RuntimeError, "Operators.chain() failed");
 			return NULL;
 		}
-		
 	}
-	
 	Py_RETURN_NONE;
 }
 
-static char Operators_bidirectionalChain___doc__[] =
-".. staticmethod:: bidirectionalChain(it, pred)\n"
+PyDoc_STRVAR(Operators_bidirectional_chain_doc,
+".. staticmethod:: bidirectional_chain(it, pred)\n"
 "\n"
 "   Builds a set of chains from the current set of ViewEdges.  Each\n"
 "   ViewEdge of the current list potentially starts a new chain.  The\n"
@@ -212,7 +210,7 @@ static char Operators_bidirectionalChain___doc__[] =
 "      stopping condition.\n"
 "   :type pred: :class:`UnaryPredicate1D`\n"
 "\n"
-".. staticmethod:: bidirectionalChain(it)\n"
+".. staticmethod:: bidirectional_chain(it)\n"
 "\n"
 "   The only difference with the above bidirectional chaining algorithm\n"
 "   is that we don't need to pass a stopping criterion.  This might be\n"
@@ -231,47 +229,47 @@ static char Operators_bidirectionalChain___doc__[] =
 "\n"
 "   :arg it: The ChainingIterator on the ViewEdges of the ViewMap.  It\n"
 "      contains the chaining rule.\n"
-"   :type it: :class:`ChainingIterator`\n";
+"   :type it: :class:`ChainingIterator`");
 
-static PyObject * Operators_bidirectionalChain(BPy_Operators* self, PyObject *args)
+static PyObject *Operators_bidirectional_chain(BPy_Operators* self, PyObject *args, PyObject *kwds)
 {
+	static const char *kwlist[] = {"it", "pred", NULL};
 	PyObject *obj1 = 0, *obj2 = 0;
 
-	if( !PyArg_ParseTuple(args, "O!|O!", &ChainingIterator_Type, &obj1, &UnaryPredicate1D_Type, &obj2) )
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!|O!", (char **)kwlist,
+	                                 &ChainingIterator_Type, &obj1, &UnaryPredicate1D_Type, &obj2))
+	{
 		return NULL;
-	if ( !((BPy_ChainingIterator *) obj1)->c_it ) {
-		PyErr_SetString(PyExc_TypeError, "Operators.bidirectionalChain(): 1st argument: invalid ChainingIterator object");
+	}
+	if (!((BPy_ChainingIterator *)obj1)->c_it) {
+		PyErr_SetString(PyExc_TypeError, "Operators.bidirectional_chain(): 1st argument: invalid ChainingIterator object");
 		return NULL;
 	}
-
-	if( !obj2 ) {
-
-		if (Operators::bidirectionalChain( 	*( ((BPy_ChainingIterator *) obj1)->c_it ) ) < 0) {
+	if (!obj2) {
+		if (Operators::bidirectionalChain(*(((BPy_ChainingIterator *)obj1)->c_it)) < 0) {
 			if (!PyErr_Occurred())
-				PyErr_SetString(PyExc_RuntimeError, "Operators.bidirectionalChain() failed");
+				PyErr_SetString(PyExc_RuntimeError, "Operators.bidirectional_chain() failed");
 			return NULL;
 		}
-							
-	} else {
-
-		if ( !((BPy_UnaryPredicate1D *) obj2)->up1D ) {
-			PyErr_SetString(PyExc_TypeError, "Operators.bidirectionalChain(): 2nd argument: invalid UnaryPredicate1D object");
+	}
+	else {
+		if (!((BPy_UnaryPredicate1D *)obj2)->up1D) {
+			PyErr_SetString(PyExc_TypeError, "Operators.bidirectional_chain(): 2nd argument: invalid UnaryPredicate1D object");
 			return NULL;
 		}
-		if (Operators::bidirectionalChain( 	*( ((BPy_ChainingIterator *) obj1)->c_it ),
-											*( ((BPy_UnaryPredicate1D *) obj2)->up1D ) ) < 0) {
+		if (Operators::bidirectionalChain(*(((BPy_ChainingIterator *)obj1)->c_it),
+		                                  *(((BPy_UnaryPredicate1D *)obj2)->up1D)) < 0)
+		{
 			if (!PyErr_Occurred())
-				PyErr_SetString(PyExc_RuntimeError, "Operators.bidirectionalChain() failed");
+				PyErr_SetString(PyExc_RuntimeError, "Operators.bidirectional_chain() failed");
 			return NULL;
 		}
-		
 	}
-	
 	Py_RETURN_NONE;
 }
 
-static char Operators_sequentialSplit___doc__[] =
-".. staticmethod:: sequentialSplit(startingPred, stoppingPred, sampling=0.0)\n"
+PyDoc_STRVAR(Operators_sequential_split_doc,
+".. staticmethod:: sequential_split(starting_pred, stopping_pred, sampling=0.0)\n"
 "\n"
 "   Splits each chain of the current set of chains in a sequential way.\n"
 "   The points of each chain are processed (with a specified sampling)\n"
@@ -282,19 +280,19 @@ static char Operators_sequentialSplit___doc__[] =
 "   first point of one of the resulting chains. The splitting ends when\n"
 "   no more chain can start.\n"
 "\n"
-"   :arg startingPred: The predicate on a point that expresses the\n"
+"   :arg starting_pred: The predicate on a point that expresses the\n"
 "      starting condition.\n"
-"   :type startingPred: :class:`UnaryPredicate0D`\n"
-"   :arg stoppingPred: The predicate on a point that expresses the\n"
+"   :type starting_pred: :class:`UnaryPredicate0D`\n"
+"   :arg stopping_pred: The predicate on a point that expresses the\n"
 "      stopping condition.\n"
-"   :type stoppingPred: :class:`UnaryPredicate0D`\n"
+"   :type stopping_pred: :class:`UnaryPredicate0D`\n"
 "   :arg sampling: The resolution used to sample the chain for the\n"
 "      predicates evaluation. (The chain is not actually resampled;\n"
 "      a virtual point only progresses along the curve using this\n"
 "      resolution.)\n"
 "   :type sampling: float\n"
 "\n"
-".. staticmethod:: sequentialSplit(pred, sampling=0.0)\n"
+".. staticmethod:: sequential_split(pred, sampling=0.0)\n"
 "\n"
 "   Splits each chain of the current set of chains in a sequential way.\n"
 "   The points of each chain are processed (with a specified sampling)\n"
@@ -309,56 +307,58 @@ static char Operators_sequentialSplit___doc__[] =
 "      predicate evaluation. (The chain is not actually resampled; a\n"
 "      virtual point only progresses along the curve using this\n"
 "      resolution.)\n"
-"   :type sampling: float\n";
+"   :type sampling: float");
 
-static PyObject * Operators_sequentialSplit(BPy_Operators* self, PyObject *args)
+static PyObject *Operators_sequential_split(BPy_Operators* self, PyObject *args, PyObject *kwds)
 {
+	static const char *kwlist_1[] = {"starting_pred", "stopping_pred", "sampling", NULL};
+	static const char *kwlist_2[] = {"pred", "sampling", NULL};
 	PyObject *obj1 = 0, *obj2 = 0;
-	float f = 0.0;
+	float f = 0.0f;
 
-	if( !PyArg_ParseTuple(args, "O!|Of", &UnaryPredicate0D_Type, &obj1, &obj2, &f) )
-		return NULL;
-	if ( !((BPy_UnaryPredicate0D *) obj1)->up0D ) {
-		PyErr_SetString(PyExc_TypeError, "Operators.sequentialSplit(): 1st argument: invalid UnaryPredicate0D object");
-		return NULL;
-	}
-
-	if( obj2 && BPy_UnaryPredicate0D_Check(obj2) ) {
-		
-		if ( !((BPy_UnaryPredicate0D *) obj2)->up0D ) {
-			PyErr_SetString(PyExc_TypeError, "Operators.sequentialSplit(): 2nd argument: invalid UnaryPredicate0D object");
+	if (PyArg_ParseTupleAndKeywords(args, kwds, "O!O!|f", (char **)kwlist_1,
+	                                &UnaryPredicate0D_Type, &obj1, &UnaryPredicate0D_Type, &obj2, &f))
+	{
+		if (!((BPy_UnaryPredicate0D *)obj1)->up0D) {
+			PyErr_SetString(PyExc_TypeError, "Operators.sequential_split(): 1st argument: invalid UnaryPredicate0D object");
+			return NULL;
+		}
+		if (!((BPy_UnaryPredicate0D *)obj2)->up0D) {
+			PyErr_SetString(PyExc_TypeError, "Operators.sequential_split(): 2nd argument: invalid UnaryPredicate0D object");
 			return NULL;
 		}
-		if (Operators::sequentialSplit(	*( ((BPy_UnaryPredicate0D *) obj1)->up0D ),
-										*( ((BPy_UnaryPredicate0D *) obj2)->up0D ),
-										f ) < 0) {
+		if (Operators::sequentialSplit(*(((BPy_UnaryPredicate0D *)obj1)->up0D),
+		                               *(((BPy_UnaryPredicate0D *)obj2)->up0D),
+		                               f) < 0)
+		{
 			if (!PyErr_Occurred())
-				PyErr_SetString(PyExc_RuntimeError, "Operators.sequentialSplit() failed");
+				PyErr_SetString(PyExc_RuntimeError, "Operators.sequential_split() failed");
 			return NULL;
 		}
-
-	} else {
-		
-		if ( obj2 ) {
-			if ( !PyFloat_Check(obj2) ) {
-				PyErr_SetString(PyExc_TypeError, "Operators.sequentialSplit(): invalid 2nd argument");
-				return NULL;
-			}
-			f = PyFloat_AsDouble(obj2);
+	}
+	else if (PyErr_Clear(), (f = 0.0f),
+	         PyArg_ParseTupleAndKeywords(args, kwds, "O!|f", (char **)kwlist_2,
+	                                     &UnaryPredicate0D_Type, &obj1, &f))
+	{
+		if (!((BPy_UnaryPredicate0D *)obj1)->up0D) {
+			PyErr_SetString(PyExc_TypeError, "Operators.sequential_split(): 1st argument: invalid UnaryPredicate0D object");
+			return NULL;
 		}
-		if (Operators::sequentialSplit( *( ((BPy_UnaryPredicate0D *) obj1)->up0D ), f ) < 0) {
+		if (Operators::sequentialSplit(*(((BPy_UnaryPredicate0D *)obj1)->up0D), f) < 0) {
 			if (!PyErr_Occurred())
-				PyErr_SetString(PyExc_RuntimeError, "Operators.sequentialSplit() failed");
+				PyErr_SetString(PyExc_RuntimeError, "Operators.sequential_split() failed");
 			return NULL;
 		}
-		
 	}
-	
+	else {
+		PyErr_SetString(PyExc_TypeError, "invalid argument(s)");
+		return NULL;
+	}
 	Py_RETURN_NONE;
 }
 
-static char Operators_recursiveSplit___doc__[] =
-".. staticmethod:: recursiveSplit(func, pred, sampling=0.0)\n"
+PyDoc_STRVAR(Operators_recursive_split_doc,
+".. staticmethod:: recursive_split(func, pred_1d, sampling=0.0)\n"
 "\n"
 "   Splits the current set of chains in a recursive way.  We process the\n"
 "   points of each chain (with a specified sampling) to find the point\n"
@@ -370,9 +370,9 @@ static char Operators_recursiveSplit___doc__[] =
 "   :arg func: The Unary Function evaluated at each point of the chain.\n"
 "     The splitting point is the point minimizing this function.\n"
 "   :type func: :class:`UnaryFunction0DDouble`\n"
-"   :arg pred: The Unary Predicate expressing the recursivity stopping\n"
+"   :arg pred_1d: The Unary Predicate expressing the recursivity stopping\n"
 "      condition.  This predicate is evaluated for each curve before it\n"
-"      actually gets split.  If pred(chain) is true, the curve won't be\n"
+"      actually gets split.  If pred_1d(chain) is true, the curve won't be\n"
 "      split anymore.\n"
 "   :type pred: :class:`UnaryPredicate1D`\n"
 "   :arg sampling: The resolution used to sample the chain for the\n"
@@ -381,7 +381,7 @@ static char Operators_recursiveSplit___doc__[] =
 "      resolution.)\n"
 "   :type sampling: float\n"
 "\n"
-".. staticmethod:: recursiveSplit(func, pred0d, pred, sampling=0.0)\n"
+".. staticmethod:: recursive_split(func, pred_0d, pred_1d, sampling=0.0)\n"
 "\n"
 "   Splits the current set of chains in a recursive way.  We process the\n"
 "   points of each chain (with a specified sampling) to find the point\n"
@@ -396,101 +396,105 @@ static char Operators_recursiveSplit___doc__[] =
 "   :arg func: The Unary Function evaluated at each point of the chain.\n"
 "      The splitting point is the point minimizing this function.\n"
 "   :type func: :class:`UnaryFunction0DDouble`\n"
-"   :arg pred0d: The Unary Predicate 0D used to select the candidate\n"
+"   :arg pred_0d: The Unary Predicate 0D used to select the candidate\n"
 "      points where the split can occur.  For example, it is very likely\n"
 "      that would rather have your chain splitting around its middle\n"
 "      point than around one of its extremities.  A 0D predicate working\n"
 "      on the curvilinear abscissa allows to add this kind of constraints.\n"
-"   :type pred0d: :class:`UnaryPredicate0D`\n"
-"   :arg pred: The Unary Predicate expressing the recursivity stopping\n"
+"   :type pred_0d: :class:`UnaryPredicate0D`\n"
+"   :arg pred_1d: The Unary Predicate expressing the recursivity stopping\n"
 "      condition. This predicate is evaluated for each curve before it\n"
-"      actually gets split.  If pred(chain) is true, the curve won't be\n"
+"      actually gets split.  If pred_1d(chain) is true, the curve won't be\n"
 "      split anymore.\n"
 "   :type pred: :class:`UnaryPredicate1D`\n"
 "   :arg sampling: The resolution used to sample the chain for the\n"
 "      predicates evaluation. (The chain is not actually resampled; a\n"
 "      virtual point only progresses along the curve using this\n"
 "      resolution.)\n"
-"   :type sampling: float\n";
+"   :type sampling: float");
 
-static PyObject * Operators_recursiveSplit(BPy_Operators* self, PyObject *args)
+static PyObject *Operators_recursive_split(BPy_Operators* self, PyObject *args, PyObject *kwds)
 {
+	static const char *kwlist_1[] = {"func", "pred_1d", "sampling", NULL};
+	static const char *kwlist_2[] = {"func", "pred_0d", "pred_1d", "sampling", NULL};
 	PyObject *obj1 = 0, *obj2 = 0, *obj3 = 0;
-	float f = 0.0;
+	float f = 0.0f;
 
-	if ( !PyArg_ParseTuple(args, "O!O|Of", &UnaryFunction0DDouble_Type, &obj1, &obj2, &obj3, &f) )
-		return NULL;
-	if ( !((BPy_UnaryFunction0DDouble *) obj1)->uf0D_double ) {
-		PyErr_SetString(PyExc_TypeError, "Operators.recursiveSplit(): 1st argument: invalid UnaryFunction0DDouble object");
-		return NULL;
-	}
-	
-	if ( BPy_UnaryPredicate1D_Check(obj2) ) {
-
-		if ( !((BPy_UnaryPredicate1D *) obj2)->up1D ) {
-			PyErr_SetString(PyExc_TypeError, "Operators.recursiveSplit(): 2nd argument: invalid UnaryPredicate1D object");
+	if (PyArg_ParseTupleAndKeywords(args, kwds, "O!O!|f", (char **)kwlist_1,
+	                                &UnaryFunction0DDouble_Type, &obj1, &UnaryPredicate1D_Type, &obj2, &f))
+	{
+		if (!((BPy_UnaryFunction0DDouble *)obj1)->uf0D_double) {
+			PyErr_SetString(PyExc_TypeError, "Operators.recursive_split(): 1st argument: invalid UnaryFunction0DDouble object");
 			return NULL;
 		}
-		if ( obj3 ) {
-			if ( !PyFloat_Check(obj3) ) {
-				PyErr_SetString(PyExc_TypeError, "Operators.recursiveSplit(): invalid 3rd argument");
-				return NULL;
-			}
-			f = PyFloat_AsDouble(obj3);
+		if (!((BPy_UnaryPredicate1D *)obj2)->up1D) {
+			PyErr_SetString(PyExc_TypeError, "Operators.recursive_split(): 2nd argument: invalid UnaryPredicate1D object");
+			return NULL;
 		}
-		if (Operators::recursiveSplit( 	*( ((BPy_UnaryFunction0DDouble *) obj1)->uf0D_double ),
-										*( ((BPy_UnaryPredicate1D *) obj2)->up1D ),
-										f ) < 0) {
+		if (Operators::recursiveSplit(*(((BPy_UnaryFunction0DDouble *)obj1)->uf0D_double),
+		                              *(((BPy_UnaryPredicate1D *)obj2)->up1D),
+		                              f) < 0)
+		{
 			if (!PyErr_Occurred())
-				PyErr_SetString(PyExc_RuntimeError, "Operators.recursiveSplit() failed");
+				PyErr_SetString(PyExc_RuntimeError, "Operators.recursive_split() failed");
 			return NULL;
 		}
-	
-	} else {
-
-		if ( !BPy_UnaryPredicate0D_Check(obj2) || !((BPy_UnaryPredicate0D *) obj2)->up0D ) {
-			PyErr_SetString(PyExc_TypeError, "Operators.recursiveSplit(): invalid 2nd argument");
+	}
+	else if (PyErr_Clear(), (f = 0.0f),
+	         PyArg_ParseTupleAndKeywords(args, kwds, "O!O!O!|f", (char **)kwlist_2,
+	                                &UnaryFunction0DDouble_Type, &obj1, &UnaryPredicate0D_Type, &obj2,
+	                                &UnaryPredicate1D_Type, &obj3, &f))
+	{
+		if (!((BPy_UnaryFunction0DDouble *)obj1)->uf0D_double) {
+			PyErr_SetString(PyExc_TypeError, "Operators.recursive_split(): 1st argument: invalid UnaryFunction0DDouble object");
 			return NULL;
 		}
-		if ( !BPy_UnaryPredicate1D_Check(obj3) || !((BPy_UnaryPredicate1D *) obj3)->up1D ) {
-			PyErr_SetString(PyExc_TypeError, "Operators.recursiveSplit(): invalid 3rd argument");
+		if (!((BPy_UnaryPredicate0D *)obj2)->up0D) {
+			PyErr_SetString(PyExc_TypeError, "Operators.recursive_split(): 2nd argument: invalid UnaryPredicate0D object");
 			return NULL;
 		}
-		if (Operators::recursiveSplit( 	*( ((BPy_UnaryFunction0DDouble *) obj1)->uf0D_double ),
-										*( ((BPy_UnaryPredicate0D *) obj2)->up0D ),
-										*( ((BPy_UnaryPredicate1D *) obj3)->up1D ),
-										f ) < 0) {
+		if (!((BPy_UnaryPredicate1D *)obj3)->up1D) {
+			PyErr_SetString(PyExc_TypeError, "Operators.recursive_split(): 3rd argument: invalid UnaryPredicate1D object");
+			return NULL;
+		}
+		if (Operators::recursiveSplit(*(((BPy_UnaryFunction0DDouble *)obj1)->uf0D_double),
+		                              *(((BPy_UnaryPredicate0D *)obj2)->up0D),
+		                              *(((BPy_UnaryPredicate1D *)obj3)->up1D),
+		                              f) < 0)
+		{
 			if (!PyErr_Occurred())
-				PyErr_SetString(PyExc_RuntimeError, "Operators.recursiveSplit() failed");
+				PyErr_SetString(PyExc_RuntimeError, "Operators.recursive_split() failed");
 			return NULL;
 		}
-
 	}
-	
+	else {
+		PyErr_SetString(PyExc_TypeError, "invalid argument(s)");
+		return NULL;
+	}
 	Py_RETURN_NONE;
 }
 
-static char Operators_sort___doc__[] =
+PyDoc_STRVAR(Operators_sort_doc,
 ".. staticmethod:: sort(pred)\n"
 "\n"
 "   Sorts the current set of chains (or viewedges) according to the\n"
 "   comparison predicate given as argument.\n"
 "\n"
 "   :arg pred: The binary predicate used for the comparison.\n"
-"   :type pred: BinaryPredicate1D\n";
+"   :type pred: BinaryPredicate1D");
 
-static PyObject * Operators_sort(BPy_Operators* self, PyObject *args)
+static PyObject *Operators_sort(BPy_Operators* self, PyObject *args, PyObject *kwds)
 {
+	static const char *kwlist[] = {"pred", NULL};
 	PyObject *obj = 0;
 
-	if ( !PyArg_ParseTuple(args, "O!", &BinaryPredicate1D_Type, &obj) )
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!", (char **)kwlist, &BinaryPredicate1D_Type, &obj))
 		return NULL;
-	if ( !((BPy_BinaryPredicate1D *) obj)->bp1D ) {
+	if (!((BPy_BinaryPredicate1D *)obj)->bp1D) {
 		PyErr_SetString(PyExc_TypeError, "Operators.sort(): 1st argument: invalid BinaryPredicate1D object");
 		return NULL;
 	}
-
-	if (Operators::sort(*( ((BPy_BinaryPredicate1D *) obj)->bp1D )) < 0) {
+	if (Operators::sort(*(((BPy_BinaryPredicate1D *)obj)->bp1D)) < 0) {
 		if (!PyErr_Occurred())
 			PyErr_SetString(PyExc_RuntimeError, "Operators.sort() failed");
 		return NULL;
@@ -498,7 +502,7 @@ static PyObject * Operators_sort(BPy_Operators* self, PyObject *args)
 	Py_RETURN_NONE;
 }
 
-static char Operators_create___doc__[] =
+PyDoc_STRVAR(Operators_create_doc,
 ".. staticmethod:: create(pred, shaders)\n"
 "\n"
 "   Creates and shades the strokes from the current set of chains.  A\n"
@@ -508,53 +512,55 @@ static char Operators_create___doc__[] =
 "      transform as a stroke.\n"
 "   :type pred: :class:`UnaryPredicate1D`\n"
 "   :arg shaders: The list of shaders used to shade the strokes.\n"
-"   :type shaders: List of StrokeShader objects\n";
+"   :type shaders: List of StrokeShader objects");
 
-static PyObject * Operators_create(BPy_Operators* self, PyObject *args)
+static PyObject *Operators_create(BPy_Operators* self, PyObject *args, PyObject *kwds)
 {
+	static const char *kwlist[] = {"pred", "shaders", NULL};
 	PyObject *obj1 = 0, *obj2 = 0;
 
-	if ( !PyArg_ParseTuple(args, "O!O!", &UnaryPredicate1D_Type, &obj1, &PyList_Type, &obj2) )
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!O!", (char **)kwlist,
+	                                 &UnaryPredicate1D_Type, &obj1, &PyList_Type, &obj2))
+	{
 		return NULL;
-	if ( !((BPy_UnaryPredicate1D *) obj1)->up1D ) {
+	}
+	if (!((BPy_UnaryPredicate1D *)obj1)->up1D) {
 		PyErr_SetString(PyExc_TypeError, "Operators.create(): 1st argument: invalid UnaryPredicate1D object");
 		return NULL;
 	}
-
 	vector<StrokeShader *> shaders;
-	for( int i = 0; i < PyList_Size(obj2); i++) {
-		PyObject *py_ss = PyList_GetItem(obj2,i);
-		
-		if ( !BPy_StrokeShader_Check(py_ss) ) {
-			PyErr_SetString(PyExc_TypeError, "Operators.create() 2nd argument must be a list of StrokeShader objects");
+	for (int i = 0; i < PyList_Size(obj2); i++) {
+		PyObject *py_ss = PyList_GetItem(obj2, i);
+		if (!BPy_StrokeShader_Check(py_ss)) {
+			PyErr_SetString(PyExc_TypeError, "Operators.create(): 2nd argument must be a list of StrokeShader objects");
 			return NULL;
 		}
-		shaders.push_back( ((BPy_StrokeShader *) py_ss)->ss );
+		shaders.push_back(((BPy_StrokeShader *)py_ss)->ss);
 	}
-	
-	if (Operators::create( *( ((BPy_UnaryPredicate1D *) obj1)->up1D ), shaders) < 0) {
+	if (Operators::create(*(((BPy_UnaryPredicate1D *)obj1)->up1D), shaders) < 0) {
 		if (!PyErr_Occurred())
 			PyErr_SetString(PyExc_RuntimeError, "Operators.create() failed");
 		return NULL;
 	}
-
 	Py_RETURN_NONE;
 }
 
-static char Operators_getViewEdgeFromIndex___doc__[] =
-".. staticmethod:: getViewEdgeFromIndex()\n"
+PyDoc_STRVAR(Operators_get_viewedge_from_index_doc,
+".. staticmethod:: get_viewedge_from_index(i)\n"
 "\n"
 "   Returns the ViewEdge at the index in the current set of ViewEdges.\n"
 "\n"
-"   :arg i: index (0 <= i < Operators.getViewEdgesSize()).\n"
+"   :arg i: index (0 <= i < Operators.get_view_edges_size()).\n"
 "   :type i: int\n"
 "   :return: The ViewEdge object.\n"
-"   :rtype: :class:`ViewEdge`\n";
+"   :rtype: :class:`ViewEdge`");
 
-static PyObject * Operators_getViewEdgeFromIndex(BPy_Operators* self, PyObject *args) {
+static PyObject *Operators_get_viewedge_from_index(BPy_Operators* self, PyObject *args, PyObject *kwds)
+{
+	static const char *kwlist[] = {"i", NULL};
 	unsigned int i;
 
-	if (!PyArg_ParseTuple(args, "I", &i))
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "I", (char **)kwlist, &i))
 		return NULL;
 	if (i >= Operators::getViewEdgesSize()) {
 		PyErr_SetString(PyExc_IndexError, "index out of range");
@@ -563,20 +569,22 @@ static PyObject * Operators_getViewEdgeFromIndex(BPy_Operators* self, PyObject *
 	return BPy_ViewEdge_from_ViewEdge(*(Operators::getViewEdgeFromIndex(i)));
 }
 
-static char Operators_getChainFromIndex___doc__[] =
-".. staticmethod:: getChainFromIndex()\n"
+PyDoc_STRVAR(Operators_get_chain_from_index_doc,
+".. staticmethod:: get_chain_from_index(i)\n"
 "\n"
 "   Returns the Chain at the index in the current set of Chains.\n"
 "\n"
-"   :arg i: index (0 <= i < Operators.getChainsSize()).\n"
+"   :arg i: index (0 <= i < Operators.get_chains_size()).\n"
 "   :type i: int\n"
 "   :return: The Chain object.\n"
-"   :rtype: :class:`Chain`\n";
+"   :rtype: :class:`Chain`");
 
-static PyObject * Operators_getChainFromIndex(BPy_Operators* self, PyObject *args) {
+static PyObject *Operators_get_chain_from_index(BPy_Operators* self, PyObject *args, PyObject *kwds)
+{
+	static const char *kwlist[] = {"i", NULL};
 	unsigned int i;
 
-	if (!PyArg_ParseTuple(args, "I", &i))
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "I", (char **)kwlist, &i))
 		return NULL;
 	if (i >= Operators::getChainsSize()) {
 		PyErr_SetString(PyExc_IndexError, "index out of range");
@@ -585,20 +593,22 @@ static PyObject * Operators_getChainFromIndex(BPy_Operators* self, PyObject *arg
 	return BPy_Chain_from_Chain(*(Operators::getChainFromIndex(i)));
 }
 
-static char Operators_getStrokeFromIndex___doc__[] =
-".. staticmethod:: getStrokeFromIndex()\n"
+PyDoc_STRVAR(Operators_get_stroke_from_index_doc,
+".. staticmethod:: get_stroke_from_index(i)\n"
 "\n"
 "   Returns the Stroke at the index in the current set of Strokes.\n"
 "\n"
-"   :arg i: index (0 <= i < Operators.getStrokesSize()).\n"
+"   :arg i: index (0 <= i < Operators.get_strokes_size()).\n"
 "   :type i: int\n"
 "   :return: The Stroke object.\n"
-"   :rtype: :class:`Stroke`\n";
+"   :rtype: :class:`Stroke`");
 
-static PyObject * Operators_getStrokeFromIndex(BPy_Operators* self, PyObject *args) {
+static PyObject *Operators_get_stroke_from_index(BPy_Operators* self, PyObject *args, PyObject *kwds)
+{
+	static const char *kwlist[] = {"i", NULL};
 	unsigned int i;
 
-	if (!PyArg_ParseTuple(args, "I", &i))
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "I", (char **)kwlist, &i))
 		return NULL;
 	if (i >= Operators::getStrokesSize()) {
 		PyErr_SetString(PyExc_IndexError, "index out of range");
@@ -607,57 +617,60 @@ static PyObject * Operators_getStrokeFromIndex(BPy_Operators* self, PyObject *ar
 	return BPy_Stroke_from_Stroke(*(Operators::getStrokeFromIndex(i)));
 }
 
-static char Operators_getViewEdgesSize___doc__[] =
-".. staticmethod:: getViewEdgesSize()\n"
+PyDoc_STRVAR(Operators_get_view_edges_size_doc,
+".. staticmethod:: get_view_edges_size()\n"
 "\n"
 "   Returns the number of ViewEdges.\n"
 "\n"
 "   :return: The number of ViewEdges.\n"
-"   :rtype: int\n";
+"   :rtype: int");
 
-static PyObject * Operators_getViewEdgesSize( BPy_Operators* self) {
-	return PyLong_FromLong( Operators::getViewEdgesSize() );
+static PyObject *Operators_get_view_edges_size(BPy_Operators* self)
+{
+	return PyLong_FromLong(Operators::getViewEdgesSize());
 }
 
-static char Operators_getChainsSize___doc__[] =
-".. staticmethod:: getChainsSize()\n"
+PyDoc_STRVAR(Operators_get_chains_size_doc,
+".. staticmethod:: get_chains_size()\n"
 "\n"
 "   Returns the number of Chains.\n"
 "\n"
 "   :return: The number of Chains.\n"
-"   :rtype: int\n";
+"   :rtype: int");
 
-static PyObject * Operators_getChainsSize( BPy_Operators* self ) {
-	return PyLong_FromLong( Operators::getChainsSize() );
+static PyObject *Operators_get_chains_size(BPy_Operators* self)
+{
+	return PyLong_FromLong(Operators::getChainsSize());
 }
 
-static char Operators_getStrokesSize___doc__[] =
-".. staticmethod:: getStrokesSize()\n"
+PyDoc_STRVAR(Operators_get_strokes_size_doc,
+".. staticmethod:: get_strokes_size()\n"
 "\n"
 "   Returns the number of Strokes.\n"
 "\n"
 "   :return: The number of Strokes.\n"
-"   :rtype: int\n";
+"   :rtype: int");
 
-static PyObject * Operators_getStrokesSize( BPy_Operators* self) {
-	return PyLong_FromLong( Operators::getStrokesSize() );
+static PyObject *Operators_get_strokes_size(BPy_Operators* self)
+{
+	return PyLong_FromLong(Operators::getStrokesSize());
 }
 
 /*----------------------Operators instance definitions ----------------------------*/
 static PyMethodDef BPy_Operators_methods[] = {
-	{"select", ( PyCFunction ) Operators_select, METH_VARARGS | METH_STATIC, Operators_select___doc__},
-	{"chain", ( PyCFunction ) Operators_chain, METH_VARARGS | METH_STATIC, Operators_chain___doc__},
-	{"bidirectionalChain", ( PyCFunction ) Operators_bidirectionalChain, METH_VARARGS | METH_STATIC, Operators_bidirectionalChain___doc__},
-	{"sequentialSplit", ( PyCFunction ) Operators_sequentialSplit, METH_VARARGS | METH_STATIC, Operators_sequentialSplit___doc__},
-	{"recursiveSplit", ( PyCFunction ) Operators_recursiveSplit, METH_VARARGS | METH_STATIC, Operators_recursiveSplit___doc__},
-	{"sort", ( PyCFunction ) Operators_sort, METH_VARARGS | METH_STATIC, Operators_sort___doc__},
-	{"create", ( PyCFunction ) Operators_create, METH_VARARGS | METH_STATIC, Operators_create___doc__},
-	{"getViewEdgeFromIndex", ( PyCFunction ) Operators_getViewEdgeFromIndex, METH_VARARGS | METH_STATIC, Operators_getViewEdgeFromIndex___doc__},
-	{"getChainFromIndex", ( PyCFunction ) Operators_getChainFromIndex, METH_VARARGS | METH_STATIC, Operators_getChainFromIndex___doc__},
-	{"getStrokeFromIndex", ( PyCFunction ) Operators_getStrokeFromIndex, METH_VARARGS | METH_STATIC, Operators_getStrokeFromIndex___doc__},
-	{"getViewEdgesSize", ( PyCFunction ) Operators_getViewEdgesSize, METH_NOARGS | METH_STATIC, Operators_getViewEdgesSize___doc__},
-	{"getChainsSize", ( PyCFunction ) Operators_getChainsSize, METH_NOARGS | METH_STATIC, Operators_getChainsSize___doc__},
-	{"getStrokesSize", ( PyCFunction ) Operators_getStrokesSize, METH_NOARGS | METH_STATIC, Operators_getStrokesSize___doc__},
+	{"select", (PyCFunction) Operators_select, METH_VARARGS | METH_KEYWORDS | METH_STATIC, Operators_select_doc},
+	{"chain", (PyCFunction) Operators_chain, METH_VARARGS | METH_KEYWORDS | METH_STATIC, Operators_chain_doc},
+	{"bidirectional_chain", (PyCFunction) Operators_bidirectional_chain, METH_VARARGS | METH_KEYWORDS | METH_STATIC, Operators_bidirectional_chain_doc},
+	{"sequential_split", (PyCFunction) Operators_sequential_split, METH_VARARGS | METH_KEYWORDS | METH_STATIC, Operators_sequential_split_doc},
+	{"recursive_split", (PyCFunction) Operators_recursive_split, METH_VARARGS | METH_KEYWORDS | METH_STATIC, Operators_recursive_split_doc},
+	{"sort", (PyCFunction) Operators_sort, METH_VARARGS | METH_KEYWORDS | METH_STATIC, Operators_sort_doc},
+	{"create", (PyCFunction) Operators_create, METH_VARARGS | METH_KEYWORDS | METH_STATIC, Operators_create_doc},
+	{"get_viewedge_from_index", (PyCFunction) Operators_get_viewedge_from_index, METH_VARARGS | METH_KEYWORDS | METH_STATIC, Operators_get_viewedge_from_index_doc},
+	{"get_chain_from_index", (PyCFunction) Operators_get_chain_from_index, METH_VARARGS | METH_KEYWORDS | METH_STATIC, Operators_get_chain_from_index_doc},
+	{"get_stroke_from_index", (PyCFunction) Operators_get_stroke_from_index, METH_VARARGS | METH_KEYWORDS | METH_STATIC, Operators_get_stroke_from_index_doc},
+	{"get_view_edges_size", (PyCFunction) Operators_get_view_edges_size, METH_NOARGS | METH_STATIC, Operators_get_view_edges_size_doc},
+	{"get_chains_size", (PyCFunction) Operators_get_chains_size, METH_NOARGS | METH_STATIC, Operators_get_chains_size_doc},
+	{"get_strokes_size", (PyCFunction) Operators_get_strokes_size, METH_NOARGS | METH_STATIC, Operators_get_strokes_size_doc},
 	{NULL, NULL, 0, NULL}
 };
 
@@ -668,7 +681,7 @@ PyTypeObject Operators_Type = {
 	"Operators",                    /* tp_name */
 	sizeof(BPy_Operators),          /* tp_basicsize */
 	0,                              /* tp_itemsize */
-	(destructor)Operators___dealloc__, /* tp_dealloc */
+	(destructor)Operators_dealloc,  /* tp_dealloc */
 	0,                              /* tp_print */
 	0,                              /* tp_getattr */
 	0,                              /* tp_setattr */
@@ -684,7 +697,7 @@ PyTypeObject Operators_Type = {
 	0,                              /* tp_setattro */
 	0,                              /* tp_as_buffer */
 	Py_TPFLAGS_DEFAULT,             /* tp_flags */
-	Operators___doc__,              /* tp_doc */
+	Operators_doc,                  /* tp_doc */
 	0,                              /* tp_traverse */
 	0,                              /* tp_clear */
 	0,                              /* tp_richcompare */
@@ -709,5 +722,3 @@ PyTypeObject Operators_Type = {
 #ifdef __cplusplus
 }
 #endif
-
-
diff --git a/source/blender/freestyle/intern/python/BPy_SShape.cpp b/source/blender/freestyle/intern/python/BPy_SShape.cpp
index 47b83d2582f..7d03ea06bc0 100644
--- a/source/blender/freestyle/intern/python/BPy_SShape.cpp
+++ b/source/blender/freestyle/intern/python/BPy_SShape.cpp
@@ -102,37 +102,39 @@ static PyObject * SShape_repr(BPy_SShape *self)
 }
 
 static char SShape_add_edge_doc[] =
-".. method:: add_edge(iEdge)\n"
+".. method:: add_edge(edge)\n"
 "\n"
 "   Adds an FEdge to the list of FEdges.\n"
 "\n"
-"   :arg iEdge: An FEdge object.\n"
-"   :type iEdge: :class:`FEdge`\n";
+"   :arg edge: An FEdge object.\n"
+"   :type edge: :class:`FEdge`\n";
 
-static PyObject * SShape_add_edge(BPy_SShape *self , PyObject *args)
+static PyObject * SShape_add_edge(BPy_SShape *self , PyObject *args, PyObject *kwds)
 {
+	static const char *kwlist[] = {"edge", NULL};
 	PyObject *py_fe = 0;
 
-	if (!PyArg_ParseTuple(args, "O!", &FEdge_Type, &py_fe))
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!", (char **)kwlist, &FEdge_Type, &py_fe))
 		return NULL;
 	self->ss->AddEdge(((BPy_FEdge *)py_fe)->fe);
 	Py_RETURN_NONE;
 }
 
 PyDoc_STRVAR(SShape_add_vertex_doc,
-".. method:: add_vertex(iv)\n"
+".. method:: add_vertex(vertex)\n"
 "\n"
 "   Adds an SVertex to the list of SVertex of this Shape.  The SShape\n"
 "   attribute of the SVertex is also set to this SShape.\n"
 "\n"
-"   :arg iv: An SVertex object.\n"
-"   :type iv: :class:`SVertex`");
+"   :arg vertex: An SVertex object.\n"
+"   :type vertex: :class:`SVertex`");
 
-static PyObject * SShape_add_vertex(BPy_SShape *self , PyObject *args)
+static PyObject * SShape_add_vertex(BPy_SShape *self , PyObject *args, PyObject *kwds)
 {
+	static const char *kwlist[] = {"edge", NULL};
 	PyObject *py_sv = 0;
 
-	if (!PyArg_ParseTuple(args, "O!", &SVertex_Type, &py_sv))
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!", (char **)kwlist, &SVertex_Type, &py_sv))
 		return NULL;
 	self->ss->AddNewVertex(((BPy_SVertex *)py_sv)->sv);
 	Py_RETURN_NONE;
@@ -154,8 +156,8 @@ static PyObject * SShape_compute_bbox(BPy_SShape *self)
 // void 	SetMaterials (const vector< Material > &iMaterials)
 
 static PyMethodDef BPy_SShape_methods[] = {
-	{"add_edge", (PyCFunction)SShape_add_edge, METH_VARARGS, SShape_add_edge_doc},
-	{"add_vertex", (PyCFunction)SShape_add_vertex, METH_VARARGS, SShape_add_vertex_doc},
+	{"add_edge", (PyCFunction)SShape_add_edge, METH_VARARGS | METH_KEYWORDS, SShape_add_edge_doc},
+	{"add_vertex", (PyCFunction)SShape_add_vertex, METH_VARARGS | METH_KEYWORDS, SShape_add_vertex_doc},
 	{"compute_bbox", (PyCFunction)SShape_compute_bbox, METH_NOARGS, SShape_compute_bbox_doc},
 	{NULL, NULL, 0, NULL}
 };
diff --git a/source/blender/freestyle/intern/python/BPy_StrokeAttribute.cpp b/source/blender/freestyle/intern/python/BPy_StrokeAttribute.cpp
index 811b21ea246..3a5abd21d07 100644
--- a/source/blender/freestyle/intern/python/BPy_StrokeAttribute.cpp
+++ b/source/blender/freestyle/intern/python/BPy_StrokeAttribute.cpp
@@ -156,172 +156,173 @@ static PyObject * StrokeAttribute_repr(BPy_StrokeAttribute* self)
 }
 
 PyDoc_STRVAR(StrokeAttribute_get_attribute_real_doc,
-".. method:: get_attribute_real(iName)\n"
+".. method:: get_attribute_real(name)\n"
 "\n"
 "   Returns an attribute of float type.\n"
 "\n"
-"   :arg iName: The name of the attribute.\n"
-"   :type iName: str\n"
+"   :arg name: The name of the attribute.\n"
+"   :type name: str\n"
 "   :return: The attribute value.\n"
 "   :rtype: float\n");
 
-static PyObject *StrokeAttribute_get_attribute_real(BPy_StrokeAttribute *self, PyObject *args)
+static PyObject *StrokeAttribute_get_attribute_real(BPy_StrokeAttribute *self, PyObject *args, PyObject *kwds)
 {
+	static const char *kwlist[] = {"name", NULL};
 	char *attr;
 
-	if(!(PyArg_ParseTuple(args, "s", &attr)))
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "s", (char **)kwlist, &attr))
 		return NULL;
-
 	double a = self->sa->getAttributeReal(attr);
 	return PyFloat_FromDouble(a);
 }
 
 PyDoc_STRVAR(StrokeAttribute_get_attribute_vec2_doc,
-".. method:: get_attribute_vec2(iName)\n"
+".. method:: get_attribute_vec2(name)\n"
 "\n"
 "   Returns an attribute of two-dimensional vector type.\n"
 "\n"
-"   :arg iName: The name of the attribute.\n"
-"   :type iName: str\n"
+"   :arg name: The name of the attribute.\n"
+"   :type name: str\n"
 "   :return: The attribute value.\n"
 "   :rtype: :class:`mathutils.Vector`\n");
 
-static PyObject *StrokeAttribute_get_attribute_vec2(BPy_StrokeAttribute *self, PyObject *args)
+static PyObject *StrokeAttribute_get_attribute_vec2(BPy_StrokeAttribute *self, PyObject *args, PyObject *kwds)
 {
+	static const char *kwlist[] = {"name", NULL};
 	char *attr;
 
-	if(!(PyArg_ParseTuple(args, "s", &attr)))
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "s", (char **)kwlist, &attr))
 		return NULL;
-
 	Vec2f a = self->sa->getAttributeVec2f(attr);
 	return Vector_from_Vec2f(a);
 }
 
 PyDoc_STRVAR(StrokeAttribute_get_attribute_vec3_doc,
-".. method:: get_attribute_vec3(iName)\n"
+".. method:: get_attribute_vec3(name)\n"
 "\n"
 "   Returns an attribute of three-dimensional vector type.\n"
 "\n"
-"   :arg iName: The name of the attribute.\n"
-"   :type iName: str\n"
+"   :arg name: The name of the attribute.\n"
+"   :type name: str\n"
 "   :return: The attribute value.\n"
 "   :rtype: :class:`mathutils.Vector`\n");
 
-static PyObject *StrokeAttribute_get_attribute_vec3(BPy_StrokeAttribute *self, PyObject *args)
+static PyObject *StrokeAttribute_get_attribute_vec3(BPy_StrokeAttribute *self, PyObject *args, PyObject *kwds)
 {
+	static const char *kwlist[] = {"name", NULL};
 	char *attr;
 
-	if(!(PyArg_ParseTuple(args, "s", &attr)))
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "s", (char **)kwlist, &attr))
 		return NULL;
-
 	Vec3f a = self->sa->getAttributeVec3f(attr);
 	return Vector_from_Vec3f(a);
 }
 
 PyDoc_STRVAR(StrokeAttribute_has_attribute_real_doc,
-".. method:: has_attribute_real(iName)\n"
+".. method:: has_attribute_real(name)\n"
 "\n"
-"   Checks whether the attribute iName of float type is available.\n"
+"   Checks whether the attribute name of float type is available.\n"
 "\n"
-"   :arg iName: The name of the attribute.\n"
-"   :type iName: str\n"
+"   :arg name: The name of the attribute.\n"
+"   :type name: str\n"
 "   :return: True if the attribute is availbale.\n"
 "   :rtype: bool\n");
 
-static PyObject *StrokeAttribute_has_attribute_real(BPy_StrokeAttribute *self, PyObject *args)
+static PyObject *StrokeAttribute_has_attribute_real(BPy_StrokeAttribute *self, PyObject *args, PyObject *kwds)
 {
+	static const char *kwlist[] = {"name", NULL};
 	char *attr;
 
-	if(!(PyArg_ParseTuple(args, "s", &attr)))
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "s", (char **)kwlist, &attr))
 		return NULL;
-
 	return PyBool_from_bool(self->sa->isAttributeAvailableReal(attr));
 }
 
 PyDoc_STRVAR(StrokeAttribute_has_attribute_vec2_doc,
-".. method:: has_attribute_vec2(iName)\n"
+".. method:: has_attribute_vec2(name)\n"
 "\n"
-"   Checks whether the attribute iName of two-dimensional vector type\n"
+"   Checks whether the attribute name of two-dimensional vector type\n"
 "   is available.\n"
 "\n"
-"   :arg iName: The name of the attribute.\n"
-"   :type iName: str\n"
+"   :arg name: The name of the attribute.\n"
+"   :type name: str\n"
 "   :return: True if the attribute is availbale.\n"
 "   :rtype: bool\n");
 
-static PyObject *StrokeAttribute_has_attribute_vec2(BPy_StrokeAttribute *self, PyObject *args)
+static PyObject *StrokeAttribute_has_attribute_vec2(BPy_StrokeAttribute *self, PyObject *args, PyObject *kwds)
 {
+	static const char *kwlist[] = {"name", NULL};
 	char *attr;
 
-	if(!(PyArg_ParseTuple(args, "s", &attr)))
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "s", (char **)kwlist, &attr))
 		return NULL;
-
 	return PyBool_from_bool(self->sa->isAttributeAvailableVec2f(attr));
 }
 
 PyDoc_STRVAR(StrokeAttribute_has_attribute_vec3_doc,
-".. method:: has_attribute_vec3(iName)\n"
+".. method:: has_attribute_vec3(name)\n"
 "\n"
-"   Checks whether the attribute iName of three-dimensional vector\n"
+"   Checks whether the attribute name of three-dimensional vector\n"
 "   type is available.\n"
 "\n"
-"   :arg iName: The name of the attribute.\n"
-"   :type iName: str\n"
+"   :arg name: The name of the attribute.\n"
+"   :type name: str\n"
 "   :return: True if the attribute is availbale.\n"
 "   :rtype: bool\n");
 
-static PyObject *StrokeAttribute_has_attribute_vec3(BPy_StrokeAttribute *self, PyObject *args)
+static PyObject *StrokeAttribute_has_attribute_vec3(BPy_StrokeAttribute *self, PyObject *args, PyObject *kwds)
 {
+	static const char *kwlist[] = {"name", NULL};
 	char *attr;
 
-	if(!(PyArg_ParseTuple(args, "s", &attr)))
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "s", (char **)kwlist, &attr))
 		return NULL;
-
 	return PyBool_from_bool(self->sa->isAttributeAvailableVec3f(attr));
 }
 
 PyDoc_STRVAR(StrokeAttribute_set_attribute_real_doc,
-".. method:: set_attribute_real(iName, att)\n"
+".. method:: set_attribute_real(name, value)\n"
 "\n"
 "   Adds a user-defined attribute of float type.  If there is no\n"
 "   attribute of the given name, it is added.  Otherwise, the new value\n"
 "   replaces the old one.\n"
 "\n"
-"   :arg iName: The name of the attribute.\n"
-"   :type iName: str\n"
-"   :arg att: The attribute value.\n"
-"   :type att: float\n");
+"   :arg name: The name of the attribute.\n"
+"   :type name: str\n"
+"   :arg value: The attribute value.\n"
+"   :type value: float\n");
 
-static PyObject * StrokeAttribute_set_attribute_real(BPy_StrokeAttribute *self, PyObject *args)
+static PyObject * StrokeAttribute_set_attribute_real(BPy_StrokeAttribute *self, PyObject *args, PyObject *kwds)
 {
+	static const char *kwlist[] = {"name", "value", NULL};
 	char *s = 0;
 	double d = 0;
 
-	if(!(PyArg_ParseTuple(args, "sd", &s, &d)))
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "sd", (char **)kwlist, &s, &d))
 		return NULL;
-
 	self->sa->setAttributeReal(s, d);
 	Py_RETURN_NONE;
 }
 
 PyDoc_STRVAR(StrokeAttribute_set_attribute_vec2_doc,
-".. method:: set_attribute_vec2(iName, att)\n"
+".. method:: set_attribute_vec2(name, value)\n"
 "\n"
 "   Adds a user-defined attribute of two-dimensional vector type.  If\n"
 "   there is no attribute of the given name, it is added.  Otherwise,\n"
 "   the new value replaces the old one.\n"
 "\n"
-"   :arg iName: The name of the attribute.\n"
-"   :type iName: str\n"
-"   :arg att: The attribute value.\n"
-"   :type att: :class:`mathutils.Vector`, list or tuple of 2 real numbers\n");
+"   :arg name: The name of the attribute.\n"
+"   :type name: str\n"
+"   :arg value: The attribute value.\n"
+"   :type value: :class:`mathutils.Vector`, list or tuple of 2 real numbers\n");
 
-static PyObject * StrokeAttribute_set_attribute_vec2(BPy_StrokeAttribute *self, PyObject *args)
+static PyObject * StrokeAttribute_set_attribute_vec2(BPy_StrokeAttribute *self, PyObject *args, PyObject *kwds)
 {
+	static const char *kwlist[] = {"name", "value", NULL};
 	char *s;
 	PyObject *obj = 0;
 
-	if(!(PyArg_ParseTuple(args, "sO", &s, &obj)))
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "sO", (char **)kwlist, &s, &obj))
 		return NULL;
 	Vec2f *v = Vec2f_ptr_from_PyObject(obj);
 	if (!v) {
@@ -330,28 +331,28 @@ static PyObject * StrokeAttribute_set_attribute_vec2(BPy_StrokeAttribute *self,
 	}
 	self->sa->setAttributeVec2f(s, *v);
 	delete v;
-
 	Py_RETURN_NONE;
 }
 
 PyDoc_STRVAR(StrokeAttribute_set_attribute_vec3_doc,
-".. method:: set_attribute_vec3(iName, att)\n"
+".. method:: set_attribute_vec3(name, value)\n"
 "\n"
 "   Adds a user-defined attribute of three-dimensional vector type.\n"
 "   If there is no attribute of the given name, it is added.\n"
 "   Otherwise, the new value replaces the old one.\n"
 "\n"
-"   :arg iName: The name of the attribute.\n"
-"   :type iName: str\n"
-"   :arg att: The attribute value.\n"
-"   :type att: :class:`mathutils.Vector`, list or tuple of 3 real numbers\n");
+"   :arg name: The name of the attribute.\n"
+"   :type name: str\n"
+"   :arg value: The attribute value.\n"
+"   :type value: :class:`mathutils.Vector`, list or tuple of 3 real numbers\n");
 
-static PyObject * StrokeAttribute_set_attribute_vec3(BPy_StrokeAttribute *self, PyObject *args)
+static PyObject * StrokeAttribute_set_attribute_vec3(BPy_StrokeAttribute *self, PyObject *args, PyObject *kwds)
 {
+	static const char *kwlist[] = {"name", "value", NULL};
 	char *s;
 	PyObject *obj = 0;
 
-	if(!(PyArg_ParseTuple(args, "sO", &s, &obj)))
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "sO", (char **)kwlist, &s, &obj))
 		return NULL;
 	Vec3f *v = Vec3f_ptr_from_PyObject(obj);
 	if (!v) {
@@ -360,21 +361,19 @@ static PyObject * StrokeAttribute_set_attribute_vec3(BPy_StrokeAttribute *self,
 	}
 	self->sa->setAttributeVec3f(s, *v);
 	delete v;
-
 	Py_RETURN_NONE;
 }
 
-/*----------------------StrokeAttribute instance definitions ----------------------------*/
 static PyMethodDef BPy_StrokeAttribute_methods[] = {
-	{"get_attribute_real", (PyCFunction) StrokeAttribute_get_attribute_real, METH_VARARGS, StrokeAttribute_get_attribute_real_doc},
-	{"get_attribute_vec2", (PyCFunction) StrokeAttribute_get_attribute_vec2, METH_VARARGS, StrokeAttribute_get_attribute_vec2_doc},
-	{"get_attribute_vec3", (PyCFunction) StrokeAttribute_get_attribute_vec3, METH_VARARGS, StrokeAttribute_get_attribute_vec3_doc},
-	{"has_attribute_real", (PyCFunction) StrokeAttribute_has_attribute_real, METH_VARARGS, StrokeAttribute_has_attribute_real_doc},
-	{"has_attribute_vec2", (PyCFunction) StrokeAttribute_has_attribute_vec2, METH_VARARGS, StrokeAttribute_has_attribute_vec2_doc},
-	{"has_attribute_vec3", (PyCFunction) StrokeAttribute_has_attribute_vec3, METH_VARARGS, StrokeAttribute_has_attribute_vec3_doc},
-	{"set_attribute_real", (PyCFunction) StrokeAttribute_set_attribute_real, METH_VARARGS, StrokeAttribute_set_attribute_real_doc},
-	{"set_attribute_vec2", (PyCFunction) StrokeAttribute_set_attribute_vec2, METH_VARARGS, StrokeAttribute_set_attribute_vec2_doc},
-	{"set_attribute_vec3", (PyCFunction) StrokeAttribute_set_attribute_vec3, METH_VARARGS, StrokeAttribute_set_attribute_vec3_doc},
+	{"get_attribute_real", (PyCFunction) StrokeAttribute_get_attribute_real, METH_VARARGS | METH_KEYWORDS, StrokeAttribute_get_attribute_real_doc},
+	{"get_attribute_vec2", (PyCFunction) StrokeAttribute_get_attribute_vec2, METH_VARARGS | METH_KEYWORDS, StrokeAttribute_get_attribute_vec2_doc},
+	{"get_attribute_vec3", (PyCFunction) StrokeAttribute_get_attribute_vec3, METH_VARARGS | METH_KEYWORDS, StrokeAttribute_get_attribute_vec3_doc},
+	{"has_attribute_real", (PyCFunction) StrokeAttribute_has_attribute_real, METH_VARARGS | METH_KEYWORDS, StrokeAttribute_has_attribute_real_doc},
+	{"has_attribute_vec2", (PyCFunction) StrokeAttribute_has_attribute_vec2, METH_VARARGS | METH_KEYWORDS, StrokeAttribute_has_attribute_vec2_doc},
+	{"has_attribute_vec3", (PyCFunction) StrokeAttribute_has_attribute_vec3, METH_VARARGS | METH_KEYWORDS, StrokeAttribute_has_attribute_vec3_doc},
+	{"set_attribute_real", (PyCFunction) StrokeAttribute_set_attribute_real, METH_VARARGS | METH_KEYWORDS, StrokeAttribute_set_attribute_real_doc},
+	{"set_attribute_vec2", (PyCFunction) StrokeAttribute_set_attribute_vec2, METH_VARARGS | METH_KEYWORDS, StrokeAttribute_set_attribute_vec2_doc},
+	{"set_attribute_vec3", (PyCFunction) StrokeAttribute_set_attribute_vec3, METH_VARARGS | METH_KEYWORDS, StrokeAttribute_set_attribute_vec3_doc},
 	{NULL, NULL, 0, NULL}
 };
 
diff --git a/source/blender/freestyle/intern/python/BPy_ViewMap.cpp b/source/blender/freestyle/intern/python/BPy_ViewMap.cpp
index 2160a9d2e38..46aad0d788c 100644
--- a/source/blender/freestyle/intern/python/BPy_ViewMap.cpp
+++ b/source/blender/freestyle/intern/python/BPy_ViewMap.cpp
@@ -99,11 +99,12 @@ PyDoc_STRVAR(ViewMap_get_closest_viewedge_doc,
 "   :return: The ViewEdge nearest to the specified 2D point.\n"
 "   :rtype: :class:`ViewEdge`");
 
-static PyObject * ViewMap_get_closest_viewedge(BPy_ViewMap *self , PyObject *args)
+static PyObject * ViewMap_get_closest_viewedge(BPy_ViewMap *self , PyObject *args, PyObject *kwds)
 {
+	static const char *kwlist[] = {"x", "y", NULL};
 	double x, y;
 
-	if (!PyArg_ParseTuple(args, "dd", &x, &y))
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "dd", (char **)kwlist, &x, &y))
 		return NULL;
 	ViewEdge *ve = const_cast<ViewEdge *>(self->vm->getClosestViewEdge(x,y));
 	if (ve)
@@ -123,11 +124,12 @@ PyDoc_STRVAR(ViewMap_get_closest_fedge_doc,
 "   :return: The FEdge nearest to the specified 2D point.\n"
 "   :rtype: :class:`FEdge`");
 
-static PyObject * ViewMap_get_closest_fedge(BPy_ViewMap *self , PyObject *args)
+static PyObject * ViewMap_get_closest_fedge(BPy_ViewMap *self , PyObject *args, PyObject *kwds)
 {
+	static const char *kwlist[] = {"x", "y", NULL};
 	double x, y;
 
-	if (!PyArg_ParseTuple(args, "dd", &x, &y))
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "dd", (char **)kwlist, &x, &y))
 		return NULL;
 	FEdge *fe = const_cast<FEdge *>(self->vm->getClosestFEdge(x,y));
 	if (fe)
@@ -138,8 +140,8 @@ static PyObject * ViewMap_get_closest_fedge(BPy_ViewMap *self , PyObject *args)
 // static ViewMap *getInstance ();
 
 static PyMethodDef BPy_ViewMap_methods[] = {
-	{"get_closest_viewedge", (PyCFunction)ViewMap_get_closest_viewedge, METH_VARARGS, ViewMap_get_closest_viewedge_doc},
-	{"get_closest_fedge", (PyCFunction)ViewMap_get_closest_fedge, METH_VARARGS, ViewMap_get_closest_fedge_doc},
+	{"get_closest_viewedge", (PyCFunction)ViewMap_get_closest_viewedge, METH_VARARGS | METH_KEYWORDS, ViewMap_get_closest_viewedge_doc},
+	{"get_closest_fedge", (PyCFunction)ViewMap_get_closest_fedge, METH_VARARGS | METH_KEYWORDS, ViewMap_get_closest_fedge_doc},
 	{NULL, NULL, 0, NULL}
 };
 
diff --git a/source/blender/freestyle/intern/python/BPy_ViewShape.cpp b/source/blender/freestyle/intern/python/BPy_ViewShape.cpp
index 72ebe43fab5..fdb2a695456 100644
--- a/source/blender/freestyle/intern/python/BPy_ViewShape.cpp
+++ b/source/blender/freestyle/intern/python/BPy_ViewShape.cpp
@@ -125,40 +125,42 @@ static void ViewShape_dealloc(BPy_ViewShape *self)
 
 static PyObject * ViewShape_repr(BPy_ViewShape *self)
 {
-	return PyUnicode_FromFormat("ViewShape - address: %p", self->vs );
+	return PyUnicode_FromFormat("ViewShape - address: %p", self->vs);
 }
 
 PyDoc_STRVAR(ViewShape_add_edge_doc,
-".. method:: add_edge(iEdge)\n"
+".. method:: add_edge(edge)\n"
 "\n"
 "   Adds a ViewEdge to the list of ViewEdge objects.\n"
 "\n"
-"   :arg iEdge: A ViewEdge object.\n"
-"   :type iEdge: :class:`ViewEdge`\n");
+"   :arg edge: A ViewEdge object.\n"
+"   :type edge: :class:`ViewEdge`\n");
 
-static PyObject * ViewShape_add_edge(BPy_ViewShape *self , PyObject *args)
+static PyObject * ViewShape_add_edge(BPy_ViewShape *self, PyObject *args, PyObject *kwds)
 {
+	static const char *kwlist[] = {"edge", NULL};
 	PyObject *py_ve = 0;
 
-	if (!PyArg_ParseTuple(args, "O!", &ViewEdge_Type, &py_ve))
+	if (PyArg_ParseTupleAndKeywords(args, kwds, "O!", (char **)kwlist, &ViewEdge_Type, &py_ve))
 		return NULL;
 	self->vs->AddEdge(((BPy_ViewEdge *)py_ve)->ve);
 	Py_RETURN_NONE;
 }
 
 PyDoc_STRVAR(ViewShape_add_vertex_doc,
-".. method:: add_vertex(iVertex)\n"
+".. method:: add_vertex(vertex)\n"
 "\n"
 "   Adds a ViewVertex to the list of the ViewVertex objects.\n"
 "\n"
-"   :arg iVertex: A ViewVertex object.\n"
-"   :type iVertex: :class:`ViewVertex`");
+"   :arg vertex: A ViewVertex object.\n"
+"   :type vertex: :class:`ViewVertex`");
 
-static PyObject * ViewShape_add_vertex(BPy_ViewShape *self , PyObject *args)
+static PyObject * ViewShape_add_vertex(BPy_ViewShape *self, PyObject *args, PyObject *kwds)
 {
+	static const char *kwlist[] = {"vertex", NULL};
 	PyObject *py_vv = 0;
 
-	if (!PyArg_ParseTuple(args, "O!", &ViewVertex_Type, &py_vv))
+	if (PyArg_ParseTupleAndKeywords(args, kwds, "O!", (char **)kwlist, &ViewVertex_Type, &py_vv))
 		return NULL;
 	self->vs->AddVertex(((BPy_ViewVertex *)py_vv)->vv);
 	Py_RETURN_NONE;
@@ -167,8 +169,8 @@ static PyObject * ViewShape_add_vertex(BPy_ViewShape *self , PyObject *args)
 // virtual ViewShape *duplicate()
 
 static PyMethodDef BPy_ViewShape_methods[] = {
-	{"add_edge", (PyCFunction)ViewShape_add_edge, METH_VARARGS, ViewShape_add_edge_doc},
-	{"add_vertex", (PyCFunction)ViewShape_add_vertex, METH_VARARGS, ViewShape_add_vertex_doc},
+	{"add_edge", (PyCFunction)ViewShape_add_edge, METH_VARARGS | METH_KEYWORDS, ViewShape_add_edge_doc},
+	{"add_vertex", (PyCFunction)ViewShape_add_vertex, METH_VARARGS | METH_KEYWORDS, ViewShape_add_vertex_doc},
 	{NULL, NULL, 0, NULL}
 };
 
diff --git a/source/blender/freestyle/intern/python/Interface0D/BPy_SVertex.cpp b/source/blender/freestyle/intern/python/Interface0D/BPy_SVertex.cpp
index 6cc16494b87..072a602cf29 100644
--- a/source/blender/freestyle/intern/python/Interface0D/BPy_SVertex.cpp
+++ b/source/blender/freestyle/intern/python/Interface0D/BPy_SVertex.cpp
@@ -102,18 +102,20 @@ static int SVertex_init(BPy_SVertex *self, PyObject *args, PyObject *kwds)
 }
 
 PyDoc_STRVAR(SVertex_add_normal_doc,
-".. method:: add_normal(n)\n"
+".. method:: add_normal(normal)\n"
 "\n"
 "   Adds a normal to the SVertex's set of normals.  If the same normal\n"
 "   is already in the set, nothing changes.\n"
 "\n"
-"   :arg n: A three-dimensional vector.\n"
-"   :type n: :class:`mathutils.Vector`, list or tuple of 3 real numbers");
+"   :arg normal: A three-dimensional vector.\n"
+"   :type normal: :class:`mathutils.Vector`, list or tuple of 3 real numbers");
 
-static PyObject *SVertex_add_normal( BPy_SVertex *self , PyObject *args) {
+static PyObject *SVertex_add_normal(BPy_SVertex *self , PyObject *args, PyObject *kwds)
+{
+	static const char *kwlist[] = {"normal", NULL};
 	PyObject *py_normal;
 
-	if (!PyArg_ParseTuple(args, "O", &py_normal))
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O", (char **)kwlist, &py_normal))
 		return NULL;
 	Vec3r *n = Vec3r_ptr_from_PyObject(py_normal);
 	if (!n) {
@@ -127,29 +129,29 @@ static PyObject *SVertex_add_normal( BPy_SVertex *self , PyObject *args) {
 }
 
 PyDoc_STRVAR(SVertex_add_fedge_doc,
-".. method:: add_fedge(fe)\n"
+".. method:: add_fedge(fedge)\n"
 "\n"
 "   Add an FEdge to the list of edges emanating from this SVertex.\n"
 "\n"
-"   :arg fe: An FEdge.\n"
-"   :type fe: :class:`FEdge`");
+"   :arg fedge: An FEdge.\n"
+"   :type fedge: :class:`FEdge`");
 
-static PyObject *SVertex_add_fedge( BPy_SVertex *self , PyObject *args) {
+static PyObject *SVertex_add_fedge(BPy_SVertex *self , PyObject *args, PyObject *kwds)
+{
+	static const char *kwlist[] = {"fedge", NULL};
 	PyObject *py_fe;
 
-	if (!PyArg_ParseTuple(args, "O!", &FEdge_Type, &py_fe))
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!", (char **)kwlist, &FEdge_Type, &py_fe))
 		return NULL;
-	
 	self->sv->AddFEdge(((BPy_FEdge *)py_fe)->fe);
-
 	Py_RETURN_NONE;
 }
 
 // virtual bool 	operator== (const SVertex &brother)
 
 static PyMethodDef BPy_SVertex_methods[] = {
-	{"add_normal", (PyCFunction)SVertex_add_normal, METH_VARARGS, SVertex_add_normal_doc},
-	{"add_fedge", (PyCFunction)SVertex_add_fedge, METH_VARARGS, SVertex_add_fedge_doc},
+	{"add_normal", (PyCFunction)SVertex_add_normal, METH_VARARGS | METH_KEYWORDS, SVertex_add_normal_doc},
+	{"add_fedge", (PyCFunction)SVertex_add_fedge, METH_VARARGS | METH_KEYWORDS, SVertex_add_fedge_doc},
 	{NULL, NULL, 0, NULL}
 };
 
diff --git a/source/blender/freestyle/intern/python/Interface0D/BPy_ViewVertex.cpp b/source/blender/freestyle/intern/python/Interface0D/BPy_ViewVertex.cpp
index 696ab102270..1e5f70144c1 100644
--- a/source/blender/freestyle/intern/python/Interface0D/BPy_ViewVertex.cpp
+++ b/source/blender/freestyle/intern/python/Interface0D/BPy_ViewVertex.cpp
@@ -76,8 +76,6 @@ PyDoc_STRVAR(ViewVertex_edges_begin_doc,
 
 static PyObject * ViewVertex_edges_begin(BPy_ViewVertex *self)
 {
-	if (!self->vv)
-		Py_RETURN_NONE;
 	ViewVertexInternal::orientedViewEdgeIterator ove_it(self->vv->edgesBegin());
 	return BPy_orientedViewEdgeIterator_from_orientedViewEdgeIterator(ove_it, 0);
 }
@@ -94,8 +92,6 @@ PyDoc_STRVAR(ViewVertex_edges_end_doc,
 static PyObject * ViewVertex_edges_end(BPy_ViewVertex *self)
 {
 #if 0
-	if (!self->vv)
-		Py_RETURN_NONE;
 	ViewVertexInternal::orientedViewEdgeIterator ove_it(self->vv->edgesEnd());
 	return BPy_orientedViewEdgeIterator_from_orientedViewEdgeIterator(ove_it, 1);
 #else
@@ -105,23 +101,22 @@ static PyObject * ViewVertex_edges_end(BPy_ViewVertex *self)
 }
 
 PyDoc_STRVAR(ViewVertex_edges_iterator_doc,
-".. method:: edges_iterator(iEdge)\n"
+".. method:: edges_iterator(edge)\n"
 "\n"
 "   Returns an orientedViewEdgeIterator pointing to the ViewEdge given\n"
 "   as argument.\n"
 "\n"
-"   :arg iEdge: A ViewEdge object.\n"
-"   :type iEdge: :class:`ViewEdge`\n"
+"   :arg edge: A ViewEdge object.\n"
+"   :type edge: :class:`ViewEdge`\n"
 "   :return: An orientedViewEdgeIterator pointing to the given ViewEdge.\n"
 "   :rtype: :class:`orientedViewEdgeIterator`");
 
-static PyObject * ViewVertex_edges_iterator(BPy_ViewVertex *self, PyObject *args)
+static PyObject * ViewVertex_edges_iterator(BPy_ViewVertex *self, PyObject *args, PyObject *kwds)
 {
+	static const char *kwlist[] = {"edge", NULL};
 	PyObject *py_ve;
 
-	if (!self->vv)
-		Py_RETURN_NONE;
-	if (!PyArg_ParseTuple(args, "O!", &ViewEdge_Type, &py_ve))
+	if (PyArg_ParseTupleAndKeywords(args, kwds, "O!", (char **)kwlist, &ViewEdge_Type, &py_ve))
 		return NULL;
 	ViewEdge *ve = ((BPy_ViewEdge *)py_ve)->ve;
 	ViewVertexInternal::orientedViewEdgeIterator ove_it(self->vv->edgesIterator(ve));
@@ -131,7 +126,7 @@ static PyObject * ViewVertex_edges_iterator(BPy_ViewVertex *self, PyObject *args
 static PyMethodDef BPy_ViewVertex_methods[] = {
 	{"edges_begin", (PyCFunction)ViewVertex_edges_begin, METH_NOARGS, ViewVertex_edges_begin_doc},
 	{"edges_end", (PyCFunction)ViewVertex_edges_end, METH_NOARGS, ViewVertex_edges_end_doc},
-	{"edges_iterator", (PyCFunction)ViewVertex_edges_iterator, METH_VARARGS, ViewVertex_edges_iterator_doc},
+	{"edges_iterator", (PyCFunction)ViewVertex_edges_iterator, METH_VARARGS | METH_KEYWORDS, ViewVertex_edges_iterator_doc},
 	{NULL, NULL, 0, NULL}
 };
 
@@ -212,4 +207,3 @@ PyTypeObject ViewVertex_Type = {
 #ifdef __cplusplus
 }
 #endif
-
diff --git a/source/blender/freestyle/intern/python/Interface0D/ViewVertex/BPy_TVertex.cpp b/source/blender/freestyle/intern/python/Interface0D/ViewVertex/BPy_TVertex.cpp
index 7cf6e0571d5..e6285371c77 100644
--- a/source/blender/freestyle/intern/python/Interface0D/ViewVertex/BPy_TVertex.cpp
+++ b/source/blender/freestyle/intern/python/Interface0D/ViewVertex/BPy_TVertex.cpp
@@ -74,20 +74,21 @@ static int TVertex_init(BPy_TVertex *self, PyObject *args, PyObject *kwds)
 }
 
 PyDoc_STRVAR(TVertex_get_svertex_doc,
-".. method:: get_svertex(iFEdge)\n"
+".. method:: get_svertex(fedge)\n"
 "\n"
 "   Returns the SVertex (among the 2) belonging to the given FEdge.\n"
 "\n"
-"   :arg iFEdge: An FEdge object.\n"
-"   :type iFEdge: :class:`FEdge`\n"
+"   :arg fedge: An FEdge object.\n"
+"   :type fedge: :class:`FEdge`\n"
 "   :return: The SVertex belonging to the given FEdge.\n"
 "   :rtype: :class:`SVertex`");
 
-static PyObject * TVertex_get_svertex( BPy_TVertex *self, PyObject *args)
+static PyObject * TVertex_get_svertex( BPy_TVertex *self, PyObject *args, PyObject *kwds)
 {
+	static const char *kwlist[] = {"fedge", NULL};
 	PyObject *py_fe;
 
-	if (!PyArg_ParseTuple(args, "O!", &FEdge_Type, &py_fe))
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!", (char **)kwlist, &FEdge_Type, &py_fe))
 		return NULL;
 	SVertex *sv = self->tv->getSVertex(((BPy_FEdge *)py_fe)->fe);
 	if (sv)
@@ -96,22 +97,23 @@ static PyObject * TVertex_get_svertex( BPy_TVertex *self, PyObject *args)
 }
 
 PyDoc_STRVAR(TVertex_get_mate_doc,
-".. method:: get_mate(iEdgeA)\n"
+".. method:: get_mate(viewedge)\n"
 "\n"
 "   Returns the mate edge of the ViewEdge given as argument.  If the\n"
 "   ViewEdge is frontEdgeA, frontEdgeB is returned.  If the ViewEdge is\n"
 "   frontEdgeB, frontEdgeA is returned.  Same for back edges.\n"
 "\n"
-"   :arg iEdgeA: A ViewEdge object.\n"
-"   :type iEdgeA: :class:`ViewEdge`\n"
+"   :arg viewedge: A ViewEdge object.\n"
+"   :type viewedge: :class:`ViewEdge`\n"
 "   :return: The mate edge of the given ViewEdge.\n"
 "   :rtype: :class:`ViewEdge`");
 
-static PyObject * TVertex_get_mate( BPy_TVertex *self, PyObject *args)
+static PyObject * TVertex_get_mate( BPy_TVertex *self, PyObject *args, PyObject *kwds)
 {
+	static const char *kwlist[] = {"viewedge", NULL};
 	PyObject *py_ve;
 
-	if (!PyArg_ParseTuple(args, "O!", &ViewEdge_Type, &py_ve))
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!", (char **)kwlist, &ViewEdge_Type, &py_ve))
 		return NULL;
 	ViewEdge *ve = self->tv->mate(((BPy_ViewEdge *)py_ve)->ve);
 	if (ve)
@@ -120,8 +122,8 @@ static PyObject * TVertex_get_mate( BPy_TVertex *self, PyObject *args)
 }
 
 static PyMethodDef BPy_TVertex_methods[] = {
-	{"get_svertex", (PyCFunction)TVertex_get_svertex, METH_VARARGS, TVertex_get_svertex_doc},
-	{"get_mate", (PyCFunction)TVertex_get_mate, METH_VARARGS, TVertex_get_mate_doc},
+	{"get_svertex", (PyCFunction)TVertex_get_svertex, METH_VARARGS | METH_KEYWORDS, TVertex_get_svertex_doc},
+	{"get_mate", (PyCFunction)TVertex_get_mate, METH_VARARGS | METH_KEYWORDS, TVertex_get_mate_doc},
 	{NULL, NULL, 0, NULL}
 };
 
diff --git a/source/blender/freestyle/intern/python/Interface1D/BPy_FrsCurve.cpp b/source/blender/freestyle/intern/python/Interface1D/BPy_FrsCurve.cpp
index 438c0eed65e..368b6f80de3 100644
--- a/source/blender/freestyle/intern/python/Interface1D/BPy_FrsCurve.cpp
+++ b/source/blender/freestyle/intern/python/Interface1D/BPy_FrsCurve.cpp
@@ -96,62 +96,66 @@ static int FrsCurve_init(BPy_FrsCurve *self, PyObject *args, PyObject *kwds)
 }
 
 PyDoc_STRVAR(FrsCurve_push_vertex_back_doc,
-".. method:: push_vertex_back(iVertex)\n"
+".. method:: push_vertex_back(vertex)\n"
 "\n"
 "   Adds a single vertex at the end of the Curve.\n"
 "\n"
-"   :arg iVertex: A vertex object.\n"
-"   :type iVertex: :class:`SVertex` or :class:`CurvePoint`");
+"   :arg vertex: A vertex object.\n"
+"   :type vertex: :class:`SVertex` or :class:`CurvePoint`");
 
-static PyObject * FrsCurve_push_vertex_back( BPy_FrsCurve *self, PyObject *args )
+static PyObject * FrsCurve_push_vertex_back(BPy_FrsCurve *self, PyObject *args, PyObject *kwds)
 {
-	PyObject *obj;
+	static const char *kwlist[] = {"vertex", NULL};
+	PyObject *obj = 0;
 
-	if (!PyArg_ParseTuple(args, "O", &obj))
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O", (char **)kwlist, &obj))
 		return NULL;
 
 	if (BPy_CurvePoint_Check(obj)) {
 		self->c->push_vertex_back(((BPy_CurvePoint *)obj)->cp);
-	} else if (BPy_SVertex_Check(obj)) {
+	}
+	else if (BPy_SVertex_Check(obj)) {
 		self->c->push_vertex_back(((BPy_SVertex *)obj)->sv);
-	} else {
+	}
+	else {
 		PyErr_SetString(PyExc_TypeError, "invalid argument");
 		return NULL;
 	}
-
 	Py_RETURN_NONE;
 }
 
 PyDoc_STRVAR(FrsCurve_push_vertex_front_doc,
-".. method:: push_vertex_front(iVertex)\n"
+".. method:: push_vertex_front(vertex)\n"
 "\n"
 "   Adds a single vertex at the front of the Curve.\n"
 "\n"
-"   :arg iVertex: A vertex object.\n"
-"   :type iVertex: :class:`SVertex` or :class:`CurvePoint`");
+"   :arg vertex: A vertex object.\n"
+"   :type vertex: :class:`SVertex` or :class:`CurvePoint`");
 
-static PyObject * FrsCurve_push_vertex_front( BPy_FrsCurve *self, PyObject *args )
+static PyObject * FrsCurve_push_vertex_front(BPy_FrsCurve *self, PyObject *args, PyObject *kwds)
 {
-	PyObject *obj;
+	static const char *kwlist[] = {"vertex", NULL};
+	PyObject *obj = 0;
 
-	if (!PyArg_ParseTuple(args, "O", &obj))
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O", (char **)kwlist, &obj))
 		return NULL;
 
 	if (BPy_CurvePoint_Check(obj)) {
 		self->c->push_vertex_front(((BPy_CurvePoint *)obj)->cp);
-	} else if( BPy_SVertex_Check(obj)) {
+	}
+	else if (BPy_SVertex_Check(obj)) {
 		self->c->push_vertex_front(((BPy_SVertex *)obj)->sv);
-	} else {
+	}
+	else {
 		PyErr_SetString(PyExc_TypeError, "invalid argument");
 		return NULL;
 	}
-
 	Py_RETURN_NONE;
 }
 
 static PyMethodDef BPy_FrsCurve_methods[] = {	
-	{"push_vertex_back", (PyCFunction)FrsCurve_push_vertex_back, METH_VARARGS, FrsCurve_push_vertex_back_doc},
-	{"push_vertex_front", (PyCFunction)FrsCurve_push_vertex_front, METH_VARARGS, FrsCurve_push_vertex_front_doc},
+	{"push_vertex_back", (PyCFunction)FrsCurve_push_vertex_back, METH_VARARGS | METH_KEYWORDS, FrsCurve_push_vertex_back_doc},
+	{"push_vertex_front", (PyCFunction)FrsCurve_push_vertex_front, METH_VARARGS | METH_KEYWORDS, FrsCurve_push_vertex_front_doc},
 	{NULL, NULL, 0, NULL}
 };
 
diff --git a/source/blender/freestyle/intern/python/Interface1D/BPy_Stroke.cpp b/source/blender/freestyle/intern/python/Interface1D/BPy_Stroke.cpp
index fb57356775c..0cc12373eac 100644
--- a/source/blender/freestyle/intern/python/Interface1D/BPy_Stroke.cpp
+++ b/source/blender/freestyle/intern/python/Interface1D/BPy_Stroke.cpp
@@ -107,59 +107,66 @@ static PyObject *Stroke_sq_item(BPy_Stroke *self, int keynum)
 }
 
 PyDoc_STRVAR(Stroke_compute_sampling_doc,
-".. method:: compute_sampling(iNVertices)\n"
+".. method:: compute_sampling(n)\n"
 "\n"
-"   Compute the sampling needed to get iNVertices vertices.  If the\n"
+"   Compute the sampling needed to get N vertices.  If the\n"
 "   specified number of vertices is less than the actual number of\n"
 "   vertices, the actual sampling value is returned. (To remove Vertices,\n"
 "   use the RemoveVertex() method of this class.)\n"
 "\n"
-"   :arg iNVertices: The number of stroke vertices we eventually want\n"
+"   :arg n: The number of stroke vertices we eventually want\n"
 "      in our Stroke.\n"
-"   :type iNVertices: int\n"
+"   :type n: int\n"
 "   :return: The sampling that must be used in the Resample(float)\n"
 "      method.\n"
 "   :rtype: float");
 
-static PyObject * Stroke_compute_sampling(BPy_Stroke *self, PyObject *args)
+static PyObject * Stroke_compute_sampling(BPy_Stroke *self, PyObject *args, PyObject *kwds)
 {
+	static const char *kwlist[] = {"n", NULL};
 	int i;
 
-	if (!PyArg_ParseTuple(args, "i", &i))
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "i", (char **)kwlist, &i))
 		return NULL;
 	return PyFloat_FromDouble(self->s->ComputeSampling(i));
 }
 
 PyDoc_STRVAR(Stroke_resample_doc,
-".. method:: resample(iNPoints)\n"
+".. method:: resample(n)\n"
 "\n"
-"   Resamples the stroke so that it eventually has iNPoints.  That means\n"
-"   it is going to add iNPoints-vertices_size, if vertices_size is the\n"
-"   number of points we already have.  If vertices_size >= iNPoints, no\n"
+"   Resamples the stroke so that it eventually has N points.  That means\n"
+"   it is going to add N-vertices_size, where vertices_size is the\n"
+"   number of points we already have.  If vertices_size >= N, no\n"
 "   resampling is done.\n"
 "\n"
-"   :arg iNPoints: The number of vertices we eventually want in our stroke.\n"
-"   :type iNPoints: int\n"
+"   :arg n: The number of vertices we eventually want in our stroke.\n"
+"   :type n: int\n"
 "\n"
-".. method:: resample(iSampling)\n"
+".. method:: resample(sampling)\n"
 "\n"
 "   Resamples the stroke with a given sampling.  If the sampling is\n"
 "   smaller than the actual sampling value, no resampling is done.\n"
 "\n"
-"   :arg iSampling: The new sampling value.\n"
-"   :type iSampling: float");
+"   :arg sampling: The new sampling value.\n"
+"   :type sampling: float");
 
-static PyObject * Stroke_resample(BPy_Stroke *self, PyObject *args)
+static PyObject * Stroke_resample(BPy_Stroke *self, PyObject *args, PyObject *kwds)
 {
-	PyObject *obj;
+	static const char *kwlist_1[] = {"n", NULL};
+	static const char *kwlist_2[] = {"sampling", NULL};
+	int i;
+	float f;
 
-	if (!PyArg_ParseTuple(args, "O", &obj))
-		return NULL;
-	if (PyLong_Check(obj)) {
-		self->s->Resample((int)PyLong_AsLong(obj));
-	} else if (PyFloat_Check(obj)) {
-		self->s->Resample((float)PyFloat_AsDouble(obj));
-	} else {
+	if (PyArg_ParseTupleAndKeywords(args, kwds, "i", (char **)kwlist_1, &i))
+	{
+		self->s->Resample(i);
+	}
+	else if (PyErr_Clear(),
+	         PyArg_ParseTupleAndKeywords(args, kwds, "f", (char **)kwlist_2, &f))
+	{
+		self->s->Resample(f);
+	}
+	else {
 		PyErr_SetString(PyExc_TypeError, "invalid argument");
 		return NULL;
 	}
@@ -167,23 +174,28 @@ static PyObject * Stroke_resample(BPy_Stroke *self, PyObject *args)
 }
 
 PyDoc_STRVAR(Stroke_insert_vertex_doc,
-".. method:: insert_vertex(iVertex, next)\n"
+".. method:: insert_vertex(vertex, next)\n"
 "\n"
-"   Inserts the stroke vertex iVertex in the stroke before next.  The\n"
-"   length, curvilinear abscissa are updated consequently.\n"
+"   Inserts the StrokeVertex given as argument into the Stroke before the\n"
+"   point specified by next.  The length and curvilinear abscissa are\n"
+"   updated consequently.\n"
 "\n"
-"   :arg iVertex: The StrokeVertex to insert in the Stroke.\n"
-"   :type iVertex: :class:`StrokeVertex`\n"
+"   :arg vertex: The StrokeVertex to insert in the Stroke.\n"
+"   :type vertex: :class:`StrokeVertex`\n"
 "   :arg next: A StrokeVertexIterator pointing to the StrokeVertex\n"
-"      before which iVertex must be inserted.\n"
+"      before which vertex must be inserted.\n"
 "   :type next: :class:`StrokeVertexIterator`");
 
-static PyObject * Stroke_insert_vertex(BPy_Stroke *self, PyObject *args)
+static PyObject * Stroke_insert_vertex(BPy_Stroke *self, PyObject *args, PyObject *kwds)
 {
+	static const char *kwlist[] = {"vertex", "next", NULL};
 	PyObject *py_sv = 0, *py_sv_it = 0;
 
-	if (!PyArg_ParseTuple(args, "O!O!", &StrokeVertex_Type, &py_sv, &StrokeVertexIterator_Type, &py_sv_it))
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!O!", (char **)kwlist,
+	                                 &StrokeVertex_Type, &py_sv, &StrokeVertexIterator_Type, &py_sv_it))
+	{
 		return NULL;
+	}
 	StrokeVertex *sv = ((BPy_StrokeVertex *)py_sv)->sv;
 	StrokeInternal::StrokeVertexIterator sv_it(*(((BPy_StrokeVertexIterator *)py_sv_it)->sv_it));
 	self->s->InsertVertex(sv, sv_it);
@@ -191,19 +203,20 @@ static PyObject * Stroke_insert_vertex(BPy_Stroke *self, PyObject *args)
 }
 
 PyDoc_STRVAR(Stroke_remove_vertex_doc,
-".. method:: remove_vertex(iVertex)\n"
+".. method:: remove_vertex(vertex)\n"
 "\n"
-"   Removes the stroke vertex iVertex from the stroke. The length and\n"
-"   curvilinear abscissa are updated consequently.\n"
+"   Removes the StrokeVertex given as argument from the Stroke. The length\n"
+"   and curvilinear abscissa are updated consequently.\n"
 "\n"
-"   :arg iVertex: \n"
-"   :type iVertex: :class:`StrokeVertex`");
+"   :arg vertex: the StrokeVertex to remove from the Stroke.\n"
+"   :type vertex: :class:`StrokeVertex`");
 
-static PyObject * Stroke_remove_vertex( BPy_Stroke *self, PyObject *args )
+static PyObject * Stroke_remove_vertex( BPy_Stroke *self, PyObject *args, PyObject *kwds)
 {
-	PyObject *py_sv;
+	static const char *kwlist[] = {"vertex", NULL};
+	PyObject *py_sv = 0;
 
-	if (!PyArg_ParseTuple(args, "O!", &StrokeVertex_Type, &py_sv))
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!", (char **)kwlist, &StrokeVertex_Type, &py_sv))
 		return NULL;
 	if (((BPy_StrokeVertex *)py_sv)->sv) {
 		self->s->RemoveVertex(((BPy_StrokeVertex *)py_sv)->sv);
@@ -238,11 +251,12 @@ PyDoc_STRVAR(Stroke_stroke_vertices_begin_doc,
 "   :return: A StrokeVertexIterator pointing on the first StrokeVertex.\n"
 "   :rtype: :class:`StrokeVertexIterator`");
 
-static PyObject * Stroke_stroke_vertices_begin( BPy_Stroke *self , PyObject *args)
+static PyObject * Stroke_stroke_vertices_begin( BPy_Stroke *self , PyObject *args, PyObject *kwds)
 {
-	float f = 0;
+	static const char *kwlist[] = {"t", NULL};
+	float f = 0.0f;
 
-	if (!PyArg_ParseTuple(args, "|f", &f))
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "|f", (char **)kwlist, &f))
 		return NULL;
 	StrokeInternal::StrokeVertexIterator sv_it(self->s->strokeVerticesBegin(f));
 	return BPy_StrokeVertexIterator_from_StrokeVertexIterator(sv_it, 0);
@@ -277,12 +291,12 @@ static PyObject * Stroke_stroke_vertices_size(BPy_Stroke *self)
 }
 
 static PyMethodDef BPy_Stroke_methods[] = {	
-	{"compute_sampling", (PyCFunction)Stroke_compute_sampling, METH_VARARGS, Stroke_compute_sampling_doc},
-	{"resample", (PyCFunction)Stroke_resample, METH_VARARGS, Stroke_resample_doc},
-	{"remove_vertex", (PyCFunction)Stroke_remove_vertex, METH_VARARGS, Stroke_remove_vertex_doc},
-	{"insert_vertex", (PyCFunction)Stroke_insert_vertex, METH_VARARGS, Stroke_insert_vertex_doc},
+	{"compute_sampling", (PyCFunction)Stroke_compute_sampling, METH_VARARGS | METH_KEYWORDS, Stroke_compute_sampling_doc},
+	{"resample", (PyCFunction)Stroke_resample, METH_VARARGS | METH_KEYWORDS, Stroke_resample_doc},
+	{"remove_vertex", (PyCFunction)Stroke_remove_vertex, METH_VARARGS | METH_KEYWORDS, Stroke_remove_vertex_doc},
+	{"insert_vertex", (PyCFunction)Stroke_insert_vertex, METH_VARARGS | METH_KEYWORDS, Stroke_insert_vertex_doc},
 	{"update_length", (PyCFunction)Stroke_update_length, METH_NOARGS, Stroke_update_length_doc},
-	{"stroke_vertices_begin", (PyCFunction)Stroke_stroke_vertices_begin, METH_VARARGS, Stroke_stroke_vertices_begin_doc},
+	{"stroke_vertices_begin", (PyCFunction)Stroke_stroke_vertices_begin, METH_VARARGS | METH_KEYWORDS, Stroke_stroke_vertices_begin_doc},
 	{"stroke_vertices_end", (PyCFunction)Stroke_stroke_vertices_end, METH_NOARGS, Stroke_stroke_vertices_end_doc},
 	{"stroke_vertices_size", (PyCFunction)Stroke_stroke_vertices_size, METH_NOARGS, Stroke_stroke_vertices_size_doc},
 	{NULL, NULL, 0, NULL}
diff --git a/source/blender/freestyle/intern/python/Interface1D/Curve/BPy_Chain.cpp b/source/blender/freestyle/intern/python/Interface1D/Curve/BPy_Chain.cpp
index ced48f0d9ab..64e65417579 100644
--- a/source/blender/freestyle/intern/python/Interface1D/Curve/BPy_Chain.cpp
+++ b/source/blender/freestyle/intern/python/Interface1D/Curve/BPy_Chain.cpp
@@ -52,7 +52,7 @@ PyDoc_STRVAR(Chain_doc,
 "\n"
 ".. method:: __init__()\n"
 "\n"
-"   Defult constructor.\n"
+"   Default constructor.\n"
 "\n"
 ".. method:: __init__(brother)\n"
 "\n"
@@ -96,56 +96,62 @@ static int Chain_init(BPy_Chain *self, PyObject *args, PyObject *kwds)
 }
 
 PyDoc_STRVAR(Chain_push_viewedge_back_doc,
-".. method:: push_viewedge_back(iViewEdge, orientation)\n"
+".. method:: push_viewedge_back(viewedge, orientation)\n"
 "\n"
 "   Adds a ViewEdge at the end of the Chain.\n"
 "\n"
-"   :arg iViewEdge: The ViewEdge that must be added.\n"
-"   :type iViewEdge: :class:`ViewEdge`\n"
+"   :arg viewedge: The ViewEdge that must be added.\n"
+"   :type viewedge: :class:`ViewEdge`\n"
 "   :arg orientation: The orientation with which the ViewEdge must be\n"
 "      processed.\n"
 "   :type orientation: bool");
 
-static PyObject * Chain_push_viewedge_back( BPy_Chain *self, PyObject *args ) {
+static PyObject * Chain_push_viewedge_back(BPy_Chain *self, PyObject *args, PyObject *kwds)
+{
+	static const char *kwlist[] = {"viewedge", "orientation", NULL};
 	PyObject *obj1 = 0, *obj2 = 0;
 
-	if(!( PyArg_ParseTuple(args, "O!O", &ViewEdge_Type, &obj1, &obj2) ))
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!O!", (char **)kwlist,
+	                                 &ViewEdge_Type, &obj1, &PyBool_Type, &obj2))
+	{
 		return NULL;
-
-	ViewEdge *ve = ((BPy_ViewEdge *) obj1)->ve;
-	bool orientation = bool_from_PyBool( obj2 );
-	self->c->push_viewedge_back( ve, orientation);
-
+	}
+	ViewEdge *ve = ((BPy_ViewEdge *)obj1)->ve;
+	bool orientation = bool_from_PyBool(obj2);
+	self->c->push_viewedge_back(ve, orientation);
 	Py_RETURN_NONE;
 }
 
 PyDoc_STRVAR(Chain_push_viewedge_front_doc,
-".. method:: push_viewedge_front(iViewEdge, orientation)\n"
+".. method:: push_viewedge_front(viewedge, orientation)\n"
 "\n"
 "   Adds a ViewEdge at the beginning of the Chain.\n"
 "\n"
-"   :arg iViewEdge: The ViewEdge that must be added.\n"
-"   :type iViewEdge: :class:`ViewEdge`\n"
+"   :arg viewedge: The ViewEdge that must be added.\n"
+"   :type viewedge: :class:`ViewEdge`\n"
 "   :arg orientation: The orientation with which the ViewEdge must be\n"
 "      processed.\n"
 "   :type orientation: bool");
 
-static PyObject * Chain_push_viewedge_front( BPy_Chain *self, PyObject *args ) {
+static PyObject * Chain_push_viewedge_front(BPy_Chain *self, PyObject *args, PyObject *kwds)
+{
+	static const char *kwlist[] = {"viewedge", "orientation", NULL};
 	PyObject *obj1 = 0, *obj2 = 0;
 
-	if(!( PyArg_ParseTuple(args, "O!O", &ViewEdge_Type, &obj1, &obj2) ))
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!O!", (char **)kwlist,
+	                                 &ViewEdge_Type, &obj1, &PyBool_Type, &obj2))
+	{
 		return NULL;
-
-	ViewEdge *ve = ((BPy_ViewEdge *) obj1)->ve;
-	bool orientation = bool_from_PyBool( obj2 );
+	}
+	ViewEdge *ve = ((BPy_ViewEdge *)obj1)->ve;
+	bool orientation = bool_from_PyBool(obj2);
 	self->c->push_viewedge_front(ve, orientation);
-
 	Py_RETURN_NONE;
 }
 
 static PyMethodDef BPy_Chain_methods[] = {	
-	{"push_viewedge_back", (PyCFunction)Chain_push_viewedge_back, METH_VARARGS, Chain_push_viewedge_back_doc},
-	{"push_viewedge_front", (PyCFunction)Chain_push_viewedge_front, METH_VARARGS, Chain_push_viewedge_front_doc},
+	{"push_viewedge_back", (PyCFunction)Chain_push_viewedge_back, METH_VARARGS | METH_KEYWORDS, Chain_push_viewedge_back_doc},
+	{"push_viewedge_front", (PyCFunction)Chain_push_viewedge_front, METH_VARARGS | METH_KEYWORDS, Chain_push_viewedge_front_doc},
 	{NULL, NULL, 0, NULL}
 };
 
diff --git a/source/blender/freestyle/intern/python/Iterator/BPy_ChainingIterator.cpp b/source/blender/freestyle/intern/python/Iterator/BPy_ChainingIterator.cpp
index af648a66bb7..701f6871cc1 100644
--- a/source/blender/freestyle/intern/python/Iterator/BPy_ChainingIterator.cpp
+++ b/source/blender/freestyle/intern/python/Iterator/BPy_ChainingIterator.cpp
@@ -134,7 +134,6 @@ static PyObject *ChainingIterator_init(BPy_ChainingIterator *self)
 		return NULL;
 	}
 	self->c_it->init();
-	
 	Py_RETURN_NONE;
 }
 
@@ -152,27 +151,25 @@ PyDoc_STRVAR(ChainingIterator_traverse_doc,
 "   :return: Returns the next ViewEdge to follow, or None if chaining ends.\n"
 "   :rtype: :class:`ViewEdge` or None");
 
-static PyObject *ChainingIterator_traverse(BPy_ChainingIterator *self, PyObject *args)
+static PyObject *ChainingIterator_traverse(BPy_ChainingIterator *self, PyObject *args, PyObject *kwds)
 {
+	static const char *kwlist[] = {"it", NULL};
 	PyObject *py_a_it;
 
-	if(!(PyArg_ParseTuple(args, "O!", &AdjacencyIterator_Type, &py_a_it)))
-		return NULL;
-
 	if (typeid(*(self->c_it)) == typeid(ChainingIterator)) {
 		PyErr_SetString(PyExc_TypeError, "traverse() method not properly overridden");
 		return NULL;
 	}
+	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!", (char **)kwlist, &AdjacencyIterator_Type, &py_a_it))
+		return NULL;
 	if (((BPy_AdjacencyIterator *)py_a_it)->a_it)
 		self->c_it->traverse(*(((BPy_AdjacencyIterator *)py_a_it)->a_it));
-
 	Py_RETURN_NONE;
 }
 
-
 static PyMethodDef BPy_ChainingIterator_methods[] = {
 	{"init", (PyCFunction) ChainingIterator_init, METH_NOARGS, ChainingIterator_init_doc},
-	{"traverse", (PyCFunction) ChainingIterator_traverse, METH_VARARGS, ChainingIterator_traverse_doc},
+	{"traverse", (PyCFunction) ChainingIterator_traverse, METH_VARARGS | METH_KEYWORDS, ChainingIterator_traverse_doc},
 	{NULL, NULL, 0, NULL}
 };