Merge lp:~ilidrissi.amine/software-center/zeitgeist-unused-applications into lp:software-center

[Mohamed Amine Ilidrissi]

This branch adds support for unused applications via Zeitgeist.
Design feedback is welcome.

[Matthew Paul Thomas (mpt)]

Consider the case of a disk recovery utility. Ideally you will use this rarely, once every few years. That does not mean USC should constantly be nagging you to uninstall it. :-)

I think more useful would be a way to show -- in the "Installed Software" list -- frequency of use, or date last used, or both, and to sort by those columns.

review: Disapprove

Unmerged revisions

1267. By Mohamed Amine Ilidrissi on 2010-10-24

Code now checks if the app is installed and not a core application (i.e doesn't remove pkgs in IMPORTANT_METAPACKAGES)

1266. By Mohamed Amine Ilidrissi on 2010-10-24

merge with trunk

1265. By Mohamed Amine Ilidrissi on 2010-10-17

Added support for removing unused applications via Zeitgeist

=== modified file 'debian/changelog'
--- debian/changelog	2010-10-19 20:48:05 +0000
+++ debian/changelog	2010-10-24 22:41:36 +0000
@@ -13,7 +13,10 @@
   * softwarecenter/backend/config.py:
     - don't crash on a corrupted config file (LP: #662414) 
 
- -- Gary Lasker <[e-mail]>  Tue, 19 Oct 2010 16:41:40 -0400
+  [ Mohamed Amine IL Idrissi ]
+  * Added support for unused application via Zeitgeist
+
+ -- Mohamed Amine IL Idrissi <[e-mail]>  Sun, 24 Oct 2010 22:04:38 +0000
 
 software-center (3.1.0) natty; urgency=low
 

=== modified file 'softwarecenter/apt/aptcache.py'
--- softwarecenter/apt/aptcache.py	2010-09-14 20:07:34 +0000
+++ softwarecenter/apt/aptcache.py	2010-10-24 22:41:36 +0000
@@ -471,6 +471,12 @@
             addons_sug = filter(_addons_filter_slow, addons_sug)
         
         return (addons_rec, addons_sug)
+        
+    def pkg_is_important(self, pkg, distro):
+        for m in distro.IMPORTANT_METAPACKAGES:
+            if m in self.get_depends(pkg):
+                return True
+        return False
 
 if __name__ == "__main__":
     c = AptCache()

=== modified file 'softwarecenter/backend/zeitgeist_simple.py'
--- softwarecenter/backend/zeitgeist_simple.py	2010-10-12 08:56:06 +0000
+++ softwarecenter/backend/zeitgeist_simple.py	2010-10-24 22:41:36 +0000
@@ -23,7 +23,7 @@
 
 try:
     from zeitgeist.client import ZeitgeistClient
-    from zeitgeist.datamodel import Event, Interpretation, ResultType
+    from zeitgeist.datamodel import Event, Interpretation, ResultType, TimeRange
 except ImportError:
     LOG.exception("zeitgeist import failed")
     ZEITGEIST_AVAILABLE = False
@@ -89,12 +89,38 @@
         self.zg_client.find_events_for_template(
             [], _callback, num_events=1000, 
             result_type=ResultType.MostRecentEvents)
+    
+    def get_unused_applications(self, callback, timerange=None):
+        """ Get applications that weren't used for a specific timerange
+            (defaults to 1 month) and call "callback" with a list of
+            applications as an argument
+        """
+        
+        def _callback(events):
+            if timerange is not None:
+                timestamp = int(time.time() - timerange)
+            else:
+                timestamp = int(time.time() - (86400000*30)) # one month
+            
+            unused_apps = []
+            for e in events:
+                if int(e.timestamp) < timestamp:
+                    unused_apps.append(e.actor)
+            
+            callback(unused_apps)
+        
+        self.zg_client.find_events_for_template(None, _callback, 
+                            timerange=TimeRange.always(), num_events=0, 
+                            result_type=ResultType.MostRecentActor)
+        
 
 class SoftwareCenterZeitgeistDummy():
     def get_usage_counter(self, application, callback, timerange=None):
         callback(0)
     def get_popular_mimetypes(self, callback):
         callback([])
+    def get_unused_applications(self, callback, timerange=None):
+        callback([])
 
 # singleton
 if ZEITGEIST_AVAILABLE:
@@ -119,7 +145,7 @@
     def _callback_popular(mimetypes):
         print "test _callback: "
         for tuple in mimetypes:
-        	print tuple
+            print tuple
     zeitgeist_singleton.get_popular_mimetypes(_callback_popular)
 
     import gtk

=== modified file 'softwarecenter/db/database.py'
--- softwarecenter/db/database.py	2010-10-12 08:37:12 +0000
+++ softwarecenter/db/database.py	2010-10-24 22:41:36 +0000
@@ -239,6 +239,16 @@
             if len(apps) == num:
                 break
         return apps
+        
+    def get_application_from_desktop_file(self, desktop_file):
+        enquire = xapian.Enquire(self.xapiandb)
+        query = xapian.Query("AP%s" % desktop_file[14:-8])
+        enquire.set_query(query)
+        matches = enquire.get_mset(0, 100)
+        for match in matches:
+            doc = match.get_document()
+            app = Application(self.get_appname(doc), self.get_pkgname(doc))
+            return app
 
     def get_summary(self, doc):
         """ get human readable summary of the given document """

=== modified file 'softwarecenter/view/catview_gtk.py'
--- softwarecenter/view/catview_gtk.py	2010-10-12 10:30:11 +0000
+++ softwarecenter/view/catview_gtk.py	2010-10-24 22:41:36 +0000
@@ -326,6 +326,7 @@
         self._append_departments()
         self._append_featured_and_new()
         self._append_recommendations()
+        self._append_unused_applications()
         return
 
     def _append_recommendations(self):
@@ -389,7 +390,64 @@
         
         zeitgeist_singleton.get_popular_mimetypes(_popular_mimetypes_callback)
         
-
+    def _append_unused_applications(self):
+        def _show_unused_apps_widget(query, r_apps): 
+            # build UI
+            self.hbox = gtk.HBox()
+            unused = gettext.ngettext("There is",
+                                      "There are",
+                                      len(r_apps))
+            self.hbox.pack_start(gtk.Label(unused), False, False)
+            label = gettext.ngettext("%(len)i unused applications",
+                                     "%(len)i unused applications",
+                                     len(r_apps)) % { 'len' : len(r_apps) }
+            linkbutton = mkit.HLinkButton(label)
+            linkbutton.set_underline(True)
+            linkbutton.set_subdued(True)
+            self.hbox.pack_start(linkbutton, False, False)
+            self.hbox.pack_start(gtk.Label("you can remove."), False, False)
+            self.vbox.pack_start(self.hbox, False, False)
+            self.vbox.reorder_child(self.hbox, -1)
+            # build fake category
+            name = gobject.markup_escape_text(_("Unused applications"))
+            rec_btn = CategoryButton(name, "category-unused", self.icons)
+            rec_cat = Category("Unused applications", _("Unused Applications"), 
+            "category-unused", query, sortmode=SORT_BY_SEARCH_RANKING)
+            rec_btn.connect('clicked', self._on_category_clicked, rec_cat)
+            self.departments.append(rec_btn)
+            
+            linkbutton.connect('clicked', self._on_category_clicked, rec_cat)
+
+            self.show_all() 
+              
+        def _unused_applications_callback(unused):
+            def _find_applications(names):
+                apps = []
+                for name in names:
+                    app = self.db.get_application_from_desktop_file(name)
+                    if app is not None and \
+                    app.get_details(self.db).pkg_state == PKG_STATE_INSTALLED and \
+                    not self.cache.pkg_is_important(app.get_details(self.db).pkg, get_distro()):
+                        apps.append(app)
+
+                results = []
+                for app in apps:
+                    results.append("AP" + app.pkgname)
+                return results
+
+            def _make_query(r_apps):
+                if len(r_apps) > 0:
+                    return xapian.Query(xapian.Query.OP_OR, r_apps)
+                return None
+            
+            # get the unused apps     
+            r_apps =_find_applications(unused) 
+            if r_apps:
+                # build the widget
+                _show_unused_apps_widget(_make_query(r_apps), r_apps)
+        
+        zeitgeist_singleton.get_unused_applications(_unused_applications_callback)
+    
     def _append_featured_and_new(self):
         # carousel hbox
         self.hbox_inner = gtk.HBox(spacing=mkit.SPACING_MED)