aait 2.0.2.17__tar.gz → 2.0.2.18__tar.gz

{aait-2.0.2.17 → aait-2.0.2.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: aait
-Version: 2.0.2.17
+Version: 2.0.2.18
 Summary: Advanced Artificial Intelligence Tools is a package meant to develop and enable advanced AI functionalities in Orange
 Home-page: 
 Author: Orange community

{aait-2.0.2.17 → aait-2.0.2.18}/aait.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: aait
-Version: 2.0.2.17
+Version: 2.0.2.18
 Summary: Advanced Artificial Intelligence Tools is a package meant to develop and enable advanced AI functionalities in Orange
 Home-page: 
 Author: Orange community

{aait-2.0.2.17 → aait-2.0.2.18}/aait.egg-info/SOURCES.txt

@@ -236,14 +236,4 @@ orangecontrib/AAIT/widgets/icons/processdocuments.svg
 orangecontrib/AAIT/widgets/icons/qwen-color.png
 orangecontrib/AAIT/widgets/icons/startloop.png
 orangecontrib/AAIT/widgets/icons/tools.png
-orangecontrib/AAIT/widgets/icons/widgetFactory.svg
-tests/test_class_values_context_handler.py
-tests/test_credentials.py
-tests/test_domain_context_handler.py
-tests/test_gui.py
-tests/test_matplotlib_export.py
-tests/test_perfect_domain_context_handler.py
-tests/test_scatterplot_density.py
-tests/test_settings_handler.py
-tests/test_widgets_outputs.py
-tests/test_workflows.py
+orangecontrib/AAIT/widgets/icons/widgetFactory.svg

aait-2.0.2.18/aait.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[orange.widgets]
+Advanced Artificial Intelligence Tools = orangecontrib.AAIT.widgets

{aait-2.0.2.17 → aait-2.0.2.18}/aait.egg-info/requires.txt

@@ -1,4 +1,4 @@
-torch==2.7.1
+torch
 sentence-transformers==5.0.0
 gpt4all[all]==2.8.2
 sacremoses==0.1.1
@@ -16,4 +16,3 @@ python-docx==1.1.2
 psutil
 thefuzz==0.22.1
 beautifulsoup4==4.12.3
-CATEGORIT==0.0.0.7

{aait-2.0.2.17 → aait-2.0.2.18}/setup.py

@@ -4,7 +4,7 @@ from setuptools import setup, find_packages
 NAME = "aait"
 
 # Version du package PyPI
-VERSION = "2.0.2.17"  # la version doit être supérieure à la précédente sinon la publication sera refusée
+VERSION = "2.0.2.18"  # la version doit être supérieure à la précédente sinon la publication sera refusée
 
 # Facultatif / Adaptable à souhait
 AUTHOR = "Orange community"
@@ -36,7 +36,7 @@ PACKAGE_DATA = {
 # Dépendances
 
 INSTALL_REQUIRES = [
-    "torch==2.7.1",
+    "torch",
     "sentence-transformers==5.0.0",
     "gpt4all[all]==2.8.2",
     "sacremoses==0.1.1",
@@ -53,24 +53,14 @@ INSTALL_REQUIRES = [
     "python-docx==1.1.2",
     "psutil",
     "thefuzz==0.22.1",
-    "beautifulsoup4==4.12.3",
-    "CATEGORIT==0.0.0.7"]
+    "beautifulsoup4==4.12.3"]
 
 
 # Spécifie le dossier contenant les widgets et le nom de section qu'aura l'addon sur Orange
 ENTRY_POINTS = {
     "orange.widgets": (
-        "Advanced Artificial Intelligence Tools = orangecontrib.AAIT.widgets",
-        "AAIT - API = orangecontrib.API.widgets",
-        "AAIT - MODELS = orangecontrib.LLM_MODELS.widgets",
-        "AAIT - LLM INTEGRATION = orangecontrib.LLM_INTEGRATION.widgets",
-        "AAIT - TOOLBOX = orangecontrib.TOOLBOX.widgets",
-        "AAIT - ALGORITHM = orangecontrib.ALGORITHM.widgets",
-    ),
-    "orange.widgets.tutorials": (
-        "AAIT Tutorials = orangecontrib.AAIT.tutorials",
+        "Advanced Artificial Intelligence Tools = orangecontrib.AAIT.widgets"
     )
-    
 }
 # /!\ les noms de fichier 'orangecontrib.hkh_bot.widgets' doivent correspondre à l'arborescence
 

aait-2.0.2.17/aait.egg-info/entry_points.txt

@@ -1,10 +0,0 @@
-[orange.widgets]
-AAIT - ALGORITHM = orangecontrib.ALGORITHM.widgets
-AAIT - API = orangecontrib.API.widgets
-AAIT - LLM INTEGRATION = orangecontrib.LLM_INTEGRATION.widgets
-AAIT - MODELS = orangecontrib.LLM_MODELS.widgets
-AAIT - TOOLBOX = orangecontrib.TOOLBOX.widgets
-Advanced Artificial Intelligence Tools = orangecontrib.AAIT.widgets
-
-[orange.widgets.tutorials]
-AAIT Tutorials = orangecontrib.AAIT.tutorials

aait-2.0.2.17/tests/test_class_values_context_handler.py

@@ -1,75 +0,0 @@
-from unittest import TestCase
-from unittest.mock import Mock
-from Orange.data import DiscreteVariable, Domain
-from Orange.data import ContinuousVariable
-from Orange.widgets.settings import ContextSetting, ClassValuesContextHandler
-from Orange.widgets.utils import vartype
-
-Continuous = vartype(ContinuousVariable("x"))
-Discrete = vartype(DiscreteVariable("x"))
-
-
-class TestClassValuesContextHandler(TestCase):
-    def setUp(self):
-        self.domain = Domain(
-            attributes=[ContinuousVariable('c1'),
-                        DiscreteVariable('d1', values='abc'),
-                        DiscreteVariable('d2', values='def')],
-            class_vars=[DiscreteVariable('d3', values='ghi')],
-            metas=[ContinuousVariable('c2'),
-                   DiscreteVariable('d4', values='jkl')]
-        )
-        self.args = (self.domain,
-                     {'c1': Continuous, 'd1': Discrete,
-                      'd2': Discrete, 'd3': Discrete},
-                     {'c2': Continuous, 'd4': Discrete, })
-        self.handler = ClassValuesContextHandler()
-        self.handler.read_defaults = lambda: None
-
-    def test_open_context(self):
-        self.handler.bind(SimpleWidget)
-        context = Mock(
-            classes=['g', 'h', 'i'], values=dict(
-                text='u',
-                with_metas=[('d1', Discrete), ('d2', Discrete)]
-            ))
-        self.handler.global_contexts = \
-            [Mock(classes=[], values={}), context, Mock(classes=[], values={})]
-
-        widget = SimpleWidget()
-        self.handler.initialize(widget)
-        self.handler.open_context(widget, self.args[0].class_var)
-        self.assertEqual(widget.text, 'u')
-        self.assertEqual(widget.with_metas, [('d1', Discrete),
-                                             ('d2', Discrete)])
-
-    def test_open_context_with_no_match(self):
-        self.handler.bind(SimpleWidget)
-        context = Mock(
-            classes=['g', 'h', 'i'], values=dict(
-                text='u',
-                with_metas=[('d1', Discrete), ('d2', Discrete)]
-            ))
-        self.handler.global_contexts = \
-            [Mock(classes=[], values={}), context, Mock(classes=(), values={})]
-        widget = SimpleWidget()
-        self.handler.initialize(widget)
-        widget.text = 'u'
-
-        self.handler.open_context(widget, self.args[0][1])
-
-        context = widget.current_context
-        self.assertEqual(context.classes, ('a', 'b', 'c'))
-        self.assertEqual(widget.text, 'u')
-        self.assertEqual(widget.with_metas, [])
-
-
-class SimpleWidget:
-    text = ContextSetting("")
-    with_metas = ContextSetting([])
-    required = ContextSetting("", required=ContextSetting.REQUIRED)
-
-    def retrieveSpecificSettings(self):
-        pass
-    def storeSpecificSettings(self):
-        pass

aait-2.0.2.17/tests/test_credentials.py

@@ -1,76 +0,0 @@
-import unittest
-from unittest.mock import patch
-
-import keyring
-import keyring.errors
-import keyring.backend
-
-from Orange.widgets.credentials import CredentialManager
-
-
-# minimal in-memory keyring implementation so the test is not dependent on
-# the system config/services.
-class Keyring(keyring.backend.KeyringBackend):
-    priority = 0
-
-    def __init__(self):
-        self.__store = {}
-
-    def set_password(self, service, username, password=None):
-        self.__store[(service, username)] = password
-
-    def get_password(self, service, username):
-        return self.__store.get((service, username), None)
-
-    def delete_password(self, service, username):
-        try:
-            del self.__store[service, username]
-        except KeyError:
-            raise keyring.errors.PasswordDeleteError()
-
-
-class TestCredentialManager(unittest.TestCase):
-    def setUp(self):
-        self._ring = keyring.get_keyring()
-        keyring.set_keyring(Keyring())
-        self.cm = CredentialManager('Orange')
-
-    def tearDown(self):
-        keyring.set_keyring(self._ring)
-
-    def test_credential_manager(self):
-        cm = CredentialManager('Orange')
-        cm.key = 'Foo'
-        self.assertEqual(cm.key, 'Foo')
-        del cm.key
-        self.assertEqual(cm.key, None)
-
-    def test_set_password(self):
-        """
-        Handle error when setting password fails.
-        GH-2354
-        """
-        with patch("keyring.set_password", side_effect=Exception), \
-                patch("Orange.widgets.credentials.log.exception") as log:
-            self.cm.key = ""
-            log.assert_called()
-
-    def test_delete_password(self):
-        """
-        Handling error when deleting password fails
-        GH-2354
-        """
-        with patch("keyring.delete_password", side_effect=Exception), \
-                patch("Orange.widgets.credentials.log.exception") as log:
-            del self.cm.key
-            log.assert_called()
-
-    def test_get_password(self):
-        """
-        Handling errors when getting password fails.
-        GH-2354
-        """
-        with patch("keyring.get_password", side_effect=Exception), \
-                patch("Orange.widgets.credentials.log.exception") as log:
-            self.assertEqual(self.cm.key, None)
-            log.assert_called()

aait-2.0.2.17/tests/test_domain_context_handler.py

@@ -1,401 +0,0 @@
-import warnings
-from unittest import TestCase
-from unittest.mock import Mock
-
-from Orange.data import Domain, DiscreteVariable
-from Orange.data import ContinuousVariable
-from Orange.util import OrangeDeprecationWarning
-from Orange.widgets.settings import DomainContextHandler, ContextSetting
-from Orange.widgets.utils import vartype
-
-Continuous = 100 + vartype(ContinuousVariable("x"))
-Discrete = 100 + vartype(DiscreteVariable("x"))
-
-
-class TestDomainContextHandler(TestCase):
-    def setUp(self):
-        self.domain = Domain(
-            attributes=[ContinuousVariable('c1'),
-                        DiscreteVariable('d1', values='abc'),
-                        DiscreteVariable('d2', values='def')],
-            class_vars=[DiscreteVariable('d3', values='ghi')],
-            metas=[ContinuousVariable('c2'),
-                   DiscreteVariable('d4', values='jkl')]
-        )
-        self.args = (self.domain,
-                     {'c1': Continuous - 100, 'd1': Discrete - 100,
-                      'd2': Discrete - 100, 'd3': Discrete - 100},
-                     {'c2': Continuous - 100, 'd4': Discrete - 100, })
-        self.handler = DomainContextHandler()
-        self.handler.read_defaults = lambda: None
-
-    def test_encode_domain_with_match_none(self):
-        handler = DomainContextHandler(
-            match_values=DomainContextHandler.MATCH_VALUES_NONE)
-
-        encoded_attributes, encoded_metas = handler.encode_domain(self.domain)
-
-        self.assertEqual(encoded_attributes,
-                         {'c1': Continuous - 100, 'd1': Discrete - 100,
-                          'd2': Discrete - 100, 'd3': Discrete - 100})
-        self.assertEqual(encoded_metas,
-                         {'c2': Continuous - 100, 'd4': Discrete - 100, })
-
-    def test_encode_domain_with_match_class(self):
-        handler = DomainContextHandler(
-            match_values=DomainContextHandler.MATCH_VALUES_CLASS)
-
-        encoded_attributes, encoded_metas = handler.encode_domain(self.domain)
-
-        self.assertEqual(encoded_attributes,
-                         {'c1': Continuous - 100, 'd1': Discrete - 100,
-                          'd2': Discrete - 100,
-                          'd3': tuple('ghi')})
-        self.assertEqual(encoded_metas,
-                         {'c2': Continuous - 100, 'd4': Discrete - 100})
-
-    def test_encode_domain_with_match_all(self):
-        handler = DomainContextHandler(
-            match_values=DomainContextHandler.MATCH_VALUES_ALL)
-
-        encoded_attributes, encoded_metas = handler.encode_domain(self.domain)
-
-        self.assertEqual(encoded_attributes,
-                         {'c1': Continuous - 100, 'd1': tuple('abc'),
-                          'd2': tuple('def'), 'd3': tuple('ghi')})
-        self.assertEqual(encoded_metas,
-                         {'c2': Continuous - 100, 'd4': tuple('jkl')})
-
-    def test_match_returns_1_if_everything_matches(self):
-        self.handler.bind(SimpleWidget)
-
-        # Attributes in values
-        context = Mock(values=dict(
-            with_metas=('d1', Discrete),
-            required=('d1', Discrete)))
-        self.assertEqual(1., self.handler.match(context, *self.args))
-
-        # Metas in values
-        context = Mock(values=dict(
-            with_metas=('d4', Discrete),
-            required=('d1', Discrete)))
-        self.assertEqual(1., self.handler.match(context, *self.args))
-
-        # Attributes in lists
-        context = Mock(values=dict(
-            with_metas=[("d1", Discrete)]
-        ))
-        self.assertEqual(1., self.handler.match(context, *self.args))
-
-        # Metas in lists
-        context = Mock(values=dict(
-            with_metas=[("d4", Discrete)]
-        ))
-        self.assertEqual(1., self.handler.match(context, *self.args))
-
-    def test_match_when_nothing_to_match(self):
-        self.handler.bind(SimpleWidget)
-
-        context = Mock(values={})
-        self.assertEqual(0.1, self.handler.match(context, *self.args))
-
-    def test_match_returns_zero_on_incompatible_context(self):
-        self.handler.bind(SimpleWidget)
-
-        # required
-        context = Mock(values=dict(required=('u', Discrete),
-                                   with_metas=('d1', Discrete)))
-        self.assertEqual(0, self.handler.match(context, *self.args))
-
-    def test_clone_context(self):
-        self.handler.bind(SimpleWidget)
-        context = self.create_context(self.domain, dict(
-            text=('u', -2),
-            with_metas=[('d1', Discrete), ('d1', Continuous),
-                        ('c1', Continuous), ('c1', Discrete)],
-            required=('u', Continuous)
-        ))
-
-        new_values = self.handler.clone_context(context, *self.args).values
-
-        self.assertEqual(new_values['text'], ('u', -2))
-        self.assertEqual([('d1', Discrete), ('c1', Continuous)],
-                         new_values['with_metas'])
-        self.assertNotIn('required', new_values)
-
-    def test_open_context(self):
-        self.handler.bind(SimpleWidget)
-        context = self.create_context(self.domain, dict(
-            text=('u', -2),
-            with_metas=[('d1', Discrete), ('d2', Discrete)]
-        ))
-        self.handler.global_contexts = \
-            [context, Mock(values={})]
-
-        widget = SimpleWidget()
-        self.handler.initialize(widget)
-        old_metas_list = widget.with_metas
-        self.handler.open_context(widget, self.args[0])
-
-        context = widget.current_context
-        self.assertEqual(context.attributes, self.args[1])
-        self.assertEqual(context.metas, self.args[2])
-        self.assertIs(old_metas_list, widget.with_metas)
-
-        self.assertEqual(widget.text, 'u')
-        self.assertEqual(widget.with_metas, [('d1', Discrete),
-                                             ('d2', Discrete)])
-
-    def test_open_context_with_imperfect_match(self):
-        self.handler.bind(SimpleWidget)
-        context = self.create_context(None, dict(
-            text=('u', -2),
-            with_metas=[('d1', Discrete), ('d1', Continuous),
-                        ('c1', Continuous), ('c1', Discrete)]
-        ))
-        self.handler.global_contexts = \
-            [context, Mock(values={})]
-
-        widget = SimpleWidget()
-        self.handler.initialize(widget)
-        self.handler.open_context(widget, self.args[0])
-
-        context = widget.current_context
-        self.assertEqual(context.attributes, self.args[1])
-        self.assertEqual(context.metas, self.args[2])
-
-        self.assertEqual(widget.text, 'u')
-        self.assertEqual(widget.with_metas, [('d1', Discrete),
-                                             ('c1', Continuous)])
-
-    def test_open_context_not_first_match(self):
-        self.handler.bind(SimpleWidget)
-        context = self.create_context(None, dict(
-            text=('u', -2),
-            with_metas=[('d1', Discrete), ('d1', Continuous),
-                        ('c1', Continuous), ('c1', Discrete)]
-        ))
-        self.handler.global_contexts = \
-            [Mock(values={}), context, Mock(values={})]
-        self.handler.first_match = False
-
-        widget = SimpleWidget()
-        self.handler.initialize(widget)
-        self.handler.open_context(widget, self.args[0])
-
-        context = widget.current_context
-        self.assertEqual(context.attributes, self.args[1])
-        self.assertEqual(context.metas, self.args[2])
-
-        self.assertEqual(widget.text, 'u')
-        self.assertEqual(widget.with_metas, [('d1', Discrete),
-                                             ('c1', Continuous)])
-
-    def test_open_context_with_no_match(self):
-        self.handler.bind(SimpleWidget)
-        widget = SimpleWidget()
-        self.handler.initialize(widget)
-        widget.text = 'u'
-
-        self.handler.open_context(widget, self.args[0])
-
-        self.assertEqual(widget.text, 'u')
-        self.assertEqual(widget.with_metas, [])
-        context = widget.current_context
-        self.assertEqual(context.attributes, self.args[1])
-        self.assertEqual(context.metas, self.args[2])
-        self.assertEqual(context.values['text'], ('u', -2))
-
-    def test_filter_value(self):
-        setting = ContextSetting([])
-        setting.name = "value"
-
-        def test_filter(before_value, after_value):
-            data = dict(value=before_value)
-            self.handler.filter_value(setting, data, *self.args)
-            self.assertEqual(data.get("value", None), after_value)
-
-        # filter list values
-        test_filter([], [])
-        # When list contains attributes asa tuple of (name, type),
-        # Attributes not present in domain should be filtered out
-        test_filter([("d1", Discrete), ("d1", Continuous),
-                     ("c1", Continuous), ("c1", Discrete)],
-                    [("d1", Discrete), ("c1", Continuous)])
-        # All other values in list should remain
-        test_filter([0, [1, 2, 3], "abcd", 5.4], [0, [1, 2, 3], "abcd", 5.4])
-
-    def test_filter_value_dict(self):
-        setting = ContextSetting({})
-        setting.name = "value"
-
-        def test_filter(before_value, after_value):
-            data = dict(value=before_value)
-            self.handler.filter_value(setting, data, *self.args)
-            self.assertEqual(data.get("value", None), after_value)
-
-        # filter list values
-        test_filter({}, {})
-        # When list contains attributes asa tuple of (name, type),
-        # Attributes not present in domain should be filtered out
-        test_filter({("d1", Discrete): 1, ("d1", Continuous): 2,
-                     ("c1", Continuous): 3, ("c1", Discrete): 4},
-                    {("d1", Discrete): 1, ("c1", Continuous): 3})
-        # All other values in list should remain
-        test_filter([0, [1, 2, 3], "abcd", 5.4], [0, [1, 2, 3], "abcd", 5.4])
-
-    def test_encode_setting(self):
-        setting = ContextSetting(None)
-
-        var = self.domain[0]
-        val = self.handler.encode_setting(None, setting, var)
-        self.assertEqual(val, (var.name, 100 + vartype(var)))
-
-        # Should not crash on anonymous variables
-        with self.assertWarns(OrangeDeprecationWarning):
-            var = ContinuousVariable()
-        val = self.handler.encode_setting(None, setting, var)
-        self.assertEqual(val, (var.name, 100 + vartype(var)))
-
-    def test_encode_list_settings(self):
-        setting = ContextSetting(None)
-
-        var1, var2 = self.domain[:2]
-        val = self.handler.encode_setting(None, setting, [None, var1, var2])
-        self.assertEqual(
-            val,
-            ([None,
-              (var1.name, 100 + vartype(var1)),
-              (var2.name, 100 + vartype(var2))], -3))
-
-        a_list = [1, 2, 3]
-        val = self.handler.encode_setting(None, setting, a_list)
-        self.assertEqual(val, [1, 2, 3])
-        self.assertIsNot(val, a_list)
-
-        a_list = []
-        val = self.handler.encode_setting(None, setting, a_list)
-        self.assertEqual(val, [])
-        self.assertIsNot(val, a_list)
-
-        a_list = [None, None]
-        val = self.handler.encode_setting(None, setting, a_list)
-        self.assertEqual(val, [None, None])
-        self.assertIsNot(val, a_list)
-
-    def test_encode_dict_settings(self):
-        setting = ContextSetting(None)
-
-        var1, var2 = self.domain[:2]
-        val = self.handler.encode_setting(None, setting, {var1: 1, var2: 2})
-        self.assertEqual(
-            val,
-            ({(var1.name, 100 + vartype(var1)): 1,
-              (var2.name, 100 + vartype(var2)): 2}, -4))
-
-        a_dict = {1: 2, 2: 3, 3: 4}
-        val = self.handler.encode_setting(None, setting, a_dict)
-        self.assertEqual(val, ({1: 2, 2: 3, 3: 4}, -2))
-        self.assertIsNot(val, a_dict)
-
-        a_dict = {}
-        val = self.handler.encode_setting(None, setting, a_dict)
-        self.assertEqual(val, ({}, -4))
-        self.assertIsNot(val, a_dict)
-
-    def test_decode_setting(self):
-        setting = ContextSetting(None)
-
-        var = self.domain[0]
-        val = self.handler.decode_setting(setting, (var.name, 100 + vartype(var)),
-                                          self.domain)
-        self.assertIs(val, var)
-
-        all_metas_domain = Domain([], metas=[var])
-        val = self.handler.decode_setting(setting, (var.name, 100 + vartype(var)),
-                                          all_metas_domain)
-        self.assertIs(val, var)
-
-        self.assertRaises(ValueError,
-                          self.handler.decode_setting,
-                          setting, (var.name, 100 + vartype(var)))
-        self.handler.decode_setting(setting, None, None)
-
-    def test_decode_list_setting(self):
-        setting = ContextSetting(None)
-
-        var1, var2 = self.domain[:2]
-        val = self.handler.decode_setting(
-            setting,
-            ([None,
-              (var1.name, 100 + vartype(var1)),
-              (var2.name, 100 + vartype(var2))], -3),
-            self.domain)
-        self.assertEqual(val, [None, var1, var2])
-
-        val = self.handler.decode_setting(setting, [1, 2, 3], self.domain)
-        self.assertEqual(val, [1, 2, 3])
-
-        self.assertRaises(ValueError,
-                          self.handler.decode_setting,
-                          setting,
-                          ([None,
-                            (var1.name, 100 + vartype(var1)),
-                            (var2.name, 100 + vartype(var2))], -3)
-                          )
-        val = self.handler.decode_setting(setting, ([None, None], -3), None)
-        self.assertEqual(val, [None, None])
-
-
-    def test_decode_dict_setting(self):
-        setting = ContextSetting(None)
-
-        var1, var2 = self.domain[:2]
-        val = self.handler.decode_setting(
-            setting,
-            ({(var1.name, 100 + vartype(var1)): 1,
-              (var2.name, 100 + vartype(var2)): 2}, -4),
-            self.domain)
-        self.assertEqual(val, {var1: 1, var2: 2})
-
-        val = self.handler.decode_setting(
-            setting, ({1: 2, 2: 3, 3: 4}, -2), self.domain)
-        self.assertEqual(val, {1: 2, 2: 3, 3: 4})
-
-        self.assertRaises(ValueError,
-                          self.handler.decode_setting,
-                          setting,
-                          ({(var1.name, 100 + vartype(var1)): 1,
-                            (var2.name, 100 + vartype(var2)): 2}, -4))
-
-        val = self.handler.decode_setting(setting, ({1: 2, 2: 3, 3: 4}, -2))
-        self.assertEqual(val, {1: 2, 2: 3, 3: 4})
-
-
-    def test_backward_compatible_params(self):
-        with warnings.catch_warnings(record=True) as w:
-            warnings.simplefilter("always")
-            DomainContextHandler(metas_in_res=True)
-            self.assertIn(OrangeDeprecationWarning,
-                          [x.category for x in w])
-
-    def create_context(self, domain, values):
-        if domain is None:
-            domain = Domain([])
-
-        context = self.handler.new_context(domain,
-                                           *self.handler.encode_domain(domain))
-        context.values = values
-        return context
-
-
-class SimpleWidget:
-    text = ContextSetting("")
-    with_metas = ContextSetting([], required=ContextSetting.OPTIONAL)
-    required = ContextSetting("", required=ContextSetting.REQUIRED)
-
-    def retrieveSpecificSettings(self):
-        pass
-
-    def storeSpecificSettings(self):
-        pass