Merge branch 'release-v0.5.x' into develop

# Conflicts:
#	kolibri/plugins/learn/assets/src/views/content-card-grid/index.vue
#	kolibri/plugins/management/assets/src/views/manage-content-page/channels-grid.vue
#	requirements/base.txt

Author: rtibbles

kolibri/content/api.py

@@ -12,6 +12,7 @@
 from le_utils.constants import content_kinds
 from rest_framework import filters, pagination, viewsets
 from rest_framework.decorators import detail_route, list_route
+from rest_framework.generics import get_object_or_404
 from rest_framework.response import Response
 from six.moves.urllib.parse import parse_qs, urlparse
 
@@ -250,15 +251,48 @@ class ContentNodeViewset(viewsets.ModelViewSet):
     filter_class = ContentNodeFilter
     pagination_class = OptionalPageNumberPagination
 
-    def get_queryset(self):
-        return models.ContentNode.objects.all().prefetch_related(
+    def prefetch_related(self, queryset):
+        return queryset.prefetch_related(
             'assessmentmetadata',
             'files',
         ).select_related('license')
 
+    def get_queryset(self, prefetch=True):
+        queryset = models.ContentNode.objects.all()
+        if prefetch:
+            return self.prefetch_related(queryset)
+        return queryset
+
+    def get_object(self, prefetch=True):
+        """
+        Returns the object the view is displaying.
+        You may want to override this if you need to provide non-standard
+        queryset lookups.  Eg if objects are referenced using multiple
+        keyword arguments in the url conf.
+        """
+        queryset = self.filter_queryset(self.get_queryset(prefetch=prefetch))
+
+        # Perform the lookup filtering.
+        lookup_url_kwarg = self.lookup_url_kwarg or self.lookup_field
+
+        assert lookup_url_kwarg in self.kwargs, (
+            'Expected view %s to be called with a URL keyword argument '
+            'named "%s". Fix your URL conf, or set the `.lookup_field` '
+            'attribute on the view correctly.' %
+            (self.__class__.__name__, lookup_url_kwarg)
+        )
+
+        filter_kwargs = {self.lookup_field: self.kwargs[lookup_url_kwarg]}
+        obj = get_object_or_404(queryset, **filter_kwargs)
+
+        # May raise a permission denied
+        self.check_object_permissions(self.request, obj)
+
+        return obj
+
     @detail_route(methods=['get'])
     def descendants(self, request, **kwargs):
-        node = self.get_object()
+        node = self.get_object(prefetch=False)
         kind = self.request.query_params.get('descendant_kind', None)
         descendants = node.get_descendants()
         if kind:
@@ -269,7 +303,16 @@ def descendants(self, request, **kwargs):
 
     @detail_route(methods=['get'])
     def ancestors(self, request, **kwargs):
-        return Response(self.get_object().get_ancestors().values('pk', 'title'))
+        cache_key = 'contentnode_ancestors_{db}_{pk}'.format(db=get_active_content_database(), pk=kwargs.get('pk'))
+
+        if cache.get(cache_key) is not None:
+            return Response(cache.get(cache_key))
+
+        ancestors = list(self.get_object(prefetch=False).get_ancestors().values('pk', 'title'))
+
+        cache.set(cache_key, ancestors, 60 * 10)
+
+        return Response(ancestors)
 
     @detail_route(methods=['get'])
     def next_content(self, request, **kwargs):

kolibri/content/serializers.py

@@ -1,3 +1,4 @@
+from django.core.cache import cache
 from django.db.models import Manager, Sum
 from django.db.models.query import RawQuerySet
 from kolibri.content.models import AssessmentMetaData, ChannelMetadataCache, ContentNode, File
@@ -115,6 +116,20 @@ class ContentNodeListSerializer(serializers.ListSerializer):
 
     def to_representation(self, data):
 
+        # Dealing with nested relationships, data can be a Manager,
+        # so, first get a queryset from the Manager if needed
+        data = data.all() if isinstance(data, Manager) else data
+
+        cache_key = None
+        # Cache parent look ups only
+        if "parent" in self.context['request'].GET:
+            cache_key = 'contentnode_list_{db}_{parent}'.format(
+                db=get_active_content_database(),
+                parent=self.context['request'].GET.get('parent'))
+
+            if cache.get(cache_key):
+                return cache.get(cache_key)
+
         if not data:
             return data
 
@@ -125,17 +140,25 @@ def to_representation(self, data):
             # Don't annotate topic progress as too expensive
             progress_dict = get_content_progress_fractions(data, user)
 
-        # Dealing with nested relationships, data can be a Manager,
-        # so, first get a queryset from the Manager if needed
-        iterable = data.all() if isinstance(data, Manager) else data
-
-        return [
-            self.child.to_representation(
+        result = []
+        topic_only = True
+        for item in data:
+            obj = self.child.to_representation(
                 item,
                 progress_fraction=progress_dict.get(item.content_id),
                 annotate_progress_fraction=False
-            ) for item in iterable
-        ]
+            )
+            topic_only = topic_only and obj.get('kind') == content_kinds.TOPIC
+            result.append(obj)
+
+        # Only store if all nodes are topics, because we don't annotate progress on them
+        # This has the happy side effect of not caching our dynamically calculated
+        # recommendation queries, which might change for the same user over time
+        # because they do not return topics
+        if topic_only and cache_key:
+            cache.set(cache_key, result, 60 * 10)
+
+        return result
 
 
 class ContentNodeSerializer(serializers.ModelSerializer):
@@ -165,7 +188,8 @@ def to_representation(self, instance, progress_fraction=None, annotate_progress_
                 progress_fraction = 0.0
             else:
                 user = self.context["request"].user
-                progress_fraction = get_content_progress_fraction(instance, user)
+                if instance.kind != content_kinds.TOPIC:
+                    progress_fraction = get_content_progress_fraction(instance, user)
         value = super(ContentNodeSerializer, self).to_representation(instance)
         value['progress_fraction'] = progress_fraction
         return value

kolibri/core/__init__.py

@@ -3,3 +3,5 @@
 
 """
 from __future__ import print_function, unicode_literals, absolute_import
+
+default_app_config = "kolibri.core.apps.KolibriCoreConfig"

kolibri/core/apps.py

@@ -0,0 +1,57 @@
+from __future__ import unicode_literals
+
+from django.apps import AppConfig
+from django.db.backends.signals import connection_created
+
+
+class KolibriCoreConfig(AppConfig):
+    name = 'kolibri.core'
+
+    def ready(self):
+        """
+        Sets up PRAGMAs.
+        """
+        connection_created.connect(self.activate_pragmas_per_connection)
+        self.activate_pragmas_on_start()
+
+    @staticmethod
+    def activate_pragmas_per_connection(sender, connection, **kwargs):
+        """
+        Activate SQLite3 PRAGMAs that apply on a per-connection basis. A no-op
+        right now, but kept around as infrastructure if we ever want to add
+        PRAGMAs in the future.
+        """
+
+        if connection.vendor == "sqlite":
+            cursor = connection.cursor()
+
+            # Shorten the default WAL autocheckpoint from 1000 pages to 500
+            cursor.execute("PRAGMA wal_autocheckpoint=500;")
+
+            # We don't turn on the following pragmas, because they have negligible
+            # performance impact. For reference, here's what we've tested:
+
+            # Don't ensure that the OS has fully flushed
+            # our data to disk.
+            # cursor.execute("PRAGMA synchronous=OFF;")
+
+            # Store cross-database JOINs in memory.
+            # cursor.execute("PRAGMA temp_store=MEMORY;")
+
+    @staticmethod
+    def activate_pragmas_on_start():
+        """
+        Activate a set of PRAGMAs that apply to the database itself,
+        and not on a per connection basis.
+        :return:
+        """
+        from django.db import connection
+
+        if connection.vendor == "sqlite":
+            cursor = connection.cursor()
+
+            # http://www.sqlite.org/wal.html
+            # WAL's main advantage allows simultaneous reads
+            # and writes (vs. the default exclusive write lock)
+            # at the cost of a slight penalty to all reads.
+            cursor.execute("PRAGMA journal_mode=WAL;")

kolibri/core/assets/src/heartbeat.js

@@ -3,7 +3,7 @@ import logger from 'kolibri.lib.logging';
 const logging = logger.getLogger(__filename);
 
 export default class HeartBeat {
-  constructor(kolibri, delay = 60000) {
+  constructor(kolibri, delay = 150000) {
     if (!kolibri) {
       throw new ReferenceError('A kolibri instance must be passed into the constructor');
     }

kolibri/core/assets/src/state/actions.js

@@ -21,8 +21,8 @@ import { redirectBrowser } from '../utils/browser';
 
 const logging = logger.getLogger(__filename);
 const intervalTime = 5000; // Frequency at which time logging is updated
-const progressThreshold = 0.1; // Update logs if user has reached 20% more progress
-const timeThreshold = 30; // Update logs if 30 seconds have passed since last update
+const progressThreshold = 0.25; // Update logs if user has reached 25% more progress
+const timeThreshold = 60; // Update logs if 60 seconds have passed since last update
 
 /**
  * Vuex State Mappers

kolibri/core/assets/src/utils/import-intl-locale.js

@@ -24,6 +24,12 @@ module.exports = (locale, callback) => {
           resolve(() => require('intl/locale-data/jsonp/es-ES.js'));
         });
       });
+    case 'es-MX':
+      return new Promise(resolve => {
+        require.ensure([], require => {
+          resolve(() => require('intl/locale-data/jsonp/es-MX.js'));
+        });
+      });
     default:
       return new Promise(resolve => {
         require.ensure([], require => {

kolibri/core/webpack/hooks.py

@@ -138,7 +138,7 @@ def bundle(self):
         """
         for f in self._stats_file_content["files"]:
             filename = f['name']
-            if any(regex.match(filename) for regex in settings.IGNORE_PATTERNS):
+            if any(list(regex.match(filename) for regex in settings.IGNORE_PATTERNS)):
                 continue
             relpath = '{0}/{1}'.format(self.unique_slug, filename)
             if django_settings.DEBUG:

kolibri/locale/docs/es_ES/LC_MESSAGES/authors.po

@@ -2,8 +2,8 @@ msgid ""
 msgstr ""
 "Project-Id-Version: kolibri\n"
 "Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2017-02-02 00:07+0000\n"
-"PO-Revision-Date: 2017-03-31 03:03-0400\n"
+"POT-Creation-Date: 2017-03-02 23:01+0000\n"
+"PO-Revision-Date: 2017-07-28 17:27-0400\n"
 "Last-Translator: learningequality <[email protected]>\n"
 "Language-Team: Spanish\n"
 "MIME-Version: 1.0\n"
@@ -14,7 +14,7 @@ msgstr ""
 "X-Generator: crowdin.com\n"
 "X-Crowdin-Project: kolibri\n"
 "X-Crowdin-Language: es-ES\n"
-"X-Crowdin-File: /release/docs/en/LC_MESSAGES/authors.po\n"
+"X-Crowdin-File: /release-v0.5.x/docs/en/LC_MESSAGES/authors.po\n"
 "Language: es_ES\n"
 
 #: ../../../AUTHORS.rst:3

kolibri/locale/docs/es_ES/LC_MESSAGES/changelog.po

@@ -3,7 +3,7 @@ msgstr ""
 "Project-Id-Version: kolibri\n"
 "Report-Msgid-Bugs-To: \n"
 "POT-Creation-Date: 2017-03-02 23:01+0000\n"
-"PO-Revision-Date: 2017-05-19 01:26-0400\n"
+"PO-Revision-Date: 2017-07-28 17:27-0400\n"
 "Last-Translator: learningequality <[email protected]>\n"
 "Language-Team: Spanish\n"
 "MIME-Version: 1.0\n"
@@ -14,7 +14,7 @@ msgstr ""
 "X-Generator: crowdin.com\n"
 "X-Crowdin-Project: kolibri\n"
 "X-Crowdin-Language: es-ES\n"
-"X-Crowdin-File: /release-v0.4.x/docs/en/LC_MESSAGES/changelog.po\n"
+"X-Crowdin-File: /release-v0.5.x/docs/en/LC_MESSAGES/changelog.po\n"
 "Language: es_ES\n"
 
 #: ../../../CHANGELOG.rst:4