gh-106016: Support customizing of module attributes access with __setattr__/__delattr__ (PEP 726)

Doc/reference/datamodel.rst

@@ -2007,56 +2007,75 @@ Customizing module attribute access
 
 .. index::
    single: __getattr__ (module attribute)
+   single: __setattr__ (module attribute)
+   single: __delattr__ (module attribute)
    single: __dir__ (module attribute)
    single: __class__ (module attribute)
 
-Special names ``__getattr__`` and ``__dir__`` can be also used to customize
-access to module attributes. The ``__getattr__`` function at the module level
+Special names ``__getattr__``, ``__setattr__``, ``__delattr__`` and ``__dir__``
+can be also used to customize access to module attributes.
+
+The ``__getattr__`` function at the module level
 should accept one argument which is the name of an attribute and return the
 computed value or raise an :exc:`AttributeError`. If an attribute is
 not found on a module object through the normal lookup, i.e.
 :meth:`object.__getattribute__`, then ``__getattr__`` is searched in
 the module ``__dict__`` before raising an :exc:`AttributeError`. If found,
 it is called with the attribute name and the result is returned.
 
+The ``__setattr__`` function should accept two arguments, respectively, the
+name of an attribute and the value to be assigned. It can
+raise an :exc:`AttributeError`.  If present, this function overrides the
+standard :func:`setattr` behaviour on a module.  For example::
+
+   def __setattr__(name, value):
+       print(f'Setting {name} to {value}...')
+       globals()[name] = value
+
+The ``__delattr__`` function should accept one argument which is the name of an
+attribute. It can raise an :exc:`AttributeError`.  If present,
+this function overrides the standard :func:`delattr` behaviour on a module.
+
 The ``__dir__`` function should accept no arguments, and return an iterable of
 strings that represents the names accessible on module. If present, this
 function overrides the standard :func:`dir` search on a module.
 
-For a more fine grained customization of the module behavior (setting
-attributes, properties, etc.), one can set the ``__class__`` attribute of
-a module object to a subclass of :class:`types.ModuleType`. For example::
+For a more fine grained customization of the module behavior, one can set the
+``__class__`` attribute of a module object to a subclass of
+:class:`types.ModuleType`. For example::
 
    import sys
    from types import ModuleType
 
-   class VerboseModule(ModuleType):
-       def __repr__(self):
-           return f'Verbose {self.__name__}'
+   class CallableModule(ModuleType):
+       def __call__(self, *args, **kwargs):
+           raise RuntimeError("NO-body expects the Spanish Inquisition!")
 
-       def __setattr__(self, attr, value):
-           print(f'Setting {attr}...')
-           super().__setattr__(attr, value)
-
-   sys.modules[__name__].__class__ = VerboseModule
+   sys.modules[__name__].__class__ = CallableModule
 
 .. note::
-   Defining module ``__getattr__`` and setting module ``__class__`` only
-   affect lookups made using the attribute access syntax -- directly accessing
-   the module globals (whether by code within the module, or via a reference
-   to the module's globals dictionary) is unaffected.
+   Defining module ``__getattr__``, ``__setattr__``, ``__delattr__``, ``__dir__``
+   and setting module ``__class__`` only affect lookups made using the attribute access
+   syntax -- directly accessing the module globals (whether by code within the
+   module, or via a reference to the module's globals dictionary) is unaffected.
 
 .. versionchanged:: 3.5
    ``__class__`` module attribute is now writable.
 
 .. versionadded:: 3.7
    ``__getattr__`` and ``__dir__`` module attributes.
 
+.. versionadded:: 3.13
+   ``__setattr__`` and ``__delattr__`` module attributes.
+
 .. seealso::
 
    :pep:`562` - Module __getattr__ and __dir__
       Describes the ``__getattr__`` and ``__dir__`` functions on modules.
 
+   :pep:`726` - Module __setattr__ and __delattr__
+      Proposes the ``__setattr__`` and ``__delattr__`` functions on modules.
+
 
 .. _descriptors:
 

Doc/whatsnew/3.13.rst

@@ -131,6 +131,10 @@ Other Language Changes
   of the ``optimize`` argument.
   (Contributed by Irit Katriel in :gh:`108113`).
 
+* Support customizing module attribute access with ``__setattr__`` and
+  ``__delattr__`` functions at the module level.  (Contributed by
+  Sergey B Kirpichev in :gh:`108261`).
+
 * :mod:`multiprocessing`, :mod:`concurrent.futures`, :mod:`compileall`:
   Replace :func:`os.cpu_count` with :func:`os.process_cpu_count` to select the
   default number of worker threads and processes. Get the CPU affinity

Lib/test/test_module/__init__.py

@@ -151,6 +151,57 @@ def test_module_getattr_errors(self):
         if 'test.test_module.bad_getattr2' in sys.modules:
             del sys.modules['test.test_module.bad_getattr2']
 
+    def test_module_setattr(self):
+        import test.test_module.good_setattr as gsa
+        self.assertEqual(gsa.foo, 1)
+        with self.assertRaises(AttributeError):
+            gsa.bar
+        with self.assertRaisesRegex(AttributeError, "Read-only attribute"):
+            gsa.foo = 2
+        gsa.bar = 3
+        self.assertEqual(gsa.bar, 3)
+        del sys.modules['test.test_module.good_setattr']
+
+    def test_module_setattr_errors(self):
+        import test.test_module.bad_setattr as bsa
+        from test.test_module import bad_setattr2
+        self.assertEqual(bsa.foo, 1)
+        self.assertEqual(bad_setattr2.foo, 1)
+        with self.assertRaises(TypeError):
+            bsa.foo = 2
+        with self.assertRaises(TypeError):
+            bad_setattr2.foo = 2
+        del sys.modules['test.test_module.bad_setattr']
+        if 'test.test_module.bad_setattr2' in sys.modules:
+            del sys.modules['test.test_module.bad_setattr2']
+
+    def test_module_delattr(self):
+        import test.test_module.good_delattr as gda
+        self.assertEqual(gda.foo, 1)
+        with self.assertRaises(AttributeError):
+            gda.bar
+        with self.assertRaisesRegex(AttributeError, "Read-only attribute"):
+            del gda.foo
+        gda.bar = 3
+        self.assertEqual(gda.bar, 3)
+        del gda.bar
+        with self.assertRaises(AttributeError):
+            gda.bar
+            del sys.modules['test.test_module.good_delattr']
+
+    def test_module_delattr_errors(self):
+        import test.test_module.bad_delattr as bda
+        from test.test_module import bad_delattr2
+        self.assertEqual(bda.foo, 1)
+        self.assertEqual(bad_delattr2.foo, 1)
+        with self.assertRaises(TypeError):
+            del bda.foo
+        with self.assertRaises(TypeError):
+            del bad_delattr2.foo
+        del sys.modules['test.test_module.bad_delattr']
+        if 'test.test_module.bad_delattr2' in sys.modules:
+            del sys.modules['test.test_module.bad_delattr2']
+
     def test_module_dir(self):
         import test.test_module.good_getattr as gga
         self.assertEqual(dir(gga), ['a', 'b', 'c'])

Lib/test/test_module/bad_delattr.py

@@ -0,0 +1,2 @@
+foo = 1
+__delattr__ = "Oops"

Lib/test/test_module/bad_delattr2.py

@@ -0,0 +1,4 @@
+foo = 1
+
+def __delattr__():
+    "Bad function signature"

Lib/test/test_module/bad_setattr.py

@@ -0,0 +1,2 @@
+foo = 1
+__setattr__ = "Oops"

Lib/test/test_module/bad_setattr2.py

@@ -0,0 +1,4 @@
+foo = 1
+
+def __setattr__():
+    "Bad function signature"

Lib/test/test_module/good_delattr.py

@@ -0,0 +1,6 @@
+foo = 1
+
+def __delattr__(name):
+    if name == 'foo':
+        raise AttributeError("Read-only attribute")
+    del globals()[name]

Lib/test/test_module/good_setattr.py

@@ -0,0 +1,6 @@
+foo = 1
+
+def __setattr__(name, value):
+    if name == 'foo':
+        raise AttributeError("Read-only attribute")
+    globals()[name] = value

Misc/NEWS.d/next/Core and Builtins/2023-08-22-09-57-59.gh-issue-106016.lpbUq8.rst

@@ -0,0 +1,2 @@
+Add support for module ``__setattr__`` and ``__delattr__``. Patch by Sergey
+B Kirpichev.

Objects/moduleobject.c

@@ -891,6 +891,43 @@ _Py_module_getattro(PyModuleObject *m, PyObject *name)
     return _Py_module_getattro_impl(m, name, 0);
 }
 
+static int
+module_setattro(PyModuleObject *mod, PyObject *name, PyObject *value)
+{
+    assert(mod->md_dict != NULL);
+    if (value) {
+        PyObject *setattr;
+        if (PyDict_GetItemRef(mod->md_dict, &_Py_ID(__setattr__), &setattr) < 0) {
+            return -1;
+        }
+        if (setattr) {
+            PyObject *res = PyObject_CallFunctionObjArgs(setattr, name, value, NULL);
+            Py_DECREF(setattr);
+            if (res == NULL) {
+                return -1;
+            }
+            Py_DECREF(res);
+            return 0;
+        }
+    }
+    else {
+        PyObject *delattr;
+        if (PyDict_GetItemRef(mod->md_dict, &_Py_ID(__delattr__), &delattr) < 0) {
+            return -1;
+        }
+        if (delattr) {
+            PyObject *res = PyObject_CallFunctionObjArgs(delattr, name, NULL);
+            Py_DECREF(delattr);
+            if (res == NULL) {
+                return -1;
+            }
+            Py_DECREF(res);
+            return 0;
+        }
+    }
+    return PyObject_GenericSetAttr((PyObject *)mod, name, value);
+}
+
 static int
 module_traverse(PyModuleObject *m, visitproc visit, void *arg)
 {
@@ -1039,7 +1076,7 @@ PyTypeObject PyModule_Type = {
     0,                                          /* tp_call */
     0,                                          /* tp_str */
     (getattrofunc)_Py_module_getattro,          /* tp_getattro */
-    PyObject_GenericSetAttr,                    /* tp_setattro */
+    (setattrofunc)module_setattro,              /* tp_setattro */
     0,                                          /* tp_as_buffer */
     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
         Py_TPFLAGS_BASETYPE,                    /* tp_flags */