Consistent spacing is a pre-requisite to consistently good writing.

Author: hunterhogan

Doc/c-api/abstract.rst

@@ -8,7 +8,7 @@ Abstract Objects Layer
 
 The functions in this chapter interact with Python objects regardless of their
 type, or with wide classes of object types (e.g. all numerical types, or all
-sequence types).  When used on object types for which they do not apply, they
+sequence types). When used on object types for which they do not apply, they
 will raise a Python exception.
 
 It is not possible to use these functions on objects that are not properly

Doc/c-api/allocation.rst

@@ -15,10 +15,10 @@ Allocating Objects on the Heap
 .. c:function:: PyObject* PyObject_Init(PyObject *op, PyTypeObject *type)
 
    Initialize a newly allocated object *op* with its type and initial
-   reference.  Returns the initialized object.  Other fields of the object are
-   not initialized.  Despite its name, this function is unrelated to the
+   reference. Returns the initialized object. Other fields of the object are
+   not initialized. Despite its name, this function is unrelated to the
    object's :meth:`~object.__init__` method (:c:member:`~PyTypeObject.tp_init`
-   slot).  Specifically, this function does **not** call the object's
+   slot). Specifically, this function does **not** call the object's
    :meth:`!__init__` method.
 
    In general, consider this function to be a low-level routine. Use
@@ -29,7 +29,7 @@ Allocating Objects on the Heap
    .. note::
 
       This function only initializes the object's memory corresponding to the
-      initial :c:type:`PyObject` structure.  It does not zero the rest.
+      initial :c:type:`PyObject` structure. It does not zero the rest.
 
 
 .. c:function:: PyVarObject* PyObject_InitVar(PyVarObject *op, PyTypeObject *type, Py_ssize_t size)
@@ -39,7 +39,7 @@ Allocating Objects on the Heap
 
    .. note::
 
-      This function only initializes some of the object's memory.  It does not
+      This function only initializes some of the object's memory. It does not
       zero the rest.
 
 
@@ -48,7 +48,7 @@ Allocating Objects on the Heap
    Allocates a new Python object using the C structure type *TYPE* and the
    Python type object *typeobj* (``PyTypeObject*``) by calling
    :c:func:`PyObject_Malloc` to allocate memory and initializing it like
-   :c:func:`PyObject_Init`.  The caller will own the only reference to the
+   :c:func:`PyObject_Init`. The caller will own the only reference to the
    object (i.e. its reference count will be one).
 
    Avoid calling this directly to allocate memory for an object; call the type's
@@ -77,8 +77,8 @@ Allocating Objects on the Heap
 
       This macro does not construct a fully initialized object of the given
       type; it merely allocates memory and prepares it for further
-      initialization by :c:member:`~PyTypeObject.tp_init`.  To construct a
-      fully initialized object, call *typeobj* instead.  For example::
+      initialization by :c:member:`~PyTypeObject.tp_init`. To construct a
+      fully initialized object, call *typeobj* instead. For example::
 
          PyObject *foo = PyObject_CallNoArgs((PyObject *)&PyFoo_Type);
 
@@ -100,7 +100,7 @@ Allocating Objects on the Heap
    * The memory is initialized like :c:func:`PyObject_InitVar`.
 
    This is useful for implementing objects like tuples, which are able to
-   determine their size at construction time.  Embedding the array of fields
+   determine their size at construction time. Embedding the array of fields
    into the same allocation decreases the number of allocations, improving the
    memory management efficiency.
 
@@ -127,8 +127,8 @@ Allocating Objects on the Heap
 
       This macro does not construct a fully initialized object of the given
       type; it merely allocates memory and prepares it for further
-      initialization by :c:member:`~PyTypeObject.tp_init`.  To construct a
-      fully initialized object, call *typeobj* instead.  For example::
+      initialization by :c:member:`~PyTypeObject.tp_init`. To construct a
+      fully initialized object, call *typeobj* instead. For example::
 
          PyObject *list_instance = PyObject_CallNoArgs((PyObject *)&PyList_Type);
 
@@ -146,7 +146,7 @@ Allocating Objects on the Heap
 
 .. c:var:: PyObject _Py_NoneStruct
 
-   Object which is visible in Python as ``None``.  This should only be accessed
+   Object which is visible in Python as ``None``. This should only be accessed
    using the :c:macro:`Py_None` macro, which evaluates to a pointer to this
    object.
 

Doc/c-api/arg.rst

@@ -5,9 +5,9 @@
 Boolean Objects
 ---------------
 
-Booleans in Python are implemented as a subclass of integers.  There are only
-two booleans, :c:data:`Py_False` and :c:data:`Py_True`.  As such, the normal
-creation and deletion functions don't apply to booleans.  The following macros
+Booleans in Python are implemented as a subclass of integers. There are only
+two booleans, :c:data:`Py_False` and :c:data:`Py_True`. As such, the normal
+creation and deletion functions don't apply to booleans. The following macros
 are available, however.
 
 
@@ -19,13 +19,13 @@ are available, however.
 
 .. c:function:: int PyBool_Check(PyObject *o)
 
-   Return true if *o* is of type :c:data:`PyBool_Type`.  This function always
+   Return true if *o* is of type :c:data:`PyBool_Type`. This function always
    succeeds.
 
 
 .. c:var:: PyObject* Py_False
 
-   The Python ``False`` object.  This object has no methods and is
+   The Python ``False`` object. This object has no methods and is
    :term:`immortal`.
 
    .. versionchanged:: 3.12
@@ -34,7 +34,7 @@ are available, however.
 
 .. c:var:: PyObject* Py_True
 
-   The Python ``True`` object.  This object has no methods and is
+   The Python ``True`` object. This object has no methods and is
    :term:`immortal`.
 
    .. versionchanged:: 3.12

Doc/c-api/bool.rst

@@ -16,18 +16,18 @@ Buffer Protocol
 
 
 Certain objects available in Python wrap access to an underlying memory
-array or *buffer*.  Such objects include the built-in :class:`bytes` and
+array or *buffer*. Such objects include the built-in :class:`bytes` and
 :class:`bytearray`, and some extension types like :class:`array.array`.
 Third-party libraries may define their own types for special purposes, such
 as image processing or numeric analysis.
 
 While each of these types have their own semantics, they share the common
-characteristic of being backed by a possibly large memory buffer.  It is
+characteristic of being backed by a possibly large memory buffer. It is
 then desirable, in some situations, to access that buffer directly and
 without intermediate copying.
 
 Python provides such a facility at the C and Python level in the form of the
-:ref:`buffer protocol <bufferobjects>`.  This protocol has two sides:
+:ref:`buffer protocol <bufferobjects>`. This protocol has two sides:
 
 .. index:: single: PyBufferProcs (C type)
 
@@ -41,15 +41,15 @@ Python provides such a facility at the C and Python level in the form of the
   Python see :class:`memoryview`.
 
 Simple objects such as :class:`bytes` and :class:`bytearray` expose their
-underlying buffer in byte-oriented form.  Other forms are possible; for example,
+underlying buffer in byte-oriented form. Other forms are possible; for example,
 the elements exposed by an :class:`array.array` can be multi-byte values.
 
 An example consumer of the buffer interface is the :meth:`~io.BufferedIOBase.write`
 method of file objects: any object that can export a series of bytes through
-the buffer interface can be written to a file.  While :meth:`!write` only
+the buffer interface can be written to a file. While :meth:`!write` only
 needs read-only access to the internal contents of the object passed to it,
 other methods such as :meth:`~io.BufferedIOBase.readinto` need write access
-to the contents of their argument.  The buffer interface allows objects to
+to the contents of their argument. The buffer interface allows objects to
 selectively allow or reject exporting of read-write and read-only buffers.
 
 There are two ways for a consumer of the buffer interface to acquire a buffer
@@ -61,7 +61,7 @@ over a target object:
   ``y*``, ``w*`` or ``s*`` :ref:`format codes <arg-parsing>`.
 
 In both cases, :c:func:`PyBuffer_Release` must be called when the buffer
-isn't needed anymore.  Failure to do so could lead to various issues such as
+isn't needed anymore. Failure to do so could lead to various issues such as
 resource leaks.
 
 .. versionadded:: 3.12
@@ -75,17 +75,17 @@ Buffer structure
 ================
 
 Buffer structures (or simply "buffers") are useful as a way to expose the
-binary data from another object to the Python programmer.  They can also be
-used as a zero-copy slicing mechanism.  Using their ability to reference a
+binary data from another object to the Python programmer. They can also be
+used as a zero-copy slicing mechanism. Using their ability to reference a
 block of memory, it is possible to expose any data to the Python programmer
-quite easily.  The memory could be a large, constant array in a C extension,
+quite easily. The memory could be a large, constant array in a C extension,
 it could be a raw block of memory for manipulation before passing to an
 operating system library, or it could be used to pass around structured data
 in its native, in-memory format.
 
 Contrary to most data types exposed by the Python interpreter, buffers
-are not :c:type:`PyObject` pointers but rather simple C structures.  This
-allows them to be created and copied very simply.  When a generic wrapper
+are not :c:type:`PyObject` pointers but rather simple C structures. This
+allows them to be created and copied very simply. When a generic wrapper
 around a buffer is needed, a :ref:`memoryview <memoryview-objects>` object
 can be created.
 
@@ -142,7 +142,7 @@ a buffer, see :c:func:`PyObject_GetBuffer`.
 
       Important exception: If a consumer requests a buffer without the
       :c:macro:`PyBUF_FORMAT` flag, :c:member:`~Py_buffer.format` will
-      be set to  ``NULL``,  but :c:member:`~Py_buffer.itemsize` still has
+      be set to ``NULL``, ut :c:member:`~Py_buffer.itemsize` still has
       the value for the original format.
 
       If :c:member:`~Py_buffer.shape` is present, the equality

Doc/c-api/buffer.rst

@@ -16,15 +16,15 @@ Refer to :ref:`using-capsules` for more information on using these objects.
 
    This subtype of :c:type:`PyObject` represents an opaque value, useful for C
    extension modules who need to pass an opaque value (as a :c:expr:`void*`
-   pointer) through Python code to other C code.  It is often used to make a C
+   pointer) through Python code to other C code. It is often used to make a C
    function pointer defined in one module available to other modules, so the
    regular import mechanism can be used to access C APIs defined in dynamically
    loaded modules.
 
 
 .. c:type:: PyCapsule_Destructor
 
-   The type of a destructor callback for a capsule.  Defined as::
+   The type of a destructor callback for a capsule. Defined as::
 
       typedef void (*PyCapsule_Destructor)(PyObject *);
 
@@ -34,81 +34,81 @@ Refer to :ref:`using-capsules` for more information on using these objects.
 
 .. c:function:: int PyCapsule_CheckExact(PyObject *p)
 
-   Return true if its argument is a :c:type:`PyCapsule`.  This function always
+   Return true if its argument is a :c:type:`PyCapsule`. This function always
    succeeds.
 
 
 .. c:function:: PyObject* PyCapsule_New(void *pointer, const char *name, PyCapsule_Destructor destructor)
 
-   Create a :c:type:`PyCapsule` encapsulating the *pointer*.  The *pointer*
+   Create a :c:type:`PyCapsule` encapsulating the *pointer*. The *pointer*
    argument may not be ``NULL``.
 
    On failure, set an exception and return ``NULL``.
 
-   The *name* string may either be ``NULL`` or a pointer to a valid C string.  If
-   non-``NULL``, this string must outlive the capsule.  (Though it is permitted to
+   The *name* string may either be ``NULL`` or a pointer to a valid C string. If
+   non-``NULL``, this string must outlive the capsule. (Though it is permitted to
    free it inside the *destructor*.)
 
    If the *destructor* argument is not ``NULL``, it will be called with the
    capsule as its argument when it is destroyed.
 
    If this capsule will be stored as an attribute of a module, the *name* should
-   be specified as ``modulename.attributename``.  This will enable other modules
+   be specified as ``modulename.attributename``. This will enable other modules
    to import the capsule using :c:func:`PyCapsule_Import`.
 
 
 .. c:function:: void* PyCapsule_GetPointer(PyObject *capsule, const char *name)
 
-   Retrieve the *pointer* stored in the capsule.  On failure, set an exception
+   Retrieve the *pointer* stored in the capsule. On failure, set an exception
    and return ``NULL``.
 
    The *name* parameter must compare exactly to the name stored in the capsule.
    If the name stored in the capsule is ``NULL``, the *name* passed in must also
-   be ``NULL``.  Python uses the C function :c:func:`!strcmp` to compare capsule
+   be ``NULL``. Python uses the C function :c:func:`!strcmp` to compare capsule
    names.
 
 
 .. c:function:: PyCapsule_Destructor PyCapsule_GetDestructor(PyObject *capsule)
 
-   Return the current destructor stored in the capsule.  On failure, set an
+   Return the current destructor stored in the capsule. On failure, set an
    exception and return ``NULL``.
 
-   It is legal for a capsule to have a ``NULL`` destructor.  This makes a ``NULL``
+   It is legal for a capsule to have a ``NULL`` destructor. This makes a ``NULL``
    return code somewhat ambiguous; use :c:func:`PyCapsule_IsValid` or
    :c:func:`PyErr_Occurred` to disambiguate.
 
 
 .. c:function:: void* PyCapsule_GetContext(PyObject *capsule)
 
-   Return the current context stored in the capsule.  On failure, set an
+   Return the current context stored in the capsule. On failure, set an
    exception and return ``NULL``.
 
-   It is legal for a capsule to have a ``NULL`` context.  This makes a ``NULL``
+   It is legal for a capsule to have a ``NULL`` context. This makes a ``NULL``
    return code somewhat ambiguous; use :c:func:`PyCapsule_IsValid` or
    :c:func:`PyErr_Occurred` to disambiguate.
 
 
 .. c:function:: const char* PyCapsule_GetName(PyObject *capsule)
 
-   Return the current name stored in the capsule.  On failure, set an exception
+   Return the current name stored in the capsule. On failure, set an exception
    and return ``NULL``.
 
-   It is legal for a capsule to have a ``NULL`` name.  This makes a ``NULL`` return
+   It is legal for a capsule to have a ``NULL`` name. This makes a ``NULL`` return
    code somewhat ambiguous; use :c:func:`PyCapsule_IsValid` or
    :c:func:`PyErr_Occurred` to disambiguate.
 
 
 .. c:function:: void* PyCapsule_Import(const char *name, int no_block)
 
-   Import a pointer to a C object from a capsule attribute in a module.  The
+   Import a pointer to a C object from a capsule attribute in a module. The
    *name* parameter should specify the full name to the attribute, as in
-   ``module.attribute``.  The *name* stored in the capsule must match this
+   ``module.attribute``. The *name* stored in the capsule must match this
    string exactly.
 
    This function splits *name* on the ``.`` character, and imports the first
    element. It then processes further elements using attribute lookups.
 
-   Return the capsule's internal *pointer* on success.  On failure, set an
+   Return the capsule's internal *pointer* on success. On failure, set an
    exception and return ``NULL``.
 
    .. note::
@@ -124,9 +124,9 @@ Refer to :ref:`using-capsules` for more information on using these objects.
 
 .. c:function:: int PyCapsule_IsValid(PyObject *capsule, const char *name)
 
-   Determines whether or not *capsule* is a valid capsule.  A valid capsule is
+   Determines whether or not *capsule* is a valid capsule. A valid capsule is
    non-``NULL``, passes :c:func:`PyCapsule_CheckExact`, has a non-``NULL`` pointer
-   stored in it, and its internal name matches the *name* parameter.  (See
+   stored in it, and its internal name matches the *name* parameter. (See
    :c:func:`PyCapsule_GetPointer` for information on how capsule names are
    compared.)
 
@@ -135,35 +135,35 @@ Refer to :ref:`using-capsules` for more information on using these objects.
    guaranteed to succeed.
 
    Return a nonzero value if the object is valid and matches the name passed in.
-   Return ``0`` otherwise.  This function will not fail.
+   Return ``0`` otherwise. This function will not fail.
 
 
 .. c:function:: int PyCapsule_SetContext(PyObject *capsule, void *context)
 
    Set the context pointer inside *capsule* to *context*.
 
-   Return ``0`` on success.  Return nonzero and set an exception on failure.
+   Return ``0`` on success. Return nonzero and set an exception on failure.
 
 
 .. c:function:: int PyCapsule_SetDestructor(PyObject *capsule, PyCapsule_Destructor destructor)
 
    Set the destructor inside *capsule* to *destructor*.
 
-   Return ``0`` on success.  Return nonzero and set an exception on failure.
+   Return ``0`` on success. Return nonzero and set an exception on failure.
 
 
 .. c:function:: int PyCapsule_SetName(PyObject *capsule, const char *name)
 
-   Set the name inside *capsule* to *name*.  If non-``NULL``, the name must
-   outlive the capsule.  If the previous *name* stored in the capsule was not
+   Set the name inside *capsule* to *name*. If non-``NULL``, the name must
+   outlive the capsule. If the previous *name* stored in the capsule was not
    ``NULL``, no attempt is made to free it.
 
-   Return ``0`` on success.  Return nonzero and set an exception on failure.
+   Return ``0`` on success. Return nonzero and set an exception on failure.
 
 
 .. c:function:: int PyCapsule_SetPointer(PyObject *capsule, void *pointer)
 
-   Set the void pointer inside *capsule* to *pointer*.  The pointer may not be
+   Set the void pointer inside *capsule* to *pointer*. The pointer may not be
    ``NULL``.
 
-   Return ``0`` on success.  Return nonzero and set an exception on failure.
+   Return ``0`` on success. Return nonzero and set an exception on failure.