Merge pull request #3112 from irgolic/smart-widget-suggestions

[ENH] Smart widget suggestions

Author: lanzagar

Orange/canvas/document/interactions.py

@@ -80,6 +80,7 @@ def __init__(self, document, parent=None, deleteOnEnd=True):
         self.document = document
         self.scene = document.scene()
         self.scheme = document.scheme()
+        self.suggestions = document.suggestions()
         self.deleteOnEnd = deleteOnEnd
 
         self.cancelOnEsc = False
@@ -428,6 +429,7 @@ def mouseReleaseEvent(self, event):
                 else:
                     source_node = node
                     sink_node = self.scene.node_for_item(self.sink_item)
+                self.suggestions.set_direction(self.direction)
                 self.connect_nodes(source_node, sink_node)
 
                 if not self.isCanceled() or not self.isFinished() and \
@@ -458,6 +460,15 @@ def is_compatible(source, sink):
         if self.direction == self.FROM_SINK:
             # Reverse the argument order.
             is_compatible = reversed_arguments(is_compatible)
+            suggestion_sort = self.suggestions.get_source_suggestions(from_desc.name)
+        else:
+            suggestion_sort = self.suggestions.get_sink_suggestions(from_desc.name)
+
+        def sort(left, right):
+            # list stores frequencies, so sign is flipped
+            return suggestion_sort[left] > suggestion_sort[right]
+
+        menu.setSortingFunc(sort)
 
         def filter(index):
             desc = index.data(QtWidgetRegistry.WIDGET_DESC_ROLE)
@@ -776,6 +787,15 @@ def create_new(self, pos, search_text=""):
         menu = self.document.quickMenu()
         menu.setFilterFunc(None)
 
+        # compares probability of the user needing the widget as a source
+        def defaultSort(left, right):
+            default_suggestions = self.suggestions.get_default_suggestions()
+            left_frequency = sum(default_suggestions[left].values())
+            right_frequency = sum(default_suggestions[right].values())
+            return left_frequency > right_frequency
+
+        menu.setSortingFunc(defaultSort)
+
         action = menu.exec_(pos, search_text)
         if action:
             item = action.property("item")

Orange/canvas/document/quickmenu.py

@@ -279,6 +279,11 @@ def setFilterRegExp(self, pattern):
         """
         filter_proxy = self.view().model()
         filter_proxy.setFilterRegExp(pattern)
+
+        # re-sorts to make sure items that match by title are on top
+        filter_proxy.invalidate()
+        filter_proxy.sort(0)
+
         self.ensureCurrent()
 
     def setFilterWildCard(self, pattern):
@@ -296,17 +301,25 @@ def setFilterFunc(self, func):
         filter_proxy = self.view().model()
         filter_proxy.setFilterFunc(func)
 
+    def setSortingFunc(self, func):
+        """
+        Set a sorting function.
+        """
+        filter_proxy = self.view().model()
+        filter_proxy.setSortingFunc(func)
+
 
 class SortFilterProxyModel(QSortFilterProxyModel):
     """
-    An filter proxy model used to filter items based on a filtering
-    function.
+    An filter proxy model used to sort and filter items based on
+    a sort and filtering function.
 
     """
     def __init__(self, parent=None):
         QSortFilterProxyModel.__init__(self, parent)
 
         self.__filterFunc = None
+        self.__sortingFunc = None
 
     def setFilterFunc(self, func):
         """
@@ -344,6 +357,32 @@ def filterAcceptsRow(self, row, parent=QModelIndex()):
         else:
             return accepted
 
+    def setSortingFunc(self, func):
+        self.__sortingFunc = func
+        self.invalidate()
+        self.sort(0)
+
+    def sortingFunc(self):
+        return self.__sortingFunc
+
+    def lessThan(self, left, right):
+        if self.__sortingFunc is None:
+            return QSortFilterProxyModel.lessThan(self, left, right)
+        model = self.sourceModel()
+        left_data = model.data(left)
+        right_data = model.data(right)
+
+        flat_model = self.sourceModel()
+        left_description = flat_model.data(left, role=QtWidgetRegistry.WIDGET_DESC_ROLE)
+        right_description = flat_model.data(right, role=QtWidgetRegistry.WIDGET_DESC_ROLE)
+
+        left_matches_title = self.filterRegExp().indexIn(left_description.name) > -1
+        right_matches_title = self.filterRegExp().indexIn(right_description.name) > -1
+
+        if left_matches_title != right_matches_title:
+            return left_matches_title
+        return self.__sortingFunc(left_data, right_data)
+
 
 class SearchWidget(LineEdit):
     def __init__(self, parent=None, **kwargs):
@@ -864,6 +903,7 @@ def __init__(self, parent=None, **kwargs):
         self.setWindowFlags(Qt.Popup)
 
         self.__filterFunc = None
+        self.__sortingFunc = None
 
         self.__setupUi()
 
@@ -1027,6 +1067,16 @@ def setModel(self, model):
         self.__model = model
         self.__suggestPage.setModel(model)
 
+    def setSortingFunc(self, func):
+        """
+        Set a sorting function in the suggest (search) menu.
+        """
+        if self.__sortingFunc != func:
+            self.__sortingFunc = func
+            for i in range(0, self.__pages.count()):
+                if isinstance(self.__pages.page(i), SuggestMenuPage):
+                    self.__pages.page(i).setSortingFunc(func)
+
     def setFilterFunc(self, func):
         """
         Set a filter function.
@@ -1157,6 +1207,14 @@ def __on_textEdited(self, text):
         patt.setCaseSensitivity(False)
         self.__suggestPage.setFilterRegExp(patt)
         self.__pages.setCurrentPage(self.__suggestPage)
+        self.__selectFirstIndex()
+
+    def __selectFirstIndex(self):
+        view = self.__pages.currentPage().view()
+        model = view.model()
+
+        index = model.index(0, 0)
+        view.setCurrentIndex(index)
 
     def triggerSearch(self):
         """

Orange/canvas/document/schemeedit.py

@@ -34,6 +34,7 @@
 
 from AnyQt.QtCore import pyqtProperty as Property, pyqtSignal as Signal
 
+from .suggestions import Suggestions
 from ..registry.qt import whats_this_helper
 from ..gui.quickhelp import QuickHelpTipEvent
 from ..gui.utils import message_information, disabled
@@ -173,6 +174,8 @@ def __init__(self, parent=None, ):
         self.__linkMenu.addAction(self.__linkRemoveAction)
         self.__linkMenu.addAction(self.__linkResetAction)
 
+        self.__suggestions = Suggestions()
+
     def __setupActions(self):
         self.__cleanUpAction = \
             QAction(self.tr("Clean Up"), self,
@@ -640,6 +643,7 @@ def setScheme(self, scheme):
                         self.__signalManagerStateChanged)
 
             self.__scheme = scheme
+            self.__suggestions.set_scheme(self)
 
             self.setPath("")
 
@@ -728,6 +732,12 @@ def view(self):
         """
         return self.__view
 
+    def suggestions(self):
+        """
+        Return the widget suggestion prediction class.
+        """
+        return self.__suggestions
+
     def setRegistry(self, registry):
         # Is this method necessary?
         # It should be removed when the scene (items) is fixed
@@ -857,6 +867,12 @@ def removeLink(self, link):
         command = commands.RemoveLinkCommand(self.__scheme, link)
         self.__undoStack.push(command)
 
+    def onNewLink(self, func):
+        """
+        Runs function when new link is added to current scheme.
+        """
+        self.__scheme.link_added.connect(func)
+
     def addAnnotation(self, annotation):
         """
         Add `annotation` (:class:`.BaseSchemeAnnotation`) to the scheme

Orange/canvas/document/suggestions.py

@@ -0,0 +1,115 @@
+import os
+import pickle
+from collections import defaultdict
+import logging
+
+from Orange.canvas import config
+from .interactions import NewLinkAction
+
+log = logging.getLogger(__name__)
+
+
+class Suggestions:
+    """
+    Handles sorting of quick menu items when dragging a link from a widget onto empty canvas.
+    """
+    class __Suggestions:
+        def __init__(self):
+            self.__frequencies_path = os.path.join(config.data_dir(), "widget-use-frequency.p")
+            self.__import_factor = 0.8  # upon starting Orange, imported frequencies are reduced
+
+            self.__scheme = None
+            self.__direction = None
+            self.link_frequencies = defaultdict(int)
+            self.source_probability = defaultdict(lambda: defaultdict(float))
+            self.sink_probability = defaultdict(lambda: defaultdict(float))
+
+            if not self.load_link_frequency():
+                self.default_link_frequency()
+
+        def load_link_frequency(self):
+            if not os.path.isfile(self.__frequencies_path):
+                return False
+
+            try:
+                with open(self.__frequencies_path, "rb") as f:
+                    imported_freq = pickle.load(f)
+            except OSError:
+                log.warning("Failed to open widget link frequencies.")
+                return False
+
+            for k, v in imported_freq.items():
+                imported_freq[k] = self.__import_factor * v
+
+            self.link_frequencies = imported_freq
+            self.overwrite_probabilities_with_frequencies()
+            return True
+
+        def default_link_frequency(self):
+            self.link_frequencies[("File", "Data Table", NewLinkAction.FROM_SOURCE)] = 3
+            self.overwrite_probabilities_with_frequencies()
+
+        def overwrite_probabilities_with_frequencies(self):
+            for link, count in self.link_frequencies.items():
+                self.increment_probability(link[0], link[1], link[2], count)
+
+        def new_link(self, link):
+            # direction is none when a widget was not added+linked via quick menu
+            if self.__direction is None:
+                return
+
+            source_id = link.source_node.description.name
+            sink_id = link.sink_node.description.name
+
+            link_key = (source_id, sink_id, self.__direction)
+            self.link_frequencies[link_key] += 1
+
+            self.increment_probability(source_id, sink_id, self.__direction, 1)
+            self.write_link_frequency()
+
+            self.__direction = None
+
+        def increment_probability(self, source_id, sink_id, direction, factor):
+            if direction == NewLinkAction.FROM_SOURCE:
+                self.source_probability[source_id][sink_id] += factor
+                self.sink_probability[sink_id][source_id] += factor * 0.5
+            else:  # FROM_SINK
+                self.source_probability[source_id][sink_id] += factor * 0.5
+                self.sink_probability[sink_id][source_id] += factor
+
+        def write_link_frequency(self):
+            try:
+                with open(self.__frequencies_path, "wb") as f:
+                    pickle.dump(self.link_frequencies, f)
+            except OSError:
+                log.warning("Failed to write widget link frequencies.")
+                return
+
+        def set_direction(self, direction):
+            """
+            When opening quick menu, before the widget is created, set the direction
+            of creation (FROM_SINK, FROM_SOURCE).
+            """
+            self.__direction = direction
+
+        def set_scheme(self, scheme):
+            self.__scheme = scheme
+            scheme.onNewLink(self.new_link)
+
+        def get_sink_suggestions(self, source_id):
+            return self.source_probability[source_id]
+
+        def get_source_suggestions(self, sink_id):
+            return self.sink_probability[sink_id]
+
+        def get_default_suggestions(self):
+            return self.source_probability
+
+    instance = None
+
+    def __init__(self):
+        if not Suggestions.instance:
+            Suggestions.instance = Suggestions.__Suggestions()
+
+    def __getattr__(self, name):
+        return getattr(self.instance, name)