Commits

Aleš Erjavec committed 2b6cc6f

Renamed widget channel names in line with the new naming rules/convention.
Added backwards compatibility in orngDoc loadDocument to enable loading of schemas saved before the change.

  • Participants
  • Parent commits b8492dd

Comments (0)

Files changed (116)

File orange/OrangeCanvas/orngDoc.py

 from orngSignalManager import SignalManager
 import cPickle, math, orngHistory
 
+_CHANNEL_NAME_MAP = \
+    {'Additional Tables': 'Additional Data',
+     'Attribute Definitions': 'Feature Definitions',
+     'Attribute List': 'Features',
+     'Attribute Pair': 'Interacting Features',
+     'Attribute Selection List': 'Features',
+     'Attribute Statistics': 'Feature Statistics',
+     'Attribute selection': 'Features',
+     'Attributes': 'Features',
+     'Choosen Tree': 'Selected Tree',
+     'Covered Examples': 'Covered Data',
+     'Data Instances': 'Data',
+     'Data Table': 'Data',
+     'Distance Matrix': 'Distances',
+     'Distance matrix': 'Distances',
+     'Example Subset': 'Data Subset',
+     'Example Table': 'Data',
+     'Examples': 'Data',
+     'Examples A': 'Data',
+     'Examples B': 'Data',
+     'Graph with ExampleTable': 'Graph with Data',
+     'Input Data': 'Data',
+     'Input Table': 'Data',
+     'Instances': 'Data',
+     'Items Distance Matrix': 'Distances',
+     'Items Subset': 'Item Subset',
+     'Items to Mark': 'Marked Itenms',
+     'KNN Classifier': 'kNN Classifier',
+     'Marked Examples': 'Marked Data',
+     'Matching Examples': 'Merged Data',
+     'Mismatching Examples': 'Mismatched Data',
+     'Output Data': 'Data',
+     'Output Table': 'Data',
+     'Preprocessed Example Table': 'Preprocessed Data',
+     'Primary Table': 'Primary Data',
+     'Reduced Example Table': 'Reduced Data',
+     'Remaining Examples': 'Remaining Data',
+     'SOMMap': 'SOM',
+     'Sample': 'Data Sample',
+     'Selected Attributes List': 'Selected Features',
+     'Selected Examples': 'Selected Data',
+     'Selected Instances': 'Selected Data',
+     'Selected Items Distance Matrix': 'Distance Matrix',
+     'Shuffled Data Table': 'Shuffled Data',
+     'Train Data': 'Training Data',
+     'Training data': 'Data',
+     'Unselected Examples': 'Other Data',
+     'Unselected Items': 'Other Items',
+     }
+    
+
 class SchemaDoc(QWidget):
     def __init__(self, canvasDlg, *args):
         QWidget.__init__(self, *args)
                     continue
 
                 signalList = eval(signals)
+                
                 for (outName, inName) in signalList:
+                    if not outName in [t[0] for t in outWidget.instance.outputs] \
+                            and outName in _CHANNEL_NAME_MAP:
+                        outName = _CHANNEL_NAME_MAP[outName]
+                        
+                    if not inName in [t[0] for t in inWidget.instance.inputs] \
+                            and inName in _CHANNEL_NAME_MAP:
+                        inName = _CHANNEL_NAME_MAP[inName]
+                        
                     self.addLink(outWidget, inWidget, outName, inName, enabled, saveTempDoc=False)
                 #qApp.processEvents()
         finally:

File orange/OrangeWidgets/Associate/OWAssociationRules.py

     def __init__(self,parent=None, signalManager = None):
         OWWidget.__init__(self, parent, signalManager, "AssociationRules", wantMainArea = 0)
 
-        self.inputs = [("Examples", ExampleTable, self.setData)]
+        self.inputs = [("Data", ExampleTable, self.setData)]
         self.outputs = [("Association Rules", orange.AssociationRules)]
 
         self.useSparseAlgorithm = 0

File orange/OrangeWidgets/Associate/OWAssociationRulesTreeViewer.py

         OWWidget.__init__(self, parent, signalManager, "Association rules viewer")
 
         self.inputs = [("Association Rules", orange.AssociationRules, self.arules)]
-        self.outputs = [("Association Rules", orange.AssociationRules), ("Covered Examples", ExampleTable), ("Matching Examples", ExampleTable), ("Mismatching Examples", ExampleTable)]
+        self.outputs = [("Association Rules", orange.AssociationRules), ("Covered Data", ExampleTable), ("Merged Data", ExampleTable), ("Mismatched Data", ExampleTable)]
 
         self.showWholeRules = 1
         self.treeDepth = 2
         else:
             coveredExamples = matchingExamples = mismatchingExamples = None
 
-        self.send("Covered Examples", coveredExamples)
-        self.send("Matching Examples", matchingExamples)
-        self.send("Mismatching Examples", mismatchingExamples)
+        self.send("Covered Data", coveredExamples)
+        self.send("Merged Data", matchingExamples)
+        self.send("Mismatched Data", mismatchingExamples)
         
 
     def setInfo(self):

File orange/OrangeWidgets/Associate/OWItemsets.py

         OWWidget.__init__(self, parent, signalManager, "Itemsets", wantMainArea = 0)
 
         from OWItemsets import Itemsets
-        self.inputs = [("Examples", ExampleTable, self.setData)]
+        self.inputs = [("Data", ExampleTable, self.setData)]
         self.outputs = [("Itemsets", Itemsets)]
 
         self.minSupport = 60

File orange/OrangeWidgets/Associate/OWItemsetsExplorer.py

         OWWidget.__init__(self, parent, signalManager, "Itemsets explorer")
 
         self.inputs = [("Itemsets", Itemsets, self.setItemsets)]
-        self.outputs = [("Itemsets", Itemsets), ("Examples", ExampleTable)]
+        self.outputs = [("Itemsets", Itemsets), ("Data", ExampleTable)]
 
         self.showWholeItemsets = 1
         self.treeDepth = 2
         else:
             examples = None
 
-        self.send("Examples", examples)
+        self.send("Data", examples)
        
 
     def setInfo(self):

File orange/OrangeWidgets/Classify/OWC45Tree.py

 
         self.callbackDeposit = []
 
-        self.inputs = [("Examples", ExampleTable, self.setData), ("Preprocess", PreprocessedLearner, self.setPreprocessor)]
+        self.inputs = [("Data", ExampleTable, self.setData), ("Preprocess", PreprocessedLearner, self.setPreprocessor)]
         self.outputs = [("Learner", orange.Learner),("Classification Tree", orange.TreeClassifier)]#, ("C45 Tree", orange.C45Classifier)]
 
         # Settings

File orange/OrangeWidgets/Classify/OWCN2.py

     def __init__(self, parent=None, signalManager=None):
         OWWidget.__init__(self,parent,signalManager,"CN2", wantMainArea = 0, resizingEnabled = 0)
 
-        self.inputs = [("Example Table", ExampleTable, self.dataset), ("Preprocess", PreprocessedLearner, self.setPreprocessor)]
+        self.inputs = [("Data", ExampleTable, self.dataset), ("Preprocess", PreprocessedLearner, self.setPreprocessor)]
         self.outputs = [("Learner", orange.Learner),("Classifier",orange.Classifier),("Unordered CN2 Classifier", orngCN2.CN2UnorderedClassifier)]
         self.QualityButton = 0
         self.CoveringButton = 0

File orange/OrangeWidgets/Classify/OWCN2RulesViewer.py

     def __init__(self, parent=None, signalManager=None, name="CN2 Rules Viewer"):
         OWWidget.__init__(self, parent, signalManager, name)
         self.inputs = [("Rule Classifier", orange.RuleClassifier, self.setRuleClassifier)]
-        self.outputs = [("Examples", ExampleTable), ("Attribute List", AttributeList)]
+        self.outputs = [("Data", ExampleTable), ("Features", AttributeList)]
         
         self.show_Rule_length = True
         self.show_Rule_quality = True
             else:
                 selectedExamples = orange.ExampleTable(selectedExamples)
                 
-            self.send("Examples", selectedExamples)
-            self.send("Attribute List", orange.VarList(list(selectedAttrs)))
+            self.send("Data", selectedExamples)
+            self.send("Features", orange.VarList(list(selectedAttrs)))
         
         else:
-            self.send("Examples", None)
-            self.send("Attribute List", None)
+            self.send("Data", None)
+            self.send("Features", None)
         
         self.changedFlag = False
         

File orange/OrangeWidgets/Classify/OWClassificationTree.py

     def __init__(self, parent=None, signalManager = None, name='Classification Tree'):
         OWWidget.__init__(self, parent, signalManager, name, wantMainArea = 0, resizingEnabled = 0)
 
-        self.inputs = [("Examples", ExampleTable, self.setData), ("Preprocess", PreprocessedLearner, self.setPreprocessor)]
+        self.inputs = [("Data", ExampleTable, self.setData), ("Preprocess", PreprocessedLearner, self.setPreprocessor)]
         self.outputs = [("Learner", orange.TreeLearner),("Classification Tree", orange.TreeClassifier)]
 
         self.name = 'Classification Tree'

File orange/OrangeWidgets/Classify/OWClassificationTreeGraph.py

         OWTreeViewer2D.__init__(self, parent, signalManager, name)
 
         self.inputs = [("Classification Tree", orange.TreeClassifier, self.ctree)]
-        self.outputs = [("Examples", ExampleTable)]
+        self.outputs = [("Data", ExampleTable)]
 
         self.scene=TreeGraphicsScene(self)
         self.sceneView=TreeGraphicsView(self, self.scene)
         self.scene.update()
 
     def ctree(self, tree=None):
-        self.send("Examples", None)
+        self.send("Data", None)
         self.closeContext()
         self.targetCombo.clear()
         if tree:

File orange/OrangeWidgets/Classify/OWClassificationTreeViewer.py

 #        self.callbackDeposit = []
 
         self.inputs = [("Classification Tree", orange.TreeClassifier, self.setClassificationTree)]
-        self.outputs = [("Examples", ExampleTable)]
+        self.outputs = [("Data", ExampleTable)]
 
         # Settings
         for s in self.settingsList[:6]:
         self.handleSelectionChanged(item)
         if self.tree and item:
             data = self.nodeClassDict[item].examples
-            self.send("Examples", data)
+            self.send("Data", data)
 
             tx = ""
             f = 1
             else:
                 self.rule.setText("%(className)s = %(classLabel)s" % vars())
         else:
-            self.send("Examples", None)
+            self.send("Data", None)
             self.rule.setText("")
 
     def handleSelectionChanged(self, item):

File orange/OrangeWidgets/Classify/OWEnsemble.py

     def __init__(self, parent=None, signalManager=None, name="Ensemble"):
         OWWidget.__init__(self, parent, signalManager, name, wantMainArea=False)
         
-        self.inputs = [("Learner", orange.Learner, self.setLearner), ("Examples", ExampleTable, self.setData)]
+        self.inputs = [("Learner", orange.Learner, self.setLearner), ("Data", ExampleTable, self.setData)]
         self.outputs = [("Learner", orange.Learner), ("Classifier", orange.Classifier)]
         
         self.method = 0

File orange/OrangeWidgets/Classify/OWITree.py

 
     def __init__(self,parent = None, signalManager = None):
         OWClassificationTreeViewer.__init__(self, parent, signalManager, 'I&nteractive Tree Builder')
-        self.inputs = [("Examples", ExampleTable, self.setData), ("Tree Learner", orange.Learner, self.setLearner)]
-        self.outputs = [("Examples", ExampleTable), ("Classifier", orange.TreeClassifier), ("Tree Learner", orange.Learner)]
+        self.inputs = [("Data", ExampleTable, self.setData), ("Tree Learner", orange.Learner, self.setLearner)]
+        self.outputs = [("Data", ExampleTable), ("Classifier", orange.TreeClassifier), ("Tree Learner", orange.Learner)]
 
         self.attridx = 0
         self.cutoffPoint = 0.0
         self.learner = FixedTreeLearner(self.tree, self.captionTitle)
         self.infoa.setText("Number of nodes: %i" % orngTree.countNodes(self.tree))
         self.infob.setText("Number of leaves: %i" % orngTree.countLeaves(self.tree))
-#        self.send("Examples", self.tree)
+#        self.send("Data", self.tree)
         self.send("Classifier", self.tree)
         self.send("Tree Learner", self.learner)
 
             self.send("Tree Learner", self.learner)
             self.openContext("", None)
 
-        self.send("Examples", None)
+        self.send("Data", None)
         self.updateTree()
         self.v.invisibleRootItem().child(0).setSelected(1)
 

File orange/OrangeWidgets/Classify/OWKNN.py

 
         self.callbackDeposit = []
 
-        self.inputs = [("Examples", ExampleTable, self.setData), ("Preprocess", PreprocessedLearner, self.setPreprocessor)]
-        self.outputs = [("Learner", orange.Learner),("KNN Classifier", orange.kNNClassifier)]
+        self.inputs = [("Data", ExampleTable, self.setData), ("Preprocess", PreprocessedLearner, self.setPreprocessor)]
+        self.outputs = [("Learner", orange.Learner),("kNN Classifier", orange.kNNClassifier)]
 
         self.metricsList = [("Euclidean", orange.ExamplesDistanceConstructor_Euclidean),
                        ("Hamming", orange.ExamplesDistanceConstructor_Hamming),
             except Exception, (errValue):
                 self.classifier = None
                 self.error(str(errValue))
-        self.send("KNN Classifier", self.classifier)
+        self.send("kNN Classifier", self.classifier)
 
 ##############################################################################
 # Test the widget, run from DOS prompt

File orange/OrangeWidgets/Classify/OWLogisticRegression.py

     def __init__ (self, parent=None, signalManager = None, name = "Logistic regression"):
         OWWidget.__init__(self, parent, signalManager, name, wantMainArea = 0, resizingEnabled = 0)
 
-        self.inputs = [("Examples", ExampleTable, self.setData), ("Preprocess", PreprocessedLearner, self.setPreprocessor)]
-        self.outputs = [("Learner", orange.Learner), ("Classifier", orange.Classifier), ("Attributes", list)]
+        self.inputs = [("Data", ExampleTable, self.setData), ("Preprocess", PreprocessedLearner, self.setPreprocessor)]
+        self.outputs = [("Learner", orange.Learner), ("Classifier", orange.Classifier), ("Features", list)]
 
         from orngTree import TreeLearner
         imputeByModel = orange.ImputerConstructor_model()

File orange/OrangeWidgets/Classify/OWMajority.py

 
         self.callbackDeposit = []
 
-        self.inputs = [("Examples", ExampleTable, self.setData), ("Preprocess", PreprocessedLearner, self.setPreprocessor)]
+        self.inputs = [("Data", ExampleTable, self.setData), ("Preprocess", PreprocessedLearner, self.setPreprocessor)]
         self.outputs = [("Learner", orange.Learner),("Classifier", orange.Classifier)]
 
         self.name = 'Majority'

File orange/OrangeWidgets/Classify/OWNaiveBayes.py

 
     def __init__(self, parent=None, signalManager = None, name='NaiveBayes'):
         OWWidget.__init__(self, parent, signalManager, name, wantMainArea = 0, resizingEnabled = 0)
-        self.inputs = [("Examples", ExampleTable, self.setData), ("Preprocess", PreprocessedLearner, self.setPreprocessor)]
+        self.inputs = [("Data", ExampleTable, self.setData), ("Preprocess", PreprocessedLearner, self.setPreprocessor)]
         self.outputs = [("Learner", orange.Learner),("Naive Bayesian Classifier", orange.BayesClassifier)]
 
         self.m_estimator = orange.ProbabilityEstimatorConstructor_m()

File orange/OrangeWidgets/Classify/OWRandomForest.py

     def __init__(self, parent=None, signalManager = None, name='Random Forest'):
         OWWidget.__init__(self, parent, signalManager, name, wantMainArea=False, resizingEnabled=False)
 
-        self.inputs = [("Examples", ExampleTable, self.setData),
+        self.inputs = [("Data", ExampleTable, self.setData),
                        ("Preprocess", PreprocessedLearner, self.setPreprocessor)]
         
         self.outputs = [("Learner", orange.Learner),

File orange/OrangeWidgets/Classify/OWSVM.py

     def __init__(self, parent=None, signalManager=None, name="SVM"):
         OWWidget.__init__(self, parent, signalManager, name, wantMainArea = 0, resizingEnabled = 0)
         
-        self.inputs = [("Example Table", ExampleTable, self.setData),
+        self.inputs = [("Data", ExampleTable, self.setData),
                        ("Preprocess", PreprocessedLearner, self.setPreprocessor)]
         self.outputs = [("Learner", orange.Learner, Default),
                         ("Classifier", orange.Classifier, Default),

File orange/OrangeWidgets/Data/OWConcatenate.py

     
     def __init__(self,parent=None, signalManager = None):
         OWWidget.__init__(self, parent, signalManager, "Concatenate", wantMainArea=0)
-        self.inputs = [("Primary Table", orange.ExampleTable, self.setData), ("Additional Tables", orange.ExampleTable, self.setMoreData, Multiple)]
-        self.outputs = [("Examples", ExampleTable)]
+        self.inputs = [("Primary Data", orange.ExampleTable, self.setData), ("Additional Data", orange.ExampleTable, self.setMoreData, Multiple)]
+        self.outputs = [("Data", ExampleTable)]
 
         self.mergeAttributes = 0
         self.dataSourceSelected = 1
             newTable = table1
 
         self.dataReport = self.prepareDataReport(newTable)
-        self.send("Examples", newTable)
+        self.send("Data", newTable)
 
     def sendReport(self):
         self.reportData(self.primary, "Primary table", 

File orange/OrangeWidgets/Data/OWContinuize.py

     def __init__(self,parent=None, signalManager = None, name = "Continuizer"):
         OWWidget.__init__(self, parent, signalManager, name, wantMainArea = 0)
 
-        self.inputs = [("Examples", ExampleTable, self.setData)]
-        self.outputs = [("Examples", ExampleTable), ("Preprocessor", PreprocessedLearner)]
+        self.inputs = [("Data", ExampleTable, self.setData)]
+        self.outputs = [("Data", ExampleTable), ("Preprocessor", PreprocessedLearner)]
 
         self.multinomialTreatment = 0
         self.targetValue = 0
             self.data = None
             self.cbTargetValue.clear()
             self.openContext("", self.data)
-            self.send("Examples", None)
+            self.send("Data", None)
         else:
             if not self.data or data.domain.classVar != self.data.domain.classVar:
                 self.cbTargetValue.clear()
             else:
                 domain = continuizer(self.data, 0)
             domain.addmetas(self.data.domain.getmetas())
-            self.send("Examples", orange.ExampleTable(domain, self.data))
+            self.send("Data", orange.ExampleTable(domain, self.data))
         self.dataChanged = False
         
     def sendReport(self):

File orange/OrangeWidgets/Data/OWDataDomain.py

     def __init__(self, parent=None, signalManager=None, name="Select Attributes"):
         OWWidget.__init__(self, parent, signalManager, name, wantMainArea=False)
         
-        self.inputs = [("Examples", ExampleTable, self.set_data)]
-        self.outputs = [("Examples", ExampleTable), ("Attribute List", AttributeList)]
+        self.inputs = [("Data", ExampleTable, self.set_data)]
+        self.outputs = [("Data", ExampleTable), ("Features", AttributeList)]
         
         self.domain_role_hints = {}
         
             newdata = Orange.data.Table(domain, self.data)
             self.output_report = self.prepareDataReport(newdata)
             self.output_domain = domain
-            self.send("Examples", newdata)
-            self.send("Attribute List", orange.VarList(attributes))
+            self.send("Data", newdata)
+            self.send("Features", orange.VarList(attributes))
         else:
             self.output_report = []
-            self.send("Examples", None)
-            self.send("Attribute List", None)
+            self.send("Data", None)
+            self.send("Features", None)
     
     def reset(self):
         if self.data is not None:

File orange/OrangeWidgets/Data/OWDataInfo.py

     def __init__(self, parent=None, signalManager=None, name="Info"):
         OWWidget.__init__(self, parent, signalManager, name, wantMainArea=0)
         
-        self.inputs = [("Data Table", ExampleTable, self.data)]
+        self.inputs = [("Data", ExampleTable, self.data)]
         self.rowcount = 0
         self.columncount = 0
         self.discattrcount = 0

File orange/OrangeWidgets/Data/OWDataSampler.py

         OWWidget.__init__(self, parent, signalManager, 'SampleData', wantMainArea = 0)
 
         self.inputs = [("Data", ExampleTable, self.setData)]
-        self.outputs = [("Sample", ExampleTable), ("Remaining Examples", ExampleTable)]
+        self.outputs = [("Data Sample", ExampleTable), ("Remaining Data", ExampleTable)]
 
         # initialization of variables
         self.data = None                        # dataset (incoming stream)
             self.infoa.setText('No data on input.')
             self.infob.setText('')
             self.infoc.setText('')
-            self.send("Sample", None)
-            self.send("Remaining Examples", None)
+            self.send("Data Sample", None)
+            self.send("Remaining Data", None)
             self.data = None
 
     # feeds the output stream
         # send data
         self.nSample = len(sample)
         self.nRemainder = len(remainder) if remainder is not None else 0
-        self.send("Sample", sample)
-        self.send("Remaining Examples", remainder)
+        self.send("Data Sample", sample)
+        self.send("Remaining Data", remainder)
         
         self.sampleButton.setEnabled(False)
 

File orange/OrangeWidgets/Data/OWDataTable.py

     def __init__(self, parent=None, signalManager = None):
         OWWidget.__init__(self, parent, signalManager, "Data Table")
 
-        self.inputs = [("Examples", ExampleTable, self.dataset, Multiple + Default)]
-        self.outputs = [("Selected Examples", ExampleTable, Default), ("Unselected Examples", ExampleTable)]
+        self.inputs = [("Data", ExampleTable, self.dataset, Multiple + Default)]
+        self.outputs = [("Selected Data", ExampleTable, Default), ("Other Data", ExampleTable)]
 
         self.data = {}          # key: id, value: ExampleTable
         self.showMetas = {}     # key: id, value: (True/False, columnList)
             selected = self.getCurrentSelection()
             selection = [1 if i in selected else 0 for i in range(len(model.examples))]
             data = model.examples.select(selection)
-            self.send("Selected Examples", data if len(data) > 0 else None)
+            self.send("Selected Data", data if len(data) > 0 else None)
             data = model.examples.select(selection, 0)
-            self.send("Unselected Examples", data if len(data) > 0 else None)
+            self.send("Other Data", data if len(data) > 0 else None)
         else:
-            self.send("Selected Examples", None)
-            self.send("Unselected Examples", None)
+            self.send("Selected Data", None)
+            self.send("Other Data", None)
             
         self.selectionChangedFlag = False
             

File orange/OrangeWidgets/Data/OWDiscretize.py

 
         self.loadSettings()
 
-        self.inputs=[("Examples", ExampleTable, self.setData)]
-        self.outputs=[("Examples", ExampleTable)]
+        self.inputs=[("Data", ExampleTable, self.setData)]
+        self.outputs=[("Data", ExampleTable)]
         self.measures=[("Information gain", orange.MeasureAttribute_info()),
                        #("Gain ratio", orange.MeasureAttribute_gainRatio),
                        ("Gini", orange.MeasureAttribute_gini()),
         else:
             newdata = None
 
-        self.send("Examples", newdata)
+        self.send("Data", newdata)
         dataChanged = False
 
 

File orange/OrangeWidgets/Data/OWEditDomain.py

     def __init__(self, parent=None, signalManager=None, title="Edit Domain"):
         OWWidget.__init__(self, parent, signalManager, title)
         
-        self.inputs = [("Input Data", Orange.data.Table, self.set_data)]
-        self.outputs = [("Output Data", Orange.data.Table)]
+        self.inputs = [("Data", Orange.data.Table, self.set_data)]
+        self.outputs = [("Data", Orange.data.Table)]
         
         # Settings
         
                 
             new_data = Orange.data.Table(new_domain, self.data)
         
-        self.send("Output Data", new_data)
+        self.send("Data", new_data)
         self.changed_flag = False
             
         

File orange/OrangeWidgets/Data/OWFeatureConstructor.py

     def __init__(self,parent=None, signalManager = None):
         OWWidget.__init__(self, parent, signalManager, "FeatureConstructor")
 
-        self.inputs = [("Examples", orange.ExampleTable, self.setData)]
-        self.outputs = [("Examples", ExampleTable)]
+        self.inputs = [("Data", orange.ExampleTable, self.setData)]
+        self.outputs = [("Data", ExampleTable)]
 
         self.expression = self.attrname = ""
         self.selectedDef = []
     def apply(self):
         self.dataChanged = False
         if not self.data:
-            self.send("Examples", None)
+            self.send("Data", None)
             return
 
         oldDomain = self.data.domain
         for name in names:
             if names.count(name)>1 or name in oldDomain > 1:
                 self.error(1, "Multiple attributes with the same name (%s)" % name)
-                self.send("Examples", None)
+                self.send("Data", None)
                 return
 
         unknown = [[name, exp, set([id[0] or id[1] for id in re_identifier.findall(exp) if id[0] in names or id[1][1:-1] in names])] for name, exp in self.definitions]
                     solved.add(name)
             if not solved:
                 self.error(1, "Circular attribute definitions (%s)" % ", ".join([x[0] for x in unknown]))
-                self.send("Examples", None)
+                self.send("Data", None)
                 return
             for name, exp, unk_attrs in unknown:
                 unk_attrs -= solved
 
         newDomain = orange.Domain(oldDomain.attributes + [orange.FloatVariable(str(attrname), getValueFrom = AttrComputer(reinserted[attrname])) for attrname in names], oldDomain.classVar)
         newDomain.addmetas(oldDomain.getmetas())
-        self.send("Examples", orange.ExampleTable(newDomain, self.data))
+        self.send("Data", orange.ExampleTable(newDomain, self.data))

File orange/OrangeWidgets/Data/OWFile.py

         OWWidget.__init__(self, parent, signalManager, "File", wantMainArea = 0, resizingEnabled = 1)
 
         self.inputs = []
-        self.outputs = [("Examples", ExampleTable)]
+        self.outputs = [("Data", ExampleTable)]
 
         self.recentFiles=["(none)"]
         self.symbolDC = "?"
         self.loadedFile = ""
         
         if fn == "(none)":
-            self.send("Examples", None)
+            self.send("Data", None)
             self.infoa.setText("No data loaded")
             self.infob.setText("")
             self.warnings.setText("")
             data.name = fName
 
         self.dataReport = self.prepareDataReport(data)
-        self.send("Examples", data)
+        self.send("Data", data)
         if self.processingHandler: self.processingHandler(self, 0)    # remove focus from this widget
 
     def sendReport(self):

File orange/OrangeWidgets/Data/OWImageViewer.py

     def __init__(self, parent=None, signalManager=None, name="Image viewer"):
         OWWidget.__init__(self, parent, signalManager, name, wantGraph=True)
         
-        self.inputs = [("Example Table", ExampleTable, self.setData)]
-        self.outputs = [("Example Table", ExampleTable)]
+        self.inputs = [("Data", ExampleTable, self.setData)]
+        self.outputs = [("Data", ExampleTable)]
         
         self.imageAttr = 0
         self.titleAttr = 0
                 selected = orange.ExampleTable(self.data.domain, self.selectedExamples)
             else:
                 selected = None
-            self.send("Example Table", selected)
+            self.send("Data", selected)
         else:
-            self.send("Example Table", None)
+            self.send("Data", None)
         self.selectionChangedFlag = False
             
     def saveScene(self):

File orange/OrangeWidgets/Data/OWImpute.py

     def __init__(self,parent=None, signalManager = None, name = "Impute"):
         OWWidget.__init__(self, parent, signalManager, name, wantMainArea = 0)
 
-        self.inputs = [("Examples", ExampleTable, self.setData, Default), ("Learner for Imputation", orange.Learner, self.setModel)]
-        self.outputs = [("Examples", ExampleTable), ("Imputer", orange.ImputerConstructor)]
+        self.inputs = [("Data", ExampleTable, self.setData, Default), ("Learner for Imputation", orange.Learner, self.setModel)]
+        self.outputs = [("Data", ExampleTable), ("Imputer", orange.ImputerConstructor)]
 
         self.attrIcons = self.createAttributeIconDict()
 
         if not data or not len(data.domain):
             self.indibox.setDisabled(True)
             self.data = None
-            self.send("Examples", data)
+            self.send("Data", data)
             self.attrList.clear()
         else:
             self.indibox.setDisabled(False)
                     data = None
             else:
                 data = None
-            self.send("Examples", data)
+            self.send("Data", data)
         else:
             self.dataChanged = False
 

File orange/OrangeWidgets/Data/OWMergeData.py

         OWWidget.__init__(self, parent, signalManager, name, wantMainArea = 0)  #initialize base class
 
         # set channels
-        self.inputs = [("Examples A", ExampleTable, self.onDataAInput),
-                       ("Examples B", ExampleTable, self.onDataBInput)]
+        self.inputs = [("Data", ExampleTable, self.onDataAInput),
+                       ("Data", ExampleTable, self.onDataBInput)]
         
         self.outputs = [("Merged Examples A+B", ExampleTable),
                         ("Merged Examples B+A", ExampleTable)]

File orange/OrangeWidgets/Data/OWOutliers.py

     def __init__(self, parent=None, signalManager = None, name='Outlier'):
         OWWidget.__init__(self, parent, signalManager, name, wantMainArea = 0)
 
-        self.inputs = [("Examples", ExampleTable, self.cdata),("Distance matrix", orange.SymMatrix, self.cdistance)]
+        self.inputs = [("Data", ExampleTable, self.cdata),("Distances", orange.SymMatrix, self.cdistance)]
         self.outputs = [("Outliers", ExampleTable), ("Inliers", ExampleTable), ("Examples with Z-scores", ExampleTable)]
                
         # Settings

File orange/OrangeWidgets/Data/OWPaintData.py

     def __init__(self, parent=None, signalManager=None, name="Data Generator"):
         OWWidget.__init__(self, parent, signalManager, name, wantGraph=True)
         
-        self.outputs = [("Example Table", ExampleTable)]
+        self.outputs = [("Data", ExampleTable)]
         
         self.addClassAsMeta = False
         self.attributes = []
             # Remove the useless class variable.
             domain = orange.Domain(data.domain.attributes, None)
             data = orange.ExampleTable(domain, data)
-        self.send("Example Table", data)
+        self.send("Data", data)
         
         
 if __name__ == "__main__":

File orange/OrangeWidgets/Data/OWPreprocess.py

     def __init__(self, parent=None, signalManager=None, name="Preprocess"):
         OWWidget.__init__(self, parent, signalManager, name)
         
-        self.inputs = [("Example Table", ExampleTable, self.setData)] #, ("Learner", orange.Learner, self.setLearner)]
-        self.outputs = [("Preprocess", orngWrap.PreprocessedLearner), ("Preprocessed Example Table", ExampleTable)] #, ("Preprocessor", orange.Preprocessor)]
+        self.inputs = [("Data", ExampleTable, self.setData)] #, ("Learner", orange.Learner, self.setLearner)]
+        self.outputs = [("Preprocess", orngWrap.PreprocessedLearner), ("Preprocessed Data", ExampleTable)] #, ("Preprocessor", orange.Preprocessor)]
         
         self.autoCommit = False
         self.changedFlag = False
         wrap = orngWrap.PreprocessedLearner(list(self.preprocessorsList))
         if self.data is not None:
             data = wrap.processData(self.data)
-            self.send("Preprocessed Example Table", data)
+            self.send("Preprocessed Data", data)
         self.send("Preprocess", wrap)
             
 #        self.send("Preprocessor", Preprocessor_preprocessorList(list(self.preprocessorsList)))

File orange/OrangeWidgets/Data/OWPurgeDomain.py

         OWWidget.__init__(self, parent, signalManager, 'PurgeDomain', wantMainArea=False)
         self.settingsList=["removeValues", "removeAttributes", "removeClassAttribute", "removeClasses", "autoSend", "sortValues", "sortClasses"]
 
-        self.inputs = [("Examples", ExampleTable, self.setData)]
-        self.outputs = [("Examples", ExampleTable)]
+        self.inputs = [("Data", ExampleTable, self.setData)]
+        self.outputs = [("Data", ExampleTable)]
 
         self.data = None
 
             self.process()
         else:
             self.reducedAttrs = self.removedAttrs = self.resortedAttrs = self.classAttr = ""
-            self.send("Examples", None)
+            self.send("Data", None)
             self.data = None
         self.dataChanged = False
 
         else:
             newData = self.data
 
-        self.send("Examples", newData)
+        self.send("Data", newData)
 
         self.dataChanged = False
 

File orange/OrangeWidgets/Data/OWRank.py

     def __init__(self,parent=None, signalManager = None):
         OWWidget.__init__(self, parent, signalManager, "Rank")
 
-        self.inputs = [("Examples", ExampleTable, self.setData)]
-        self.outputs = [("Reduced Example Table", ExampleTable, Default + Single)]
+        self.inputs = [("Data", ExampleTable, self.setData)]
+        self.outputs = [("Reduced Data", ExampleTable, Default + Single)]
 
         self.nDecimals = 3
         self.nIntervals = 4
     def apply(self):
         selected = self.selectedAttrs()
         if not self.data or not selected:
-            self.send("Reduced Example Table", None)
+            self.send("Reduced Data", None)
         else:
             domain = orange.Domain(selected, self.data.domain.classVar)
             domain.addmetas(self.data.domain.getmetas())
             data = orange.ExampleTable(domain, self.data)
-            self.send("Reduced Example Table", data)
+            self.send("Reduced Data", data)
         self.dataChanged = False
         
     def selectedAttrs(self):

File orange/OrangeWidgets/Data/OWSave.py

     def __init__(self,parent=None, signalManager = None):
         OWWidget.__init__(self, parent, signalManager, "Save", wantMainArea = 0, resizingEnabled = 0)
 
-        self.inputs = [("Examples", ExampleTable, self.dataset)]
+        self.inputs = [("Data", ExampleTable, self.dataset)]
         self.outputs = []
 
         self.recentFiles=[]

File orange/OrangeWidgets/Data/OWSelectData.py

     def __init__(self, parent = None, signalManager = None, name = "Select data"):
         OWWidget.__init__(self, parent, signalManager, name, wantMainArea = 0)  #initialize base class
 
-        self.inputs = [("Examples", ExampleTable, self.setData)]
-        self.outputs = [("Matching Examples", ExampleTable, Default), ("Non-Matching Examples", ExampleTable)]
+        self.inputs = [("Data", ExampleTable, self.setData)]
+        self.outputs = [("Merged Data", ExampleTable, Default), ("Non-Matching Examples", ExampleTable)]
 
         self.name2var = {}   # key: variable name, item: orange.Variable
         self.Conditions = []
                 if newDomain != nonMatchingOutput.domain:
                     nonmatchingOutput = orange.ExampleTable(newDomain, nonMatchingOutput)
 
-        self.send("Matching Examples", matchingOutput)
+        self.send("Merged Data", matchingOutput)
         self.send("Non-Matching Examples", nonMatchingOutput)
 
         self.updateInfoOut(matchingOutput)

File orange/OrangeWidgets/Evaluate/OWConfusionMatrix.py

 
         # inputs
         self.inputs=[("Evaluation Results", orngTest.ExperimentResults, self.setTestResults, Default)]
-        self.outputs=[("Selected Examples", ExampleTable, 8)]
+        self.outputs=[("Selected Data", ExampleTable, 8)]
 
         self.selectedLearner = []
         self.learnerNames = []
         selected = [(x.row(), x.column()) for x in self.table.selectedIndexes()]
         res = self.res
         if not res or not selected or not self.selectedLearner:
-            self.send("Selected Examples", None)
+            self.send("Selected Data", None)
             return
 
         learnerI = self.selectedLearner[0]
                     for id, p in zip(probIds, res.results[i].probabilities[learnerI]):
                         ex[id] = p
     
-        self.send("Selected Examples", data)
+        self.send("Selected Data", data)
 
 
 if __name__ == "__main__":

File orange/OrangeWidgets/Evaluate/OWPredictions.py

         OWWidget.__init__(self, parent, signalManager, "Predictions")
 
         self.callbackDeposit = []
-        self.inputs = [("Examples", ExampleTable, self.setData), ("Predictors", orange.Classifier, self.setPredictor, Multiple)]
+        self.inputs = [("Data", ExampleTable, self.setData), ("Predictors", orange.Classifier, self.setPredictor, Multiple)]
         self.outputs = [("Predictions", ExampleTable)]
         self.predictors = {}
 

File orange/OrangeWidgets/Evaluate/OWReliability.py

         OWWidget.__init__(self, parent, signalManager, title, wantMainArea=False)
         
         self.inputs = [("Learner", Orange.core.Learner, self.set_learner),
-                       ("Train Data", Orange.data.Table, self.set_train_data),
+                       ("Training Data", Orange.data.Table, self.set_train_data),
                        ("Test Data", Orange.data.Table, self.set_test_data)]
         
         self.outputs = [("Reliability Scores", Orange.data.Table)]

File orange/OrangeWidgets/Prototypes/OWAddRowIds.py

     def __init__(self, parent=None, signalManager=None, title="Add row ids"):
         OWWidget.__init__(self, parent, signalManager, title, wantMainArea=False)
         
-        self.inputs = [("Input Table", Orange.data.Table, self.set_table)]
-        self.outputs = [("Output Table", Orange.data.Table)]
+        self.inputs = [("Data", Orange.data.Table, self.set_table)]
+        self.outputs = [("Data", Orange.data.Table)]
         
         self.use_guid = False
         
         else:
             table = None
             
-        self.send("Output Table", table)
+        self.send("Data", table)
             
             
                 

File orange/OrangeWidgets/Prototypes/OWCalibratedClassifier.py

     def __init__(self, parent=None, signalManager = None, title = "Calibrated Classifier"):
         OWWidget.__init__(self, parent, signalManager, title)
 
-        self.inputs = [("Examples", ExampleTable, self.setData), ("Base Learner", orange.Learner, self.setBaseLearner)]
+        self.inputs = [("Data", ExampleTable, self.setData), ("Base Learner", orange.Learner, self.setBaseLearner)]
         self.outputs = [("Learner", orange.Learner),("Classifier", orange.Classifier)]
 
         # Settings

File orange/OrangeWidgets/Prototypes/OWCompare.py

 
     def __init__(self,parent=None, signalManager = None):
         OWWidget.__init__(self, parent, signalManager, "Compare Examples")
-        self.inputs = [("Examples", ExampleTable, self.setData, Default)]
+        self.inputs = [("Data", ExampleTable, self.setData, Default)]
         self.outputs = [("Bars", list, Default)]
         self.icons = self.createAttributeIconDict()
 

File orange/OrangeWidgets/Prototypes/OWCorrelations.py

         OWBaseWidget.__init__(self, parent, signalManager, title,)
 #                          wantMainAre=False, noReport=True)
         
-        self.inputs = [("Example Table", Orange.data.Table, self.set_data)]
+        self.inputs = [("Data", Orange.data.Table, self.set_data)]
         
         self.outputs = [("Correlations", Orange.data.Table),
                         ("Variables", AttributeList)]

File orange/OrangeWidgets/Prototypes/OWDataDomainMk2.py

     def __init__(self, parent=None, signalManager=None, name="Select Attributes Mk2"):
         OWWidget.__init__(self, parent, signalManager, name, wantMainArea=False)
         
-        self.inputs = [("Examples", ExampleTable, self.set_data)]
-        self.outputs = [("Examples", ExampleTable), ("Attribute List", AttributeList)]
+        self.inputs = [("Data", ExampleTable, self.set_data)]
+        self.outputs = [("Data", ExampleTable), ("Features", AttributeList)]
         
         self.domain_role_hints = {}
         
             newdata = Orange.data.Table(domain, self.data)
             self.output_report = self.prepareDataReport(newdata)
             self.output_domain = domain
-            self.send("Examples", newdata)
-            self.send("Attribute List", orange.VarList(attributes))
+            self.send("Data", newdata)
+            self.send("Features", orange.VarList(attributes))
         else:
             self.output_report = []
-            self.send("Examples", None)
-            self.send("Attribute List", None)
+            self.send("Data", None)
+            self.send("Features", None)
     
     def reset(self):
         if self.data is not None:

File orange/OrangeWidgets/Prototypes/OWGaussianMixtures.py

     def __init__(self, parent=None, signalManager=None, title="Gaussin Mixture"):
         OWWidget.__init__(self, parent, signalManager, title)
         
-        self.inputs = [("Data Instances", Orange.data.Table, self.set_data)]
+        self.inputs = [("Data", Orange.data.Table, self.set_data)]
         self.outputs = [("Data with Indicator Matrix", Orange.data.Table)]
         
         self.init_method = 0

File orange/OrangeWidgets/Prototypes/OWGroupBy.py

         OWWidget.__init__(self, parent, signalManager, title, 
                           wantMainArea=False)
         
-        self.inputs = [("Input Data", Table, self.set_data)]
-        self.outputs = [("Output Data", Table)]
+        self.inputs = [("Data", Table, self.set_data)]
+        self.outputs = [("Data", Table)]
         
         self.auto_commit = False
         self.hints = {}
             data = utils.group_by(self.data, group, attr_aggregate=aggregates)
         else:
             data = None
-        self.send("Output Data", data)
+        self.send("Data", data)
         self.state_chaged_flag = False
         
 

File orange/OrangeWidgets/Prototypes/OWInteractionGraphProto.py

     def __init__(self, parent=None, signalManager = None):
         OWWidget.__init__(self, parent, signalManager, "Interaction graph")
 
-        self.inputs = [("Examples", ExampleTable, self.setData)]
-        self.outputs = [("Examples", ExampleTable), ("Attribute Pair", list), ("Selected Attributes List", list), ("Network", Network)]
+        self.inputs = [("Data", ExampleTable, self.setData)]
+        self.outputs = [("Data", ExampleTable), ("Interacting Features", list), ("Selected Features", list), ("Network", Network)]
 
 
         #set default settings
                 
             for (attr1, attr2, rect) in self.lines:
                 if self.clickInside(rect.rect(), ev.pos()) == 1:
-                    self.send("Attribute Pair", [attr1, attr2])
+                    self.send("Interacting Features", [attr1, attr2])
                     return
                 
         elif ev.button() == Qt.LeftButton and name == "interactions":
                 if 1 in [self.clickInside(item.rect(), ev.pos()) for item in [rect1, rect2, rect3, nbrect]]:
                     (rect1, rect2, rect3, nbrect, text1, text2) = rects
                     if rect2.pen().color() == Qt.green:
-                        self.send("Attribute Pair", [str(text1.text()), str(text2.text())])
+                        self.send("Interacting Features", [str(text1.text()), str(text2.text())])
                     
         elif ev.button() == Qt.LeftButton and name == "correlations":
             self.rest = None
                 if 1 in [self.clickInside(item.rect(), ev.pos()) for item in [rect1, rect2, rect3, nbrect]]:
                     (rect1, rect2, rect3, nbrect, text1, text2) = rects
                     if rect2.pen().color() != Qt.green:
-                        self.send("Attribute Pair", [str(text1.text()), str(text2.text())])
+                        self.send("Interacting Features", [str(text1.text()), str(text2.text())])
 
         elif ev.button() == Qt.RightButton and (name == "interactions" or name == "correlations") and self.mergeAttributes:
             found = 0
     def selectionClick(self):
         if self.data == None: return
         l = [str(self.shownAttribsLB.item(i).text()) for i in range(self.shownAttribsLB.count())]
-        self.send("Selected Attributes List", l)
+        self.send("Selected Features", l)
 
 
     # receive new data and update all fields
 
         self.updateCanvas()
 
-        self.send("Examples", data)
+        self.send("Data", data)
         self.send("Network", self.graph)
 
     #########################################

File orange/OrangeWidgets/Prototypes/OWItemsetViz.py

     def __init__(self, parent=None, signalManager=None):
         OWWidget.__init__(self, parent, signalManager, 'Itemset visualizer')
 
-        self.inputs = [("Graph with ExampleTable", orange.Graph, self.setGraph), ("Example Subset", orange.ExampleTable, self.setExampleSubset)]
-        self.outputs=[("Selected Examples", ExampleTable), ("Selected Graph", orange.Graph)]
+        self.inputs = [("Graph with Data", orange.Graph, self.setGraph), ("Data Subset", orange.ExampleTable, self.setExampleSubset)]
+        self.outputs=[("Selected Data", ExampleTable), ("Selected Graph", orange.Graph)]
         
         self.markerAttributes = []
         self.tooltipAttributes = []
         
         if graph != None:
             if graph.items != None:
-                self.send("Selected Examples", graph.items)
+                self.send("Selected Data", graph.items)
             else:
-                self.send("Selected Examples", self.graph.getSelectedExamples())
+                self.send("Selected Data", self.graph.getSelectedExamples())
                 
             self.send("Selected Graph", graph)
         else:
             items = self.graph.getSelectedExamples()
             if items != None:
-                self.send("Selected Examples", items)
+                self.send("Selected Data", items)
             self.send("Selected Graph", None)
    
     

File orange/OrangeWidgets/Prototypes/OWLogTransform.py

 
     def __init__(self,parent=None, signalManager = None):
         OWWidget.__init__(self, parent, signalManager, "Compare Examples")
-        self.inputs = [("Examples", ExampleTable, self.setData, Default)]
-        self.outputs = [("Examples", ExampleTable, Default)]
+        self.inputs = [("Data", ExampleTable, self.setData, Default)]
+        self.outputs = [("Data", ExampleTable, Default)]
         
         self.transformed = []
         self.controlArea.setFixedWidth(0)
             oldDomain = self.data.domain
             newDomain = orange.Domain([transs.get(attr.name, attr) for attr in oldDomain.attributes],
                                       transs.get(oldDomain.classVar.name, oldDomain.classVar))
-            self.send("Examples", orange.ExampleTable(newDomain, self.data))
+            self.send("Data", orange.ExampleTable(newDomain, self.data))

File orange/OrangeWidgets/Prototypes/OWMissingValues.py

 
     def __init__(self,parent=None, signalManager = None):
         OWWidget.__init__(self, parent, signalManager, "Compare Examples", noReport=True)
-        self.inputs = [("Instances", ExampleTable, self.setData, Default)]
-        self.outputs = [("Instances", ExampleTable, Default), ("Selected Instances", ExampleTable)]
+        self.inputs = [("Data", ExampleTable, self.setData, Default)]
+        self.outputs = [("Data", ExampleTable, Default), ("Selected Data", ExampleTable)]
         
         self.check = []
         self.resize(520, 560)
             self.dataout = orange.ExampleTable(orange.Domain(variables), dataout)
         else:
             self.dataout = None
-        self.send("Instances", self.dataout)
+        self.send("Data", self.dataout)
             
     def sendSelected(self):
         toSend = None
                 filt_unk.negate=1
                 filt_unk.check = [i==row for i in range(len(data.domain))]
                 toSend = data.filterref(filt_unk)
-        self.send("Selected Instances", toSend)
+        self.send("Selected Data", toSend)
 
     def sendReport(self):
         import OWReport

File orange/OrangeWidgets/Prototypes/OWModelMap.py

         OWNxExplorer.__init__(self, parent, signalManager, name, 
                                NetworkCanvas=OWModelMapCanvas)
         
-        self.inputs = [("Distance Matrix", orange.SymMatrix, self.setMatrix, Default),
+        self.inputs = [("Distances", orange.SymMatrix, self.setMatrix, Default),
                        ("Model Subset", orange.ExampleTable, self.setSubsetModels)]
         self.outputs = [("Model", orange.Example),
                         ("Classifier", orange.Classifier),

File orange/OrangeWidgets/Prototypes/OWPivot.py

     
     def __init__(self,parent=None, signalManager = None):
         OWWidget.__init__(self, parent, signalManager, "Pivot")
-        self.inputs = [("Examples", ExampleTable, self.setData, Default)]
+        self.inputs = [("Data", ExampleTable, self.setData, Default)]
         self.outputs = [("Selected Group", ExampleTable, Default)]
         self.settingsList = [a[1] for a in self.aggregates]
         self.icons = self.createAttributeIconDict() 

File orange/OrangeWidgets/Prototypes/OWQuickSelect.py

        
     def __init__(self,parent=None, signalManager = None):
         OWWidget.__init__(self, parent, signalManager, "Quick Select", wantMainArea=0)
-        self.inputs = [("Examples", ExampleTable, self.setData, Default)]
-        self.outputs = [("Selected Examples", ExampleTable, Default), ("Remaining Examples", ExampleTable)]
+        self.inputs = [("Data", ExampleTable, self.setData, Default)]
+        self.outputs = [("Selected Data", ExampleTable, Default), ("Remaining Data", ExampleTable)]
         self.icons = self.createAttributeIconDict()
 
         self.attributes = []
         
     def updateOutput(self):
         if not self.data or not self.selectedAttribute or not self.selectedValues:
-            self.send("Selected Examples", None)
-            self.send("Remaining Examples", None)
+            self.send("Selected Data", None)
+            self.send("Remaining Data", None)
             self.outSelected = self.outRemaining = 0
             return
         
         pp = orange.Preprocessor_take() 
         pp.values[attr] = [self.valuesList[j].encode("utf-8") for j in self.selectedValues]
         selected = pp(self.data)
-        self.send("Selected Examples", selected)
+        self.send("Selected Data", selected)
         
         pp = orange.Preprocessor_drop() 
         pp.values[attr] = [self.valuesList[j].encode("utf-8") for j in self.selectedValues]
         remaining = pp(self.data)
-        self.send("Remaining Examples", remaining)
+        self.send("Remaining Data", remaining)
 
         self.outSelected = len(selected)
         self.outRemaining = len(remaining)

File orange/OrangeWidgets/Prototypes/OWRandomForestOld.py

     def __init__(self, parent=None, signalManager = None, name='Random Forest'):
         OWWidget.__init__(self, parent, signalManager, name, wantMainArea=False, resizingEnabled=False)
 
-        self.inputs = [("Examples", ExampleTable, self.setData), ("Preprocess", PreprocessedLearner, self.setPreprocessor)]
-        self.outputs = [("Learner", orange.Learner),("Random Forest Classifier", orange.Classifier),("Choosen Tree", orange.TreeClassifier) ]
+        self.inputs = [("Data", ExampleTable, self.setData), ("Preprocess", PreprocessedLearner, self.setPreprocessor)]
+        self.outputs = [("Learner", orange.Learner),("Random Forest Classifier", orange.Classifier),("Selected Tree", orange.TreeClassifier) ]
 
         self.name = 'Random Forest'
         self.trees = 10
         elif self.outtree >= self.claTrees: self.outtree = 0
 
     def extree(self):
-        self.send("Choosen Tree", self.classifier.classifiers[self.outtree])
+        self.send("Selected Tree", self.classifier.classifiers[self.outtree])
 
     def streeEnabled(self, status):
         if status:

File orange/OrangeWidgets/Prototypes/OWSQL.py

     settingsList = ["host", "username", "password", "showPassword", "database", "query", "library", "lastDir", "databaseType"]
     def __init__(self,parent=None, signalManager = None):
         OWWidget.__init__(self, parent, signalManager, "Compare Examples", wantMainArea=0)
-        self.outputs = [("Examples", ExampleTable, Default)]
+        self.outputs = [("Data", ExampleTable, Default)]
 
         self.host = "localhost"
         self.username = "root"
                 self.error = "Error: " + str(d)
             self.errorIcon.setVisible(True)
             data = None
-        self.send("Examples", data)
+        self.send("Data", data)
         
     def saveToLibrary(self):
         ci = self.libraryList.currentItem()

File orange/OrangeWidgets/Prototypes/OWSQLSelect.py

             self.sqlReader.execute(query)
         except Exception, e:
             self.setInfo(('Query failed:', str(e)))
-        self.send("Examples", self.sqlReader.data())
+        self.send("Data", self.sqlReader.data())
         self.setInfo(('Query returned', 'Read ' + str(len(self.sqlReader.data())) + ' examples!'))
-        self.send("Attribute Definitions", self.sqlReader.domain)
+        self.send("Feature Definitions", self.sqlReader.domain)
         self.setMeta()
         self.lastQuery = query
     
         OWSubSQLSelect.__init__(self, parent, signalManager, "SQL select")
         self.sqlReader = orngSQL.SQLReader()
         self.inputs = []
-        self.outputs = [("Examples", ExampleTable), ("Attribute Definitions", orange.Domain)]
+        self.outputs = [("Data", ExampleTable), ("Feature Definitions", orange.Domain)]
 
         #set default settings
         self.domain = None

File orange/OrangeWidgets/Prototypes/OWShuffle.py

         OWWidget.__init__(self, parent, signalManager, title,
                           wantMainArea=False)
         
-        self.inputs = [("Data Table", Orange.data.Table, self.set_data)]
-        self.outputs = [("Shuffled Data Table", Orange.data.Table)]
+        self.inputs = [("Data", Orange.data.Table, self.set_data)]
+        self.outputs = [("Shuffled Data", Orange.data.Table)]
         
         self.seed = 0
         
             rand.shuffle(shuffled)
             shuffled = Orange.data.Table(shuffled) if shuffled else \
                        Orange.data.Table(self.data.domain) # In case of empty table
-        self.send("Shuffled Data Table", shuffled)
+        self.send("Shuffled Data", shuffled)
     

File orange/OrangeWidgets/Prototypes/OWTimeDataVisualizer.py

     def __init__(self, parent=None, signalManager = None):
         OWWidget.__init__(self, parent, signalManager, "Time Data Visualizer", TRUE)
 
-        self.inputs =  [("Examples", ExampleTable, self.setData, Default), ("Example Subset", ExampleTable, self.setSubsetData), ("Attribute selection", AttributeList, self.setShownAttributes)]
-        self.outputs = [("Selected Examples", ExampleTable), ("Unselected Examples", ExampleTable)]
+        self.inputs =  [("Data", ExampleTable, self.setData, Default), ("Data Subset", ExampleTable, self.setSubsetData), ("Features", AttributeList, self.setShownAttributes)]
+        self.outputs = [("Selected Data", ExampleTable), ("Other Data", ExampleTable)]
 
         # local variables
         self.autoSendSelection = 1
     def sendSelections(self):
         pass
 #        (selected, unselected) = self.graph.getSelectionsAsExampleTables([self.attrX, self.attrY])
-#        self.send("Selected Examples",selected)
-#        self.send("Unselected Examples",unselected)
+#        self.send("Selected Data",selected)
+#        self.send("Other Data",unselected)
 
 
     # ##############################################################################################################################################################

File orange/OrangeWidgets/Prototypes/OWTimeline.py

 
     def __init__(self, parent=None, signalManager=None, name="Timeline"):
         OWWidget.__init__(self, parent, signalManager, name)
-        self.inputs = [("Examples", ExampleTable, self.setData)]
+        self.inputs = [("Data", ExampleTable, self.setData)]
         self.outputs = []
         self.lineDistance = 40
         self.timeScale = 2

File orange/OrangeWidgets/Regression/OWEarth.py

                  title="Earth"):
         OWWidget.__init__(self, parent, signalManager, title, wantMainArea=False)
         
-        self.inputs = [("Training data", Orange.data.Table, self.set_data), ("Preprocessor", PreprocessedLearner, self.set_preprocessor)]
+        self.inputs = [("Data", Orange.data.Table, self.set_data), ("Preprocessor", PreprocessedLearner, self.set_preprocessor)]
         self.outputs = [("Learner", earth.EarthLearner), ("Predictor", earth.EarthClassifier)]
         
         self.name = "Earth Learner"

File orange/OrangeWidgets/Regression/OWKNNRegression.py

     def __init__(self, parent=None, signalManager=None, title="kNN Regression"):
         OWKNN.__init__(self, parent, signalManager, title)
         
-        self.inputs = [("Examples", ExampleTable, self.setData), ("Preprocess", PreprocessedLearner, self.setPreprocessor)]
-        self.outputs = [("Learner", orange.Learner),("KNN Classifier", orange.kNNClassifier)]
+        self.inputs = [("Data", ExampleTable, self.setData), ("Preprocess", PreprocessedLearner, self.setPreprocessor)]
+        self.outputs = [("Learner", orange.Learner),("kNN Classifier", orange.kNNClassifier)]
             
     def setData(self,data):
         self.data = self.isDataWithClass(data, orange.VarTypes.Continuous, checkMissing=True) and data or None

File orange/OrangeWidgets/Regression/OWLinearRegression.py

     def __init__(self, parent=None, signalManager=None, title="Linear Regression"):
         OWWidget.__init__(self, parent, signalManager, title, wantMainArea=False)
         
-        self.inputs = [("Training data", Orange.data.Table, self.set_data),
+        self.inputs = [("Data", Orange.data.Table, self.set_data),
                        ("Preprocessor", PreprocessedLearner, self.set_preprocessor)]
         
         self.outputs = [("Learner", Orange.core.Learner), 

File orange/OrangeWidgets/Regression/OWMean.py

     def __init__(self, parent=None, signalManager=None, title="Mean"):
         OWWidget.__init__(self, parent, signalManager, title, wantMainArea=False)
 
-        self.inputs = [("Examples", ExampleTable, self.setData),
+        self.inputs = [("Data", ExampleTable, self.setData),
                        ("Preprocess", PreprocessedLearner, self.setPreprocessor)]
         
         self.outputs = [("Learner", orange.Learner),

File orange/OrangeWidgets/Regression/OWPLS.py

     def __init__(self, parent=None, signalManager=None, title="PLS Regression"):
         OWWidget.__init__(self, parent, signalManager, title, wantMainArea=False)
         
-        self.inputs = [("Training data", Orange.data.Table, self.set_data),
+        self.inputs = [("Data", Orange.data.Table, self.set_data),
                        ("Preprocessor", PreprocessedLearner, self.set_preprocessor)]
         
         self.outputs = [("Learner", Orange.core.Learner), 

File orange/OrangeWidgets/Regression/OWPade.py

     
     def __init__(self, parent = None, signalManager = None, name = "Pade"):
         OWWidget.__init__(self, parent, signalManager, name, wantMainArea = 0)  #initialize base class
-        self.inputs = [("Examples", ExampleTable, self.onDataInput)]
-        self.outputs = [("Examples", ExampleTable)]
+        self.inputs = [("Data", ExampleTable, self.onDataInput)]
+        self.outputs = [("Data", ExampleTable)]
 
         self.attributes = []
         self.dimensions = []
     def apply(self):
         data = self.data
         if not data or not self.contAttributes:
-            self.send("Examples", None)
+            self.send("Data", None)
             return
 
         if not self.deltas:
                                                              not self.output and -1 or self.outputAttr,
                                                              self.enableThreshold and abs(self.threshold),
                                                              self.useMQCNotation, self.derivativeAsMeta, self.differencesAsMeta, False, self.originalAsMeta)
-        self.send("Examples", paded)
+        self.send("Data", paded)
 
 
 

File orange/OrangeWidgets/Regression/OWRandomForestRegression.py

     def __init__(self, parent=None, signalManager=None, title="Random forest regression"):
         OWRandomForest.__init__(self, parent, signalManager, title)
         
-        self.inputs = [("Examples", ExampleTable, self.setData),
+        self.inputs = [("Data", ExampleTable, self.setData),
                        ("Preprocess", PreprocessedLearner, self.setPreprocessor)]
         
         self.outputs = [("Learner", orange.Learner),

File orange/OrangeWidgets/Regression/OWRegressionTree.py

         self.data=None
         self.preprocessor = None
 
-        self.inputs=[("Example Table",ExampleTable,self.dataset), ("Preprocess", PreprocessedLearner, self.setPreprocessor)]
+        self.inputs=[("Data",ExampleTable,self.dataset), ("Preprocess", PreprocessedLearner, self.setPreprocessor)]
         self.outputs=[("Learner",orange.Learner),("Regressor",orange.Classifier),("Regression Tree",orange.TreeClassifier)]
 
         ##

File orange/OrangeWidgets/Regression/OWRegressionTreeViewer2D.py

         OWTreeViewer2D.__init__(self, parent, signalManager, name)
 
         self.inputs = [("Classification Tree", orange.TreeClassifier, self.ctree)]
-        self.outputs = [("Examples", ExampleTable)]
+        self.outputs = [("Data", ExampleTable)]
         
         self.NodeColorMethod = 1
         self.showNodeInfoText = False
 #        self.treeNav.leech()
 
     def ctree(self, tree=None):
-        self.send("Examples", None)
+        self.send("Data", None)
         OWTreeViewer2D.ctree(self, tree)
 
     def walkcreate(self, tree, parent=None, level=0, attrVal=""):

File orange/OrangeWidgets/Unsupervised/OWAttributeDistance.py

         self.callbackDeposit = [] # deposit for OWGUI callback functions
         OWWidget.__init__(self, parent, signalManager, name, wantMainArea = 0, resizingEnabled = 0)
 
-        self.inputs = [("Examples", ExampleTable, self.dataset)]
-        self.outputs = [("Distance Matrix", orange.SymMatrix)]
+        self.inputs = [("Data", ExampleTable, self.dataset)]
+        self.outputs = [("Distances", orange.SymMatrix)]
 
         self.data = None
 
             matrix = self.computeMatrix()
         else:
             matrix = None
-        self.send("Distance Matrix", matrix)
+        self.send("Distances", matrix)
 
 
 ##################################################################################################

File orange/OrangeWidgets/Unsupervised/OWDistanceFile.py

         OWWidget.__init__(self, parent, signalManager, name, wantMainArea = 0, resizingEnabled = 1)
         
         if inputItems: 
-            self.inputs = [("Examples", ExampleTable, self.getExamples, Default)]
+            self.inputs = [("Data", ExampleTable, self.getExamples, Default)]
             
-        self.outputs = [("Distance Matrix", orange.SymMatrix)]
+        self.outputs = [("Distances", orange.SymMatrix)]
 
         self.recentFiles=[]
         self.fileIndex = 0
             matrix.setattr("items", [str(i) for i in range(matrix.dim)])
         
         self.matrix.matrixType = orange.SymMatrix.Symmetric
-        self.send("Distance Matrix", self.matrix)
+        self.send("Distances", self.matrix)
 
     def getExamples(self, data):
         self.data = data

File orange/OrangeWidgets/Unsupervised/OWDistanceFilter.py

     def __init__(self, parent=None, signalManager = None, name='Distance Matrix Filter'):
         OWWidget.__init__(self, parent, signalManager, name, wantMainArea = 0, resizingEnabled = 0)
         
-        self.inputs = [("Distance Matrix", orange.SymMatrix, self.setSymMatrix, Default), ("Example Subset", ExampleTable, self.setExampleSubset)]
-        self.outputs = [("Distance Matrix", orange.SymMatrix)]
+        self.inputs = [("Distances", orange.SymMatrix, self.setSymMatrix, Default), ("Data Subset", ExampleTable, self.setExampleSubset)]
+        self.outputs = [("Distances", orange.SymMatrix)]
         
         self.matrix = None
         self.subset = None
                 print var.name
                 self.subsetAttrCombo.addItem(self.icons[var.varType], unicode(var.name))
         
-        self.send("Distance Matrix", self.matrix)
+        self.send("Distances", self.matrix)
         
     def filter(self):
         if self.subsetAttr > 0:
                     
             matrix.items = self.matrix.items.getitems(nodes)
                     
-            self.send("Distance Matrix", matrix)
+            self.send("Distances", matrix)
 
 if __name__=="__main__":
     import orange

File orange/OrangeWidgets/Unsupervised/OWDistanceMap.py

     def __init__(self, parent=None, signalManager = None):
         OWWidget.__init__(self, parent, signalManager, 'Distance Map', wantGraph=True)
 
-        self.inputs = [("Distance Matrix", orange.SymMatrix, self.setMatrix)]
-        self.outputs = [("Examples", ExampleTable), ("Attribute List", orange.VarList)]
+        self.inputs = [("Distances", orange.SymMatrix, self.setMatrix)]
+        self.outputs = [("Data", ExampleTable), ("Features", orange.VarList)]
 
         self.clicked = False
         self.offsetX = 5
         tmp = []
 
         if len(self.selection.getSelection())==0:
-            self.send("Attribute List", None)
-            self.send("Examples", None)
+            self.send("Features", None)
+            self.send("Data", None)
         else:
             selection = self.selection.getSelection()
             
                 selected = orange.VarList()
                 for i in selectedIndices:
                     selected.append(items[i])
-                self.send("Attribute List", selected)
+                self.send("Features", selected)