biolab · sstanovnik · Jun 10, 2016 · Jun 17, 2016 · Jun 17, 2016 · Jun 22, 2016
diff --git a/.travis.yml b/.travis.yml
@@ -11,6 +11,8 @@ matrix:
           addons: { apt: { packages: [] } }
           cache: {}
         - python: '3.4'
+        - python: '3.4'
+          env: PANDAS_GIT=true
         - python: '3.5'
         - python: 'nightly'
     allow_failures:

diff --git a/.travis/install_orange.sh b/.travis/install_orange.sh
@@ -5,7 +5,8 @@ cat requirements-core.txt \
     requirements-dev.txt \
     requirements-doc.txt |
     while read dep; do
-        dep="${dep%%#*}"  # Strip the comment
+        # Strip the comment, but check for "egg" after # to allow "-e git://...#egg=.."
+        dep="${dep%%#!(egg)*}"
         [ "$dep" ] &&
             foldable pip install $dep
     done

diff --git a/.travis/stage_install.sh b/.travis/stage_install.sh
@@ -1,6 +1,14 @@
 
 [ "$RUN_PYLINT" ] && return 0   # Nothing to do
 
+# pandas requires cython to install from source, cython recommends --no-cython-compile for CI builds
+# install pandas manually, then remove the version requirement from requirements-core.txt
+# to avoid pip complaints
+[ "$PANDAS_GIT" ] && \
+    pip install Cython --install-option="--no-cython-compile" && \
+    pip install git+git://github.com/pydata/pandas.git && \
+    sed -Eibak "s/^pandas.*/pandas/" "$TRAVIS_BUILD_DIR/requirements-core.txt"
+
 for script in \
     install_orange.sh    \
     install_postgres.sh  \

diff --git a/Orange/base.py b/Orange/base.py
@@ -3,7 +3,7 @@
 import numpy as np
 import scipy
 
-from Orange.data import Table, Storage, Instance, Value
+from Orange.data import Table, TableSeries, TableBase, SeriesBase
 from Orange.preprocess import (RemoveNaNClasses, Continuize,
                                RemoveNaNColumns, SklImpute)
 from Orange.misc.wrapper_meta import WrapperMeta
@@ -31,16 +31,12 @@ def fit(self, X, Y, W=None):
             "Descendants of Learner must overload method fit")
 
     def fit_storage(self, data):
-        return self.fit(data.X, data.Y, data.W)
+        return self.fit(data.X, data.Y, data.weights)
 
     def __call__(self, data):
         if not self.check_learner_adequacy(data.domain):
             raise ValueError(self.learner_adequacy_err_msg)
-
         origdomain = data.domain
-
-        if isinstance(data, Instance):
-            data = Table(data.domain, [data])
         data = self.preprocess(data)
 
         if len(data.domain.class_vars) > 1 and not self.supports_multiclass:
@@ -52,8 +48,8 @@ def __call__(self, data):
         if type(self).fit is Learner.fit:
             model = self.fit_storage(data)
         else:
-            X, Y, W = data.X, data.Y, data.W if data.has_weights() else None
-            model = self.fit(X, Y, W)
+            X, Y, W = data.X, data.Y, data.weights
+            model = self.fit(X, Y, W if data.has_weights else None)
         model.domain = data.domain
         model.supports_multiclass = self.supports_multiclass
         model.name = self.name
@@ -99,10 +95,8 @@ def predict(self, X):
             return self.predict_storage(table)
 
     def predict_storage(self, data):
-        if isinstance(data, Storage):
+        if isinstance(data, (TableBase, SeriesBase)):
             return self.predict(data.X)
-        elif isinstance(data, Instance):
-            return self.predict(np.atleast_2d(data.x))
         raise TypeError("Unrecognized argument (instance of '{}')"
                         .format(type(data).__name__))
 
@@ -117,14 +111,9 @@ def __call__(self, data, ret=Value):
             prediction = self.predict(np.atleast_2d(data))
         elif isinstance(data, scipy.sparse.csr.csr_matrix):
             prediction = self.predict(data)
-        elif isinstance(data, Instance):
+        elif isinstance(data, (TableBase, SeriesBase)):
             if data.domain != self.domain:
-                data = Instance(self.domain, data)
-            data = Table(data.domain, [data])
-            prediction = self.predict_storage(data)
-        elif isinstance(data, Table):
-            if data.domain != self.domain:
-                data = data.from_table(self.domain, data)
+                data = Table.from_table(self.domain, data)
             prediction = self.predict_storage(data)
         elif isinstance(data, (list, tuple)):
             if not isinstance(data[0], (list, tuple)):
@@ -168,8 +157,7 @@ def __call__(self, data, ret=Value):
         # Return what we need to
         if ret == Model.Probs:
             return probs
-        if isinstance(data, Instance) and not multitarget:
-            value = Value(self.domain.class_var, value[0])
+
         if ret == Model.Value:
             return value
         else:  # ret == Model.ValueProbs
@@ -254,7 +242,8 @@ def __call__(self, data):
     def fit(self, X, Y, W=None):
         clf = self.__wraps__(**self.params)
         Y = Y.reshape(-1)
-        if W is None or not self.supports_weights:
+        # don't use weights if they don't exist, they aren't supported, or are all identical
+        if W is None or not self.supports_weights or (W == W[0]).all() == 1:
             return self.__returns__(clf.fit(X, Y))
         return self.__returns__(clf.fit(X, Y, sample_weight=W.reshape(-1)))
 

diff --git a/Orange/canvas/report/tests/test_report.py b/Orange/canvas/report/tests/test_report.py
@@ -4,7 +4,7 @@
 
 from PyQt4.QtGui import QFont, QBrush
 from PyQt4.QtCore import Qt
-from Orange.data.table import Table
+from Orange.data import Table
 from Orange.classification import LogisticRegressionLearner
 from Orange.classification.tree import TreeLearner
 from Orange.regression.tree import TreeRegressionLearner

diff --git a/Orange/canvas/scheme/link.py b/Orange/canvas/scheme/link.py
@@ -102,8 +102,8 @@ def __init__(self, source_node, source_channel,
 
         if not compatible_channels(source_channel, sink_channel):
             raise IncompatibleChannelTypeError(
-                    "Cannot connect %r to %r" \
-                    % (source_channel.type, sink_channel.type)
+                    "Cannot connect {!r} to {!r} from {} to {}".format(source_channel.type, sink_channel.type,
+                                                                       source_node.title, sink_node.title)
                 )
 
         self.__enabled = enabled

diff --git a/Orange/canvas/scheme/scheme.py b/Orange/canvas/scheme/scheme.py
@@ -351,8 +351,7 @@ def check_connect(self, link):
 
         if not self.compatible_channels(link):
             raise IncompatibleChannelTypeError(
-                    "Cannot connect %r to %r." \
-                    % (link.source_channel.type, link.sink_channel.type)
+                    "Cannot connect %r to %r." % (link.source_channel.type, link.sink_channel.type)
                 )
 
         links = self.find_links(source_node=link.source_node,

diff --git a/Orange/classification/naive_bayes.py b/Orange/classification/naive_bayes.py
@@ -1,8 +1,8 @@
 import numpy as np
 
 from Orange.classification import Learner, Model
-from Orange.data import Instance, Storage
-from Orange.statistics import contingency
+from Orange.data import Table
+from Orange.statistics import contingency, distribution
 from Orange.preprocess import Discretize
 
 __all__ = ["NaiveBayesLearner"]
@@ -24,15 +24,14 @@ class NaiveBayesLearner(Learner):
     preprocessors = [Discretize()]
 
     def fit_storage(self, table):
-        if not isinstance(table, Storage):
-            raise TypeError("Data is not a subclass of Orange.data.Storage.")
+        if not isinstance(table, Table):
+            raise TypeError("Data is not a subclass of Orange.data.Table.")
         if not all(var.is_discrete
                    for var in table.domain.variables):
             raise NotImplementedError("Only discrete variables are supported.")
 
         cont = contingency.get_contingencies(table)
-        class_freq = np.array(np.diag(
-            contingency.get_contingency(table, table.domain.class_var)))
+        class_freq = np.array(distribution.class_distribution(table))
         return NaiveBayesModel(cont, class_freq, table.domain)
 
 
@@ -43,8 +42,6 @@ def __init__(self, cont, class_freq, domain):
         self.class_freq = class_freq
 
     def predict_storage(self, data):
-        if isinstance(data, Instance):
-            data = [data]
         n_cls = len(self.class_freq)
         class_prob = (self.class_freq + 1) / (np.sum(self.class_freq) + n_cls)
         if len(data.domain.attributes) == 0:
@@ -55,9 +52,9 @@ def predict_storage(self, data):
                                               c.shape[1])) for c in self.cont]
             probs = np.exp(np.array([np.sum(attr_prob[:, int(attr_val)]
                                             for attr_val, attr_prob
-                                            in zip(ins, log_cont_prob)
+                                            in zip(row, log_cont_prob)
                                             if not np.isnan(attr_val))
-                                     for ins in data]) + np.log(class_prob))
+                                     for row in data.X]) + np.log(class_prob))
         probs /= probs.sum(axis=1)[:, None]
         values = probs.argmax(axis=1)
         return values, probs

diff --git a/Orange/classification/simple_tree.py b/Orange/classification/simple_tree.py
@@ -93,9 +93,9 @@ def fit_storage(self, data):
 
 class SimpleTreeModel(Model):
     def __init__(self, learner, data):
-        X = np.ascontiguousarray(data.X)
-        Y = np.ascontiguousarray(data.Y)
-        W = np.ascontiguousarray(data.W)
+        X = data.X
+        Y = data.Y
+        W = data.weights
         self.num_attrs = X.shape[1]
         self.dom_attr = data.domain.attributes
         self.cls_vars = list(data.domain.class_vars)
@@ -157,7 +157,7 @@ def __init__(self, learner, data):
             learner.seed)
 
     def predict_storage(self, data):
-        X = np.ascontiguousarray(data.X)
+        X = data.X
         if self.type == Classification:
             p = np.zeros((X.shape[0], self.cls_vals))
             _tree.predict_classification(

diff --git a/Orange/clustering/dbscan.py b/Orange/clustering/dbscan.py
@@ -1,5 +1,5 @@
 import sklearn.cluster as skl_cluster
-from Orange.data import Table, DiscreteVariable, Domain, Instance
+from Orange.data import Table, DiscreteVariable, Domain
 from Orange.projection import SklProjector, Projection
 from numpy import atleast_2d, ndarray, where
 
@@ -41,10 +41,3 @@ def __call__(self, data):
             c = DiscreteVariable(name='Core sample index', values=vals)
             domain = Domain([c])
             return Table(domain, y.reshape(len(y), 1))
-
-        elif isinstance(data, Instance):
-            if data.domain is not self.pre_domain:
-                data = Instance(self.pre_domain, data)
-            # Instances-by-Instance classification is not defined;
-            raise Exception("Core sample assignment is not supported "
-                            "for single instances.")
diff --git a/Orange/clustering/kmeans.py b/Orange/clustering/kmeans.py
@@ -2,7 +2,7 @@
 import sklearn.cluster as skl_cluster
 from sklearn.metrics import silhouette_score
 
-from Orange.data import Table, DiscreteVariable, Domain, Instance
+from Orange.data import Table, TableSeries, DiscreteVariable, Domain
 from Orange.projection import SklProjector, Projection
 from Orange.distance import Euclidean
 
@@ -42,21 +42,17 @@ def __init__(self, proj, preprocessors=None):
         self.centroids = self.proj.cluster_centers_
 
     def __call__(self, data):
+        # convert to a table so everything works the same
+        if isinstance(data, TableSeries):
+            new_table = Table(data.domain)
+            new_table = Table.concatenate([new_table, data], axis=0, reindex=False)
+            data = new_table
+
         if isinstance(data, Table):
             if data.domain is not self.pre_domain:
                 data = Table(self.pre_domain, data)
             c = DiscreteVariable(name='Cluster id', values=range(self.k))
             domain = Domain([c])
-            return Table(
-                domain,
-                self.proj.predict(data.X).astype(int).reshape((len(data), 1)))
-        elif isinstance(data, Instance):
-            if data.domain is not self.pre_domain:
-                data = Instance(self.pre_domain, data)
-            c = DiscreteVariable(name='Cluster id', values=range(self.k))
-            domain = Domain([c])
-            return Table(
-                domain,
-                np.atleast_2d(self.proj.predict(data._x)).astype(int))
+            return Table(domain, self.proj.predict(data.X).astype(int).reshape((len(data), 1)))
         else:
             return self.proj.predict(data).reshape((len(data), 1))
diff --git a/Orange/data/__init__.py b/Orange/data/__init__.py
@@ -1,6 +1,12 @@
-from .instance import *
 from .variable import *
 from .domain import *
-from .storage import *
-from .table import *
+from .table.impl import *
 from .io import *
+
+
+def get_sample_datasets_dir():
+    orange_data_table = os.path.dirname(__file__)
+    dataset_dir = os.path.join(orange_data_table, '..', 'datasets')
+    return os.path.realpath(dataset_dir)
+
+dataset_dirs = ['', get_sample_datasets_dir()]