Speed up getting tag's random image

boards/models/image.py

@@ -1,125 +1,123 b''
 import hashlib
 import os
 from random import random
 import time
 
 from django.db import models
 from django.template.defaultfilters import filesizeformat
 
 from boards import thumbs
 import boards
 from boards.models.base import Viewable
 
 __author__ = 'neko259'
 
 
 IMAGE_THUMB_SIZE = (200, 150)
 IMAGES_DIRECTORY = 'images/'
 FILE_EXTENSION_DELIMITER = '.'
 HASH_LENGTH = 36
 
 CSS_CLASS_IMAGE = 'image'
 CSS_CLASS_THUMB = 'thumb'
 
 
 class PostImageManager(models.Manager):
     def create_with_hash(self, image):
         image_hash = self.get_hash(image)
         existing = self.filter(hash=image_hash)
         if len(existing) > 0:
             post_image = existing[0]
         else:
             post_image = PostImage.objects.create(image=image)
 
         return post_image
 
     def get_hash(self, image):
         """
         Gets hash of an image.
         """
         md5 = hashlib.md5()
         for chunk in image.chunks():
             md5.update(chunk)
         return md5.hexdigest()
 
     def get_random_images(self, count, include_archived=False, tags=None):
         images = self.filter(post_images__thread__archived=include_archived)
         if tags is not None:
             images = images.filter(post_images__threads__tags__in=tags)
         return images.order_by('?')[:count]
 
 
 class PostImage(models.Model, Viewable):
     objects = PostImageManager()
 
     class Meta:
         app_label = 'boards'
         ordering = ('id',)
 
     def _update_image_filename(self, filename):
         """
         Gets unique image filename
         """
 
         path = IMAGES_DIRECTORY
 
         # TODO Use something other than random number in file name
         new_name = '{}{}.{}'.format(
             str(int(time.mktime(time.gmtime()))),
             str(int(random() * 1000)),
             filename.split(FILE_EXTENSION_DELIMITER)[-1:][0])
 
         return os.path.join(path, new_name)
 
     width = models.IntegerField(default=0)
     height = models.IntegerField(default=0)
 
     pre_width = models.IntegerField(default=0)
     pre_height = models.IntegerField(default=0)
 
     image = thumbs.ImageWithThumbsField(upload_to=_update_image_filename,
                                         blank=True, sizes=(IMAGE_THUMB_SIZE,),
                                         width_field='width',
                                         height_field='height',
                                         preview_width_field='pre_width',
                                         preview_height_field='pre_height')
     hash = models.CharField(max_length=HASH_LENGTH)
 
     def save(self, *args, **kwargs):
         """
         Saves the model and computes the image hash for deduplication purposes.
         """
 
         if not self.pk and self.image:
             self.hash = PostImage.objects.get_hash(self.image)
         super(PostImage, self).save(*args, **kwargs)
 
     def __str__(self):
         return self.image.url
 
     def get_view(self):
         metadata = '{}, {}'.format(self.image.name.split('.')[-1],
                                    filesizeformat(self.image.size))
         return '<div class="{}">' \
                '<a class="{}" href="{full}">' \
                '<img class="post-image-preview"' \
                ' src="{}"' \
                ' alt="{}"' \
                ' width="{}"' \
                ' height="{}"' \
                ' data-width="{}"' \
                ' data-height="{}" />' \
                '</a>' \
                '<div class="image-metadata">{image_meta}</div>' \
                '</div>'\
             .format(CSS_CLASS_IMAGE, CSS_CLASS_THUMB,
                     self.image.url_200x150,
                     str(self.hash), str(self.pre_width),
                     str(self.pre_height), str(self.width), str(self.height),
                     full=self.image.url, image_meta=metadata)
 
-    def get_random_associated_post(self, tags=None):
+    def get_random_associated_post(self):
         posts = boards.models.Post.objects.filter(images__in=[self])
-        if tags is not None:
-            posts = posts.filter(threads__tags__in=tags)
         return posts.order_by('?').first()

boards/models/tag.py

@@ -1,92 +1,98 b''
 from django.template.loader import render_to_string
 from django.db import models
 from django.db.models import Count
 from django.core.urlresolvers import reverse
 
 from boards.models.base import Viewable
 from boards.utils import cached_result
-
+import boards
 
 __author__ = 'neko259'
 
 
 class TagManager(models.Manager):
 
     def get_not_empty_tags(self):
         """
         Gets tags that have non-archived threads.
         """
 
         return self.annotate(num_threads=Count('thread')).filter(num_threads__gt=0)\
             .order_by('-required', 'name')
 
     def get_tag_url_list(self, tags: list) -> str:
         """
         Gets a comma-separated list of tag links.
         """
 
         return ', '.join([tag.get_view() for tag in tags])
 
 
 class Tag(models.Model, Viewable):
     """
     A tag is a text node assigned to the thread. The tag serves as a board
     section. There can be multiple tags for each thread
     """
 
     objects = TagManager()
 
     class Meta:
         app_label = 'boards'
         ordering = ('name',)
 
     name = models.CharField(max_length=100, db_index=True, unique=True)
     required = models.BooleanField(default=False, db_index=True)
     description = models.TextField(blank=True)
 
     def __str__(self):
         return self.name
 
     def is_empty(self) -> bool:
         """
         Checks if the tag has some threads.
         """
 
         return self.get_thread_count() == 0
 
     def get_thread_count(self, archived=None) -> int:
         threads = self.get_threads()
         if archived is not None:
             threads = threads.filter(archived=archived)
         return threads.count()
 
     def get_active_thread_count(self) -> int:
         return self.get_thread_count(archived=False)
 
     def get_absolute_url(self):
         return reverse('tag', kwargs={'tag_name': self.name})
 
     def get_threads(self):
         return self.thread_set.order_by('-bump_time')
 
     def is_required(self):
         return self.required
 
     def get_view(self):
         link = '<a class="tag" href="{}">{}</a>'.format(
             self.get_absolute_url(), self.name)
         if self.is_required():
             link = '<b>{}</b>'.format(link)
         return link
 
     def get_search_view(self, *args, **kwargs):
         return render_to_string('boards/tag.html', {
             'tag': self,
         })
 
     @cached_result()
     def get_post_count(self):
         return self.get_threads().aggregate(num_posts=Count('post'))['num_posts']
 
     def get_description(self):
         return self.description
+
+    def get_random_image_post(self):
+        return boards.models.Post.objects.annotate(images_count=Count(
+            'images')).filter(images_count__gt=0, threads__tags__in=[self])\
+                    .order_by('?').first()
+

boards/templates/boards/all_threads.html

@@ -1,179 +1,181 b''
 {% extends "boards/base.html" %}
 
 {% load i18n %}
 {% load board %}
 {% load static %}
 {% load tz %}
 
 {% block head %}
     <meta name="robots" content="noindex">
 
     {% if tag %}
         <title>{{ tag.name }} - {{ site_name }}</title>
     {% else %}
         <title>{{ site_name }}</title>
     {% endif %}
 
     {% if prev_page_link %}
         <link rel="prev" href="{{ prev_page_link }}" />
     {% endif %}
     {% if next_page_link %}
         <link rel="next" href="{{ next_page_link }}" />
     {% endif %}
 
 {% endblock %}
 
 {% block content %}
 
     {% get_current_language as LANGUAGE_CODE %}
     {% get_current_timezone as TIME_ZONE %}
 
     {% for banner in banners %}
         <div class="post">
             <div class="title">{{ banner.title }}</div>
             <div>{{ banner.text }}</div>
             <div>{% trans 'Related message' %}: <a href="{{ banner.post.get_absolute_url }}">>>{{ banner.post.id }}</a></div>
         </div>
     {% endfor %}
 
 {% if tag %}
     <div class="tag_info">
         <div class="tag-image">
+            {% with image=random_image_post.images.first %}
             <a href="{{ random_image_post.get_absolute_url }}"><img 
-                src="{{ random_image.image.url_200x150 }}"
-                width="{{ random_image.pre_width }}"
-                height="{{ random_image.pre_height }}"/></a>
+                    src="{{ image.image.url_200x150 }}"
+                    width="{{ image.pre_width }}"
+                    height="{{ image.pre_height }}"/></a>
+            {% endwith %}
         </div>
         <div class="tag-text-data">
             <h2>
                 <form action="{% url 'tag' tag.name %}" method="post" class="post-button-form">
                     {% if is_favorite %}
                         <button name="method" value="unsubscribe" class="fav">★</button>
                     {% else %}
                         <button name="method" value="subscribe" class="not_fav">★</button>
                     {% endif %}
                 </form>
                 <form action="{% url 'tag' tag.name %}" method="post" class="post-button-form">
                     {% if is_hidden %}
                         <button name="method" value="unhide" class="fav">H</button>
                     {% else %}
                         <button name="method" value="hide" class="not_fav">H</button>
                     {% endif %}
                 </form>
                 {% autoescape off %}
                     {{ tag.get_view }}
                 {% endautoescape %}
                 {% if moderator %}
                 <span class="moderator_info">| <a href="{% url 'admin:boards_tag_change' tag.id %}">{% trans 'Edit tag' %}</a></span>
                 {% endif %}
             </h2>
             {% if tag.get_description %}
                 {% autoescape off %}
                     <p>{{ tag.get_description }}</p>
                 {% endautoescape %}
             {% endif %}
             <p>{% blocktrans with active_thread_count=tag.get_active_thread_count thread_count=tag.get_thread_count post_count=tag.get_post_count %}This tag has {{ active_thread_count}}/{{ thread_count }} threads and {{ post_count }} posts.{% endblocktrans %}</p>
         </div>
     </div>
 {% endif %}
 
     {% if threads %}
         {% if prev_page_link %}
             <div class="page_link">
                 <a href="{{ prev_page_link }}">{% trans "Previous page" %}</a>
             </div>
         {% endif %}
 
         {% for thread in threads %}
             <div class="thread">
                 {% post_view thread.get_opening_post moderator=moderator is_opening=True thread=thread truncated=True need_open_link=True %}
                 {% if not thread.archived %}
                     {% with last_replies=thread.get_last_replies %}
                         {% if last_replies %}
                             {% with skipped_replies_count=thread.get_skipped_replies_count %}
                                 {% if skipped_replies_count %}
                                     <div class="skipped_replies">
                                         <a href="{% url 'thread' thread.get_opening_post_id %}">
                                             {% blocktrans with count=skipped_replies_count %}Skipped {{ count }} replies. Open thread to see all replies.{% endblocktrans %}
                                         </a>
                                     </div>
                                 {% endif %}
                             {% endwith %}
                             <div class="last-replies">
                                 {% for post in last_replies %}
                                     {% post_view post is_opening=False moderator=moderator truncated=True %}
                                 {% endfor %}
                             </div>
                         {% endif %}
                     {% endwith %}
                 {% endif %}
             </div>
         {% endfor %}
 
         {% if next_page_link %}
             <div class="page_link">
                 <a href="{{ next_page_link }}">{% trans "Next page" %}</a>
             </div>
         {% endif %}
     {% else %}
         <div class="post">
             {% trans 'No threads exist. Create the first one!' %}</div>
     {% endif %}
 
     <div class="post-form-w">
         <script src="{% static 'js/panel.js' %}"></script>
         <div class="post-form">
             <div class="form-title">{% trans "Create new thread" %}</div>
             <div class="swappable-form-full">
             <form enctype="multipart/form-data" method="post" id="form">{% csrf_token %}
                 {{ form.as_div }}
                 <div class="form-submit">
                     <input type="submit" value="{% trans "Post" %}"/>
                 </div>
             </form>
             </div>
             <div>
                 {% trans 'Tags must be delimited by spaces. Text or image is required.' %}
             </div>
             <div><button id="preview-button">{% trans 'Preview' %}</button></div>
             <div id="preview-text"></div>
             <div><a href="{% url "staticpage" name="help" %}">{% trans 'Text syntax' %}</a></div>
             <div><a href="{% url "tags" "required" %}">{% trans 'Tags' %}</a></div>
         </div>
     </div>
 
     <script src="{% static 'js/form.js' %}"></script>
     <script src="{% static 'js/thread_create.js' %}"></script>
 
 {% endblock %}
 
 {% block metapanel %}
 
     <span class="metapanel">
         <b><a href="{% url "authors" %}">{{ site_name }}</a> {{ version }}</b>
         {% trans "Pages:" %}
         [
         {% with dividers=paginator.get_dividers %}
             {% for page in paginator.get_divided_range %}
                 {% if page in dividers %}
                     …,
                 {% endif %}
                 <a
                     {% ifequal page current_page.number %}
                         class="current_page"
                     {% endifequal %}
                     href="
                 {% if tag %}
                 {% url "tag" tag_name=tag.name %}?page={{ page }}
                 {% else %}
                     {% url "index" %}?page={{ page }}
                 {% endif %}
                 ">{{ page }}</a>
                 {% if not forloop.last %},{% endif %}
             {% endfor %}
         {% endwith %}
         ]
         [<a href="rss/">RSS</a>]
     </span>
 
 {% endblock %}

boards/views/tag_threads.py

@@ -1,126 +1,123 b''
 from django.shortcuts import get_object_or_404, redirect
 from django.core.urlresolvers import reverse
 
 from boards.abstracts.settingsmanager import get_settings_manager, \
         SETTING_FAVORITE_TAGS, SETTING_HIDDEN_TAGS
 from boards.models import Tag, PostImage
 from boards.views.all_threads import AllThreadsView, DEFAULT_PAGE
 from boards.views.mixins import DispatcherMixin
 from boards.forms import ThreadForm, PlainErrorList
 
 PARAM_HIDDEN_TAGS = 'hidden_tags'
 PARAM_TAG = 'tag'
 PARAM_IS_FAVORITE = 'is_favorite'
 PARAM_IS_HIDDEN = 'is_hidden'
-PARAM_RANDOM_IMAGE = 'random_image'
 PARAM_RANDOM_IMAGE_POST = 'random_image_post'
 
 __author__ = 'neko259'
 
 
 class TagView(AllThreadsView, DispatcherMixin):
 
     tag_name = None
 
     def get_threads(self):
         tag = get_object_or_404(Tag, name=self.tag_name)
 
         hidden_tags = self.settings_manager.get_hidden_tags()
 
         try:
             hidden_tags.remove(tag)
         except ValueError:
             pass
 
         return tag.get_threads().exclude(
             tags__in=hidden_tags)
 
     def get_context_data(self, **kwargs):
         params = super(TagView, self).get_context_data(**kwargs)
 
         settings_manager = get_settings_manager(kwargs['request'])
 
         tag = get_object_or_404(Tag, name=self.tag_name)
         params[PARAM_TAG] = tag
 
         fav_tag_names = settings_manager.get_setting(SETTING_FAVORITE_TAGS)
         hidden_tag_names = settings_manager.get_setting(SETTING_HIDDEN_TAGS)
 
         params[PARAM_IS_FAVORITE] = fav_tag_names is not None and tag.name in fav_tag_names
         params[PARAM_IS_HIDDEN] = hidden_tag_names is not None and tag.name in hidden_tag_names
 
-        image = PostImage.objects.get_random_images(1, tags=[tag])[0]
-        params[PARAM_RANDOM_IMAGE] = image
-        params[PARAM_RANDOM_IMAGE_POST] = image.get_random_associated_post(tags=[tag])
+        params[PARAM_RANDOM_IMAGE_POST] = tag.get_random_image_post()
 
         return params
 
     def get_previous_page_link(self, current_page):
         return reverse('tag', kwargs={
             'tag_name': self.tag_name,
         }) + '?page=' + str(current_page.previous_page_number())
 
     def get_next_page_link(self, current_page):
         return reverse('tag', kwargs={
             'tag_name': self.tag_name,
         }) + '?page=' + str(current_page.next_page_number())
 
     def get(self, request, tag_name, form=None):
         self.tag_name = tag_name
 
         return super(TagView, self).get(request, form)
 
 
     def post(self, request, tag_name):
         self.tag_name = tag_name
 
         if 'method' in request.POST:
             self.dispatch_method(request)
             form = None
 
             return redirect('tag', tag_name)
         else:
             form = ThreadForm(request.POST, request.FILES,
                               error_class=PlainErrorList)
             form.session = request.session
 
             if form.is_valid():
                 return self.create_thread(request, form)
             if form.need_to_ban:
                 # Ban user because he is suspected to be a bot
                 self._ban_current_user(request)
 
             return self.get(request, tag_name, page, form)
 
     def subscribe(self, request):
         tag = get_object_or_404(Tag, name=self.tag_name)
 
         settings_manager = get_settings_manager(request)
         settings_manager.add_fav_tag(tag)
 
     def unsubscribe(self, request):
         tag = get_object_or_404(Tag, name=self.tag_name)
 
         settings_manager = get_settings_manager(request)
         settings_manager.del_fav_tag(tag)
 
     def hide(self, request):
         """
         Adds tag to user's hidden tags. Threads with this tag will not be
         shown.
         """
 
         tag = get_object_or_404(Tag, name=self.tag_name)
 
         settings_manager = get_settings_manager(request)
         settings_manager.add_hidden_tag(tag)
 
     def unhide(self, request):
         """
         Removed tag from user's hidden tags.
         """
 
         tag = get_object_or_404(Tag, name=self.tag_name)
 
         settings_manager = get_settings_manager(request)
         settings_manager.del_hidden_tag(tag)