Table: Deprecate calling Table(X, Y, metas) without domain

janezd · janezd · commit 8605fac01f9c · 2019-12-06T12:48:15.000+01:00
diff --git a/Orange/classification/naive_bayes.py b/Orange/classification/naive_bayes.py
@@ -61,7 +61,7 @@ def __init__(self, log_cont_prob, class_prob, domain):
 
     def predict_storage(self, data):
         if isinstance(data, Instance):
-            data = Table(np.atleast_2d(data.x))
+            data = Table.from_numpy(None, np.atleast_2d(data.x))
         if type(data) is Table:  # pylint: disable=unidiomatic-typecheck
             return self.predict(data.X)
 
diff --git a/Orange/data/table.py b/Orange/data/table.py
@@ -249,6 +249,10 @@ def warn_deprecated(method):
                 warn_deprecated("from_list")
                 return cls.from_list(domain, *args, **kwargs)
         else:
+            warnings.warn("Omitting domain in a call to Table(X, Y, metas), is "
+                          "deprecated and will be removed. "
+                          "Call Table.from_numpy(None, X, Y, metas) instead.",
+                          OrangeDeprecationWarning, stacklevel=2)
             domain = None
 
         return cls.from_numpy(domain, *args, **kwargs)
diff --git a/Orange/data/tests/test_table.py b/Orange/data/tests/test_table.py
@@ -25,6 +25,7 @@ def test_warnings(self):
         self.assertWarns(OrangeDeprecationWarning, Table, domain)
         self.assertWarns(OrangeDeprecationWarning, Table, domain, Table())
         self.assertWarns(OrangeDeprecationWarning, Table, domain, [[12]])
+        self.assertWarns(OrangeDeprecationWarning, Table, np.zeros((5, 5)))
 
     def test_invalid_call_with_kwargs(self):
         self.assertRaises(TypeError, Table, Y=[])
diff --git a/Orange/tests/sql/test_sql_table.py b/Orange/tests/sql/test_sql_table.py
@@ -277,7 +277,7 @@ def construct_universal_table(self):
         for row in range(1, 6):
             for col in range(1, 6):
                 values.extend((row, col, row * col))
-        table = Table(np.array(values).reshape((-1, 3)))
+        table = Table.from_numpy(None, np.array(values).reshape((-1, 3)))
         return self.create_sql_table(table)
 
     IRIS_VARIABLE = DiscreteVariable(
diff --git a/Orange/tests/test_classification.py b/Orange/tests/test_classification.py
@@ -39,15 +39,15 @@ def test_unsupported(self):
 
         # multiple class variables
         y = np.random.randint(0, 2, (nrows, 2))
-        t = Table(x, y)
+        t = Table.from_numpy(None, x, y)
         learn = DummyLearner()
         # TODO: Errors raised from various data checks should be made consistent
         with self.assertRaises((ValueError, TypeError)):
             clf = learn(t)
 
         # single class variable
         y = np.random.randint(0, 2, (nrows, 1))
-        t = Table(x, y)
+        t = Table.from_numpy(None, x, y)
         learn = DummyLearner()
         clf = learn(t)
         z = clf(x)
@@ -58,7 +58,7 @@ def test_supported(self):
         ncols = 10
         x = np.random.randint(1, 4, (nrows, ncols))
         y = np.random.randint(0, 2, (nrows, 2))
-        t = Table(x, y)
+        t = Table.from_numpy(None, x, y)
         learn = DummyMulticlassLearner()
         clf = learn(t)
         z = clf(x)
@@ -117,7 +117,7 @@ def test_value_from_probs(self):
 
         # single class variable
         y = np.random.randint(1, 4, (nrows, 1)) // 2    # majority = 1
-        t = Table(x, y)
+        t = Table.from_numpy(None, x, y)
         learn = DummyLearner()
         clf = learn(t)
         clf.ret = Model.Probs
diff --git a/Orange/tests/test_clustering_hierarchical.py b/Orange/tests/test_clustering_hierarchical.py
@@ -128,7 +128,7 @@ def score(root):
         self.assertEqual(score_ordered, 21.0)
 
     def test_table_clustering(self):
-        table = Orange.data.Table(numpy.eye(3))
+        table = Orange.data.Table.from_numpy(None, numpy.eye(3))
         tree = hierarchical.data_clustering(table, linkage="single")
         numpy.testing.assert_almost_equal(tree.value.height, numpy.sqrt(2))
 
diff --git a/Orange/tests/test_discretize.py b/Orange/tests/test_discretize.py
@@ -21,23 +21,23 @@ def test_equifreq_with_too_few_values(self):
         s = [0] * 50 + [1] * 50
         random.shuffle(s)
         X = np.array(s).reshape((100, 1))
-        table = data.Table(X)
+        table = data.Table.from_numpy(None, X)
         disc = discretize.EqualFreq(n=4)
         dvar = disc(table, table.domain[0])
         self.assertEqual(len(dvar.values), 2)
         self.assertEqual(dvar.compute_value.points, [0.5])
 
     def test_equifreq_100_to_4(self):
         X = np.arange(100).reshape((100, 1))
-        table = data.Table(X)
+        table = data.Table.from_numpy(None, X)
         disc = discretize.EqualFreq(n=4)
         dvar = disc(table, table.domain[0])
         self.assertEqual(len(dvar.values), 4)
         self.assertEqual(dvar.compute_value.points, [24.5, 49.5, 74.5])
 
     def test_equifreq_with_k_instances(self):
         X = np.array([[1], [2], [3], [4]])
-        table = data.Table(X)
+        table = data.Table.from_numpy(None, X)
         disc = discretize.EqualFreq(n=4)
         dvar = disc(table, table.domain[0])
         self.assertEqual(len(dvar.values), 4)
@@ -50,7 +50,7 @@ def test_equalwidth_on_two_values(self):
         s = [0] * 50 + [1] * 50
         random.shuffle(s)
         X = np.array(s).reshape((100, 1))
-        table = data.Table(X)
+        table = data.Table.from_numpy(None, X)
         disc = discretize.EqualWidth(n=4)
         dvar = disc(table, table.domain[0])
         self.assertEqual(len(dvar.values), 4)
@@ -59,15 +59,15 @@ def test_equalwidth_on_two_values(self):
     @table_dense_sparse
     def test_equalwidth_100_to_4(self, prepare_table):
         X = np.arange(101).reshape((101, 1))
-        table = prepare_table(data.Table(X))
+        table = prepare_table(data.Table.from_numpy(None, X))
         disc = discretize.EqualWidth(n=4)
         dvar = disc(table, table.domain[0])
         self.assertEqual(len(dvar.values), 4)
         self.assertEqual(dvar.compute_value.points, [25, 50, 75])
 
     def test_equalwidth_const_value(self):
         X = np.ones((100, 1))
-        table = data.Table(X)
+        table = data.Table.from_numpy(None, X)
         disc = discretize.EqualFreq(n=4)
         dvar = disc(table, table.domain[0])
         self.assertEqual(len(dvar.values), 1)
@@ -80,7 +80,7 @@ def test_entropy_with_two_values(self):
         s = [0] * 50 + [1] * 50
         random.shuffle(s)
         X = np.array(s).reshape((100, 1))
-        table = data.Table(X, X)
+        table = data.Table.from_numpy(None, X, X)
         disc = discretize.EntropyMDL()
         dvar = disc(table, table.domain[0])
         self.assertEqual(len(dvar.values), 2)
@@ -89,7 +89,7 @@ def test_entropy_with_two_values(self):
     def test_entropy_with_two_values_useless(self):
         X = np.array([0] * 50 + [1] * 50).reshape((100, 1))
         Y = np.array([0] * 25 + [1] * 50 + [0] * 25)
-        table = data.Table(X, Y)
+        table = data.Table.from_numpy(None, X, Y)
         disc = discretize.EntropyMDL()
         dvar = disc(table, table.domain[0])
         self.assertEqual(len(dvar.values), 1)
@@ -109,7 +109,7 @@ def test_entropy(self):
         X = np.array([0] * 25 + [1] * 25 + [2] * 25 + [3] * 25
                     ).reshape((100, 1))
         Y = np.array([0] * 25 + [1] * 75)
-        table = data.Table(X, Y)
+        table = data.Table.from_numpy(None, X, Y)
         disc = discretize.EntropyMDL()
         dvar = disc(table, table.domain[0])
         self.assertEqual(len(dvar.values), 2)
@@ -241,8 +241,8 @@ def setUpClass(cls):
         X2 = np.arange(100).reshape((100, 1))
         X3 = np.ones((100, 1))
         X = np.hstack([X1, X2, X3])
-        cls.table_no_class = data.Table(X)
-        cls.table_class = data.Table(X, X1)
+        cls.table_no_class = data.Table.from_numpy(None, X)
+        cls.table_class = data.Table.from_numpy(None, X, X1)
 
     def test_discretize_exclude_constant(self):
         dom = discretize.DomainDiscretizer()(self.table_no_class)
diff --git a/Orange/tests/test_distances.py b/Orange/tests/test_distances.py
@@ -205,7 +205,8 @@ class TestEuclidean(TestCase):
     @classmethod
     def setUpClass(cls):
         cls.iris = Table('iris')
-        cls.sparse = Table(csr_matrix([[1, 2, 0], [0, 0, 3], [4, 0, 5]]))
+        cls.sparse = Table.from_numpy(
+            None, csr_matrix([[1, 2, 0], [0, 0, 3], [4, 0, 5]]))
         cls.dist = Euclidean
 
     def test_euclidean_distance_one_example(self):
@@ -290,7 +291,8 @@ class TestManhattan(TestCase):
     @classmethod
     def setUpClass(cls):
         cls.iris = Table('iris')
-        cls.sparse = Table(csr_matrix([[1, 2, 0], [0, 0, 3], [4, 0, 5]]))
+        cls.sparse = Table.from_numpy(
+            None, csr_matrix([[1, 2, 0], [0, 0, 3], [4, 0, 5]]))
         cls.dist = Manhattan
 
     def test_manhattan_distance_one_example(self):
@@ -378,7 +380,8 @@ class TestCosine(TestCase):
     @classmethod
     def setUpClass(cls):
         cls.iris = Table('iris')
-        cls.sparse = Table(csr_matrix([[1, 2, 0], [0, 0, 3], [4, 0, 5]]))
+        cls.sparse = Table.from_numpy(
+            None, csr_matrix([[1, 2, 0], [0, 0, 3], [4, 0, 5]]))
         cls.dist = Cosine
 
     def test_cosine_distance_one_example(self):
diff --git a/Orange/tests/test_evaluation_clustering.py b/Orange/tests/test_evaluation_clustering.py
@@ -14,7 +14,8 @@
 class TestClusteringResults(unittest.TestCase):
     @staticmethod
     def test_init():
-        data = Orange.data.Table(np.arange(100).reshape((100, 1)))
+        data = Orange.data.Table.from_numpy(
+            None, np.arange(100).reshape((100, 1)))
         res = ClusteringResults(data=data, nmethods=2, nrows=100)
         res.actual[:50] = 0
         res.actual[50:] = 1
diff --git a/Orange/tests/test_evaluation_scoring.py b/Orange/tests/test_evaluation_scoring.py
@@ -254,7 +254,7 @@ def test_bayes(self):
         x = np.random.randint(2, size=(100, 5))
         col = np.random.randint(5)
         y = x[:, col].copy().reshape(100, 1)
-        t = Table(x, y)
+        t = Table.from_numpy(None, x, y)
         t = Discretize(
             method=discretize.EqualWidth(n=3))(t)
         nb = NaiveBayesLearner()
diff --git a/Orange/tests/test_evaluation_testing.py b/Orange/tests/test_evaluation_testing.py
@@ -21,7 +21,7 @@ def random_data(nrows, ncols):
     x = np.random.randint(0, 2, (nrows, ncols))
     col = np.random.randint(ncols)
     y = x[:nrows, col].reshape(nrows, 1)
-    table = Table(x, y)
+    table = Table.from_numpy(None, x, y)
     table = preprocess.Discretize(discretize.EqualWidth(n=3))(table)
     return table
 
@@ -253,7 +253,7 @@ def test_miss_majority():
         x = np.zeros((50, 3))
         y = x[:, -1]
         x[-4:] = np.ones((4, 3))
-        data = Table(x, y)
+        data = Table.from_numpy(None, x, y)
         cv = CrossValidation(k=3)
         res = cv(data, [MajorityLearner()])
         np.testing.assert_equal(res.predicted[0][:49], 0)
@@ -436,7 +436,7 @@ def test_miss_majority():
         x = np.zeros((50, 3))
         y = x[:, -1]
         x[49] = 1
-        data = Table(x, y)
+        data = Table.from_numpy(None, x, y)
         res = LeaveOneOut()(data, [MajorityLearner()])
         np.testing.assert_equal(res.predicted[0][:49], 0)
 
@@ -445,7 +445,7 @@ def test_miss_majority():
         np.testing.assert_equal(res.predicted[0][:49], 0)
 
         x[25:] = 1
-        data = Table(x, y)
+        data = Table.from_numpy(None, x, y)
         res = LeaveOneOut()(data, [MajorityLearner()])
         np.testing.assert_equal(res.predicted[0],
                                 1 - data.Y[res.row_indices].flatten())
@@ -512,7 +512,7 @@ def test_miss_majority():
         x = np.zeros((50, 3))
         y = x[:, -1]
         x[49] = 1
-        data = Table(x, y)
+        data = Table.from_numpy(None, x, y)
         res = TestOnTrainingData()(data, [MajorityLearner()])
         np.testing.assert_equal(res.predicted[0][:49], 0)
 
@@ -521,7 +521,7 @@ def test_miss_majority():
         np.testing.assert_equal(res.predicted[0][:49], 0)
 
         x[25:] = 1
-        data = Table(x, y)
+        data = Table.from_numpy(None, x, y)
         res = TestOnTrainingData()(data, [MajorityLearner()])
         np.testing.assert_equal(res.predicted[0], res.predicted[0][0])
 
@@ -600,7 +600,7 @@ def test_miss_majority():
         x = np.zeros((50, 3))
         y = x[:, -1]
         x[49] = 1
-        data = Table(x, y)
+        data = Table.from_numpy(None, x, y)
         res = TestOnTrainingData()(data, [MajorityLearner()])
         np.testing.assert_equal(res.predicted[0][:49], 0)
 
@@ -610,7 +610,7 @@ def test_miss_majority():
 
         x[25:] = 1
         y = x[:, -1]
-        data = Table(x, y)
+        data = Table.from_numpy(None, x, y)
         res = TestOnTrainingData()(data, [MajorityLearner()])
         np.testing.assert_equal(res.predicted[0], res.predicted[0][0])
 
diff --git a/Orange/tests/test_linear_regression.py b/Orange/tests/test_linear_regression.py
@@ -31,7 +31,7 @@ def test_LinearRegression(self):
 
         x1, x2 = np.split(x, 2)
         y1, y2 = np.split(y, 2)
-        t = Table(x1, y1)
+        t = Table.from_numpy(None, x1, y1)
         learn = LinearRegressionLearner()
         clf = learn(t)
         z = clf(x2)
@@ -81,7 +81,7 @@ def test_scorer_feature(self):
                 np.testing.assert_array_almost_equal(score, scores[:, i])
 
     def test_coefficients(self):
-        data = Table([[11], [12], [13]], [0, 1, 2])
+        data = Table.from_numpy(None, [[11], [12], [13]], [0, 1, 2])
         model = LinearRegressionLearner()(data)
         self.assertAlmostEqual(float(model.intercept), -11)
         self.assertEqual(len(model.coefficients), 1)
diff --git a/Orange/tests/test_majority.py b/Orange/tests/test_majority.py
@@ -21,7 +21,7 @@ def test_majority(self):
         ncols = 10
         x = np.random.randint(1, 4, (nrows, ncols))
         y = np.random.randint(1, 4, (nrows, 1)) // 2
-        t = Table(x, y)
+        t = Table.from_numpy(None, x, y)
         clf = self.learn(t)
 
         x2 = np.random.randint(1, 4, (nrows, ncols))
@@ -35,7 +35,7 @@ def test_weights(self):
         y = np.array(70*[0] + 30*[1]).reshape((nrows, 1))
         heavy_class = 1
         w = (y == heavy_class) * 2 + 1
-        t = Table(x, y, W=w)
+        t = Table.from_numpy(None, x, y, W=w)
         clf = self.learn(t)
 
         y2 = clf(x)
diff --git a/Orange/tests/test_mean.py b/Orange/tests/test_mean.py
@@ -19,7 +19,7 @@ def test_mean(self):
         ncols = 10
         x = np.random.randint(1, 4, (nrows, ncols))
         y = np.random.randint(0, 5, (nrows, 1)) / 3.0
-        t = Table(x, y)
+        t = Table.from_numpy(None, x, y)
         clf = self.learn(t)
 
         true_mean = np.average(y)
@@ -34,7 +34,7 @@ def test_weights(self):
         y = np.random.randint(0, 5, (nrows, 1)) / 3.0
         heavy = 1
         w = ((y == heavy) * 123 + 1.0) / 124.0
-        t = Table(x, y, W=w)
+        t = Table.from_numpy(None, x, y, W=w)
         clf = self.learn(t)
 
         expected_mean = np.average(y, weights=w)
diff --git a/Orange/tests/test_pca.py b/Orange/tests/test_pca.py
@@ -252,7 +252,7 @@ def test_PCA_scorer_all_components(self):
 
     def test_max_components(self):
         d = np.random.RandomState(0).rand(20, 20)
-        data = Table(d)
+        data = Table.from_numpy(None, d)
         pca = PCA()(data)
         self.assertEqual(len(pca.explained_variance_ratio_), 20)
         pca = PCA(n_components=10)(data)
diff --git a/Orange/tests/test_polynomial_learner.py b/Orange/tests/test_polynomial_learner.py
@@ -12,8 +12,8 @@ class TestPolynomialLearner(unittest.TestCase):
     def test_PolynomialLearner(self):
         x = np.array([0.172, 0.167, 0.337, 0.420, 0.355, 0.710, 0.801, 0.876])
         y = np.array([0.784, 0.746, 0.345, 0.363, 0.366, 0.833, 0.490, 0.445])
-        
-        data = Table(x.reshape(-1, 1), y)
+
+        data = Table.from_numpy(None, x.reshape(-1, 1), y)
         data.domain = Domain([ContinuousVariable('x')],
                              class_vars=[ContinuousVariable('y')])
 
diff --git a/Orange/tests/test_preprocess.py b/Orange/tests/test_preprocess.py
@@ -54,7 +54,7 @@ def test_remove_columns(self):
         X[3, 1] = np.nan
         X[1, 1] = np.nan
         X[:, 4] = np.nan
-        data = Table(X)
+        data = Table.from_numpy(None, X)
         d = RemoveConstant()(data)
         self.assertEqual(len(d.domain.attributes), 2)
 
@@ -103,10 +103,10 @@ def test_column_filtering_sparse(self):
 class TestScaling(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
-        cls.table = Table([[1, 2, 3],
-                           [2, 3, 4],
-                           [3, 4, 5],
-                           [4, 5, 6]])
+        cls.table = Table.from_numpy(None, [[1, 2, 3],
+                                            [2, 3, 4],
+                                            [3, 4, 5],
+                                            [4, 5, 6]])
 
     def test_scaling_mean_span(self):
         table = Scale(center=Scale.Mean, scale=Scale.Span)(self.table)
diff --git a/Orange/tests/test_score_feature.py b/Orange/tests/test_score_feature.py
diff --git a/Orange/tests/test_sgd.py b/Orange/tests/test_sgd.py
diff --git a/Orange/tests/test_svm.py b/Orange/tests/test_svm.py
diff --git a/Orange/tests/test_tab_reader.py b/Orange/tests/test_tab_reader.py
diff --git a/Orange/tests/test_table.py b/Orange/tests/test_table.py
diff --git a/Orange/widgets/data/tests/test_owoutliers.py b/Orange/widgets/data/tests/test_owoutliers.py
diff --git a/Orange/widgets/unsupervised/tests/test_owkmeans.py b/Orange/widgets/unsupervised/tests/test_owkmeans.py
diff --git a/Orange/widgets/unsupervised/tests/test_owpca.py b/Orange/widgets/unsupervised/tests/test_owpca.py
