Consistent spacing is apre-requisite toconsistently good writing.

Author: hunterhogan

Doc/c-api/buffer.rst

@@ -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``, ut :c:member:`~Py_buffer.itemsize` still has
+      be set to ``NULL``, but :c:member:`~Py_buffer.itemsize` still has
       the value for the original format.
 
       If :c:member:`~Py_buffer.shape` is present, the equality
@@ -446,14 +446,14 @@ Buffer-related functions
 
 .. c:function:: int PyObject_CheckBuffer(PyObject *obj)
 
-   Return ``1`` if *obj* supports the buffer interface otherwise ``0``.  When ``1`` is
+   Return ``1`` if *obj* supports the buffer interface otherwise ``0``. When ``1`` is
    returned, it doesn't guarantee that :c:func:`PyObject_GetBuffer` will
-   succeed.  This function always succeeds.
+   succeed. This function always succeeds.
 
 
 .. c:function:: int PyObject_GetBuffer(PyObject *exporter, Py_buffer *view, int flags)
 
-   Send a request to *exporter* to fill in *view* as specified by  *flags*.
+   Send a request to *exporter* to fill in *view* as specified by *flags*.
    If the exporter cannot provide a buffer of the exact type, it MUST raise
    :exc:`BufferError`, set ``view->obj`` to ``NULL`` and
    return ``-1``.
@@ -492,7 +492,7 @@ Buffer-related functions
 
    Return ``1`` if the memory defined by the *view* is C-style (*order* is
    ``'C'``) or Fortran-style (*order* is ``'F'``) :term:`contiguous` or either one
-   (*order* is ``'A'``).  Return ``0`` otherwise.  This function always succeeds.
+   (*order* is ``'A'``). Return ``0`` otherwise. This function always succeeds.
 
 
 .. c:function:: void* PyBuffer_GetPointer(const Py_buffer *view, const Py_ssize_t *indices)

Doc/c-api/bytearray.rst

@@ -25,13 +25,13 @@ Type check macros
 .. c:function:: int PyByteArray_Check(PyObject *o)
 
    Return true if the object *o* is a bytearray object or an instance of a
-   subtype of the bytearray type.  This function always succeeds.
+   subtype of the bytearray type. This function always succeeds.
 
 
 .. c:function:: int PyByteArray_CheckExact(PyObject *o)
 
    Return true if the object *o* is a bytearray object, but not an instance of a
-   subtype of the bytearray type.  This function always succeeds.
+   subtype of the bytearray type. This function always succeeds.
 
 
 Direct API functions
@@ -67,7 +67,7 @@ Direct API functions
 .. c:function:: char* PyByteArray_AsString(PyObject *bytearray)
 
    Return the contents of *bytearray* as a char array after checking for a
-   ``NULL`` pointer.  The returned array always has an extra
+   ``NULL`` pointer. The returned array always has an extra
    null byte appended.
 
 

Doc/c-api/bytes.rst

@@ -25,36 +25,36 @@ called with a non-bytes parameter.
 .. c:function:: int PyBytes_Check(PyObject *o)
 
    Return true if the object *o* is a bytes object or an instance of a subtype
-   of the bytes type.  This function always succeeds.
+   of the bytes type. This function always succeeds.
 
 
 .. c:function:: int PyBytes_CheckExact(PyObject *o)
 
    Return true if the object *o* is a bytes object, but not an instance of a
-   subtype of the bytes type.  This function always succeeds.
+   subtype of the bytes type. This function always succeeds.
 
 
 .. c:function:: PyObject* PyBytes_FromString(const char *v)
 
    Return a new bytes object with a copy of the string *v* as value on success,
-   and ``NULL`` on failure.  The parameter *v* must not be ``NULL``; it will not be
+   and ``NULL`` on failure. The parameter *v* must not be ``NULL``; it will not be
    checked.
 
 
 .. c:function:: PyObject* PyBytes_FromStringAndSize(const char *v, Py_ssize_t len)
 
    Return a new bytes object with a copy of the string *v* as value and length
-   *len* on success, and ``NULL`` on failure.  If *v* is ``NULL``, the contents of
+   *len* on success, and ``NULL`` on failure. If *v* is ``NULL``, the contents of
    the bytes object are uninitialized.
 
 
 .. c:function:: PyObject* PyBytes_FromFormat(const char *format, ...)
 
    Take a C :c:func:`printf`\ -style *format* string and a variable number of
    arguments, calculate the size of the resulting Python bytes object and return
-   a bytes object with the values formatted into it.  The variable arguments
+   a bytes object with the values formatted into it. The variable arguments
    must be C types and must correspond exactly to the format characters in the
-   *format* string.  The following format characters are allowed:
+   *format* string. The following format characters are allowed:
 
    .. % XXX: This should be exactly the same as the table in PyErr_Format.
    .. % One should just refer to the other.
@@ -136,12 +136,12 @@ called with a non-bytes parameter.
 
 .. c:function:: char* PyBytes_AsString(PyObject *o)
 
-   Return a pointer to the contents of *o*.  The pointer
+   Return a pointer to the contents of *o*. The pointer
    refers to the internal buffer of *o*, which consists of ``len(o) + 1``
-   bytes.  The last byte in the buffer is always null, regardless of
-   whether there are any other null bytes.  The data must not be
+   bytes. The last byte in the buffer is always null, regardless of
+   whether there are any other null bytes. The data must not be
    modified in any way, unless the object was just created using
-   ``PyBytes_FromStringAndSize(NULL, size)``. It must not be deallocated.  If
+   ``PyBytes_FromStringAndSize(NULL, size)``. It must not be deallocated. If
    *o* is not a bytes object at all, :c:func:`PyBytes_AsString` returns ``NULL``
    and raises :exc:`TypeError`.
 
@@ -162,9 +162,9 @@ called with a non-bytes parameter.
    if it does, the function returns ``-1`` and a :exc:`ValueError` is raised.
 
    The buffer refers to an internal buffer of *obj*, which includes an
-   additional null byte at the end (not counted in *length*).  The data
+   additional null byte at the end (not counted in *length*). The data
    must not be modified in any way, unless the object was just created using
-   ``PyBytes_FromStringAndSize(NULL, size)``.  It must not be deallocated.  If
+   ``PyBytes_FromStringAndSize(NULL, size)``. It must not be deallocated. If
    *obj* is not a bytes object at all, :c:func:`PyBytes_AsStringAndSize`
    returns ``-1`` and raises :exc:`TypeError`.
 
@@ -176,16 +176,16 @@ called with a non-bytes parameter.
 .. c:function:: void PyBytes_Concat(PyObject **bytes, PyObject *newpart)
 
    Create a new bytes object in *\*bytes* containing the contents of *newpart*
-   appended to *bytes*; the caller will own the new reference.  The reference to
-   the old value of *bytes* will be stolen.  If the new object cannot be
+   appended to *bytes*; the caller will own the new reference. The reference to
+   the old value of *bytes* will be stolen. If the new object cannot be
    created, the old reference to *bytes* will still be discarded and the value
    of *\*bytes* will be set to ``NULL``; the appropriate exception will be set.
 
 
 .. c:function:: void PyBytes_ConcatAndDel(PyObject **bytes, PyObject *newpart)
 
    Create a new bytes object in *\*bytes* containing the contents of *newpart*
-   appended to *bytes*.  This version releases the :term:`strong reference`
+   appended to *bytes*. This version releases the :term:`strong reference`
    to *newpart* (i.e. decrements its reference count).
 
 
@@ -214,8 +214,8 @@ called with a non-bytes parameter.
    one, only more efficiently.
    Pass the address of an
    existing bytes object as an lvalue (it may be written into), and the new size
-   desired.  On success, *\*bytes* holds the resized bytes object and ``0`` is
-   returned; the address in *\*bytes* may differ from its input value.  If the
+   desired. On success, *\*bytes* holds the resized bytes object and ``0`` is
+   returned; the address in *\*bytes* may differ from its input value. If the
    reallocation fails, the original bytes object at *\*bytes* is deallocated,
    *\*bytes* is set to ``NULL``, :exc:`MemoryError` is set, and ``-1`` is
    returned.

Doc/c-api/call.rst

@@ -254,7 +254,7 @@ please see individual documentation for details.
 .. c:function:: PyObject* PyObject_CallObject(PyObject *callable, PyObject *args)
 
    Call a callable Python object *callable*, with arguments given by the
-   tuple *args*.  If no arguments are needed, then *args* can be *NULL*.
+   tuple *args*. If no arguments are needed, then *args* can be *NULL*.
 
    Return the result of the call on success, or raise an exception and return
    *NULL* on failure.
@@ -266,7 +266,7 @@ please see individual documentation for details.
 
    Call a callable Python object *callable*, with a variable number of C arguments.
    The C arguments are described using a :c:func:`Py_BuildValue` style format
-   string.  The format can be *NULL*, indicating that no arguments are provided.
+   string. The format can be *NULL*, indicating that no arguments are provided.
 
    Return the result of the call on success, or raise an exception and return
    *NULL* on failure.
@@ -283,7 +283,7 @@ please see individual documentation for details.
 .. c:function:: PyObject* PyObject_CallMethod(PyObject *obj, const char *name, const char *format, ...)
 
    Call the method named *name* of object *obj* with a variable number of C
-   arguments.  The C arguments are described by a :c:func:`Py_BuildValue` format
+   arguments. The C arguments are described by a :c:func:`Py_BuildValue` format
    string that should produce a tuple.
 
    The format can be *NULL*, indicating that no arguments are provided.
@@ -304,7 +304,7 @@ please see individual documentation for details.
 .. c:function:: PyObject* PyObject_CallFunctionObjArgs(PyObject *callable, ...)
 
    Call a callable Python object *callable*, with a variable number of
-   :c:expr:`PyObject *` arguments.  The arguments are provided as a variable number
+   :c:expr:`PyObject *` arguments. The arguments are provided as a variable number
    of parameters followed by *NULL*.
 
    Return the result of the call on success, or raise an exception and return
@@ -317,8 +317,8 @@ please see individual documentation for details.
 .. c:function:: PyObject* PyObject_CallMethodObjArgs(PyObject *obj, PyObject *name, ...)
 
    Call a method of the Python object *obj*, where the name of the method is given as a
-   Python string object in *name*.  It is called with a variable number of
-   :c:expr:`PyObject *` arguments.  The arguments are provided as a variable number
+   Python string object in *name*. It is called with a variable number of
+   :c:expr:`PyObject *` arguments. The arguments are provided as a variable number
    of parameters followed by *NULL*.
 
    Return the result of the call on success, or raise an exception and return
@@ -400,5 +400,5 @@ Call Support API
 
 .. c:function:: int PyCallable_Check(PyObject *o)
 
-   Determine if the object *o* is callable.  Return ``1`` if the object is callable
-   and ``0`` otherwise.  This function always succeeds.
+   Determine if the object *o* is callable. Return ``1`` if the object is callable
+   and ``0`` otherwise. This function always succeeds.

Doc/c-api/init.rst

@@ -351,7 +351,7 @@ Initializing and finalizing the interpreter
       triple: module; search; path
       single: Py_FinalizeEx (C function)
 
-   Initialize the Python interpreter. In an application embedding ython,
+   Initialize the Python interpreter. In an application embedding Python,
    this should be called before using any other Python/C API functions; see
    :ref:`Before Python Initialization <pre-init-safe>` for the few exceptions.
 
@@ -613,7 +613,7 @@ Process-wide parameters
    formed from the "official" name of the operating system, converted to lower
    case, followed by the major revision number; e.g., for Solaris 2.x, which is
    also known as SunOS 5.x, the value is ``'sunos5'``. On macOS, it is
-   ``'darwin'``. On Windows, it is ``'win'``. he returned string points into
+   ``'darwin'``. On Windows, it is ``'win'``. The returned string points into
    static storage; the caller should not modify its value. The value is available
    to Python code as ``sys.platform``.
 

Doc/c-api/memory.rst

@@ -48,7 +48,7 @@ API functions listed in this document.
 
 To avoid memory corruption, extension writers should never try to operate on
 Python objects with the functions exported by the C library: :c:func:`malloc`,
-:c:func:`calloc`, :c:func:`realloc` and :c:func:`free`. This will result in ixed
+:c:func:`calloc`, :c:func:`realloc` and :c:func:`free`. This will result in mixed
 calls between the C allocator and the Python memory manager with fatal
 consequences, because they implement different algorithms and operate on
 different heaps. However, one may safely allocate and release memory blocks
@@ -267,14 +267,14 @@ The :ref:`default memory allocator <default-memory-allocators>` uses the
 
    If *p* is ``NULL``, no operation is performed.
 
-The following type-oriented macros are provided for convenience. Note hat
+The following type-oriented macros are provided for convenience. Note that
 *TYPE* refers to any C type.
 
 
 .. c:macro:: PyMem_New(TYPE, n)
 
    Same as :c:func:`PyMem_Malloc`, but allocates ``(n * sizeof(TYPE))`` bytes of
-   memory. Returns a pointer cast to ``TYPE*``. he memory will not have
+   memory. Returns a pointer cast to ``TYPE*``. The memory will not have
    been initialized in any way.
 
 
@@ -417,7 +417,7 @@ Legend:
 * ``malloc``: system allocators from the standard C library, C functions:
   :c:func:`malloc`, :c:func:`calloc`, :c:func:`realloc` and :c:func:`free`.
 * ``pymalloc``: :ref:`pymalloc memory allocator <pymalloc>`.
-* ``mimalloc``: :ref:`mimalloc memory allocator <mimalloc>`.  The pymalloc
+* ``mimalloc``: :ref:`mimalloc memory allocator <mimalloc>`. The pymalloc
   allocator will be used if mimalloc support isn't available.
 * "+ debug": with :ref:`debug hooks on the Python memory allocators
   <pymem-debug-hooks>`.
@@ -617,7 +617,7 @@ that the treatment of negative indices differs from a Python slice):
     default).
 
     A serial number, incremented by 1 on each call to a malloc-like or
-    realloc-like function. Big-endian :c:type:`size_t`.  f "bad memory" is detected
+    realloc-like function. Big-endian :c:type:`size_t`. If "bad memory" is detected
     later, the serial number gives an excellent way to set a breakpoint on the
     next run, to capture the instant at which this block was passed out. The
     static function bumpserialno() in obmalloc.c is the only place the serial
@@ -776,7 +776,7 @@ allocators operating on different heaps. ::
    ...
    PyMem_Del(buf3);  /* Wrong -- should be PyMem_Free() */
    free(buf2);       /* Right -- allocated via malloc() */
-   free(buf1);       /* Fatal -- should be PyMem_Free()  */
+   free(buf1);       /* Fatal -- should be PyMem_Free() */
 
 In addition to the functions aimed at handling raw memory blocks from the Python
 heap, objects in Python are allocated and released with :c:macro:`PyObject_New`,

Doc/c-api/object.rst

@@ -79,7 +79,7 @@ Object Protocol
 
 .. c:function:: int PyObject_Print(PyObject *o, FILE *fp, int flags)
 
-   Print an object *o*, on file *fp*. Returns ``-1`` on error. he flags argument
+   Print an object *o*, on file *fp*. Returns ``-1`` on error. The flags argument
    is used to enable certain printing options. The only option currently supported
    is :c:macro:`Py_PRINT_RAW`; if given, the :func:`str` of the object is written
    instead of the :func:`repr`.

Doc/c-api/typeobj.rst

@@ -163,11 +163,11 @@ Quick Reference
 
 .. [#cols] Columns:
 
-   **"O"**:  set on :c:data:`PyBaseObject_Type`
+   **"O"**: set on :c:data:`PyBaseObject_Type`
 
-   **"T"**:  set on :c:data:`PyType_Type`
+   **"T"**: set on :c:data:`PyType_Type`
 
-   **"D"**:  default (if slot is set to ``NULL``)
+   **"D"**: default (if slot is set to ``NULL``)
 
    .. code-block:: none
 
@@ -177,7 +177,7 @@ Quick Reference
 
       Also see the inheritance column ("I").
 
-   **"I"**:  inheritance
+   **"I"**: inheritance
 
    .. code-block:: none
 
@@ -2245,7 +2245,7 @@ and :c:data:`PyType_Type` effectively act as defaults.)
 
 .. c:member:: void* PyTypeObject.tp_subclasses
 
-   A collection of subclasses. Internal use only.  ay be an invalid pointer.
+   A collection of subclasses. Internal use only. May be an invalid pointer.
 
    To get a list of subclasses, call the Python method
    :py:meth:`~type.__subclasses__`.
@@ -2732,7 +2732,7 @@ Sequence Object Structures
 
    Negative indexes are handled as follows: if the :c:member:`~PySequenceMethods.sq_length` slot is
    filled, it is called and the sequence length is used to compute a positive
-   index which is passed to :c:member:`~PySequenceMethods.sq_item`.  f :c:member:`!sq_length` is ``NULL``,
+   index which is passed to :c:member:`~PySequenceMethods.sq_item`. If :c:member:`!sq_length` is ``NULL``,
    the index is passed as is to the function.
 
 .. c:member:: ssizeobjargproc PySequenceMethods.sq_ass_item
@@ -2754,7 +2754,7 @@ Sequence Object Structures
 .. c:member:: binaryfunc PySequenceMethods.sq_inplace_concat
 
    This function is used by :c:func:`PySequence_InPlaceConcat` and has the same
-   signature. It should modify its first operand, and return it.  his slot
+   signature. It should modify its first operand, and return it. This slot
    may be left to ``NULL``, in this case :c:func:`!PySequence_InPlaceConcat`
    will fall back to :c:func:`PySequence_Concat`. It is also used by the
    augmented assignment ``+=``, after trying numeric in-place addition
@@ -2763,7 +2763,7 @@ Sequence Object Structures
 .. c:member:: ssizeargfunc PySequenceMethods.sq_inplace_repeat
 
    This function is used by :c:func:`PySequence_InPlaceRepeat` and has the same
-   signature. It should modify its first operand, and return it.  his slot
+   signature. It should modify its first operand, and return it. This slot
    may be left to ``NULL``, in this case :c:func:`!PySequence_InPlaceRepeat`
    will fall back to :c:func:`PySequence_Repeat`. It is also used by the
    augmented assignment ``*=``, after trying numeric in-place multiplication