def test_item(self):
d = orange.Domain(self.vars)
self.assertEqual(d[2], self.vars[2])
self.assertEqual(d[9], self.vars[9])
#self.assertEqual(d[-1], d.class_var)
with self.assertRaises(IndexError):
d[-2]
self.assertEqual(d[2], self.vars[2])
self.assertEqual(d[self.vars[-1].name], self.vars[-1])
with self.assertRaises(IndexError):
d["foo"]
self.assertEqual(d[self.vars[2]], self.vars[2])
self.assertEqual(d[self.vars[-1]], self.vars[-1])
with self.assertRaises(IndexError):
d[orange.ContinuousVariable("foo")]
with self.assertRaises(IndexError):
d[orange.ContinuousVariable("a")]
a = orange.Variable.make("a", orange.Variable.Type.Continuous)[0]
self.assertIs(a, self.vars[0])
self.assertEqual(d[a], self.vars[0])
with self.assertRaises(TypeError):
d[orange]
def setUp(self):
self.domain = orange.Domain([
orange.ContinuousVariable("a"),
orange.ContinuousVariable("b"),
orange.DiscreteVariable("c", values="abc")
])
self.data = orange.ExampleTable(self.domain)
def test_saveTab(self):
d = orange.ExampleTable("iris")[:3]
d.save("test-save.tab")
try:
d2 = orange.ExampleTable("test-save.tab")
for e1, e2 in zip(d, d2):
self.assertEqual(e1, e2)
finally:
os.remove("test-save.tab")
dom = orange.Domain([orange.ContinuousVariable("a")])
d = orange.ExampleTable(dom)
d += [[i] for i in range(3)]
d.save("test-save.tab")
try:
d2 = orange.ExampleTable("test-save.tab")
self.assertEqual(len(d.domain.attributes), 0)
self.assertEqual(d.domain.classVar, dom[0])
for i in range(3):
self.assertEqual(d2[i], [i])
finally:
os.remove("test-save.tab")
dom = orange.Domain([orange.ContinuousVariable("a")], None)
d = orange.ExampleTable(dom)
d += [[i] for i in range(3)]
d.save("test-save.tab")
try:
d2 = orange.ExampleTable("test-save.tab")
self.assertEqual(len(d.domain.attributes), 1)
self.assertEqual(d.domain[0], dom[0])
for i in range(3):
self.assertEqual(d2[i], [i])
finally:
os.remove("test-save.tab")
def test_aliases(self):
d = orange.Domain([])
id = orange.newmetaid()
d.addmeta(id, orange.ContinuousVariable())
d.hasmeta(id)
id = orange.newmetaid()
d.add_meta(id, orange.ContinuousVariable())
d.has_meta(id)
def test_addGaussianClassNoise(self):
self.assertRaises(ValueError,
orange.Preprocessor_addGaussianClassNoise, self.data)
domain = orange.Domain(
[orange.ContinuousVariable("a"),
orange.ContinuousVariable("b")])
data = orange.ExampleTable(domain)
data += [[0, 0]] * 12 + [[1, 1]] * 12 + [[2, 2]] * 12
d2 = orange.Preprocessor_addGaussianClassNoise(data, deviation=1)
cd = len([e for e in d2 if float(e[0]) == float(e[1])])
self.assertLessEqual(cd, 2)
def test_in(self):
i = self.ll[1] in self.l
self.assertTrue(i)
i = orange.ContinuousVariable("a") in self.l
self.assertFalse(i)
with self.assertRaises(TypeError):
42 in self.l
def test_append(self):
f = orange.ContinuousVariable("f")
self.ll.append(f)
self.l.append(f)
self.assertEqual(self.l, self.ll)
with self.assertRaises(TypeError):
self.l.append(12)
def test_remove(self):
self.l.remove(self.ll[2])
self.ll.remove(self.ll[2])
self.assertEqual(self.l, self.ll)
self.assertRaises(ValueError, self.l.remove,
orange.ContinuousVariable())
self.assertRaises(TypeError, self.l.remove, 42)
def test_camel(self):
f = orange.ContinuousVariable()
# For builtins, it must support both forms
self.assertEqual(f.numberOfDecimals, 3)
self.assertEqual(f.number_of_decimals, 3)
# Both forms must be equivalent - for built-ins,
# for both setting and getting
f.numberOfDecimals = 4
self.assertEqual(f.numberOfDecimals, 4)
self.assertEqual(f.number_of_decimals, 4)
f.number_of_decimals = 5
self.assertEqual(f.numberOfDecimals, 5)
self.assertEqual(f.number_of_decimals, 5)
# For non-builtins, they must be separate
f.abc_abc = 5
self.assertEqual(f.abc_abc, 5)
with self.assertRaises(AttributeError):
f.abcAbc
f.abcAbc = 6
self.assertEqual(f.abc_abc, 5)
self.assertEqual(f.abcAbc, 6)
f.defDef = 5
self.assertEqual(f.defDef, 5)
with self.assertRaises(AttributeError):
f.def_def
f.def_def = 6
self.assertEqual(f.defDef, 5)
self.assertEqual(f.def_def, 6)
def test_make_continuous_old(self):
# Creates a new variable
v1 = orange.ContinuousVariable("a123")
# Reuses v1
v2, s = orange.Variable.make("a123", orange.VarTypes.Continuous)
self.assertEqual(s, orange.Variable.MakeStatus.OK)
self.assertIs(v1, v2)
def setUp(self):
self.contvars = [orange.ContinuousVariable(x) for x in "abcde"]
self.discvars = [orange.DiscreteVariable(x, values=["ana", "berta", "cilka"]) for x in "ABCDE"]
self.yvar = [orange.DiscreteVariable("y", values="01")]
self.contdomain = orange.Domain(self.contvars, self.yvar)
self.discdomain = orange.Domain(self.discvars, self.yvar)
self.allvars = self.contvars+self.discvars+[self.yvar]
self.domain = orange.Domain(self.contvars+self.discvars, self.yvar)
def test_anonymous_from_numpy(self):
a = numpy.zeros((4, 5))
a[0, 0] = 0.5
a[3, 1] = 11
a[3, 2] = -1
a[1, 3] = 5
knn = orange.kNNLearner(a)
data = knn.find_nearest.examples
domain = data.domain
self.assertEqual([var.name for var in domain.variables],
["var%05i" % i for i in range(5)])
self.assertEqual(domain[0].var_type, orange.VarTypes.Continuous)
self.assertEqual(domain[1].var_type, orange.VarTypes.Continuous)
self.assertEqual(domain[2].var_type, orange.VarTypes.Continuous)
self.assertEqual(domain[3].var_type, orange.VarTypes.Discrete)
self.assertEqual(domain[3].values, ["v%i" % i for i in range(6)])
self.assertEqual(domain[4].var_type, orange.VarTypes.Discrete)
self.assertEqual(domain[4].values, ["v0"])
dom2 = orange.Domain([
orange.ContinuousVariable("a"),
orange.ContinuousVariable("b"),
orange.ContinuousVariable("c"),
orange.DiscreteVariable("d", values="abcdef"),
orange.DiscreteVariable("e", values="ab")
])
ex = orange.Example(dom2, [3.14, 42, 2.7, "d", "a"])
knn(ex)
ex1 = domain(ex)
self.assertEqual(list(map(float, ex1)), list(map(float, ex)))
ex2 = dom2(ex1)
self.assertEqual(list(map(float, ex1)), list(map(float, ex2)))
self.assertEqual(ex1, ex2)
self.assertEqual(ex1, ex)
iris = orange.ExampleTable("iris")
with self.assertRaises(ValueError):
domain(iris[0])
knn.find_nearest.examples = numpy.zeros((3, 3))
domain = knn.find_nearest.examples.domain
for i in range(3):
var = domain[i]
self.assertEqual(var.name, "var%05i" % i)
self.assertEqual(var.values, ["v0"])
def test_floatvariable(self):
f = orange.ContinuousVariable()
self.assertEqual(f.name, "")
self.assertIsNone(f.source_variable)
self.assertEqual(f.number_of_decimals, 3)
self.assertEqual(f.adjust_decimals, 2)
val = orange.PyValue(f, "2.1")
self.assertEqual(f.number_of_decimals, 1)
self.assertEqual(f.adjust_decimals, 1)
self.assertAlmostEqual(float(val), 2.1, 2)
f = orange.ContinuousVariable("x")
self.assertEqual(f.name, "x")
f = orange.ContinuousVariable(name="x")
self.assertEqual(f.name, "x")
s = pickle.dumps(f)
f2 = pickle.loads(s)
self.assertEqual(f.name, f2.name)
self.assertEqual(id(f), id(f2))
def test_gaussian(self):
d = orange.ExampleTable("iris")
var = orange.ContinuousVariable("iq")
cc2 = orange.RandomClassifier(var, orange.GaussianDistribution(100, 20))
for e in d[0:150:20]:
anss = set()
for i in range(5):
anss.add(cc2(e))
self.assertEqual(len(anss), 1)
anss = set()
for e in d:
anss.add(cc2(e))
self.assertGreater(len(anss), 10)
def test_attrtypes(self):
d = orange.Domain([])
self.assertFalse(d.has_continuous_attributes(include_class=True))
self.assertFalse(d.has_continuous_attributes(include_class=False))
self.assertFalse(d.has_discrete_attributes(include_class=True))
self.assertFalse(d.has_discrete_attributes(include_class=False))
d = orange.Domain([orange.ContinuousVariable("a")])
self.assertTrue(d.has_continuous_attributes(include_class=True))
self.assertFalse(d.has_continuous_attributes(include_class=False))
self.assertFalse(d.has_discrete_attributes(include_class=True))
self.assertFalse(d.has_discrete_attributes(include_class=False))
d = orange.Domain([orange.DiscreteVariable("a")])
self.assertFalse(d.has_continuous_attributes(include_class=True))
self.assertFalse(d.has_continuous_attributes(include_class=False))
self.assertTrue(d.has_discrete_attributes(include_class=True))
self.assertFalse(d.has_discrete_attributes(include_class=False))
d = orange.Domain([orange.ContinuousVariable("a"), orange.DiscreteVariable("b")])
self.assertTrue(d.has_continuous_attributes(include_class=True))
self.assertTrue(d.has_continuous_attributes(include_class=False))
self.assertTrue(d.has_discrete_attributes(include_class=True))
self.assertFalse(d.has_discrete_attributes(include_class=False))
def test_from_numpy(self):
import random
a = numpy.arange(20, dtype="d").reshape((4, 5))
a[:, -1] = [0, 0, 0, 1]
dom = orange.Domain([orange.ContinuousVariable(x) for x in "abcd"],
orange.DiscreteVariable("e", values=["no", "yes"]))
table = orange.ExampleTable(dom, a)
for i in range(4):
self.assertEqual(table[i].getclass(), "no" if i < 3 else "yes")
for j in range(5):
self.assertEqual(a[i, j], table[i, j])
table[i, j] = random.random()
self.assertEqual(a[i, j], table[i, j])
with self.assertRaises(ValueError):
table[0, orange.newmetaid()] = 5
def test_index(self):
d = orange.Domain(self.vars)
self.assertEqual(d.index("c"), 2)
self.assertEqual(d.index(self.vars[2]), 2)
self.assertEqual(d.index(2), 2)
self.assertEqual(d.index("j"), 9)
with self.assertRaises(IndexError):
d.index("x")
with self.assertRaises(IndexError):
d.index(orange.ContinuousVariable("x"))
with self.assertRaises(IndexError):
d.index(15)
with self.assertRaises(TypeError):
d.index[orange]
def test_repr(self):
d = orange.Domain([])
self.assertEqual(repr(d), "<orange.Domain []>")
d = orange.Domain([self.vars[0]])
self.assertEqual(repr(d), "<orange.Domain [(no attrs) -> a]>")
d = orange.Domain([self.vars[0]], class_var=False)
self.assertEqual(repr(d), "<orange.Domain [a -> (no class)]>")
d = orange.Domain(self.vars, class_var=False)
self.assertEqual(repr(d), "<orange.Domain [a, b, c, d, e, f, g, h, i, j -> (no class)]>")
d = orange.Domain(self.vars)
self.assertEqual(repr(d), "<orange.Domain [a, b, c, d, e, f, g, h, i -> j]>")
d = orange.Domain([orange.ContinuousVariable("A%i" % i) for i in range(1, 101)])
self.assertEqual(repr(d), "<orange.Domain [%s, ... -> A100]>" % ", ".join("A%i" % i for i in range(1, 21)))
def test_pickle(self):
import pickle
d = orange.ExampleTable("iris")
e = d[0]
self.assertRaises(pickle.PicklingError, pickle.dumps, e)
e = orange.Example(e)
s = pickle.dumps(e)
e2 = pickle.loads(s)
self.assertEqual(e, e)
self.assertEqual(e, e2)
id = orange.newmetaid()
e[id] = 33
d.domain.addmeta(id, orange.ContinuousVariable("x"))
id2 = orange.newmetaid()
d.domain.addmeta(id2, orange.StringVariable("y"))
e[id2] = "foo"
s = pickle.dumps(e)
e2 = pickle.loads(s)
self.assertEqual(e, e2)
self.assertEqual(e2[id], 33)
self.assertEqual(e2[id2], "foo")
def setUp(self):
self.domain = orange.Domain([
orange.DiscreteVariable("corr2", values="01"),
orange.DiscreteVariable("corr2_h", values="01"),
orange.DiscreteVariable("corr4", values="0123"),
orange.DiscreteVariable("uncorr", values="01"),
orange.DiscreteVariable("const1", values="0"),
orange.DiscreteVariable("const2", values="01"),
orange.DiscreteVariable("unk_disc", values="01"),
orange.ContinuousVariable("const"),
orange.ContinuousVariable("thresh"),
orange.ContinuousVariable("thresh_h"),
orange.ContinuousVariable("bin_corr"),
orange.ContinuousVariable("bin_uncorr"),
orange.ContinuousVariable("unk_cont"),
orange.DiscreteVariable("y", values="01")
])
self.art = orange.ExampleTable(self.domain)
for i in range(24):
self.art.append([
i // 12, i // 12 if i % 2 else "?", i // 6, i % 2, 0, 0, None,
42, i, i if i % 2 else "?", i // 12, i % 2, None, i // 12
])
def test_ass_item(self):
self.l[2] = self.ll[2] = orange.ContinuousVariable("x")
self.assertEqual(self.l, self.ll)
def test_meta_direct(self):
e = orange.ExampleTableReader("iris.tab", 3).read()[0]
d = e.domain
e[0] = 3.14
mid1 = orange.newmetaid()
e[mid1] = 2.79
self.assertEqual(e[0], 3.14)
self.assertEqual(e[mid1], 2.79)
mid2 = orange.newmetaid()
nf = orange.ContinuousVariable("m2")
d.addmeta(mid2, nf)
e[nf] = 6.28
self.assertEqual(e[nf], 6.28)
self.assertEqual(e[mid2], 6.28)
self.assertEqual(e["m2"], 6.28)
mid3 = orange.newmetaid()
sf = orange.StringVariable("m3")
d.addmeta(mid3, sf)
e["m3"] = "pixies"
self.assertEqual(e[sf], "pixies")
self.assertEqual(e[mid3], "pixies")
self.assertEqual(e["m3"], "pixies")
self.assertEqual(set(e.get_metas().values()), set([2.79, 6.28, "pixies"]))
del e[mid1]
with self.assertRaises(KeyError):
e[mid1]
self.assertEqual(set(e.get_metas().values()), set([6.28, "pixies"]))
del e[mid3]
with self.assertRaises(KeyError):
e[sf]
self.assertEqual(set(e.get_metas().values()), set([6.28]))
del e[mid2]
with self.assertRaises(KeyError):
e["m2"]
self.assertEqual(set(e.get_metas().values()), set([]))
with self.assertRaises(TypeError):
e[mid1] = "3.15"
with self.assertRaises(TypeError):
e[mid3] = 3.15
with self.assertRaises(TypeError):
e.set_meta(mid1, "3.15")
with self.assertRaises(TypeError):
e.set_meta(mid3 = 3.15)
e.set_meta(mid1, 3.15)
e.set_meta("m2", 3.16)
e.set_meta(sf, "3.17")
self.assertTrue(e.has_meta(mid1))
self.assertTrue(e.has_meta(nf))
self.assertTrue(e.has_meta(sf))
e.remove_meta(sf)
self.assertTrue(e.has_meta(mid1))
self.assertTrue(e.has_meta(nf))
self.assertFalse(e.has_meta(sf))
e.remove_meta(mid1)
self.assertFalse(e.has_meta(mid1))
self.assertTrue(e.has_meta(nf))
self.assertFalse(e.has_meta(sf))
e.remove_meta("m2")
self.assertFalse(e.has_meta(mid1))
self.assertFalse(e.has_meta(nf))
self.assertFalse(e.has_meta(sf))
def test_insert(self):
f = orange.ContinuousVariable("f")
self.ll.insert(2, f)
self.l.insert(2, f)
self.assertEqual(self.l, self.ll)
def test_index(self):
self.assertEqual(self.l.index(self.ll[2]), 2)
self.assertRaises(ValueError, self.l.index,
orange.ContinuousVariable())
self.assertRaises(TypeError, self.l.index, 13)
def test_count(self):
self.assertEqual(self.l.count(self.ll[1]), 1)
self.assertEqual(self.l.count(orange.ContinuousVariable()), 0)
self.assertRaises(TypeError, self.l.count, 42)
self.assertEqual((self.l * 3).count(self.ll[1]), 3)
def tv(s):
return [orange.ContinuousVariable(x) for x in s]
