add __notes__ attribute in add_note. Traceback ignores it if it's not…

… a sequence of strings
iritkatriel · Apr 16, 2022 · Feb 13, 2022 · Feb 23, 2022 · Mar 2, 2022 · Mar 16, 2022
commit f518aa5f67e0ca6466868cf71175c40548cedb86
@@ -502,7 +502,9 @@ def leaves(exc):
                 self.assertIs(eg.__cause__, part.__cause__)
                 self.assertIs(eg.__context__, part.__context__)
                 self.assertIs(eg.__traceback__, part.__traceback__)
-                self.assertEqual(eg.__notes__, part.__notes__)
+                self.assertEqual(
+                    getattr(eg, '__notes__', None),
+                    getattr(part, '__notes__', None))
 
         def tbs_for_leaf(leaf, eg):
             for e, tbs in leaf_generator(eg):

@@ -541,27 +541,25 @@ def testAttributes(self):
     def test_notes(self):
         for e in [BaseException(1), Exception(2), ValueError(3)]:
             with self.subTest(e=e):
-                self.assertEqual(e.__notes__, ())
+                self.assertFalse(hasattr(e, '__notes__'))
                 e.add_note("My Note")
-                self.assertEqual(e.__notes__, ("My Note",))
+                self.assertEqual(e.__notes__, ["My Note"])
 
                 with self.assertRaises(TypeError):
                     e.add_note(42)
-                self.assertEqual(e.__notes__, ("My Note",))
+                self.assertEqual(e.__notes__, ["My Note"])
 
                 e.add_note("Your Note")
-                self.assertEqual(e.__notes__, ("My Note", "Your Note"))
-
-                with self.assertRaises(AttributeError):
-                    e.__notes__ = ("NewNote",)
-                self.assertEqual(e.__notes__, ("My Note", "Your Note"))
+                self.assertEqual(e.__notes__, ["My Note", "Your Note"])
 
                 del e.__notes__
-                self.assertEqual(e.__notes__, ())
+                self.assertFalse(hasattr(e, '__notes__'))
 
                 e.add_note("Our Note")
-                self.assertEqual(e.__notes__, ("Our Note",))
+                self.assertEqual(e.__notes__, ["Our Note"])
 
+                e.__notes__ = 42
+                self.assertEqual(e.__notes__, 42)
 
     def testWithTraceback(self):
         try:

diff --git a/Lib/test/test_traceback.py b/Lib/test/test_traceback.py
@@ -1340,6 +1340,14 @@ def test_exception_with_note(self):
         del e.__notes__
         self.assertEqual(self.get_report(e), vanilla)
 
+        # non-sequence __notes__ is ignored
+        e.__notes__ = 42
+        self.assertEqual(self.get_report(e), vanilla)
+
+        # non-string items in the __notes__ sequence are ignored
+        e.__notes__  = [42, 'Final Note']
+        self.assertEqual(self.get_report(e), vanilla + 'Final Note\n')
+
     def test_exception_with_note_with_multiple_notes(self):
         e = ValueError(42)
         vanilla = self.get_report(e)

diff --git a/Lib/traceback.py b/Lib/traceback.py
@@ -1,6 +1,6 @@
 """Extract, format and print information about Python stack traces."""
 
-import collections
+import collections.abc
 import itertools
 import linecache
 import sys
@@ -689,7 +689,7 @@ def __init__(self, exc_type, exc_value, exc_traceback, *, limit=None,
         # Capture now to permit freeing resources: only complication is in the
         # unofficial API _format_final_exc_line
         self._str = _some_str(exc_value)
-        self.__notes__ = exc_value.__notes__ if exc_value else None
+        self.__notes__ = getattr(exc_value, '__notes__', None)
 
         if exc_type and issubclass(exc_type, SyntaxError):
             # Handle SyntaxError's specially
@@ -822,9 +822,10 @@ def format_exception_only(self):
             yield _format_final_exc_line(stype, self._str)
         else:
             yield from self._format_syntax_error(stype)
-        if self.__notes__ is not None:
+        if isinstance(self.__notes__, collections.abc.Sequence):
             for note in self.__notes__:
-                yield from [l + '\n' for l in note.split('\n')]
+                if isinstance(note, str):
+                    yield from [l + '\n' for l in note.split('\n')]
 
     def _format_syntax_error(self, stype):
         """Format SyntaxError exceptions (internal helper)."""

@@ -194,25 +194,34 @@ _PyBaseExceptionObject_cast(PyObject *exc)
 }
 
 static PyObject *
-BaseException_add_note(PyObject *self_, PyObject *args, PyObject *kwds)
+BaseException_add_note(PyObject *self, PyObject *args, PyObject *kwds)
 {
-    PyBaseExceptionObject *self = _PyBaseExceptionObject_cast(self_);
     PyObject *note = NULL;
 
     if (!PyArg_ParseTuple(args, "U:add_note", &note)) {
         return NULL;
     }
 
-    if (self->notes == NULL) {
-        self->notes = PyList_New(0);
-        if (self->notes == NULL) {
+    if (!PyObject_HasAttr(self, &_Py_ID(__notes__))) {
+        PyObject *new_notes = PyList_New(0);
+        if (new_notes == NULL) {
             return NULL;
         }
+        if (PyObject_SetAttr(self, &_Py_ID(__notes__), new_notes) < 0) {
+            Py_DECREF(new_notes);
+            return NULL;
+        }
+        Py_DECREF(new_notes);
+    }
+    PyObject *notes = PyObject_GetAttr(self, &_Py_ID(__notes__));
+    if (notes == NULL) {
+        return NULL;
     }
-    assert(PyUnicode_CheckExact(note)); 
-    if (PyList_Append(self->notes, note) < 0) {
+    if (PyList_Append(notes, note) < 0) {
+        Py_DECREF(notes);
         return NULL;
     }
+    Py_DECREF(notes);
     Py_RETURN_NONE;
 }
 
@@ -255,31 +264,6 @@ BaseException_set_args(PyBaseExceptionObject *self, PyObject *val, void *Py_UNUS
     return 0;
 }
 
-static PyObject *
-BaseException_get_notes(PyBaseExceptionObject *self, void *Py_UNUSED(ignored))
-{
-    if (self->notes == NULL) {
-        return PyTuple_New(0);
-    }
-    return PySequence_Tuple(self->notes);
-}
-
-static int
-BaseException_set_notes(PyBaseExceptionObject *self, PyObject *note,
-                       void *Py_UNUSED(ignored))
-{
-    if (note == NULL) {
-        Py_CLEAR(self->notes);
-    }
-    else {
-        PyErr_SetString(
-            PyExc_AttributeError,
-            "Cannot assign a value to __notes__. Use add_note().");
-        return -1;
-    }
-    return 0;
-}
-
 static PyObject *
 BaseException_get_tb(PyBaseExceptionObject *self, void *Py_UNUSED(ignored))
 {
@@ -370,7 +354,6 @@ BaseException_set_cause(PyObject *self, PyObject *arg, void *Py_UNUSED(ignored))
 static PyGetSetDef BaseException_getset[] = {
     {"__dict__", PyObject_GenericGetDict, PyObject_GenericSetDict},
     {"args", (getter)BaseException_get_args, (setter)BaseException_set_args},
-    {"__notes__", (getter)BaseException_get_notes, (setter)BaseException_set_notes},
     {"__traceback__", (getter)BaseException_get_tb, (setter)BaseException_set_tb},
     {"__context__", BaseException_get_context,
      BaseException_set_context, PyDoc_STR("exception context")},
@@ -930,9 +913,17 @@ exceptiongroup_subset(
     PyException_SetContext(eg, PyException_GetContext(orig));
     PyException_SetCause(eg, PyException_GetCause(orig));
 
-    PyObject *notes = _PyBaseExceptionObject_cast(orig)->notes;
-    Py_XINCREF(notes);
-    _PyBaseExceptionObject_cast(eg)->notes = notes;
+    if (PyObject_HasAttr(orig, &_Py_ID(__notes__))) {
+        PyObject *notes = PyObject_GetAttr(orig, &_Py_ID(__notes__));
+        if (notes == NULL) {
+            goto error;
+        }
+        if (PyObject_SetAttr(eg, &_Py_ID(__notes__), notes) < 0) {
+            Py_DECREF(notes);
+            goto error;
+        }
+        Py_DECREF(notes);
+    }
 
     *result = eg;
     return 0;

@@ -1137,40 +1137,48 @@ print_exception_notes(struct exception_print_context *ctx, PyObject *value)
         return 0;
     }
 
+    if (!PyObject_HasAttr(value, &_Py_ID(__notes__))) {
+        return 0;
+    }
     PyObject *notes = PyObject_GetAttr(value, &_Py_ID(__notes__));
     if (notes == NULL) {
         return -1;
     }
-    if (!PyTuple_Check(notes)) {
+    if (!PySequence_Check(notes)) {
         Py_DECREF(notes);
         return 0;
     }
-    Py_ssize_t num_notes = PyTuple_GET_SIZE(notes);
+    Py_ssize_t num_notes = PySequence_Length(notes);
     PyObject *lines = NULL;
     for (Py_ssize_t ni = 0; ni < num_notes; ni++) {
-        PyObject *note = PyTuple_GET_ITEM(notes, ni);
-        assert(PyUnicode_Check(note));
-        lines = PyUnicode_Splitlines(note, 1);
-        if (lines == NULL) {
-            Py_DECREF(notes);
-            return -1;
-        }
-
-        Py_ssize_t n = PyList_GET_SIZE(lines);
-        for (Py_ssize_t i = 0; i < n; i++) {
-            PyObject *line = PyList_GET_ITEM(lines, i);
-            assert(PyUnicode_Check(line));
-            if (write_indented_margin(ctx, f) < 0) {
+        PyObject *note = PySequence_GetItem(notes, ni);
+        if (PyUnicode_Check(note)) {
+            lines = PyUnicode_Splitlines(note, 1);
+            Py_DECREF(note);
+            if (lines == NULL) {
                 goto error;
             }
-            if (PyFile_WriteObject(line, f, Py_PRINT_RAW) < 0) {
+
+            Py_ssize_t n = PyList_GET_SIZE(lines);
+            for (Py_ssize_t i = 0; i < n; i++) {
+                PyObject *line = PyList_GET_ITEM(lines, i);
+                assert(PyUnicode_Check(line));
+                if (write_indented_margin(ctx, f) < 0) {
+                    goto error;
+                }
+                if (PyFile_WriteObject(line, f, Py_PRINT_RAW) < 0) {
+                    goto error;
+                }
+            }
+            if (PyFile_WriteString("\n", f) < 0) {
                 goto error;
             }
+            Py_CLEAR(lines);
         }
-        if (PyFile_WriteString("\n", f) < 0) {
-            goto error;
+        else {
+            /* Ignore notes which are not strings */
+            Py_DECREF(note);
         }
-        Py_CLEAR(lines);
     }
 
     Py_DECREF(notes);