def test_encode_domain_with_false_attributes_in_res(self): handler = DomainContextHandler(attributes_in_res=False, metas_in_res=True) encoded_attributes, encoded_metas = handler.encode_domain(self.domain) self.assertEqual(encoded_attributes, {}) self.assertEqual(encoded_metas, {'c2': Continuous, 'd4': Discrete})
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, 'd1': Discrete, 'd2': Discrete, 'd3': list('ghi')}) self.assertEqual(encoded_metas, {'c2': Continuous, 'd4': Discrete})
def test_encode_domain_with_false_attributes_in_res(self): handler = DomainContextHandler(attributes_in_res=False, metas_in_res=True) encoded_attributes, encoded_metas = handler.encode_domain(domain) self.assertEqual(encoded_attributes, {}) self.assertEqual(encoded_metas, { CONTINUOUS_META: Continuous, DISCRETE_META_JKL: Discrete, })
def test_encode_domain_with_match_none(self): handler = DomainContextHandler( match_values=DomainContextHandler.MATCH_VALUES_NONE, metas_in_res=True) encoded_attributes, encoded_metas = handler.encode_domain(self.domain) self.assertEqual(encoded_attributes, {'c1': Continuous, 'd1': Discrete, 'd2': Discrete, 'd3': Discrete}) self.assertEqual(encoded_metas, {'c2': Continuous, 'd4': Discrete, })
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': list('abc'), 'd2': list('def'), 'd3': list('ghi')}) self.assertEqual(encoded_metas, {'c2': Continuous - 100, 'd4': list('jkl')})
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, 'd1': list('abc'), 'd2': list('def'), 'd3': list('ghi')}) self.assertEqual(encoded_metas, {'c2': Continuous, 'd4': list('jkl')})
def test_encode_domain_with_false_metas_in_res(self): handler = DomainContextHandler(attributes_in_res=True, metas_in_res=False) encoded_attributes, encoded_metas = handler.encode_domain(domain) self.assertEqual(encoded_attributes, { CONTINOUS_ATTR: Continuous, DISCRETE_ATTR_ABC: Discrete, DISCRETE_ATTR_DEF: Discrete, DISCRETE_CLASS_GHI: Discrete, }) self.assertEqual(encoded_metas, {})
def test_encode_domain_with_false_metas_in_res(self): handler = DomainContextHandler(attributes_in_res=True, metas_in_res=False) encoded_attributes, encoded_metas = handler.encode_domain(domain) self.assertEqual( encoded_attributes, { CONTINOUS_ATTR: Continuous, DISCRETE_ATTR_ABC: Discrete, DISCRETE_ATTR_DEF: Discrete, DISCRETE_CLASS_GHI: Discrete, }) self.assertEqual(encoded_metas, {})
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, "d1": list("abc"), "d2": list("def"), "d3": list("ghi") }, ) self.assertEqual(encoded_metas, {"c2": Continuous, "d4": list("jkl")})
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, "d1": Discrete, "d2": Discrete, "d3": list("ghi") }, ) self.assertEqual(encoded_metas, {"c2": Continuous, "d4": Discrete})
def test_encode_domain_with_match_class(self): handler = DomainContextHandler( match_values=DomainContextHandler.MATCH_VALUES_CLASS, metas_in_res=True) encoded_attributes, encoded_metas = handler.encode_domain(domain) self.assertEqual(encoded_attributes, { CONTINOUS_ATTR: Continuous, DISCRETE_ATTR_ABC: Discrete, DISCRETE_ATTR_DEF: Discrete, DISCRETE_CLASS_GHI: ["g", "h", "i"], }) self.assertEqual(encoded_metas, { CONTINUOUS_META: Continuous, DISCRETE_META_JKL: Discrete, })
def test_encode_domain_with_match_all(self): handler = DomainContextHandler( match_values=DomainContextHandler.MATCH_VALUES_ALL, metas_in_res=True) encoded_attributes, encoded_metas = handler.encode_domain(domain) self.assertEqual(encoded_attributes, { CONTINOUS_ATTR: Continuous, DISCRETE_ATTR_ABC: ["a", "b", "c"], DISCRETE_ATTR_DEF: ["d", "e", "f"], DISCRETE_CLASS_GHI: ["g", "h", "i"], }) self.assertEqual(encoded_metas, { CONTINUOUS_META: Continuous, DISCRETE_META_JKL: ["j", "k", "l"], })
def test_encode_domain_with_match_none(self): handler = DomainContextHandler( match_values=DomainContextHandler.MATCH_VALUES_NONE, metas_in_res=True) encoded_attributes, encoded_metas = handler.encode_domain(domain) self.assertEqual( encoded_attributes, {CONTINOUS_ATTR: VarTypes.Continuous, DISCRETE_ATTR_ABC: VarTypes.Discrete, DISCRETE_ATTR_DEF: VarTypes.Discrete, DISCRETE_CLASS_GHI: VarTypes.Discrete, }) self.assertEqual( encoded_metas, {CONTINUOUS_META: VarTypes.Continuous, DISCRETE_META_JKL: VarTypes.Discrete, })
def test_encode_domain_with_match_class(self): handler = DomainContextHandler( match_values=DomainContextHandler.MATCH_VALUES_CLASS, metas_in_res=True) encoded_attributes, encoded_metas = handler.encode_domain(domain) self.assertEqual( encoded_attributes, { CONTINOUS_ATTR: Continuous, DISCRETE_ATTR_ABC: Discrete, DISCRETE_ATTR_DEF: Discrete, DISCRETE_CLASS_GHI: ["g", "h", "i"], }) self.assertEqual(encoded_metas, { CONTINUOUS_META: Continuous, DISCRETE_META_JKL: Discrete, })
def test_encode_domain_with_match_all(self): handler = DomainContextHandler( match_values=DomainContextHandler.MATCH_VALUES_ALL, metas_in_res=True) encoded_attributes, encoded_metas = handler.encode_domain(domain) self.assertEqual( encoded_attributes, { CONTINOUS_ATTR: Continuous, DISCRETE_ATTR_ABC: ["a", "b", "c"], DISCRETE_ATTR_DEF: ["d", "e", "f"], DISCRETE_CLASS_GHI: ["g", "h", "i"], }) self.assertEqual(encoded_metas, { CONTINUOUS_META: Continuous, DISCRETE_META_JKL: ["j", "k", "l"], })
class DomainContextHandlerTestCase(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 = DomainContextHandler(metas_in_res=True) self.handler.read_defaults = lambda: None def test_encode_domain_with_match_none(self): handler = DomainContextHandler( match_values=DomainContextHandler.MATCH_VALUES_NONE, metas_in_res=True) encoded_attributes, encoded_metas = handler.encode_domain(self.domain) self.assertEqual(encoded_attributes, { 'c1': Continuous, 'd1': Discrete, 'd2': Discrete, 'd3': Discrete }) self.assertEqual(encoded_metas, { 'c2': Continuous, 'd4': Discrete, }) def test_encode_domain_with_match_class(self): handler = DomainContextHandler( match_values=DomainContextHandler.MATCH_VALUES_CLASS, metas_in_res=True) encoded_attributes, encoded_metas = handler.encode_domain(self.domain) self.assertEqual(encoded_attributes, { 'c1': Continuous, 'd1': Discrete, 'd2': Discrete, 'd3': list('ghi') }) self.assertEqual(encoded_metas, {'c2': Continuous, 'd4': Discrete}) def test_encode_domain_with_match_all(self): handler = DomainContextHandler( match_values=DomainContextHandler.MATCH_VALUES_ALL, metas_in_res=True) encoded_attributes, encoded_metas = handler.encode_domain(self.domain) self.assertEqual( encoded_attributes, { 'c1': Continuous, 'd1': list('abc'), 'd2': list('def'), 'd3': list('ghi') }) self.assertEqual(encoded_metas, {'c2': Continuous, 'd4': list('jkl')}) def test_encode_domain_with_false_attributes_in_res(self): handler = DomainContextHandler(attributes_in_res=False, metas_in_res=True) encoded_attributes, encoded_metas = handler.encode_domain(self.domain) self.assertEqual(encoded_attributes, {}) self.assertEqual(encoded_metas, {'c2': Continuous, 'd4': Discrete}) def test_encode_domain_with_false_metas_in_res(self): handler = DomainContextHandler(attributes_in_res=True, metas_in_res=False) encoded_attributes, encoded_metas = handler.encode_domain(self.domain) self.assertEqual(encoded_attributes, { 'c1': Continuous, 'd1': Discrete, 'd2': Discrete, 'd3': Discrete }) self.assertEqual(encoded_metas, {}) def test_match_returns_2_on_perfect_match(self): context = Mock(attributes=self.args[1], metas=self.args[2], values={}) self.assertEqual(2., self.handler.match(context, *self.args)) 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_returns_point_1_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)) # selected if_selected context = Mock(values=dict(with_metas=('d1', Discrete), if_selected=[('u', Discrete)], selected=[0])) self.assertEqual(0, self.handler.match(context, *self.args)) # unselected if_selected context = Mock(values=dict(with_metas=('d1', Discrete), if_selected=[('u', Discrete), ('d1', Discrete)], selected=[1])) self.assertAlmostEqual(0.667, self.handler.match(context, *self.args), places=2) 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 = \ [Mock(values={}), 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.assertSequenceEqual(context.ordered_domain, (('c1', Continuous), ('d1', Discrete), ('d2', Discrete), ('d3', Discrete), ('c2', Continuous), ('d4', Discrete))) 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)], if_selected=[('c1', Discrete), ('c1', Continuous), ('d1', Discrete), ('d1', Continuous)], selected=[2], )) self.handler.global_contexts = \ [Mock(values={}), 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.assertSequenceEqual(context.ordered_domain, (('c1', Continuous), ('d1', Discrete), ('d2', Discrete), ('d3', Discrete), ('c2', Continuous), ('d4', Discrete))) self.assertEqual(widget.text, 'u') self.assertEqual(widget.with_metas, [('d1', Discrete), ('c1', Continuous)]) self.assertEqual(widget.if_selected, [('c1', Continuous), ('d1', Discrete)]) self.assertEqual(widget.selected, [1]) 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.assertSequenceEqual(context.ordered_domain, (('c1', Continuous), ('d1', Discrete), ('d2', Discrete), ('d3', Discrete), ('c2', Continuous), ('d4', Discrete))) self.assertEqual(context.values['text'], ('u', -2)) def create_context(self, domain, values): if not domain: domain = Domain([]) context = self.handler.new_context(domain, *self.handler.encode_domain(domain)) context.values = values return context
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, "d1": Discrete, "d2": Discrete, "d3": Discrete }, { "c2": Continuous, "d4": Discrete }, ) 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, "d1": Discrete, "d2": Discrete, "d3": Discrete }, ) self.assertEqual(encoded_metas, {"c2": Continuous, "d4": Discrete}) 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, "d1": Discrete, "d2": Discrete, "d3": list("ghi") }, ) self.assertEqual(encoded_metas, {"c2": Continuous, "d4": Discrete}) 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, "d1": list("abc"), "d2": list("def"), "d3": list("ghi") }, ) self.assertEqual(encoded_metas, {"c2": Continuous, "d4": list("jkl")}) def test_match_returns_2_on_perfect_match(self): context = Mock(attributes=self.args[1], metas=self.args[2], values={}) self.assertEqual(2.0, self.handler.match(context, *self.args)) 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.0, self.handler.match(context, *self.args)) # Metas in values context = Mock( values=dict(with_metas=("d4", Discrete), required=("d1", Discrete))) self.assertEqual(1.0, self.handler.match(context, *self.args)) # Attributes in lists context = Mock(values=dict(with_metas=[("d1", Discrete)])) self.assertEqual(1.0, self.handler.match(context, *self.args)) # Metas in lists context = Mock(values=dict(with_metas=[("d4", Discrete)])) self.assertEqual(1.0, self.handler.match(context, *self.args)) def test_match_returns_point_1_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)) # selected if_selected context = Mock(values=dict(with_metas=("d1", Discrete), if_selected=[("u", Discrete)], selected=[0])) self.assertEqual(0, self.handler.match(context, *self.args)) # unselected if_selected context = Mock(values=dict( with_metas=("d1", Discrete), if_selected=[("u", Discrete), ("d1", Discrete)], selected=[1], )) self.assertAlmostEqual(0.667, self.handler.match(context, *self.args), places=2) 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 = [ Mock(values={}), 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), ("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), ], if_selected=[ ("c1", Discrete), ("c1", Continuous), ("d1", Discrete), ("d1", Continuous), ], selected=[2], ), ) self.handler.global_contexts = [ Mock(values={}), 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)]) self.assertEqual(widget.if_selected, [("c1", Continuous), ("d1", Discrete)]) self.assertEqual(widget.selected, [1]) 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_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 var.name = "" val = self.handler.encode_setting(None, setting, var) self.assertEqual(val, (var.name, 100 + vartype(var))) 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) 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 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 DomainContextSettingsHandlerTests(unittest.TestCase): def setUp(self): self.handler = DomainContextHandler(attributes_in_res=True, metas_in_res=True) self.handler.read_defaults = lambda: None # Disable reading settings from disk self.handler.bind(MockWidget) self.widget = MockWidget() encoded_attributes, encoded_metas = self.handler.encode_domain(domain) self.widget.current_context.attributes = encoded_attributes self.widget.current_context.metas = encoded_metas self.handler.initialize(self.widget) self.handler.initialize(self.widget.subprovider) self.handler.open_context(self.widget, domain) def test_settings_from_widget(self): widget = self.widget widget.ordinary_setting = VALUE widget.string_setting = VALUE widget.list_setting = [1, 2, 3] widget.dict_setting = {1: 2} widget.continuous_setting = CONTINOUS_ATTR widget.discrete_setting = DISCRETE_ATTR_ABC widget.class_setting = DISCRETE_CLASS_GHI widget.excluded_meta_setting = DISCRETE_META_JKL widget.meta_setting = DISCRETE_META_JKL self.handler.settings_from_widget(widget) values = widget.current_context.values self.assertEqual((VALUE, UNKNOWN_TYPE), values['ordinary_setting']) self.assertEqual((VALUE, UNKNOWN_TYPE), values['string_setting']) self.assertEqual([1, 2, 3], values['list_setting']) self.assertEqual(({1: 2}, UNKNOWN_TYPE), values['dict_setting']) self.assertEqual((CONTINOUS_ATTR, Continuous), values['continuous_setting']) self.assertEqual((DISCRETE_ATTR_ABC, Discrete), values['discrete_setting']) self.assertEqual((DISCRETE_CLASS_GHI, Discrete), values['class_setting']) self.assertEqual((DISCRETE_META_JKL, UNKNOWN_TYPE), values['excluded_meta_setting']) self.assertEqual((DISCRETE_META_JKL, Discrete), values['meta_setting']) def test_settings_to_widget(self): self.widget.current_context.values = dict( string_setting=(VALUE, -2), continuous_setting=(CONTINOUS_ATTR, Continuous), discrete_setting=(DISCRETE_ATTR_ABC, Discrete), list_setting=[1, 2, 3], attr_list_setting=[DISCRETE_ATTR_ABC, DISCRETE_CLASS_GHI], selection1=[0], attr_tuple_list_setting=[(DISCRETE_META_JKL, Discrete), (CONTINUOUS_META, Continuous)], selection2=[1], ) self.handler.settings_to_widget(self.widget) self.assertEqual(self.widget.string_setting, VALUE) self.assertEqual(self.widget.continuous_setting, CONTINOUS_ATTR) self.assertEqual(self.widget.discrete_setting, DISCRETE_ATTR_ABC) self.assertEqual(self.widget.list_setting, [1, 2, 3]) self.assertEqual(self.widget.attr_list_setting, [DISCRETE_ATTR_ABC, DISCRETE_CLASS_GHI]) self.assertEqual(self.widget.attr_tuple_list_setting, [DISCRETE_META_JKL, CONTINUOUS_META]) self.assertEqual(self.widget.selection1, [0]) self.assertEqual(self.widget.selection2, [1]) def test_settings_to_widget_filters_selections(self): self.widget.current_context.values = dict( attr_list_setting=[DISCRETE_META_JKL, DISCRETE_ATTR_ABC, CONTINUOUS_META, DISCRETE_CLASS_GHI], selection1=[1, 2], ) self.handler.settings_to_widget(self.widget) self.assertEqual(self.widget.attr_list_setting, [DISCRETE_ATTR_ABC, DISCRETE_CLASS_GHI]) self.assertEqual(self.widget.selection1, [0]) def test_perfect_match_returns_2(self): attrs, metas = self.handler.encode_domain(domain) mock_context = Mock(attributes=attrs, metas=metas, values={}) self.assertEqual(self.match(mock_context), 2.) def test_match_when_nothing_to_match_returns_point_1(self): attrs, metas = self.handler.encode_domain(domain) mock_context = Mock(values={}) self.assertEqual(self.match(mock_context), 0.1) def test_match_if_all_values_match_returns_1(self): mock_context = Mock(values=dict( discrete_setting=(DISCRETE_ATTR_ABC, Discrete), required_setting=(DISCRETE_ATTR_ABC, Discrete), )) self.assertEqual(self.match(mock_context), 1.) def test_match_if_all_list_values_match_returns_1(self): mock_context = Mock(values=dict( discrete_setting=("df1", Discrete) )) self.assertEqual(self.match(mock_context), 1.) def test_match_if_all_required_list_values_match_returns_1(self): mock_context = Mock(values=dict( required_setting=(DISCRETE_ATTR_ABC, Discrete) )) self.assertEqual(self.match(mock_context), 1.) def test_clone_context(self): mock_context = Mock(values=dict( required_setting=(DISCRETE_ATTR_ABC, Discrete) )) attrs, metas = self.handler.encode_domain(domain) cloned_context = self.handler.clone_context(mock_context, domain, attrs, metas) self.assertEqual(cloned_context.values, mock_context.values) def add_setting(self, widget, name, setting): setting.name = name setattr(widget, name, setting.default) self.handler.provider.settings[name] = setting def match(self, context): attrs, metas = self.handler.encode_domain(domain) return self.handler.match(context, None, attrs, metas) def test_initialize_sets_current_context(self): self.widget = MockWidget() del self.widget.current_context self.handler.initialize(self.widget) self.assertIs(self.widget.current_context, None)
class DomainContextHandlerTestCase(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 = DomainContextHandler(metas_in_res=True) self.handler.read_defaults = lambda: None def test_encode_domain_with_match_none(self): handler = DomainContextHandler( match_values=DomainContextHandler.MATCH_VALUES_NONE, metas_in_res=True) encoded_attributes, encoded_metas = handler.encode_domain(self.domain) self.assertEqual(encoded_attributes, {'c1': Continuous, 'd1': Discrete, 'd2': Discrete, 'd3': Discrete}) self.assertEqual(encoded_metas, {'c2': Continuous, 'd4': Discrete, }) def test_encode_domain_with_match_class(self): handler = DomainContextHandler( match_values=DomainContextHandler.MATCH_VALUES_CLASS, metas_in_res=True) encoded_attributes, encoded_metas = handler.encode_domain(self.domain) self.assertEqual(encoded_attributes, {'c1': Continuous, 'd1': Discrete, 'd2': Discrete, 'd3': list('ghi')}) self.assertEqual(encoded_metas, {'c2': Continuous, 'd4': Discrete}) def test_encode_domain_with_match_all(self): handler = DomainContextHandler( match_values=DomainContextHandler.MATCH_VALUES_ALL, metas_in_res=True) encoded_attributes, encoded_metas = handler.encode_domain(self.domain) self.assertEqual(encoded_attributes, {'c1': Continuous, 'd1': list('abc'), 'd2': list('def'), 'd3': list('ghi')}) self.assertEqual(encoded_metas, {'c2': Continuous, 'd4': list('jkl')}) def test_encode_domain_with_false_attributes_in_res(self): handler = DomainContextHandler(attributes_in_res=False, metas_in_res=True) encoded_attributes, encoded_metas = handler.encode_domain(self.domain) self.assertEqual(encoded_attributes, {}) self.assertEqual(encoded_metas, {'c2': Continuous, 'd4': Discrete}) def test_encode_domain_with_false_metas_in_res(self): handler = DomainContextHandler(attributes_in_res=True, metas_in_res=False) encoded_attributes, encoded_metas = handler.encode_domain(self.domain) self.assertEqual(encoded_attributes, {'c1': Continuous, 'd1': Discrete, 'd2': Discrete, 'd3': Discrete}) self.assertEqual(encoded_metas, {}) def test_match_returns_2_on_perfect_match(self): context = Mock( attributes=self.args[1], metas=self.args[2], values={}) self.assertEqual(2., self.handler.match(context, *self.args)) 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_returns_point_1_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)) # selected if_selected context = Mock(values=dict(with_metas=('d1', Discrete), if_selected=[('u', Discrete)], selected=[0])) self.assertEqual(0, self.handler.match(context, *self.args)) # unselected if_selected context = Mock(values=dict(with_metas=('d1', Discrete), if_selected=[('u', Discrete), ('d1', Discrete)], selected=[1])) self.assertAlmostEqual(0.667, self.handler.match(context, *self.args), places=2) 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 = \ [Mock(values={}), 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.assertSequenceEqual(context.ordered_domain, (('c1', Continuous), ('d1', Discrete), ('d2', Discrete), ('d3', Discrete), ('c2', Continuous), ('d4', Discrete))) 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)], if_selected=[('c1', Discrete), ('c1', Continuous), ('d1', Discrete), ('d1', Continuous)], selected=[2], )) self.handler.global_contexts = \ [Mock(values={}), 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.assertSequenceEqual(context.ordered_domain, (('c1', Continuous), ('d1', Discrete), ('d2', Discrete), ('d3', Discrete), ('c2', Continuous), ('d4', Discrete))) self.assertEqual(widget.text, 'u') self.assertEqual(widget.with_metas, [('d1', Discrete), ('c1', Continuous)]) self.assertEqual(widget.if_selected, [('c1', Continuous), ('d1', Discrete)]) self.assertEqual(widget.selected, [1]) 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.assertSequenceEqual(context.ordered_domain, (('c1', Continuous), ('d1', Discrete), ('d2', Discrete), ('d3', Discrete), ('c2', Continuous), ('d4', Discrete))) self.assertEqual(context.values['text'], ('u', -2)) def create_context(self, domain, values): if not domain: domain = Domain([]) context = self.handler.new_context(domain, *self.handler.encode_domain(domain)) context.values = values return context
class DomainContextSettingsHandlerTests(unittest.TestCase): def setUp(self): self.handler = DomainContextHandler(attributes_in_res=True, metas_in_res=True) self.handler.read_defaults = lambda: None # Disable reading settings from disk self.handler.bind(MockWidget) self.widget = MockWidget() encoded_attributes, encoded_metas = self.handler.encode_domain(domain) self.widget.current_context.attributes = encoded_attributes self.widget.current_context.metas = encoded_metas self.handler.initialize(self.widget) self.handler.initialize(self.widget.subprovider) self.handler.open_context(self.widget, domain) def test_settings_from_widget(self): widget = self.widget widget.ordinary_setting = VALUE widget.string_setting = VALUE widget.list_setting = [1, 2, 3] widget.dict_setting = {1: 2} widget.continuous_setting = CONTINOUS_ATTR widget.discrete_setting = DISCRETE_ATTR_ABC widget.class_setting = DISCRETE_CLASS_GHI widget.excluded_meta_setting = DISCRETE_META_JKL widget.meta_setting = DISCRETE_META_JKL self.handler.settings_from_widget(widget) values = widget.current_context.values self.assertEqual((VALUE, UNKNOWN_TYPE), values['ordinary_setting']) self.assertEqual((VALUE, UNKNOWN_TYPE), values['string_setting']) self.assertEqual([1, 2, 3], values['list_setting']) self.assertEqual(({1: 2}, UNKNOWN_TYPE), values['dict_setting']) self.assertEqual((CONTINOUS_ATTR, Continuous), values['continuous_setting']) self.assertEqual((DISCRETE_ATTR_ABC, Discrete), values['discrete_setting']) self.assertEqual((DISCRETE_CLASS_GHI, Discrete), values['class_setting']) self.assertEqual((DISCRETE_META_JKL, UNKNOWN_TYPE), values['excluded_meta_setting']) self.assertEqual((DISCRETE_META_JKL, Discrete), values['meta_setting']) def test_settings_to_widget(self): self.widget.current_context.values = dict( string_setting=(VALUE, -2), continuous_setting=(CONTINOUS_ATTR, Continuous), discrete_setting=(DISCRETE_ATTR_ABC, Discrete), list_setting=[1, 2, 3], attr_list_setting=[DISCRETE_ATTR_ABC, DISCRETE_CLASS_GHI], selection1=[0], attr_tuple_list_setting=[(DISCRETE_META_JKL, Discrete), (CONTINUOUS_META, Continuous)], selection2=[1], ) self.handler.settings_to_widget(self.widget) self.assertEqual(self.widget.string_setting, VALUE) self.assertEqual(self.widget.continuous_setting, CONTINOUS_ATTR) self.assertEqual(self.widget.discrete_setting, DISCRETE_ATTR_ABC) self.assertEqual(self.widget.list_setting, [1, 2, 3]) self.assertEqual(self.widget.attr_list_setting, [DISCRETE_ATTR_ABC, DISCRETE_CLASS_GHI]) self.assertEqual(self.widget.attr_tuple_list_setting, [DISCRETE_META_JKL, CONTINUOUS_META]) self.assertEqual(self.widget.selection1, [0]) self.assertEqual(self.widget.selection2, [1]) def test_settings_to_widget_filters_selections(self): self.widget.current_context.values = dict( attr_list_setting=[ DISCRETE_META_JKL, DISCRETE_ATTR_ABC, CONTINUOUS_META, DISCRETE_CLASS_GHI ], selection1=[1, 2], ) self.handler.settings_to_widget(self.widget) self.assertEqual(self.widget.attr_list_setting, [DISCRETE_ATTR_ABC, DISCRETE_CLASS_GHI]) self.assertEqual(self.widget.selection1, [0]) def test_perfect_match_returns_2(self): attrs, metas = self.handler.encode_domain(domain) mock_context = Mock(attributes=attrs, metas=metas, values={}) self.assertEqual(self.match(mock_context), 2.) def test_match_when_nothing_to_match_returns_point_1(self): attrs, metas = self.handler.encode_domain(domain) mock_context = Mock(values={}) self.assertEqual(self.match(mock_context), 0.1) def test_match_if_all_values_match_returns_1(self): mock_context = Mock(values=dict( discrete_setting=(DISCRETE_ATTR_ABC, Discrete), required_setting=(DISCRETE_ATTR_ABC, Discrete), )) self.assertEqual(self.match(mock_context), 1.) def test_match_if_all_list_values_match_returns_1(self): mock_context = Mock(values=dict(discrete_setting=("df1", Discrete))) self.assertEqual(self.match(mock_context), 1.) def test_match_if_all_required_list_values_match_returns_1(self): mock_context = Mock(values=dict(required_setting=(DISCRETE_ATTR_ABC, Discrete))) self.assertEqual(self.match(mock_context), 1.) def test_clone_context(self): mock_context = Mock(values=dict(required_setting=(DISCRETE_ATTR_ABC, Discrete))) attrs, metas = self.handler.encode_domain(domain) cloned_context = self.handler.clone_context(mock_context, domain, attrs, metas) self.assertEqual(cloned_context.values, mock_context.values) def add_setting(self, widget, name, setting): setting.name = name setattr(widget, name, setting.default) self.handler.provider.settings[name] = setting def match(self, context): attrs, metas = self.handler.encode_domain(domain) return self.handler.match(context, None, attrs, metas) def test_initialize_sets_current_context(self): self.widget = MockWidget() del self.widget.current_context self.handler.initialize(self.widget) self.assertIs(self.widget.current_context, None)
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, 'd1': Discrete, 'd2': Discrete, 'd3': Discrete}, {'c2': Continuous, 'd4': Discrete, }) self.handler = DomainContextHandler(metas_in_res=True) self.handler.read_defaults = lambda: None def test_encode_domain_with_match_none(self): handler = DomainContextHandler( match_values=DomainContextHandler.MATCH_VALUES_NONE, metas_in_res=True) encoded_attributes, encoded_metas = handler.encode_domain(self.domain) self.assertEqual(encoded_attributes, {'c1': Continuous, 'd1': Discrete, 'd2': Discrete, 'd3': Discrete}) self.assertEqual(encoded_metas, {'c2': Continuous, 'd4': Discrete, }) def test_encode_domain_with_match_class(self): handler = DomainContextHandler( match_values=DomainContextHandler.MATCH_VALUES_CLASS, metas_in_res=True) encoded_attributes, encoded_metas = handler.encode_domain(self.domain) self.assertEqual(encoded_attributes, {'c1': Continuous, 'd1': Discrete, 'd2': Discrete, 'd3': list('ghi')}) self.assertEqual(encoded_metas, {'c2': Continuous, 'd4': Discrete}) def test_encode_domain_with_match_all(self): handler = DomainContextHandler( match_values=DomainContextHandler.MATCH_VALUES_ALL, metas_in_res=True) encoded_attributes, encoded_metas = handler.encode_domain(self.domain) self.assertEqual(encoded_attributes, {'c1': Continuous, 'd1': list('abc'), 'd2': list('def'), 'd3': list('ghi')}) self.assertEqual(encoded_metas, {'c2': Continuous, 'd4': list('jkl')}) def test_encode_domain_with_false_attributes_in_res(self): handler = DomainContextHandler(attributes_in_res=False, metas_in_res=True) encoded_attributes, encoded_metas = handler.encode_domain(self.domain) self.assertEqual(encoded_attributes, {}) self.assertEqual(encoded_metas, {'c2': Continuous, 'd4': Discrete}) def test_encode_domain_with_false_metas_in_res(self): handler = DomainContextHandler(attributes_in_res=True, metas_in_res=False) encoded_attributes, encoded_metas = handler.encode_domain(self.domain) self.assertEqual(encoded_attributes, {'c1': Continuous, 'd1': Discrete, 'd2': Discrete, 'd3': Discrete}) self.assertEqual(encoded_metas, {}) def test_match_returns_2_on_perfect_match(self): context = Mock( attributes=self.args[1], metas=self.args[2], values={}) self.assertEqual(2., self.handler.match(context, *self.args)) 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_returns_point_1_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)) # selected if_selected context = Mock(values=dict(with_metas=('d1', Discrete), if_selected=[('u', Discrete)], selected=[0])) self.assertEqual(0, self.handler.match(context, *self.args)) # unselected if_selected context = Mock(values=dict(with_metas=('d1', Discrete), if_selected=[('u', Discrete), ('d1', Discrete)], selected=[1])) self.assertAlmostEqual(0.667, self.handler.match(context, *self.args), places=2) 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 = \ [Mock(values={}), 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.assertSequenceEqual(context.ordered_domain, (('c1', Continuous), ('d1', Discrete), ('d2', Discrete), ('d3', Discrete), ('c2', Continuous), ('d4', Discrete))) 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)], if_selected=[('c1', Discrete), ('c1', Continuous), ('d1', Discrete), ('d1', Continuous)], selected=[2], )) self.handler.global_contexts = \ [Mock(values={}), 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.assertSequenceEqual(context.ordered_domain, (('c1', Continuous), ('d1', Discrete), ('d2', Discrete), ('d3', Discrete), ('c2', Continuous), ('d4', Discrete))) self.assertEqual(widget.text, 'u') self.assertEqual(widget.with_metas, [('d1', Discrete), ('c1', Continuous)]) self.assertEqual(widget.if_selected, [('c1', Continuous), ('d1', Discrete)]) self.assertEqual(widget.selected, [1]) 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.assertSequenceEqual(context.ordered_domain, (('c1', Continuous), ('d1', Discrete), ('d2', Discrete), ('d3', Discrete), ('c2', Continuous), ('d4', Discrete))) 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_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))) 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) def create_context(self, domain, values): if not domain: domain = Domain([]) context = self.handler.new_context(domain, *self.handler.encode_domain(domain)) context.values = values return context
class DomainContextSettingsHandlerTests(unittest.TestCase): def setUp(self): self.handler = DomainContextHandler(attributes_in_res=True, metas_in_res=True) self.handler.read_defaults = lambda: None # Disable reading from disk self.domain = self._create_domain() def test_encode_domain_with_match_none(self): self.handler.match_values = self.handler.MATCH_VALUES_NONE encoded_attributes, encoded_metas = \ self.handler.encode_domain(self.domain) self.assertEqual(encoded_attributes, { 'cf1': VarTypes.Continuous, 'df1': VarTypes.Discrete, 'df2': VarTypes.Discrete, 'dc1': VarTypes.Discrete, }) self.assertEqual(encoded_metas, { 'cm1': VarTypes.Continuous, 'dm1': VarTypes.Discrete, }) def test_encode_domain_with_match_class(self): self.handler.match_values = self.handler.MATCH_VALUES_CLASS encoded_attributes, encoded_metas = \ self.handler.encode_domain(self.domain) self.assertEqual(encoded_attributes, { 'cf1': VarTypes.Continuous, 'df1': VarTypes.Discrete, 'df2': VarTypes.Discrete, 'dc1': ["g", "h", "i"], }) self.assertEqual(encoded_metas, { 'cm1': VarTypes.Continuous, 'dm1': VarTypes.Discrete, }) def test_encode_domain_with_match_all(self): self.handler.match_values = self.handler.MATCH_VALUES_ALL encoded_attributes, encoded_metas = \ self.handler.encode_domain(self.domain) self.assertEqual(encoded_attributes, { 'cf1': VarTypes.Continuous, 'df1': ["a", "b", "c"], 'df2': ["d", "e", "f"], 'dc1': ["g", "h", "i"], }) self.assertEqual(encoded_metas, { 'cm1': VarTypes.Continuous, 'dm1': ["j", "k", "l"], }) def test_encode_domain_with_false_attributes_in_res(self): self.handler = DomainContextHandler(attributes_in_res=False, metas_in_res=True) encoded_attributes, encoded_metas = \ self.handler.encode_domain(self.domain) self.assertEqual(encoded_attributes, {}) self.assertEqual(encoded_metas, { 'cm1': VarTypes.Continuous, 'dm1': VarTypes.Discrete, }) def test_encode_domain_with_false_metas_in_res(self): self.handler = DomainContextHandler(attributes_in_res=True, metas_in_res=False) encoded_attributes, encoded_metas = \ self.handler.encode_domain(self.domain) self.assertEqual(encoded_attributes, { 'cf1': VarTypes.Continuous, 'df1': VarTypes.Discrete, 'df2': VarTypes.Discrete, 'dc1': VarTypes.Discrete, }) self.assertEqual(encoded_metas, {}) def test_settings_from_widget(self): widget = MockWidget() widget.current_context.attributes, widget.current_context.metas = \ self.handler.encode_domain(self.domain) self.add_setting(widget, "string_setting", ContextSetting("abc")) self.add_setting(widget, "list_setting", ContextSetting([1, 2, 3])) self.add_setting(widget, "dict_setting", ContextSetting({1: 2})) self.add_setting(widget, "continuous_setting", ContextSetting("cf1")) self.add_setting(widget, "discrete_setting", ContextSetting("df1")) self.add_setting(widget, "class_setting", ContextSetting("dc1")) self.add_setting(widget, "excluded_meta_setting", ContextSetting("dm1")) self.add_setting(widget, "meta_setting", ContextSetting("dm1", exclude_metas=False)) self.handler.settings_from_widget(widget) self.assertEqual(widget.current_context.values, dict( string_setting=("abc", -2), list_setting=[1, 2, 3], dict_setting=({1: 2}, -2), continuous_setting=("cf1", VarTypes.Continuous), discrete_setting=("df1", VarTypes.Discrete), class_setting=("dc1", VarTypes.Discrete), excluded_meta_setting=("dm1", -2), meta_setting=("dm1", VarTypes.Discrete), )) def test_settings_to_widget(self): widget = MockWidget() widget.current_context.attributes, widget.current_context.metas = \ self.handler.encode_domain(self.domain) self.add_setting(widget, "string_setting", ContextSetting("")) self.add_setting(widget, "continuous_setting", ContextSetting("")) self.add_setting(widget, "discrete_setting", ContextSetting("")) self.add_setting(widget, "list_setting", ContextSetting([])) self.add_setting(widget, "attr_list_setting", ContextSetting([], selected="selection1")) self.add_setting(widget, "attr_tuple_list_setting", ContextSetting([], selected="selection2", exclude_metas=False)) widget.current_context.values = dict( string_setting=("abc", -2), continuous_setting=("cf1", VarTypes.Continuous), discrete_setting=("df1", VarTypes.Discrete), list_setting=[1, 2, 3], attr_list_setting=["df1", "dc1"], selection1=[0], attr_tuple_list_setting=[("dm1", VarTypes.Discrete), ("cm1", VarTypes.Continuous)], selection2=[1], ) self.handler.settings_to_widget(widget) self.assertEqual(widget.string_setting, "abc") self.assertEqual(widget.continuous_setting, "cf1") self.assertEqual(widget.discrete_setting, "df1") self.assertEqual(widget.list_setting, [1, 2, 3]) self.assertEqual(widget.attr_list_setting, ["df1", "dc1"]) self.assertEqual(widget.attr_tuple_list_setting, ["dm1", "cm1"]) self.assertEqual(widget.selection1, [0]) self.assertEqual(widget.selection2, [1]) def test_settings_to_widget_filters_selections(self): widget = MockWidget() widget.current_context.attributes, widget.current_context.metas = \ self.handler.encode_domain(self.domain) self.add_setting(widget, "attr_list_setting", ContextSetting([], selected="selection")) widget.current_context.values = dict( string_setting=("abc", -2), continuous_setting=("cf1", VarTypes.Continuous), discrete_setting=("df1", VarTypes.Discrete), list_setting=[1, 2, 3], attr_list_setting=["dm1", "df1", "cm1", "dc1"], selection=[1, 2], ) self.handler.settings_to_widget(widget) self.assertEqual(widget.attr_list_setting, ["df1", "dc1"]) self.assertEqual(widget.selection, [0]) def test_perfect_match_returns_2(self): attrs, metas = self.handler.encode_domain(self.domain) mock_context = Mock(attributes=attrs, metas=metas, values={}) self.assertEqual(self.handler.match(mock_context, None, attrs, metas), 2.) def test_match_when_nothing_to_match_returns_point_1(self): attrs, metas = self.handler.encode_domain(self.domain) mock_context = Mock(values={}) self.assertEqual(self.handler.match(mock_context, None, attrs, metas), 0.1) def test_match_if_all_values_match_returns_1(self): attrs, metas = self.handler.encode_domain(self.domain) mock_context = Mock(values={}) self.add_setting(mock_context, "setting", ContextSetting("")) self.add_setting(mock_context, "required_setting", ContextSetting("", required=ContextSetting.REQUIRED)) mock_context.values["setting"] = ("df1", VarTypes.Discrete) mock_context.values["required_setting"] = ("df1", VarTypes.Discrete) self.assertEqual(self.handler.match(mock_context, None, attrs, metas), 1.) def test_match_if_all_list_values_match_returns_1(self): attrs, metas = self.handler.encode_domain(self.domain) mock_context = Mock(values={}) self.add_setting(mock_context, "setting", ContextSetting("")) mock_context.values["setting"] = [("df1", VarTypes.Discrete)] self.assertEqual(self.handler.match(mock_context, None, attrs, metas), 1.) def test_match_if_all_required_list_values_match_returns_1(self): attrs, metas = self.handler.encode_domain(self.domain) mock_context = Mock(values={}) self.add_setting(mock_context, "required_setting", ContextSetting("", required=ContextSetting.REQUIRED)) mock_context.values["required_setting"] = [("df1", VarTypes.Discrete)] self.assertEqual(self.handler.match(mock_context, None, attrs, metas), 1.) def add_setting(self, widget, name, setting): setting.name = name setattr(widget, name, setting.default) self.handler.settings[name] = setting def _create_domain(self): features = [ ContinuousVariable(name="cf1"), DiscreteVariable(name="df1", values=["a", "b", "c"]), DiscreteVariable(name="df2", values=["d", "e", "f"]) ] class_vars = [ DiscreteVariable(name="dc1", values=["g", "h", "i"]) ] metas = [ ContinuousVariable(name="cm1"), DiscreteVariable(name="dm1", values=["j", "k", "l"]), ] return Domain(features, class_vars, metas)
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': list('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': list('abc'), 'd2': list('def'), 'd3': list('ghi')}) self.assertEqual(encoded_metas, {'c2': Continuous - 100, 'd4': list('jkl')}) def test_match_returns_2_on_perfect_match(self): context = Mock( attributes=self.args[1], metas=self.args[2], values={}) self.assertEqual(2., self.handler.match(context, *self.args)) 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_returns_point_1_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 = \ [Mock(values={}), 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 = \ [Mock(values={}), 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_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_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 var.name = "" 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_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) 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]) 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 test_deprecated_str_as_var(self): if LooseVersion(Orange.__version__) >= LooseVersion("3.26"): # pragma: no cover self.fail("Remove support for variables stored as string settings " "and this test.") context = Mock() context.attributes = {"foo": 2} context.metas = {} setting = ContextSetting("") setting.name = "setting_name" with warnings.catch_warnings(record=True) as w: warnings.simplefilter("always") DomainContextHandler.encode_setting(context, setting, "foo") self.assertIn("setting_name", w[0].message.args[0]) 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