[ENH] Setting migration

Orange/widgets/settings.py

@@ -47,6 +47,8 @@
 
 _IMMUTABLES = (str, int, bytes, bool, float, tuple)
 
+VERSION_KEY = "__version__"
+
 
 class Setting:
     """Description of a setting.
@@ -386,6 +388,7 @@ def read_defaults_file(self, settings_file):
             for key, value in defaults.items()
             if not isinstance(value, Setting)
         }
+        self._migrate_settings(self.defaults)
 
     def write_defaults(self):
         """Write (global) defaults for this widget class to a file.
@@ -434,12 +437,18 @@ def initialize(self, instance, data=None):
 
         if isinstance(data, bytes):
             data = pickle.loads(data)
+        self._migrate_settings(data)
 
         if provider is self.provider:
             data = self._add_defaults(data)
 
         provider.initialize(instance, data)
 
+    def _migrate_settings(self, settings):
+        """Ask widget to migrate settings to the latest version."""
+        if settings:
+            self.widget_class.migrate_settings(settings, settings.pop(VERSION_KEY, None))
+
     def _select_provider(self, instance):
         provider = self.provider.get_provider(instance.__class__)
         if provider is None:
@@ -473,7 +482,9 @@ def pack_data(self, widget):
         ----------
         widget : OWWidget
         """
-        return self.provider.pack(widget)
+        packed_settings = self.provider.pack(widget)
+        packed_settings[VERSION_KEY] = self.widget_class.settings_version
+        return packed_settings
 
     def update_defaults(self, widget):
         """
@@ -588,6 +599,7 @@ def initialize(self, instance, data=None):
         super().initialize(instance, data)
         if data and "context_settings" in data:
             instance.context_settings = data["context_settings"]
+            self._migrate_contexts(instance.context_settings)
         else:
             instance.context_settings = []
 
@@ -596,16 +608,23 @@ def read_defaults_file(self, settings_file):
            pickle."""
         super().read_defaults_file(settings_file)
         self.global_contexts = pickle.load(settings_file)
+        self._migrate_contexts(self.global_contexts)
+
+    def _migrate_contexts(self, contexts):
+        for context in contexts:
+            self.widget_class.migrate_context(context, context.values.pop(VERSION_KEY, None))
 
     def write_defaults_file(self, settings_file):
         """Call the inherited method, then add global context to the pickle."""
         super().write_defaults_file(settings_file)
         pickle.dump(self.global_contexts, settings_file, -1)
 
     def pack_data(self, widget):
-        """Call the inherited method, then add local contexts to the pickle."""
+        """Call the inherited method, then add local contexts to the dict."""
         data = super().pack_data(widget)
         self.settings_from_widget(widget)
+        for context in widget.context_settings:
+            context.values[VERSION_KEY] = self.widget_class.settings_version
         data["context_settings"] = widget.context_settings
         return data
 

Orange/widgets/tests/test_context_handler.py

@@ -1,34 +1,112 @@
-from copy import copy
+import pickle
+from copy import copy, deepcopy
+from io import BytesIO
 from unittest import TestCase
-from unittest.mock import Mock
-from Orange.widgets.settings import ContextHandler, Setting, ContextSetting, Context
+from unittest.mock import Mock, patch, call
+from Orange.widgets.settings import ContextHandler, Setting, ContextSetting, Context, VERSION_KEY
 
 __author__ = 'anze'
 
 
 class SimpleWidget:
+    settings_version = 1
+
     setting = Setting(42)
 
     context_setting = ContextSetting(42)
 
+    migrate_settings = Mock()
+    migrate_context = Mock()
+
+
+class DummyContext(Context):
+    id = 0
+
+    def __init__(self, version=None):
+        super().__init__()
+        DummyContext.id += 1
+        self.id = DummyContext.id
+        if version:
+            self.values[VERSION_KEY] = version
+
+    def __repr__(self):
+        return "Context(id={})".format(self.id)
+    __str__ = __repr__
+
+    def __eq__(self, other):
+        if not isinstance(other, DummyContext):
+            return False
+        return self.id == other.id
+
+
+def create_defaults_file(contexts):
+    b = BytesIO()
+    pickle.dump({"x": 5}, b)
+    pickle.dump(contexts, b)
+    b.seek(0)
+    return b
+
 
 class TestContextHandler(TestCase):
+    def test_read_defaults(self):
+        contexts = [DummyContext() for _ in range(3)]
+
+        handler = ContextHandler()
+        handler.widget_class = SimpleWidget
+
+        # Old settings without version
+        migrate_context = Mock()
+        with patch.object(SimpleWidget, "migrate_context", migrate_context):
+            handler.read_defaults_file(create_defaults_file(contexts))
+        self.assertSequenceEqual(handler.global_contexts, contexts)
+        migrate_context.assert_has_calls([call(c, None) for c in contexts])
+
+        # Settings with version
+        contexts = [DummyContext(version=i) for i in range(1, 4)]
+        migrate_context.reset_mock()
+        with patch.object(SimpleWidget, "migrate_context", migrate_context):
+            handler.read_defaults_file(create_defaults_file(contexts))
+        self.assertSequenceEqual(handler.global_contexts, contexts)
+        migrate_context.assert_has_calls([call(c, c.values[VERSION_KEY]) for c in contexts])
+
     def test_initialize(self):
         handler = ContextHandler()
         handler.provider = Mock()
+        handler.widget_class = SimpleWidget
 
         # Context settings from data
         widget = SimpleWidget()
-        handler.initialize(widget, {'context_settings': 5})
+        context_settings = [DummyContext()]
+        handler.initialize(widget, {'context_settings': context_settings})
         self.assertTrue(hasattr(widget, 'context_settings'))
-        self.assertEqual(widget.context_settings, 5)
+        self.assertEqual(widget.context_settings, context_settings)
 
         # Default (global) context settings
         widget = SimpleWidget()
         handler.initialize(widget)
         self.assertTrue(hasattr(widget, 'context_settings'))
         self.assertEqual(widget.context_settings, handler.global_contexts)
 
+    def test_initialize_migrates_contexts(self):
+        handler = ContextHandler()
+        handler.bind(SimpleWidget)
+
+        widget = SimpleWidget()
+
+        # Old settings without version
+        contexts = [DummyContext() for _ in range(3)]
+        migrate_context = Mock()
+        with patch.object(SimpleWidget, "migrate_context", migrate_context):
+            handler.initialize(widget, dict(context_settings=contexts))
+        migrate_context.assert_has_calls([call(c, None) for c in contexts])
+
+        # Settings with version
+        contexts = [DummyContext(version=i) for i in range(1, 4)]
+        migrate_context = Mock()
+        with patch.object(SimpleWidget, "migrate_context", migrate_context):
+            handler.initialize(widget, dict(context_settings=deepcopy(contexts)))
+        migrate_context.assert_has_calls([call(c, c.values[VERSION_KEY]) for c in contexts])
+
     def test_fast_save(self):
         handler = ContextHandler()
         handler.bind(SimpleWidget)
@@ -68,3 +146,16 @@ def test_find_or_create_context(self):
         self.assertEqual(context.i, 5)
         self.assertEqual([c.i for c in widget.context_settings], [5, 2])
         self.assertEqual([c.i for c in handler.global_contexts], [3, 7])
+
+    def test_pack_settings_stores_version(self):
+        handler = ContextHandler()
+        handler.bind(SimpleWidget)
+
+        widget = SimpleWidget()
+        handler.initialize(widget)
+        widget.context_setting = [DummyContext() for _ in range(3)]
+
+        settings = handler.pack_data(widget)
+        self.assertIn("context_settings", settings)
+        for c in settings["context_settings"]:
+            self.assertIn(VERSION_KEY, c.values)