inducer · Kevin-Prichard · Jun 24, 2015 · Dec 11, 2017 · Sep 29, 2024 · Sep 29, 2024
diff --git a/pudb/debugger.py b/pudb/debugger.py
@@ -590,7  590,7 @@ def runcall(self, *args, **kwargs):
     labelled_value,
     make_hotkey_markup,
 )
-from pudb.var_view import FrameVarInfoKeeper
 from pudb.var_view import FrameVarInfoKeeper, Watches, WatchExpression
 
 
 # {{{ display setup
@@ -1037,11  1037,7 @@ def change_var_state(w, size, key):
             elif key == "m":
                 iinfo.show_methods = not iinfo.show_methods
             elif key == "delete":
-                fvi = self.get_frame_var_info(read_only=False)
-                for i, watch_expr in enumerate(fvi.watches):
-                    if watch_expr is var.watch_expr:
-                        del fvi.watches[i]
-                        break
                 Watches.remove(var.watch_expr)
 
             self.update_var_view(focus_index=focus_index)
 
@@ -1154,13  1150,15 @@ def edit_inspector_detail(w, size, key):
                     iinfo.access_level = "all"
 
                 if var.watch_expr is not None:
-                    var.watch_expr.expression = watch_edit.get_edit_text()
                     # Remove old expression and add new one, to avoid rehashing
                     Watches.remove(var.watch_expr)
                     var.watch_expr = WatchExpression(
                         watch_edit.get_edit_text())
                     Watches.add(var.watch_expr)
 
             elif result == "del":
-                for i, watch_expr in enumerate(fvi.watches):
-                    if watch_expr is var.watch_expr:
-                        del fvi.watches[i]
-                        break
                 # Remove saved expression
                 Watches.remove(var.watch_expr)
 
             self.update_var_view()
 
@@ -1178,11  1176,11 @@ def insert_watch(w, size, key):
                         ("Cancel", False),
                         ], title="Add Watch Expression"):
 
-                from pudb.var_view import WatchExpression
-                we = WatchExpression(watch_edit.get_edit_text())
-                fvi = self.get_frame_var_info(read_only=False)
-                fvi.watches.append(we)
-                self.update_var_view()
                 # Add new watch expression, if not empty
                 watch_text = watch_edit.get_edit_text()
                 if watch_text and watch_text.strip():
                     Watches.add(WatchExpression(watch_text))
                     self.update_var_view()
 
         self.var_list.listen("\\", change_var_state)
         self.var_list.listen(" ", change_var_state)

diff --git a/pudb/settings.py b/pudb/settings.py
@@ -62,6  62,7 @@ def get_save_config_path():
 
 SAVED_BREAKPOINTS_FILE_NAME = "saved-breakpoints-%d.%d" % sys.version_info[:2]
 BREAKPOINTS_FILE_NAME = "breakpoints-%d.%d" % sys.version_info[:2]
 SAVED_WATCHES_FILE_NAME = "saved-watches-%d.%d" % sys.version_info[:2]
 
 
 _config_ = [None]
@@ -110,6  111,8 @@ def load_config():
     conf_dict.setdefault("wrap_variables", "True")
     conf_dict.setdefault("default_variables_access_level", "public")
 
     conf_dict.setdefault("persist_watches", True)
 
     conf_dict.setdefault("display", "auto")
 
     conf_dict.setdefault("prompt_on_quit", "True")
@@ -134,6  137,7 @@ def normalize_bool_inplace(name):
 
     normalize_bool_inplace("line_numbers")
     normalize_bool_inplace("wrap_variables")
     normalize_bool_inplace("persist_watches")
     normalize_bool_inplace("prompt_on_quit")
     normalize_bool_inplace("hide_cmdline_win")
 
@@ -196,6  200,9 @@ def _update_default_variables_access_level():
     def _update_wrap_variables():
         ui.update_var_view()
 
     def _update_persist_watches():
         pass
 
     def _update_config(check_box, new_state, option_newvalue):
         option, newvalue = option_newvalue
         new_conf_dict = {option: newvalue}
@@ -252,6  259,11 @@ def _update_config(check_box, new_state, option_newvalue):
             conf_dict.update(new_conf_dict)
             _update_wrap_variables()
 
         elif option == "persist_watches":
             new_conf_dict["persist_watches"] = not check_box.get_state()
             conf_dict.update(new_conf_dict)
             _update_persist_watches()
 
     heading = urwid.Text("This is the preferences screen for PuDB. "
         "Hit Ctrl-P at any time to get back to it.\n\n"
         "Configuration settings are saved in "
@@ -416,6  428,17 @@ def _update_config(check_box, new_state, option_newvalue):
 
     # }}}
 
     # {{{ persist watches
 
     cb_persist_watches = urwid.CheckBox("Persist watches",
             bool(conf_dict["persist_watches"]), on_state_change=_update_config,
                 user_data=("persist_watches", None))
 
     persist_watches_info = urwid.Text("\nKeep watched expressions between "
                                       "debugging sessions.")
 
     # }}}
 
     # {{{ display
 
     display_info = urwid.Text("What driver is used to talk to your terminal. "
@@ -469,6  492,10 @@ def _update_config(check_box, new_state, option_newvalue):
               [cb_wrap_variables]
               [wrap_variables_info]
 
               [urwid.AttrMap(urwid.Text("\nPersist Watches:\n"), "group head")]
               [cb_persist_watches]
               [persist_watches_info]
 
               [urwid.AttrMap(urwid.Text("\nDisplay driver:\n"), "group head")]
               [display_info]
               display_rbs
@@ -618,4  645,9 @@ def save_breakpoints(bp_list):
 
 # }}}
 
 
 def get_watches_file_name():
     from os.path import join
     return join(get_save_config_path(), SAVED_WATCHES_FILE_NAME)
 
 # vim:foldmethod=marker
diff --git a/pudb/test/test_var_view.py b/pudb/test/test_var_view.py
@@ -2,6  2,9 @@
 import itertools
 import string
 import unittest
 from unittest.mock import mock_open, patch
 
 import pytest
 
 from pudb.var_view import (
     STRINGIFIERS,
@@ -12,6  15,8 @@
     PudbMapping,
     PudbSequence,
     ValueWalker,
     Watches,
     WatchExpression,
     get_stringifier,
     ui_log,
 )
@@ -402,3  407,135 @@ def test_maybe_unreasonable_classes(self):
         # This effectively makes sure that class definitions aren't considered
         # containers.
         self.assert_class_counts_equal({"other": 2048})
 
 
 class WatchExpressionTests(unittest.TestCase):
     """
     Test class WatchExpression for expected behaviors
     """
 
     def test_watch_expression_sorting(self):
         alpha_watches = [
             WatchExpression("a"),
             WatchExpression("c"),
             WatchExpression("b"),
             WatchExpression("d"),
             WatchExpression("f"),
             WatchExpression("e"),
         ]
         self.assertEqual(
             "".join(sorted(str(watch_expr)
                            for watch_expr in alpha_watches)),
             "abcdef")
 
     def test_hashing(self):
         we_a = WatchExpression("a")
         we_b = WatchExpression("b")
         self.assertEqual(hash(we_a), hash("a"))
         self.assertEqual(hash(we_b), hash("b"))
         self.assertNotEqual(hash(we_a), hash(we_b))
 
     def test_equality(self):
         we_a = WatchExpression("a")
         we_a2 = WatchExpression("a")
         we_b = WatchExpression("b")
         self.assertEqual(we_a, we_a2)
         self.assertNotEqual(we_a, we_b)
 
     def test_repr(self):
         expr = WatchExpression("a")
         self.assertEqual(repr(expr), "a")
 
     def test_str(self):
         expr = WatchExpression("a")
         self.assertEqual(str(expr), "a")
 
     def test_set(self):
         """
         watch expressions should be hashable and comparable,
         and more or less equivalent to class str
         """
         expr = WatchExpression("a")
         self.assertIn(expr, {"a"})
 
         # test set membership
         we_a = WatchExpression("a")
         we_b = WatchExpression("b")
         test_set1 = {we_a, we_b}
         self.assertIn(we_a, test_set1)
         self.assertIn(we_b, test_set1)
 
         # test equivalent sets
         test_set2 = {we_b, we_a}
         self.assertEqual(test_set1, test_set2)
         self.assertIn(we_a, test_set2)
         self.assertIn(we_b, test_set2)
 
         # test adding a duplicate
         test_set2.add(WatchExpression("a"))
         self.assertEqual(test_set1, test_set2)
 
     def test_immutability(self):
         Watches.clear()
         we_a = WatchExpression("a")
         with pytest.raises(AttributeError):
             we_a.expression = "b"
 
 
 class WatchesTests(unittest.TestCase):
     """
     Test class Watches for expected behavior
     """
 
     def tearDown(self):
         # Since Watches is a global object, we must clear out after each test
         Watches.clear()
 
     def test_add_watch(self):
         we_z = WatchExpression("z")
         Watches.add(we_z)
         self.assertIn(we_z, Watches.all())
 
     def test_add_watches(self):
         watch_expressions_file_log = []
 
         def mocked_file_write(*args):
             watch_expressions_file_log.append(args)
 
         mocked_open = mock_open()
         # mock the write method of the file object
         mocked_open.return_value.write = mocked_file_write
         we_a = WatchExpression("a")
         we_b = WatchExpression("b")
         we_c = WatchExpression("c")
         expressions = [we_a, we_b, we_c]
 
         """
         The expressions file is cumulative, writing out whatever
         current set of expressions Watches contains,
         so we expect to see: [a], [a], [b], [a], [b], [c]
         """
         expected_file_log = []
         for i in range(len(expressions)):
             for expr in expressions[:i   1]:
                 expected_file_log.append((f"{str(expr)}\n", ))
 
         with patch("builtins.open", mocked_open):
             Watches.add(we_a)
             Watches.add(we_b)
             Watches.add(we_c)
 
         self.assertEqual(len(watch_expressions_file_log), 6)
         self.assertEqual(watch_expressions_file_log, expected_file_log)
 
         self.assertIn(we_a, Watches.all())
         self.assertIn(we_b, Watches.all())
         self.assertIn(we_c, Watches.all())
 
     def test_remove_watch(self):
         we_z = WatchExpression("z")
         Watches.add(we_z)
         self.assertTrue(Watches.has(we_z))
         Watches.remove(we_z)
         self.assertFalse(Watches.has(we_z))
         self.assertEqual(len(Watches.all()), 0)