Cleanup: prefer 'arg' over 'params' for sphinx documentation

While both are supported, 'arg' is in more common use so prefer it.

18 files changed, 137 insertions, 137 deletions

diff --git a/source/blender/python/gpu/gpu_py_batch.c b/source/blender/python/gpu/gpu_py_batch.c
index 533e5154d83..879e1c0ce8b 100644
--- a/source/blender/python/gpu/gpu_py_batch.c
+++ b/source/blender/python/gpu/gpu_py_batch.c
@@ -127,7 +127,7 @@ PyDoc_STRVAR(pygpu_batch_vertbuf_add_doc,
 "   vertex buffer for vertex positions and vertex normals.\n"
 "   Current a batch can have at most " STRINGIFY(GPU_BATCH_VBO_MAX_LEN) " vertex buffers.\n"
 "\n"
-"   :param buf: The vertex buffer that will be added to the batch.\n"
+"   :arg buf: The vertex buffer that will be added to the batch.\n"
 "   :type buf: :class:`gpu.types.GPUVertBuf`\n"
 );
 static PyObject *pygpu_batch_vertbuf_add(BPyGPUBatch *self, BPyGPUVertBuf *py_buf)
@@ -171,7 +171,7 @@ PyDoc_STRVAR(
     "   This function does not need to be called when you always\n"
     "   set the shader when calling :meth:`gpu.types.GPUBatch.draw`.\n"
     "\n"
-    "   :param program: The program/shader the batch will use in future draw calls.\n"
+    "   :arg program: The program/shader the batch will use in future draw calls.\n"
     "   :type program: :class:`gpu.types.GPUShader`\n");
 static PyObject *pygpu_batch_program_set(BPyGPUBatch *self, BPyGPUShader *py_shader)
 {
@@ -209,7 +209,7 @@ PyDoc_STRVAR(pygpu_batch_draw_doc,
              "\n"
              "   Run the drawing program with the parameters assigned to the batch.\n"
              "\n"
-             "   :param program: Program that performs the drawing operations.\n"
+             "   :arg program: Program that performs the drawing operations.\n"
              "      If ``None`` is passed, the last program set to this batch will run.\n"
              "   :type program: :class:`gpu.types.GPUShader`\n");
 static PyObject *pygpu_batch_draw(BPyGPUBatch *self, PyObject *args)
diff --git a/source/blender/python/gpu/gpu_py_element.c b/source/blender/python/gpu/gpu_py_element.c
index d52a97c0c84..46f1d4d49eb 100644
--- a/source/blender/python/gpu/gpu_py_element.c
+++ b/source/blender/python/gpu/gpu_py_element.c
@@ -180,7 +180,7 @@ PyDoc_STRVAR(pygpu_IndexBuf__tp_doc,
              "   :arg type: The primitive type this index buffer is composed of.\n"
              "      Possible values are `POINTS`, `LINES`, `TRIS` and `LINE_STRIP_ADJ`.\n"
              "   :type type: str\n"
-             "   :param seq: Indices this index buffer will contain.\n"
+             "   :arg seq: Indices this index buffer will contain.\n"
              "      Whether a 1D or 2D sequence is required depends on the type.\n"
              "      Optionally the sequence can support the buffer protocol.\n"
              "   :type seq: 1D or 2D sequence\n");
diff --git a/source/blender/python/gpu/gpu_py_framebuffer.c b/source/blender/python/gpu/gpu_py_framebuffer.c
index d4c1c506450..2de8c680b23 100644
--- a/source/blender/python/gpu/gpu_py_framebuffer.c
+++ b/source/blender/python/gpu/gpu_py_framebuffer.c
@@ -421,9 +421,10 @@ PyDoc_STRVAR(pygpu_framebuffer_viewport_set_doc,
              "   Set the viewport for this framebuffer object.\n"
              "   Note: The viewport state is not saved upon framebuffer rebind.\n"
              "\n"
-             "   :param x, y: lower left corner of the viewport_set rectangle, in pixels.\n"
-             "   :param xsize, ysize: width and height of the viewport_set.\n"
-             "   :type x, y, xsize, ysize: int\n");
+             "   :arg x, y: lower left corner of the viewport_set rectangle, in pixels.\n"
+             "   :type x, y: int\n"
+             "   :arg xsize, ysize: width and height of the viewport_set.\n"
+             "   :type xsize, ysize: int\n");
 static PyObject *pygpu_framebuffer_viewport_set(BPyGPUFrameBuffer *self,
                                                 PyObject *args,
                                                 void *UNUSED(type))
@@ -462,14 +463,14 @@ PyDoc_STRVAR(
     "\n"
     "   Read a block of pixels from the frame buffer.\n"
     "\n"
-    "   :param x, y: Lower left corner of a rectangular block of pixels.\n"
-    "   :param xsize, ysize: Dimensions of the pixel rectangle.\n"
+    "   :arg x, y: Lower left corner of a rectangular block of pixels.\n"
+    "   :arg xsize, ysize: Dimensions of the pixel rectangle.\n"
     "   :type x, y, xsize, ysize: int\n"
-    "   :param channels: Number of components to read.\n"
+    "   :arg channels: Number of components to read.\n"
     "   :type channels: int\n"
-    "   :param slot: The framebuffer slot to read data from.\n"
+    "   :arg slot: The framebuffer slot to read data from.\n"
     "   :type slot: int\n"
-    "   :param format: The format that describes the content of a single channel.\n"
+    "   :arg format: The format that describes the content of a single channel.\n"
     "      Possible values are `FLOAT`, `INT`, `UINT`, `UBYTE`, `UINT_24_8` and `10_11_11_REV`.\n"
     "   :type format: str\n"
     "   :arg data: Optional Buffer object to fill with the pixels values.\n"
@@ -569,9 +570,10 @@ PyDoc_STRVAR(pygpu_framebuffer_read_depth_doc,
              "\n"
              "   Read a pixel depth block from the frame buffer.\n"
              "\n"
-             "   :param x, y: Lower left corner of a rectangular block of pixels.\n"
-             "   :param xsize, ysize: Dimensions of the pixel rectangle.\n"
-             "   :type x, y, xsize, ysize: int\n"
+             "   :arg x, y: Lower left corner of a rectangular block of pixels.\n"
+             "   :type x, y: int\n"
+             "   :arg xsize, ysize: Dimensions of the pixel rectangle.\n"
+             "   :type xsize, ysize: int\n"
              "   :arg data: Optional Buffer object to fill with the pixels values.\n"
              "   :type data: :class:`gpu.types.Buffer`\n"
              "   :return: The Buffer with the read pixels.\n"
diff --git a/source/blender/python/gpu/gpu_py_matrix.c b/source/blender/python/gpu/gpu_py_matrix.c
index a47e3dc8a5f..18925a101da 100644
--- a/source/blender/python/gpu/gpu_py_matrix.c
+++ b/source/blender/python/gpu/gpu_py_matrix.c
@@ -266,7 +266,7 @@ PyDoc_STRVAR(pygpu_matrix_multiply_matrix_doc,
              "\n"
              "   Multiply the current stack matrix.\n"
              "\n"
-             "   :param matrix: A 4x4 matrix.\n"
+             "   :arg matrix: A 4x4 matrix.\n"
              "   :type matrix: :class:`mathutils.Matrix`\n");
 static PyObject *pygpu_matrix_multiply_matrix(PyObject *UNUSED(self), PyObject *value)
 {
@@ -283,7 +283,7 @@ PyDoc_STRVAR(pygpu_matrix_scale_doc,
              "\n"
              "   Scale the current stack matrix.\n"
              "\n"
-             "   :param scale: Scale the current stack matrix.\n"
+             "   :arg scale: Scale the current stack matrix.\n"
              "   :type scale: sequence of 2 or 3 floats\n");
 static PyObject *pygpu_matrix_scale(PyObject *UNUSED(self), PyObject *value)
 {
@@ -305,7 +305,7 @@ static PyObject *pygpu_matrix_scale(PyObject *UNUSED(self), PyObject *value)
 PyDoc_STRVAR(pygpu_matrix_scale_uniform_doc,
              ".. function:: scale_uniform(scale)\n"
              "\n"
-             "   :param scale: Scale the current stack matrix.\n"
+             "   :arg scale: Scale the current stack matrix.\n"
              "   :type scale: float\n");
 static PyObject *pygpu_matrix_scale_uniform(PyObject *UNUSED(self), PyObject *value)
 {
@@ -323,7 +323,7 @@ PyDoc_STRVAR(pygpu_matrix_translate_doc,
              "\n"
              "   Scale the current stack matrix.\n"
              "\n"
-             "   :param offset: Translate the current stack matrix.\n"
+             "   :arg offset: Translate the current stack matrix.\n"
              "   :type offset: sequence of 2 or 3 floats\n");
 static PyObject *pygpu_matrix_translate(PyObject *UNUSED(self), PyObject *value)
 {
@@ -373,7 +373,7 @@ PyDoc_STRVAR(pygpu_matrix_load_matrix_doc,
              "\n"
              "   Load a matrix into the stack.\n"
              "\n"
-             "   :param matrix: A 4x4 matrix.\n"
+             "   :arg matrix: A 4x4 matrix.\n"
              "   :type matrix: :class:`mathutils.Matrix`\n");
 static PyObject *pygpu_matrix_load_matrix(PyObject *UNUSED(self), PyObject *value)
 {
@@ -390,7 +390,7 @@ PyDoc_STRVAR(pygpu_matrix_load_projection_matrix_doc,
              "\n"
              "   Load a projection matrix into the stack.\n"
              "\n"
-             "   :param matrix: A 4x4 matrix.\n"
+             "   :arg matrix: A 4x4 matrix.\n"
              "   :type matrix: :class:`mathutils.Matrix`\n");
 static PyObject *pygpu_matrix_load_projection_matrix(PyObject *UNUSED(self), PyObject *value)
 {
diff --git a/source/blender/python/gpu/gpu_py_select.c b/source/blender/python/gpu/gpu_py_select.c
index 8869ea38e32..6d11e94433e 100644
--- a/source/blender/python/gpu/gpu_py_select.c
+++ b/source/blender/python/gpu/gpu_py_select.c
@@ -31,7 +31,7 @@ PyDoc_STRVAR(pygpu_select_load_id_doc,
              "\n"
              "   Set the selection ID.\n"
              "\n"
-             "   :param id: Number (32-bit uint).\n"
+             "   :arg id: Number (32-bit uint).\n"
              "   :type select: int\n");
 static PyObject *pygpu_select_load_id(PyObject *UNUSED(self), PyObject *value)
 {
diff --git a/source/blender/python/gpu/gpu_py_shader.c b/source/blender/python/gpu/gpu_py_shader.c
index fbc45124147..9bac23fd7e7 100644
--- a/source/blender/python/gpu/gpu_py_shader.c
+++ b/source/blender/python/gpu/gpu_py_shader.c
@@ -163,7 +163,7 @@ PyDoc_STRVAR(pygpu_shader_uniform_from_name_doc,
              "\n"
              "   Get uniform location by name.\n"
              "\n"
-             "   :param name: Name of the uniform variable whose location is to be queried.\n"
+             "   :arg name: Name of the uniform variable whose location is to be queried.\n"
              "   :type name: str\n"
              "   :return: Location of the uniform variable.\n"
              "   :rtype: int\n");
@@ -184,16 +184,15 @@ static PyObject *pygpu_shader_uniform_from_name(BPyGPUShader *self, PyObject *ar
   return PyLong_FromLong(uniform);
 }
 
-PyDoc_STRVAR(
-    pygpu_shader_uniform_block_from_name_doc,
-    ".. method:: uniform_block_from_name(name)\n"
-    "\n"
-    "   Get uniform block location by name.\n"
-    "\n"
-    "   :param name: Name of the uniform block variable whose location is to be queried.\n"
-    "   :type name: str\n"
-    "   :return: The location of the uniform block variable.\n"
-    "   :rtype: int\n");
+PyDoc_STRVAR(pygpu_shader_uniform_block_from_name_doc,
+             ".. method:: uniform_block_from_name(name)\n"
+             "\n"
+             "   Get uniform block location by name.\n"
+             "\n"
+             "   :arg name: Name of the uniform block variable whose location is to be queried.\n"
+             "   :type name: str\n"
+             "   :return: The location of the uniform block variable.\n"
+             "   :rtype: int\n");
 static PyObject *pygpu_shader_uniform_block_from_name(BPyGPUShader *self, PyObject *arg)
 {
   const char *name = PyUnicode_AsUTF8(arg);
@@ -245,11 +244,11 @@ PyDoc_STRVAR(pygpu_shader_uniform_vector_float_doc,
              "\n"
              "   Set the buffer to fill the uniform.\n"
              "\n"
-             "   :param location: Location of the uniform variable to be modified.\n"
+             "   :arg location: Location of the uniform variable to be modified.\n"
              "   :type location: int\n"
-             "   :param buffer:  The data that should be set. Can support the buffer protocol.\n"
+             "   :arg buffer:  The data that should be set. Can support the buffer protocol.\n"
              "   :type buffer: sequence of floats\n"
-             "   :param length: Size of the uniform data type:\n\n"
+             "   :arg length: Size of the uniform data type:\n\n"
              "      - 1: float\n"
              "      - 2: vec2 or float[2]\n"
              "      - 3: vec3 or float[3]\n"
@@ -257,7 +256,7 @@ PyDoc_STRVAR(pygpu_shader_uniform_vector_float_doc,
              "      - 9: mat3\n"
              "      - 16: mat4\n"
              "   :type length: int\n"
-             "   :param count: Specifies the number of elements, vector or matrices that are to "
+             "   :arg count: Specifies the number of elements, vector or matrices that are to "
              "be modified.\n"
              "   :type count: int\n");
 static PyObject *pygpu_shader_uniform_vector_float(BPyGPUShader *self, PyObject *args)
@@ -305,9 +304,9 @@ PyDoc_STRVAR(pygpu_shader_uniform_bool_doc,
              "\n"
              "   Specify the value of a uniform variable for the current program object.\n"
              "\n"
-             "   :param name: Name of the uniform variable whose value is to be changed.\n"
+             "   :arg name: Name of the uniform variable whose value is to be changed.\n"
              "   :type name: str\n"
-             "   :param seq: Value that will be used to update the specified uniform variable.\n"
+             "   :arg seq: Value that will be used to update the specified uniform variable.\n"
              "   :type seq: sequence of bools\n");
 static PyObject *pygpu_shader_uniform_bool(BPyGPUShader *self, PyObject *args)
 {
@@ -370,9 +369,9 @@ PyDoc_STRVAR(pygpu_shader_uniform_float_doc,
              "\n"
              "   Specify the value of a uniform variable for the current program object.\n"
              "\n"
-             "   :param name: Name of the uniform variable whose value is to be changed.\n"
+             "   :arg name: Name of the uniform variable whose value is to be changed.\n"
              "   :type name: str\n"
-             "   :param value: Value that will be used to update the specified uniform variable.\n"
+             "   :arg value: Value that will be used to update the specified uniform variable.\n"
              "   :type value: single number or sequence of numbers\n");
 static PyObject *pygpu_shader_uniform_float(BPyGPUShader *self, PyObject *args)
 {
@@ -439,9 +438,9 @@ PyDoc_STRVAR(pygpu_shader_uniform_int_doc,
              "\n"
              "   Specify the value of a uniform variable for the current program object.\n"
              "\n"
-             "   :param name: name of the uniform variable whose value is to be changed.\n"
+             "   :arg name: name of the uniform variable whose value is to be changed.\n"
              "   :type name: str\n"
-             "   :param seq: Value that will be used to update the specified uniform variable.\n"
+             "   :arg seq: Value that will be used to update the specified uniform variable.\n"
              "   :type seq: sequence of numbers\n");
 static PyObject *pygpu_shader_uniform_int(BPyGPUShader *self, PyObject *args)
 {
@@ -510,9 +509,9 @@ PyDoc_STRVAR(pygpu_shader_uniform_sampler_doc,
              "\n"
              "   Specify the value of a texture uniform variable for the current GPUShader.\n"
              "\n"
-             "   :param name: name of the uniform variable whose texture is to be specified.\n"
+             "   :arg name: name of the uniform variable whose texture is to be specified.\n"
              "   :type name: str\n"
-             "   :param texture: Texture to attach.\n"
+             "   :arg texture: Texture to attach.\n"
              "   :type texture: :class:`gpu.types.GPUTexture`\n");
 static PyObject *pygpu_shader_uniform_sampler(BPyGPUShader *self, PyObject *args)
 {
@@ -536,9 +535,9 @@ PyDoc_STRVAR(
     "\n"
     "   Specify the value of an uniform buffer object variable for the current GPUShader.\n"
     "\n"
-    "   :param name: name of the uniform variable whose UBO is to be specified.\n"
+    "   :arg name: name of the uniform variable whose UBO is to be specified.\n"
     "   :type name: str\n"
-    "   :param ubo: Uniform Buffer to attach.\n"
+    "   :arg ubo: Uniform Buffer to attach.\n"
     "   :type texture: :class:`gpu.types.GPUUniformBuf`\n");
 static PyObject *pygpu_shader_uniform_block(BPyGPUShader *self, PyObject *args)
 {
@@ -562,16 +561,15 @@ static PyObject *pygpu_shader_uniform_block(BPyGPUShader *self, PyObject *args)
   Py_RETURN_NONE;
 }
 
-PyDoc_STRVAR(
-    pygpu_shader_attr_from_name_doc,
-    ".. method:: attr_from_name(name)\n"
-    "\n"
-    "   Get attribute location by name.\n"
-    "\n"
-    "   :param name: The name of the attribute variable whose location is to be queried.\n"
-    "   :type name: str\n"
-    "   :return: The location of an attribute variable.\n"
-    "   :rtype: int\n");
+PyDoc_STRVAR(pygpu_shader_attr_from_name_doc,
+             ".. method:: attr_from_name(name)\n"
+             "\n"
+             "   Get attribute location by name.\n"
+             "\n"
+             "   :arg name: The name of the attribute variable whose location is to be queried.\n"
+             "   :type name: str\n"
+             "   :return: The location of an attribute variable.\n"
+             "   :rtype: int\n");
 static PyObject *pygpu_shader_attr_from_name(BPyGPUShader *self, PyObject *arg)
 {
   const char *name = PyUnicode_AsUTF8(arg);
@@ -743,17 +741,17 @@ PyDoc_STRVAR(
     "   ``fragOutput = blender_srgb_to_framebuffer_space(fragOutput)``\n"
     "   to transform the output sRGB colors to the frame-buffer color-space.\n"
     "\n"
-    "   :param vertexcode: Vertex shader code.\n"
+    "   :arg vertexcode: Vertex shader code.\n"
     "   :type vertexcode: str\n"
-    "   :param fragcode: Fragment shader code.\n"
+    "   :arg fragcode: Fragment shader code.\n"
     "   :type value: str\n"
-    "   :param geocode: Geometry shader code.\n"
+    "   :arg geocode: Geometry shader code.\n"
     "   :type value: str\n"
-    "   :param libcode: Code with functions and presets to be shared between shaders.\n"
+    "   :arg libcode: Code with functions and presets to be shared between shaders.\n"
     "   :type value: str\n"
-    "   :param defines: Preprocessor directives.\n"
+    "   :arg defines: Preprocessor directives.\n"
     "   :type value: str\n"
-    "   :param name: Name of shader code, for debugging purposes.\n"
+    "   :arg name: Name of shader code, for debugging purposes.\n"
     "   :type value: str\n");
 PyTypeObject BPyGPUShader_Type = {
     PyVarObject_HEAD_INIT(NULL, 0).tp_name = "GPUShader",
@@ -812,9 +810,9 @@ PyDoc_STRVAR(
     "``CLIPPED`` value to the config parameter. Note that in this case you also need to "
     "manually set the value of ``mat4 ModelMatrix``.\n"
     "\n"
-    "   :param shader_name: One of the builtin shader names.\n"
+    "   :arg shader_name: One of the builtin shader names.\n"
     "   :type shader_name: str\n"
-    "   :param config: One of these types of shader configuration:\n"
+    "   :arg config: One of these types of shader configuration:\n"
     "\n"
     "      - ``DEFAULT``\n"
     "      - ``CLIPPED``\n"
@@ -858,7 +856,7 @@ PyDoc_STRVAR(pygpu_shader_create_from_info_doc,
              "\n"
              "   Create shader from a GPUShaderCreateInfo.\n"
              "\n"
-             "   :param shader_info: GPUShaderCreateInfo\n"
+             "   :arg shader_info: GPUShaderCreateInfo\n"
              "   :type shader_info: :class:`bpy.types.GPUShaderCreateInfo`\n"
              "   :return: Shader object corresponding to the given name.\n"
              "   :rtype: :class:`bpy.types.GPUShader`\n");
diff --git a/source/blender/python/gpu/gpu_py_shader_create_info.cc b/source/blender/python/gpu/gpu_py_shader_create_info.cc
index c9e49c5cc4b..f35c5a01145 100644
--- a/source/blender/python/gpu/gpu_py_shader_create_info.cc
+++ b/source/blender/python/gpu/gpu_py_shader_create_info.cc
@@ -189,11 +189,11 @@ PyDoc_STRVAR(pygpu_interface_info_smooth_doc,
              "\n"
              "   Add an attribute with qualifier of type `smooth` to the interface block.\n"
              "\n"
-             "   :param type: One of these types:\n"
+             "   :arg type: One of these types:\n"
              "\n" PYDOC_TYPE_LIST
              "\n"
              "   :type type: str\n"
-             "   :param name: name of the attribute.\n"
+             "   :arg name: name of the attribute.\n"
              "   :type name: str\n");
 static PyObject *pygpu_interface_info_smooth(BPyGPUStageInterfaceInfo *self, PyObject *args)
 {
@@ -213,11 +213,11 @@ PyDoc_STRVAR(pygpu_interface_info_flat_doc,
              "\n"
              "   Add an attribute with qualifier of type `flat` to the interface block.\n"
              "\n"
-             "   :param type: One of these types:\n"
+             "   :arg type: One of these types:\n"
              "\n" PYDOC_TYPE_LIST
              "\n"
              "   :type type: str\n"
-             "   :param name: name of the attribute.\n"
+             "   :arg name: name of the attribute.\n"
              "   :type name: str\n");
 static PyObject *pygpu_interface_info_flat(BPyGPUStageInterfaceInfo *self, PyObject *args)
 {
@@ -238,11 +238,11 @@ PyDoc_STRVAR(
     "\n"
     "   Add an attribute with qualifier of type `no_perspective` to the interface block.\n"
     "\n"
-    "   :param type: One of these types:\n"
+    "   :arg type: One of these types:\n"
     "\n" PYDOC_TYPE_LIST
     "\n"
     "   :type type: str\n"
-    "   :param name: name of the attribute.\n"
+    "   :arg name: name of the attribute.\n"
     "   :type name: str\n");
 static PyObject *pygpu_interface_info_no_perspective(BPyGPUStageInterfaceInfo *self,
                                                      PyObject *args)
@@ -370,7 +370,7 @@ PyDoc_STRVAR(pygpu_interface_info__tp_doc,
              "\n"
              "   List of varyings between shader stages.\n\n"
              "\n"
-             "   :param name: Name of the interface block.\n"
+             "   :arg name: Name of the interface block.\n"
              "   :type value: str\n");
 constexpr PyTypeObject pygpu_interface_info_type()
 {
@@ -403,13 +403,13 @@ PyDoc_STRVAR(pygpu_shader_info_vertex_in_doc,
              "\n"
              "   Add a vertex shader input attribute.\n"
              "\n"
-             "   :param slot: The attribute index.\n"
+             "   :arg slot: The attribute index.\n"
              "   :type slot: int\n"
-             "   :param type: One of these types:\n"
+             "   :arg type: One of these types:\n"
              "\n" PYDOC_TYPE_LIST
              "\n"
              "   :type type: str\n"
-             "   :param name: name of the attribute.\n"
+             "   :arg name: name of the attribute.\n"
              "   :type name: str\n");
 static PyObject *pygpu_shader_info_vertex_in(BPyGPUShaderCreateInfo *self, PyObject *args)
 {
@@ -436,7 +436,7 @@ PyDoc_STRVAR(pygpu_shader_info_vertex_out_doc,
              "\n"
              "   Add a vertex shader output interface block.\n"
              "\n"
-             "   :param interface: Object describing the block.\n"
+             "   :arg interface: Object describing the block.\n"
              "   :type interface: :class:`gpu.types.GPUStageInterfaceInfo`\n");
 static PyObject *pygpu_shader_info_vertex_out(BPyGPUShaderCreateInfo *self,
                                               BPyGPUStageInterfaceInfo *o)
@@ -462,15 +462,15 @@ PyDoc_STRVAR(pygpu_shader_info_fragment_out_doc,
              "\n"
              "   Specify a fragment output corresponding to a framebuffer target slot.\n"
              "\n"
-             "   :param slot: The attribute index.\n"
+             "   :arg slot: The attribute index.\n"
              "   :type slot: int\n"
-             "   :param type: One of these types:\n"
+             "   :arg type: One of these types:\n"
              "\n" PYDOC_TYPE_LIST
              "\n"
              "   :type type: str\n"
-             "   :param name: Name of the attribute.\n"
+             "   :arg name: Name of the attribute.\n"
              "   :type name: str\n"
-             "   :param blend: Dual Source Blending Index. It can be 'NONE', 'SRC_0' or 'SRC_1'.\n"
+             "   :arg blend: Dual Source Blending Index. It can be 'NONE', 'SRC_0' or 'SRC_1'.\n"
              "   :type blend: str\n");
 static PyObject *pygpu_shader_info_fragment_out(BPyGPUShaderCreateInfo *self,
                                                 PyObject *args,
@@ -521,12 +521,12 @@ PyDoc_STRVAR(
     "\n"
     "   Specify a uniform variable whose type can be one of those declared in `typedef_source`.\n"
     "\n"
-    "   :param slot: The uniform variable index.\n"
+    "   :arg slot: The uniform variable index.\n"
     "   :type slot: int\n"
-    "   :param type_name: Name of the data type. It can be a struct type defined in the source "
+    "   :arg type_name: Name of the data type. It can be a struct type defined in the source "
     "passed through the :meth:`gpu.types.GPUShaderCreateInfo.typedef_source`.\n"
     "   :type type_name: str\n"
-    "   :param name: The uniform variable name.\n"
+    "   :arg name: The uniform variable name.\n"
     "   :type name: str\n");
 static PyObject *pygpu_shader_info_uniform_buf(BPyGPUShaderCreateInfo *self, PyObject *args)
 {
@@ -556,19 +556,19 @@ PyDoc_STRVAR(
     "\n"
     "   Specify an image resource used for arbitrary load and store operations.\n"
     "\n"
-    "   :param slot: The image resource index.\n"
+    "   :arg slot: The image resource index.\n"
     "   :type slot: int\n"
-    "   :param format: The GPUTexture format that is passed to the shader. Possible values are:\n"
+    "   :arg format: The GPUTexture format that is passed to the shader. Possible values are:\n"
     "" PYDOC_TEX_FORMAT_ITEMS
     "   :type format: str\n"
-    "   :param type: The data type describing how the image is to be read in the shader. "
+    "   :arg type: The data type describing how the image is to be read in the shader. "
     "Possible values are:\n"
     "\n" PYDOC_IMAGE_TYPES
     "\n"
     "   :type type: str\n"
-    "   :param name: The image resource name.\n"
+    "   :arg name: The image resource name.\n"
     "   :type name: str\n"
-    "   :param qualifiers: Set containing values that describe how the image resource is to be "
+    "   :arg qualifiers: Set containing values that describe how the image resource is to be "
     "read or written. Possible values are:\n"
     "" PYDOC_QUALIFIERS
     ""
@@ -636,14 +636,14 @@ PyDoc_STRVAR(
     "\n"
     "   Specify an image texture sampler.\n"
     "\n"
-    "   :param slot: The image texture sampler index.\n"
+    "   :arg slot: The image texture sampler index.\n"
     "   :type slot: int\n"
-    "   :param type: The data type describing the format of each sampler unit. Possible values "
+    "   :arg type: The data type describing the format of each sampler unit. Possible values "
     "are:\n"
     "\n" PYDOC_IMAGE_TYPES
     "\n"
     "   :type type: str\n"
-    "   :param name: The image texture sampler name.\n"
+    "   :arg name: The image texture sampler name.\n"
     "   :type name: str\n");
 static PyObject *pygpu_shader_info_sampler(BPyGPUShaderCreateInfo *self, PyObject *args)
 {
@@ -748,13 +748,13 @@ PyDoc_STRVAR(pygpu_shader_info_push_constant_doc,
              "\n"
              "   Specify a global access constant.\n"
              "\n"
-             "   :param type: One of these types:\n"
+             "   :arg type: One of these types:\n"
              "\n" PYDOC_TYPE_LIST
              "\n"
              "   :type type: str\n"
-             "   :param name: Name of the constant.\n"
+             "   :arg name: Name of the constant.\n"
              "   :type name: str\n"
-             "   :param size: If not zero, indicates that the constant is an array with the "
+             "   :arg size: If not zero, indicates that the constant is an array with the "
              "specified size.\n"
              "   :type size: uint\n");
 static PyObject *pygpu_shader_info_push_constant(BPyGPUShaderCreateInfo *self,
@@ -812,7 +812,7 @@ PyDoc_STRVAR(
     "\n"
     "      \"void main {gl_Position = vec4(pos, 1.0);}\"\n"
     "\n"
-    "   :param source: The vertex shader source code.\n"
+    "   :arg source: The vertex shader source code.\n"
     "   :type source: str\n"
     "\n"
     "   .. seealso:: `GLSL Cross Compilation "
@@ -853,7 +853,7 @@ PyDoc_STRVAR(
     "\n"
     "      \"void main {fragColor = vec4(0.0, 0.0, 0.0, 1.0);}\"\n"
     "\n"
-    "   :param source: The fragment shader source code.\n"
+    "   :arg source: The fragment shader source code.\n"
     "   :type source: str\n"
     "\n"
     "   .. seealso:: `GLSL Cross Compilation "
@@ -894,7 +894,7 @@ PyDoc_STRVAR(pygpu_shader_info_typedef_source_doc,
              "\n"
              "   \"struct MyType {int foo; float bar;};\"\n"
              "\n"
-             "   :param source: The source code defining types.\n"
+             "   :arg source: The source code defining types.\n"
              "   :type source: str\n");
 static PyObject *pygpu_shader_info_typedef_source(BPyGPUShaderCreateInfo *self, PyObject *o)
 {
@@ -933,9 +933,9 @@ PyDoc_STRVAR(pygpu_shader_info_define_doc,
              "\n"
              "   #define name value\n"
              "\n"
-             "   :param name: Token name.\n"
+             "   :arg name: Token name.\n"
              "   :type name: str\n"
-             "   :param value: Text that replaces token occurrences.\n"
+             "   :arg value: Text that replaces token occurrences.\n"
              "   :type value: str\n");
 static PyObject *pygpu_shader_info_define(BPyGPUShaderCreateInfo *self, PyObject *args)
 {
diff --git a/source/blender/python/gpu/gpu_py_state.c b/source/blender/python/gpu/gpu_py_state.c
index fb69bb316c4..35ecc2aff40 100644
--- a/source/blender/python/gpu/gpu_py_state.c
+++ b/source/blender/python/gpu/gpu_py_state.c
@@ -72,7 +72,7 @@ PyDoc_STRVAR(
     "\n"
     "   Defines the fixed pipeline blending equation.\n"
     "\n"
-    "   :param mode: The type of blend mode.\n"
+    "   :arg mode: The type of blend mode.\n"
     "      * ``NONE`` No blending.\n"
     "      * ``ALPHA`` The original color channels are interpolated according to the alpha "
     "value.\n"
@@ -114,7 +114,7 @@ PyDoc_STRVAR(pygpu_state_clip_distances_set_doc,
              "\n"
              "   Sets the number of `gl_ClipDistance` planes used for clip geometry.\n"
              "\n"
-             "   :param distances_enabled: Number of clip distances enabled.\n"
+             "   :arg distances_enabled: Number of clip distances enabled.\n"
              "   :type distances_enabled: int\n");
 static PyObject *pygpu_state_clip_distances_set(PyObject *UNUSED(self), PyObject *value)
 {
@@ -136,7 +136,7 @@ PyDoc_STRVAR(pygpu_state_depth_test_set_doc,
              "\n"
              "   Defines the depth_test equation.\n"
              "\n"
-             "   :param mode: The depth test equation name.\n"
+             "   :arg mode: The depth test equation name.\n"
              "      Possible values are `NONE`, `ALWAYS`, `LESS`, `LESS_EQUAL`, `EQUAL`, "
              "`GREATER` and `GREATER_EQUAL`.\n"
              "   :type mode: str\n");
@@ -166,7 +166,7 @@ PyDoc_STRVAR(pygpu_state_depth_mask_set_doc,
              "\n"
              "   Write to depth component.\n"
              "\n"
-             "   :param value: True for writing to the depth component.\n"
+             "   :arg value: True for writing to the depth component.\n"
              "   :type near: bool\n");
 static PyObject *pygpu_state_depth_mask_set(PyObject *UNUSED(self), PyObject *value)
 {
@@ -193,9 +193,10 @@ PyDoc_STRVAR(pygpu_state_viewport_set_doc,
              "   Specifies the viewport of the active framebuffer.\n"
              "   Note: The viewport state is not saved upon framebuffer rebind.\n"
              "\n"
-             "   :param x, y: lower left corner of the viewport_set rectangle, in pixels.\n"
-             "   :param width, height: width and height of the viewport_set.\n"
-             "   :type x, y, xsize, ysize: int\n");
+             "   :arg x, y: lower left corner of the viewport_set rectangle, in pixels.\n"
+             "   :type x, y: int\n"
+             "   :arg xsize, ysize: width and height of the viewport_set.\n"
+             "   :type xsize, ysize: int\n");
 static PyObject *pygpu_state_viewport_set(PyObject *UNUSED(self), PyObject *args)
 {
   int x, y, xsize, ysize;
@@ -230,7 +231,7 @@ PyDoc_STRVAR(pygpu_state_line_width_set_doc,
              "\n"
              "   Specify the width of rasterized lines.\n"
              "\n"
-             "   :param size: New width.\n"
+             "   :arg size: New width.\n"
              "   :type mode: float\n");
 static PyObject *pygpu_state_line_width_set(PyObject *UNUSED(self), PyObject *value)
 {
@@ -258,7 +259,7 @@ PyDoc_STRVAR(pygpu_state_point_size_set_doc,
              "\n"
              "   Specify the diameter of rasterized points.\n"
              "\n"
-             "   :param size: New diameter.\n"
+             "   :arg size: New diameter.\n"
              "   :type mode: float\n");
 static PyObject *pygpu_state_point_size_set(PyObject *UNUSED(self), PyObject *value)
 {
@@ -276,7 +277,7 @@ PyDoc_STRVAR(pygpu_state_color_mask_set_doc,
              "\n"
              "   Enable or disable writing of frame buffer color components.\n"
              "\n"
-             "   :param r, g, b, a: components red, green, blue, and alpha.\n"
+             "   :arg r, g, b, a: components red, green, blue, and alpha.\n"
              "   :type r, g, b, a: bool\n");
 static PyObject *pygpu_state_color_mask_set(PyObject *UNUSED(self), PyObject *args)
 {
@@ -294,7 +295,7 @@ PyDoc_STRVAR(pygpu_state_face_culling_set_doc,
              "\n"
              "   Specify whether none, front-facing or back-facing facets can be culled.\n"
              "\n"
-             "   :param mode: `NONE`, `FRONT` or `BACK`.\n"
+             "   :arg mode: `NONE`, `FRONT` or `BACK`.\n"
              "   :type mode: str\n");
 static PyObject *pygpu_state_face_culling_set(PyObject *UNUSED(self), PyObject *value)
 {
@@ -312,7 +313,7 @@ PyDoc_STRVAR(pygpu_state_front_facing_set_doc,
              "\n"
              "   Specifies the orientation of front-facing polygons.\n"
              "\n"
-             "   :param invert: True for clockwise polygons as front-facing.\n"
+             "   :arg invert: True for clockwise polygons as front-facing.\n"
              "   :type mode: bool\n");
 static PyObject *pygpu_state_front_facing_set(PyObject *UNUSED(self), PyObject *value)
 {
@@ -331,7 +332,7 @@ PyDoc_STRVAR(pygpu_state_program_point_size_set_doc,
              "   If enabled, the derived point size is taken from the (potentially clipped) "
              "shader builtin gl_PointSize.\n"
              "\n"
-             "   :param enable: True for shader builtin gl_PointSize.\n"
+             "   :arg enable: True for shader builtin gl_PointSize.\n"
              "   :type enable: bool\n");
 static PyObject *pygpu_state_program_point_size_set(PyObject *UNUSED(self), PyObject *value)
 {
diff --git a/source/blender/python/gpu/gpu_py_texture.c b/source/blender/python/gpu/gpu_py_texture.c
index 388c4836803..ae004341304 100644
--- a/source/blender/python/gpu/gpu_py_texture.c
+++ b/source/blender/python/gpu/gpu_py_texture.c
@@ -280,7 +280,7 @@ PyDoc_STRVAR(
     "\n"
     "   Fill texture with specific value.\n"
     "\n"
-    "   :param format: The format that describes the content of a single item.\n"
+    "   :arg format: The format that describes the content of a single item.\n"
     "      Possible values are `FLOAT`, `INT`, `UINT`, `UBYTE`, `UINT_24_8` and `10_11_11_REV`.\n"
     "   :type format: str\n"
     "   :arg value: sequence each representing the value to fill.\n"
diff --git a/source/blender/python/gpu/gpu_py_vertex_buffer.c b/source/blender/python/gpu/gpu_py_vertex_buffer.c
index 8cedfb5cdb7..fd36c0a2d71 100644
--- a/source/blender/python/gpu/gpu_py_vertex_buffer.c
+++ b/source/blender/python/gpu/gpu_py_vertex_buffer.c
@@ -261,9 +261,9 @@ PyDoc_STRVAR(pygpu_vertbuf_attr_fill_doc,
              "\n"
              "   Insert data into the buffer for a single attribute.\n"
              "\n"
-             "   :param id: Either the name or the id of the attribute.\n"
+             "   :arg id: Either the name or the id of the attribute.\n"
              "   :type id: int or str\n"
-             "   :param data: Sequence of data that should be stored in the buffer\n"
+             "   :arg data: Sequence of data that should be stored in the buffer\n"
              "   :type data: sequence of floats, ints, vectors or matrices\n");
 static PyObject *pygpu_vertbuf_attr_fill(BPyGPUVertBuf *self, PyObject *args, PyObject *kwds)
 {
@@ -327,9 +327,9 @@ PyDoc_STRVAR(pygpu_vertbuf__tp_doc,
              "\n"
              "   Contains a VBO.\n"
              "\n"
-             "   :param format: Vertex format.\n"
+             "   :arg format: Vertex format.\n"
              "   :type format: :class:`gpu.types.GPUVertFormat`\n"
-             "   :param len: Amount of vertices that will fit into this buffer.\n"
+             "   :arg len: Amount of vertices that will fit into this buffer.\n"
              "   :type len: int\n");
 PyTypeObject BPyGPUVertBuf_Type = {
     PyVarObject_HEAD_INIT(NULL, 0).tp_name = "GPUVertBuf",
diff --git a/source/blender/python/gpu/gpu_py_vertex_format.c b/source/blender/python/gpu/gpu_py_vertex_format.c
index 40a0e5d1e9f..ac0ec6bdc01 100644
--- a/source/blender/python/gpu/gpu_py_vertex_format.c
+++ b/source/blender/python/gpu/gpu_py_vertex_format.c
@@ -63,15 +63,15 @@ PyDoc_STRVAR(
     "\n"
     "   Add a new attribute to the format.\n"
     "\n"
-    "   :param id: Name the attribute. Often `position`, `normal`, ...\n"
+    "   :arg id: Name the attribute. Often `position`, `normal`, ...\n"
     "   :type id: str\n"
-    "   :param comp_type: The data type that will be used store the value in memory.\n"
+    "   :arg comp_type: The data type that will be used store the value in memory.\n"
     "      Possible values are `I8`, `U8`, `I16`, `U16`, `I32`, `U32`, `F32` and `I10`.\n"
     "   :type comp_type: str\n"
-    "   :param len: How many individual values the attribute consists of\n"
+    "   :arg len: How many individual values the attribute consists of\n"
     "      (e.g. 2 for uv coordinates).\n"
     "   :type len: int\n"
-    "   :param fetch_mode: How values from memory will be converted when used in the shader.\n"
+    "   :arg fetch_mode: How values from memory will be converted when used in the shader.\n"
     "      This is mainly useful for memory optimizations when you want to store values with\n"
     "      reduced precision. E.g. you can store a float in only 1 byte but it will be\n"
     "      converted to a normal 4 byte float when used.\n"
diff --git a/source/blender/python/intern/bpy_rna_operator.c b/source/blender/python/intern/bpy_rna_operator.c
index fd6cc93ed32..e0a4356dc18 100644
--- a/source/blender/python/intern/bpy_rna_operator.c
+++ b/source/blender/python/intern/bpy_rna_operator.c
@@ -84,7 +84,7 @@ PyDoc_STRVAR(BPY_rna_operator_poll_message_set_doc,
              "   When message is callable, "
              "additional user defined positional arguments are passed to the message function.\n"
              "\n"
-             "   :param message: The message or a function that returns the message.\n"
+             "   :arg message: The message or a function that returns the message.\n"
              "   :type message: string or a callable that returns a string or None.\n");
 
 static PyObject *BPY_rna_operator_poll_message_set(PyObject *UNUSED(self), PyObject *args)
diff --git a/source/blender/python/intern/bpy_rna_types_capi.c b/source/blender/python/intern/bpy_rna_types_capi.c
index c3a07847aff..2b830eb9ffe 100644
--- a/source/blender/python/intern/bpy_rna_types_capi.c
+++ b/source/blender/python/intern/bpy_rna_types_capi.c
@@ -185,16 +185,16 @@ PyDoc_STRVAR(
     "   It will be called every time the specified region in the space type will be drawn.\n"
     "   Note: All arguments are positional only for now.\n"
     "\n"
-    "   :param callback:\n"
+    "   :arg callback:\n"
     "      A function that will be called when the region is drawn.\n"
     "      It gets the specified arguments as input.\n"
     "   :type callback: function\n"
-    "   :param args: Arguments that will be passed to the callback.\n"
+    "   :arg args: Arguments that will be passed to the callback.\n"
     "   :type args: tuple\n"
-    "   :param region_type: The region type the callback draws in; usually ``WINDOW``. "
+    "   :arg region_type: The region type the callback draws in; usually ``WINDOW``. "
     "(:class:`bpy.types.Region.type`)\n"
     "   :type region_type: str\n"
-    "   :param draw_type: Usually ``POST_PIXEL`` for 2D drawing and ``POST_VIEW`` for 3D drawing. "
+    "   :arg draw_type: Usually ``POST_PIXEL`` for 2D drawing and ``POST_VIEW`` for 3D drawing. "
     "In some cases ``PRE_VIEW`` can be used. ``BACKDROP`` can be used for backdrops in the node "
     "editor.\n"
     "   :type draw_type: str\n"
@@ -206,9 +206,9 @@ PyDoc_STRVAR(pyrna_draw_handler_remove_doc,
              "\n"
              "   Remove a draw handler that was added previously.\n"
              "\n"
-             "   :param handler: The draw handler that should be removed.\n"
+             "   :arg handler: The draw handler that should be removed.\n"
              "   :type handler: object\n"
-             "   :param region_type: Region type the callback was added to.\n"
+             "   :arg region_type: Region type the callback was added to.\n"
              "   :type region_type: str\n");
 
 static struct PyMethodDef pyrna_space_methods[] = {
diff --git a/source/blender/python/mathutils/mathutils_Color.c b/source/blender/python/mathutils/mathutils_Color.c
index 88e8d880360..955fa4b6f92 100644
--- a/source/blender/python/mathutils/mathutils_Color.c
+++ b/source/blender/python/mathutils/mathutils_Color.c
@@ -1102,7 +1102,7 @@ PyDoc_STRVAR(
     "   the OpenColorIO configuration. The notable exception is user interface theming colors, "
     "   which are in sRGB color space.\n"
     "\n"
-    "   :param rgb: (r, g, b) color values\n"
+    "   :arg rgb: (r, g, b) color values\n"
     "   :type rgb: 3d vector\n");
 PyTypeObject color_Type = {
     PyVarObject_HEAD_INIT(NULL, 0) "Color", /* tp_name */
diff --git a/source/blender/python/mathutils/mathutils_Euler.c b/source/blender/python/mathutils/mathutils_Euler.c
index f49868dfba7..8f950bce344 100644
--- a/source/blender/python/mathutils/mathutils_Euler.c
+++ b/source/blender/python/mathutils/mathutils_Euler.c
@@ -774,9 +774,9 @@ PyDoc_STRVAR(
     "\n"
     "   .. seealso:: `Euler angles <https://en.wikipedia.org/wiki/Euler_angles>`__ on Wikipedia.\n"
     "\n"
-    "   :param angles: Three angles, in radians.\n"
+    "   :arg angles: Three angles, in radians.\n"
     "   :type angles: 3d vector\n"
-    "   :param order: Optional order of the angles, a permutation of ``XYZ``.\n"
+    "   :arg order: Optional order of the angles, a permutation of ``XYZ``.\n"
     "   :type order: str\n");
 PyTypeObject euler_Type = {
     PyVarObject_HEAD_INIT(NULL, 0) "Euler", /* tp_name */
diff --git a/source/blender/python/mathutils/mathutils_Matrix.c b/source/blender/python/mathutils/mathutils_Matrix.c
index 8405b966a4e..af01c571fe9 100644
--- a/source/blender/python/mathutils/mathutils_Matrix.c
+++ b/source/blender/python/mathutils/mathutils_Matrix.c
@@ -3321,8 +3321,7 @@ PyDoc_STRVAR(
     "   This object gives access to Matrices in Blender, supporting square and rectangular\n"
     "   matrices from 2x2 up to 4x4.\n"
     "\n"
-    "   :param rows: Sequence of rows.\n"
-    "      When omitted, a 4x4 identity matrix is constructed.\n"
+    "   :arg rows: Sequence of rows. When omitted, a 4x4 identity matrix is constructed.\n"
     "   :type rows: 2d number sequence\n");
 PyTypeObject matrix_Type = {
     PyVarObject_HEAD_INIT(NULL, 0) "Matrix", /*tp_name*/
diff --git a/source/blender/python/mathutils/mathutils_Quaternion.c b/source/blender/python/mathutils/mathutils_Quaternion.c
index a5ea09bef48..d405d5e63ce 100644
--- a/source/blender/python/mathutils/mathutils_Quaternion.c
+++ b/source/blender/python/mathutils/mathutils_Quaternion.c
@@ -1662,9 +1662,9 @@ PyDoc_STRVAR(quaternion_doc,
              "\n"
              "   This object gives access to Quaternions in Blender.\n"
              "\n"
-             "   :param seq: size 3 or 4\n"
+             "   :arg seq: size 3 or 4\n"
              "   :type seq: :class:`Vector`\n"
-             "   :param angle: rotation angle, in radians\n"
+             "   :arg angle: rotation angle, in radians\n"
              "   :type angle: float\n"
              "\n"
              "   The constructor takes arguments in various forms:\n"
diff --git a/source/blender/python/mathutils/mathutils_Vector.c b/source/blender/python/mathutils/mathutils_Vector.c
index 0c9cbd6ccfa..cf684341d4f 100644
--- a/source/blender/python/mathutils/mathutils_Vector.c
+++ b/source/blender/python/mathutils/mathutils_Vector.c
@@ -3188,7 +3188,7 @@ PyDoc_STRVAR(vector_doc,
              "\n"
              "   This object gives access to Vectors in Blender.\n"
              "\n"
-             "   :param seq: Components of the vector, must be a sequence of at least two\n"
+             "   :arg seq: Components of the vector, must be a sequence of at least two\n"
              "   :type seq: sequence of numbers\n");
 PyTypeObject vector_Type = {
     PyVarObject_HEAD_INIT(NULL, 0)