Make mutable objects the default

rianhunter · rianhunter · commit d7e2f2516c35 · 2024-01-18T22:33:29.000-05:00
It's more common that the user will want a memoryview object that can
be mutated. An immutable object is more rare, so make the default case
return a mutable object.
diff --git a/Doc/library/ctypes.rst b/Doc/library/ctypes.rst
@@ -2109,19 +2109,19 @@ Utility functions
    .. audit-event:: ctypes.wstring_at address,size ctypes.wstring_at
 
 
-.. function:: memoryview_at(address, size, allow_write=False)
+.. function:: memoryview_at(address, size, readonly=False)
 
    This function returns a :class:`memoryview` object that references the
    memory starting at *address* up to (but not including) *address +
-   size*.  If *allow_write* is set to a truthy value then the
-   :class:`!memoryview` object is mutable.
+   size*.  If *readonly* is set to a truthy value then the
+   :class:`!memoryview` object is immutable.
 
    This function is similar to :func:`string_at` with the key
    difference of not making a copy of the specified memory. It is a
    semantically equivalent (but more efficient) alternative to
    ``memoryview((c_byte * size).from_address(address))``
 
-   .. audit-event:: ctypes.memoryview_at address,size,allow_write ctypes.buffer_at
+   .. audit-event:: ctypes.memoryview_at address,size,readonly ctypes.buffer_at
 
    .. versionadded:: 3.13
 
diff --git a/Lib/ctypes/__init__.py b/Lib/ctypes/__init__.py
@@ -541,11 +541,11 @@ def wstring_at(ptr, size=-1):
 from _ctypes import _memoryview_at_addr
 
 _memoryview_at = PYFUNCTYPE(py_object, c_void_p, c_ssize_t, c_int)(_memoryview_at_addr)
-def memoryview_at(ptr, size, allow_write=False):
-    """memoryview_at(addr, size[, allow_write]) -> memoryview
+def memoryview_at(ptr, size, readonly=False):
+    """memoryview_at(addr, size[, readonly]) -> memoryview
 
     Return a memoryview representing the memory at addr."""
-    return _memoryview_at(ptr, size, bool(allow_write))
+    return _memoryview_at(ptr, size, bool(readonly))
 
 if _os.name == "nt": # COM stuff
     def DllGetClassObject(rclsid, riid, ppv):
diff --git a/Modules/_ctypes/_ctypes.c b/Modules/_ctypes/_ctypes.c
@@ -5643,15 +5643,15 @@ wstring_at(const wchar_t *ptr, int size)
 }
 
 static PyObject *
-memoryview_at(char *ptr, Py_ssize_t size, int allow_write)
+memoryview_at(char *ptr, Py_ssize_t size, int readonly)
 {
     if (PySys_Audit("ctypes.memoryview_at", "nni", (Py_ssize_t)ptr, size,
-                    allow_write) < 0) {
+                    readonly) < 0) {
         return NULL;
     }
 
     return PyMemoryView_FromMemory(ptr, size,
-                                   allow_write ? PyBUF_WRITE : PyBUF_READ);
+                                   readonly ? PyBUF_READ : PyBUF_WRITE);
 }
 
 static struct PyModuleDef _ctypesmodule = {

Original file line number	Diff line number	Diff line change
`@@ -5643,15 +5643,15 @@ wstring_at(const wchar_t *ptr, int size)`
`5643`	`5643`	`}`
`5644`	`5644`
`5645`	`5645`	`static PyObject *`
`5646`		`-memoryview_at(char *ptr, Py_ssize_t size, int allow_write)`
	`5646`	`+memoryview_at(char *ptr, Py_ssize_t size, int readonly)`
`5647`	`5647`	`{`
`5648`	`5648`	`if (PySys_Audit("ctypes.memoryview_at", "nni", (Py_ssize_t)ptr, size,`
`5649`		`- allow_write) < 0) {`
	`5649`	`+ readonly) < 0) {`
`5650`	`5650`	`return NULL;`
`5651`	`5651`	`}`
`5652`	`5652`
`5653`	`5653`	`return PyMemoryView_FromMemory(ptr, size,`
`5654`		`- allow_write ? PyBUF_WRITE : PyBUF_READ);`
	`5654`	`+ readonly ? PyBUF_READ : PyBUF_WRITE);`
`5655`	`5655`	`}`
`5656`	`5656`
`5657`	`5657`	`static struct PyModuleDef _ctypesmodule = {`