Optimized loading post images in post template

boards/models/thread.py

@@ -1,164 +1,163 b''
 import logging
 from django.db.models import Count
 from django.utils import timezone
 from django.core.cache import cache
 from django.db import models
 from neboard import settings
 
 __author__ = 'neko259'
 
 
 logger = logging.getLogger(__name__)
 
 
 CACHE_KEY_OPENING_POST = 'opening_post_id'
 
 
 class Thread(models.Model):
 
     class Meta:
         app_label = 'boards'
 
     tags = models.ManyToManyField('Tag')
     bump_time = models.DateTimeField()
     last_edit_time = models.DateTimeField()
     replies = models.ManyToManyField('Post', symmetrical=False, null=True,
                                      blank=True, related_name='tre+')
     archived = models.BooleanField(default=False)
 
     def get_tags(self):
         """
         Gets a sorted tag list.
         """
 
         return self.tags.order_by('name')
 
     def bump(self):
         """
         Bumps (moves to up) thread if possible.
         """
 
         if self.can_bump():
             self.bump_time = timezone.now()
 
             logger.info('Bumped thread %d' % self.id)
 
     def get_reply_count(self):
         return self.replies.count()
 
     def get_images_count(self):
         # TODO Use sum
         total_count = 0
         for post_with_image in self.replies.annotate(images_count=Count(
                 'images')):
             total_count += post_with_image.images_count
         return total_count
 
     def can_bump(self):
         """
         Checks if the thread can be bumped by replying to it.
         """
 
         if self.archived:
             return False
 
         post_count = self.get_reply_count()
 
         return post_count < settings.MAX_POSTS_PER_THREAD
 
     def delete_with_posts(self):
         """
         Completely deletes thread and all its posts
         """
 
         if self.replies.exists():
             self.replies.all().delete()
 
         self.delete()
 
     def get_last_replies(self):
         """
         Gets several last replies, not including opening post
         """
 
         if settings.LAST_REPLIES_COUNT > 0:
             reply_count = self.get_reply_count()
 
             if reply_count > 0:
                 reply_count_to_show = min(settings.LAST_REPLIES_COUNT,
                                           reply_count - 1)
-                replies = self.replies.order_by('pub_time').defer(
-                    'poster_user_agent', 'text_markup_type')
+                replies = self.get_replies()
                 last_replies = replies[reply_count - reply_count_to_show:]
 
                 return last_replies
 
     def get_skipped_replies_count(self):
         """
         Gets number of posts between opening post and last replies.
         """
         reply_count = self.get_reply_count()
         last_replies_count = min(settings.LAST_REPLIES_COUNT,
                                  reply_count - 1)
         return reply_count - last_replies_count - 1
 
     def get_replies(self, view_fields_only=False):
         """
         Gets sorted thread posts
         """
 
-        query = self.replies.order_by('pub_time')
+        query = self.replies.order_by('pub_time').prefetch_related('images')
         if view_fields_only:
             query = query.defer('poster_user_agent', 'text_markup_type')
         return query.all()
 
     def get_replies_with_images(self, view_fields_only=False):
         return self.get_replies(view_fields_only).annotate(images_count=Count(
             'images')).filter(images_count__gt=0)
 
     def add_tag(self, tag):
         """
         Connects thread to a tag and tag to a thread
         """
 
         self.tags.add(tag)
         tag.threads.add(self)
 
     def remove_tag(self, tag):
         self.tags.remove(tag)
         tag.threads.remove(self)
 
     def get_opening_post(self, only_id=False):
         """
         Gets the first post of the thread
         """
 
         query = self.replies.order_by('pub_time')
         if only_id:
             query = query.only('id')
         opening_post = query.first()
 
         return opening_post
 
     def get_opening_post_id(self):
         """
         Gets ID of the first thread post.
         """
 
         cache_key = CACHE_KEY_OPENING_POST + str(self.id)
         opening_post_id = cache.get(cache_key)
         if not opening_post_id:
             opening_post_id = self.get_opening_post(only_id=True).id
             cache.set(cache_key, opening_post_id)
 
         return opening_post_id
 
     def __unicode__(self):
         return str(self.id)
 
     def get_pub_time(self):
         """
         Gets opening post's pub time because thread does not have its own one.
         """
 
-        return self.get_opening_post().pub_time
  No newline at end of file
+        return self.get_opening_post().pub_time

boards/templates/boards/post.html

@@ -1,98 +1,98 b''
 {% load i18n %}
 {% load board %}
 {% load cache %}
 
 {% get_current_language as LANGUAGE_CODE %}
 
 {% spaceless %}
     {% cache 600 post post.id post.last_edit_time thread.archived bumpable truncated moderator LANGUAGE_CODE need_open_link %}
         {% if thread.archived %}
             <div class="post archive_post" id="{{ post.id }}">
         {% elif bumpable %}
             <div class="post" id="{{ post.id }}">
         {% else %}
             <div class="post dead_post" id="{{ post.id }}">
         {% endif %}
 
         <div class="post-info">
             <a class="post_id" href="{% post_object_url post thread=thread %}"
                 {% if not truncated and not thread.archived %}
                     onclick="javascript:addQuickReply('{{ post.id }}'); return false;"
                     title="{% trans 'Quote' %}"
                 {% endif %}
                 >({{ post.id }}) </a>
             <span class="title">{{ post.title }} </span>
             <span class="pub_time">{{ post.pub_time }}</span>
             {% if thread.archived %}
                 — {{ thread.bump_time }}
             {% endif %}
             {% if is_opening and need_open_link %}
                 {% if thread.archived %}
                     [<a class="link" href="{% url 'thread' post.id %}">{% trans "Open" %}</a>]
                 {% else %}
                     [<a class="link" href="{% url 'thread' post.id %}#form">{% trans "Reply" %}</a>]
                 {% endif %}
             {% endif %}
 
             {% if moderator %}
                 <span class="moderator_info">
                     [<a href="{% url 'post_admin' post_id=post.id %}"
                         >{% trans 'Edit' %}</a>]
                     [<a href="{% url 'delete' post_id=post.id %}"
                         >{% trans 'Delete' %}</a>]
                     ({{ post.poster_ip }})
                     [<a href="{% url 'ban' post_id=post.id %}?next={{ request.path }}"
                         >{% trans 'Ban IP' %}</a>]
                 </span>
             {% endif %}
         </div>
         {% if post.images.exists %}
-            {% with post.get_first_image as image %}
+            {% with post.images.all.0 as image %}
             <div class="image">
                 <a
                         class="thumb"
                         href="{{ image.image.url }}"><img
                         src="{{ image.image.url_200x150 }}"
                         alt="{{ post.id }}"
                         width="{{ image.pre_width }}"
                         height="{{ image.pre_height }}"
                         data-width="{{ image.width }}"
                         data-height="{{ image.height }}"/>
                 </a>
             </div>
             {% endwith %}
         {% endif %}
         <div class="message">
             {% autoescape off %}
                 {% if truncated %}
                     {{ post.text.rendered|truncatewords_html:50 }}
                 {% else %}
                     {{ post.text.rendered }}
                 {% endif %}
             {% endautoescape %}
             {% if post.is_referenced %}
                 <div class="refmap">
                     {% autoescape off %}
                         {% trans "Replies" %}: {{ post.refmap }}
                     {% endautoescape %}
                 </div>
             {% endif %}
         </div>
     {% endcache %}
         {% if is_opening %}
         {% cache 600 post_thread thread.id thread.last_edit_time LANGUAGE_CODE need_open_link %}
             <div class="metadata">
                 {% if is_opening and need_open_link %}
                     {{ thread.get_images_count }} {% trans 'images' %}.
                 {% endif %}
                 <span class="tags">
                     {% for tag in thread.get_tags %}
                         <a class="tag" href="{% url 'tag' tag.name %}">
                             #{{ tag.name }}</a>{% if not forloop.last %},{% endif %}
                     {% endfor %}
                 </span>
             </div>
         {% endcache %}
         {% endif %}
         </div>
 {% endspaceless %}