Moving neboard to python3 support (no python2 for now until we figure out how

to make them both work)

boards/forms.py

@@ -1,341 +1,298 b''
 import re
 import time
 import hashlib
 
-from captcha.fields import CaptchaField
 from django import forms
 from django.forms.util import ErrorList
 from django.utils.translation import ugettext_lazy as _
 
 from boards.mdx_neboard import formatters
 from boards.models.post import TITLE_MAX_LENGTH
 from boards.models import PostImage
 from neboard import settings
 from boards import utils
 import boards.settings as board_settings
 
 VETERAN_POSTING_DELAY = 5
 
 ATTRIBUTE_PLACEHOLDER = 'placeholder'
 
 LAST_POST_TIME = 'last_post_time'
 LAST_LOGIN_TIME = 'last_login_time'
 TEXT_PLACEHOLDER = _('''Type message here. Use formatting panel for more advanced usage.''')
 TAGS_PLACEHOLDER = _('tag1 several_words_tag')
 
 ERROR_IMAGE_DUPLICATE = _('Such image was already posted')
 
 LABEL_TITLE = _('Title')
 LABEL_TEXT = _('Text')
 LABEL_TAG = _('Tag')
 LABEL_SEARCH = _('Search')
 
 TAG_MAX_LENGTH = 20
 
-REGEX_TAG = ur'^[\w\d]+$'
+REGEX_TAG = r'^[\w\d]+$'
 
 
 class FormatPanel(forms.Textarea):
     def render(self, name, value, attrs=None):
         output = '<div id="mark-panel">'
         for formatter in formatters:
             output += u'<span class="mark_btn"' + \
                       u' onClick="addMarkToMsg(\'' + formatter.format_left + \
                       '\', \'' + formatter.format_right + '\')">' + \
                       formatter.preview_left + formatter.name + \
                       formatter.preview_right + u'</span>'
 
         output += '</div>'
         output += super(FormatPanel, self).render(name, value, attrs=None)
 
         return output
 
 
 class PlainErrorList(ErrorList):
     def __unicode__(self):
         return self.as_text()
 
     def as_text(self):
         return ''.join([u'(!) %s ' % e for e in self])
 
 
 class NeboardForm(forms.Form):
 
     def as_div(self):
         """
         Returns this form rendered as HTML <as_div>s.
         """
 
         return self._html_output(
             # TODO Do not show hidden rows in the list here
             normal_row='<div class="form-row"><div class="form-label">'
                        '%(label)s'
                        '</div></div>'
                        '<div class="form-row"><div class="form-input">'
                        '%(field)s'
                        '</div></div>'
                        '<div class="form-row">'
                        '%(help_text)s'
                        '</div>',
             error_row='<div class="form-row">'
                       '<div class="form-label"></div>'
                       '<div class="form-errors">%s</div>'
                       '</div>',
             row_ender='</div>',
             help_text_html='%s',
             errors_on_separate_row=True)
 
     def as_json_errors(self):
         errors = []
 
         for name, field in self.fields.items():
             if self[name].errors:
                 errors.append({
                     'field': name,
                     'errors': self[name].errors.as_text(),
                 })
 
         return errors
 
 
 class PostForm(NeboardForm):
 
     title = forms.CharField(max_length=TITLE_MAX_LENGTH, required=False,
                             label=LABEL_TITLE)
     text = forms.CharField(
         widget=FormatPanel(attrs={ATTRIBUTE_PLACEHOLDER: TEXT_PLACEHOLDER}),
         required=False, label=LABEL_TEXT)
     image = forms.ImageField(required=False, label=_('Image'),
                              widget=forms.ClearableFileInput(
                                  attrs={'accept': 'image/*'}))
 
     # This field is for spam prevention only
     email = forms.CharField(max_length=100, required=False, label=_('e-mail'),
                             widget=forms.TextInput(attrs={
                                 'class': 'form-email'}))
 
     session = None
     need_to_ban = False
 
     def clean_title(self):
         title = self.cleaned_data['title']
         if title:
             if len(title) > TITLE_MAX_LENGTH:
                 raise forms.ValidationError(_('Title must have less than %s '
                                               'characters') %
                                             str(TITLE_MAX_LENGTH))
         return title
 
     def clean_text(self):
         text = self.cleaned_data['text'].strip()
         if text:
             if len(text) > board_settings.MAX_TEXT_LENGTH:
                 raise forms.ValidationError(_('Text must have less than %s '
                                               'characters') %
                                             str(board_settings
                                             .MAX_TEXT_LENGTH))
         return text
 
     def clean_image(self):
         image = self.cleaned_data['image']
         if image:
             if image.size > board_settings.MAX_IMAGE_SIZE:
                 raise forms.ValidationError(
                     _('Image must be less than %s bytes')
                     % str(board_settings.MAX_IMAGE_SIZE))
 
             md5 = hashlib.md5()
             for chunk in image.chunks():
                 md5.update(chunk)
             image_hash = md5.hexdigest()
             if PostImage.objects.filter(hash=image_hash).exists():
                 raise forms.ValidationError(ERROR_IMAGE_DUPLICATE)
 
         return image
 
     def clean(self):
         cleaned_data = super(PostForm, self).clean()
 
         if not self.session:
             raise forms.ValidationError('Humans have sessions')
 
         if cleaned_data['email']:
             self.need_to_ban = True
             raise forms.ValidationError('A human cannot enter a hidden field')
 
         if not self.errors:
             self._clean_text_image()
 
         if not self.errors and self.session:
             self._validate_posting_speed()
 
         return cleaned_data
 
     def _clean_text_image(self):
         text = self.cleaned_data.get('text')
         image = self.cleaned_data.get('image')
 
         if (not text) and (not image):
             error_message = _('Either text or image must be entered.')
             self._errors['text'] = self.error_class([error_message])
 
     def _validate_posting_speed(self):
         can_post = True
 
         # TODO Remove this, it's only for test
         if not 'user_id' in self.session:
             return
 
         posting_delay = settings.POSTING_DELAY
 
         if board_settings.LIMIT_POSTING_SPEED and LAST_POST_TIME in \
                 self.session:
             now = time.time()
             last_post_time = self.session[LAST_POST_TIME]
 
             current_delay = int(now - last_post_time)
 
             if current_delay < posting_delay:
                 error_message = _('Wait %s seconds after last posting') % str(
                     posting_delay - current_delay)
                 self._errors['text'] = self.error_class([error_message])
 
                 can_post = False
 
         if can_post:
             self.session[LAST_POST_TIME] = time.time()
 
 
 class ThreadForm(PostForm):
 
-    regex_tags = re.compile(ur'^[\w\s\d]+$', re.UNICODE)
+    regex_tags = re.compile(r'^[\w\s\d]+$', re.UNICODE)
 
     tags = forms.CharField(
         widget=forms.TextInput(attrs={ATTRIBUTE_PLACEHOLDER: TAGS_PLACEHOLDER}),
         max_length=100, label=_('Tags'), required=True)
 
     def clean_tags(self):
         tags = self.cleaned_data['tags'].strip()
 
         if not tags or not self.regex_tags.match(tags):
             raise forms.ValidationError(
                 _('Inappropriate characters in tags.'))
 
         return tags
 
     def clean(self):
         cleaned_data = super(ThreadForm, self).clean()
 
         return cleaned_data
 
 
-class PostCaptchaForm(PostForm):
-    captcha = CaptchaField()
-
-    def __init__(self, *args, **kwargs):
-        self.request = kwargs['request']
-        del kwargs['request']
-
-        super(PostCaptchaForm, self).__init__(*args, **kwargs)
-
-    def clean(self):
-        cleaned_data = super(PostCaptchaForm, self).clean()
-
-        success = self.is_valid()
-        utils.update_captcha_access(self.request, success)
-
-        if success:
-            return cleaned_data
-        else:
-            raise forms.ValidationError(_("Captcha validation failed"))
-
-
-class ThreadCaptchaForm(ThreadForm):
-    captcha = CaptchaField()
-
-    def __init__(self, *args, **kwargs):
-        self.request = kwargs['request']
-        del kwargs['request']
-
-        super(ThreadCaptchaForm, self).__init__(*args, **kwargs)
-
-    def clean(self):
-        cleaned_data = super(ThreadCaptchaForm, self).clean()
-
-        success = self.is_valid()
-        utils.update_captcha_access(self.request, success)
-
-        if success:
-            return cleaned_data
-        else:
-            raise forms.ValidationError(_("Captcha validation failed"))
-
-
 class SettingsForm(NeboardForm):
 
     theme = forms.ChoiceField(choices=settings.THEMES,
                               label=_('Theme'))
 
 
 class AddTagForm(NeboardForm):
 
     tag = forms.CharField(max_length=TAG_MAX_LENGTH, label=LABEL_TAG)
     method = forms.CharField(widget=forms.HiddenInput(), initial='add_tag')
 
     def clean_tag(self):
         tag = self.cleaned_data['tag']
 
         regex_tag = re.compile(REGEX_TAG, re.UNICODE)
         if not regex_tag.match(tag):
             raise forms.ValidationError(_('Inappropriate characters in tags.'))
 
         return tag
 
     def clean(self):
         cleaned_data = super(AddTagForm, self).clean()
 
         return cleaned_data
 
 
 class SearchForm(NeboardForm):
     query = forms.CharField(max_length=500, label=LABEL_SEARCH, required=False)
 
 
 class LoginForm(NeboardForm):
 
     password = forms.CharField()
 
     session = None
 
     def clean_password(self):
         password = self.cleaned_data['password']
         if board_settings.MASTER_PASSWORD != password:
             raise forms.ValidationError(_('Invalid master password'))
 
         return password
 
     def _validate_login_speed(self):
         can_post = True
 
         if LAST_LOGIN_TIME in self.session:
             now = time.time()
             last_login_time = self.session[LAST_LOGIN_TIME]
 
             current_delay = int(now - last_login_time)
 
             if current_delay < board_settings.LOGIN_TIMEOUT:
                 error_message = _('Wait %s minutes after last login') % str(
                     (board_settings.LOGIN_TIMEOUT - current_delay) / 60)
                 self._errors['password'] = self.error_class([error_message])
 
                 can_post = False
 
         if can_post:
             self.session[LAST_LOGIN_TIME] = time.time()
 
     def clean(self):
         self._validate_login_speed()
 
         cleaned_data = super(LoginForm, self).clean()
 
         return cleaned_data

boards/migrations/0015_post_to_thread.py

@@ -1,98 +1,98 b''
 # -*- coding: utf-8 -*-
 from south.utils import datetime_utils as datetime
 from south.db import db
 from south.v2 import DataMigration
 from django.db import models
 from boards import views
 
 
 class Migration(DataMigration):
 
     def forwards(self, orm):
         for post in orm.Post.objects.filter(thread=None):
             thread = orm.Thread.objects.create(
                 bump_time=post.bump_time,
                 last_edit_time=post.last_edit_time)
 
             thread.replies.add(post)
             post.thread_new = thread
             post.save()
-            print str(post.thread_new.id)
+            print(str(post.thread_new.id))
 
             for reply in post.replies.all():
                 thread.replies.add(reply)
                 reply.thread_new = thread
                 reply.save()
 
             for tag in post.tags.all():
                 thread.tags.add(tag)
                 tag.threads.add(thread)
 
     def backwards(self, orm):
         pass
 
     models = {
         'boards.ban': {
             'Meta': {'object_name': 'Ban'},
             'can_read': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
             u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
             'ip': ('django.db.models.fields.GenericIPAddressField', [], {'max_length': '39'}),
             'reason': ('django.db.models.fields.CharField', [], {'default': "'Auto'", 'max_length': '200'})
         },
         'boards.post': {
             'Meta': {'object_name': 'Post'},
             '_text_rendered': ('django.db.models.fields.TextField', [], {}),
             'bump_time': ('django.db.models.fields.DateTimeField', [], {}),
             u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
             'image': ('boards.thumbs.ImageWithThumbsField', [], {'max_length': '100', 'blank': 'True'}),
             'image_height': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
             'image_width': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
             'last_edit_time': ('django.db.models.fields.DateTimeField', [], {}),
             'poster_ip': ('django.db.models.fields.GenericIPAddressField', [], {'max_length': '39'}),
             'poster_user_agent': ('django.db.models.fields.TextField', [], {}),
             'pub_time': ('django.db.models.fields.DateTimeField', [], {}),
             'referenced_posts': ('django.db.models.fields.related.ManyToManyField', [], {'blank': 'True', 'related_name': "'rfp+'", 'null': 'True', 'symmetrical': 'False', 'to': "orm['boards.Post']"}),
             'replies': ('django.db.models.fields.related.ManyToManyField', [], {'blank': 'True', 'related_name': "'re+'", 'null': 'True', 'symmetrical': 'False', 'to': "orm['boards.Post']"}),
             'tags': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['boards.Tag']", 'symmetrical': 'False'}),
             'text': ('markupfield.fields.MarkupField', [], {'rendered_field': 'True'}),
             'text_markup_type': ('django.db.models.fields.CharField', [], {'default': "'markdown'", 'max_length': '30'}),
             'thread': ('django.db.models.fields.related.ForeignKey', [], {'default': 'None', 'to': "orm['boards.Post']", 'null': 'True'}),
             'thread_new': ('django.db.models.fields.related.ForeignKey', [], {'default': 'None', 'to': "orm['boards.Thread']", 'null': 'True'}),
             'title': ('django.db.models.fields.CharField', [], {'max_length': '50'}),
             'user': ('django.db.models.fields.related.ForeignKey', [], {'default': 'None', 'to': "orm['boards.User']", 'null': 'True'})
         },
         'boards.setting': {
             'Meta': {'object_name': 'Setting'},
             u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
             'name': ('django.db.models.fields.CharField', [], {'max_length': '50'}),
             'user': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['boards.User']"}),
             'value': ('django.db.models.fields.CharField', [], {'max_length': '50'})
         },
         'boards.tag': {
             'Meta': {'object_name': 'Tag'},
             u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
             'linked': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['boards.Tag']", 'null': 'True', 'blank': 'True'}),
             'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
             'threads': ('django.db.models.fields.related.ManyToManyField', [], {'blank': 'True', 'related_name': "'tag+'", 'null': 'True', 'symmetrical': 'False', 'to': "orm['boards.Thread']"})
         },
         'boards.thread': {
             'Meta': {'object_name': 'Thread'},
             'bump_time': ('django.db.models.fields.DateTimeField', [], {}),
             u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
             'last_edit_time': ('django.db.models.fields.DateTimeField', [], {}),
             'replies': ('django.db.models.fields.related.ManyToManyField', [], {'blank': 'True', 'related_name': "'tre+'", 'null': 'True', 'symmetrical': 'False', 'to': "orm['boards.Post']"}),
             'tags': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['boards.Tag']", 'symmetrical': 'False'})
         },
         'boards.user': {
             'Meta': {'object_name': 'User'},
             'fav_tags': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'to': "orm['boards.Tag']", 'null': 'True', 'blank': 'True'}),
             'fav_threads': ('django.db.models.fields.related.ManyToManyField', [], {'blank': 'True', 'related_name': "'+'", 'null': 'True', 'symmetrical': 'False', 'to': "orm['boards.Post']"}),
             u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
             'rank': ('django.db.models.fields.IntegerField', [], {}),
             'registration_time': ('django.db.models.fields.DateTimeField', [], {}),
             'user_id': ('django.db.models.fields.CharField', [], {'max_length': '50'})
         }
     }
 
     complete_apps = ['boards']
     symmetrical = True

boards/models/post.py

@@ -1,343 +1,343 b''
 from datetime import datetime, timedelta, date
 from datetime import time as dtime
 import logging
 import re
 
 from django.core.cache import cache
 from django.core.urlresolvers import reverse
 from django.db import models, transaction
 from django.template.loader import render_to_string
 from django.utils import timezone
 from markupfield.fields import MarkupField
 
 from boards.models import PostImage
 from boards.models.base import Viewable
 from boards.models.thread import Thread
 
 
 APP_LABEL_BOARDS = 'boards'
 
 CACHE_KEY_PPD = 'ppd'
 CACHE_KEY_POST_URL = 'post_url'
 
 POSTS_PER_DAY_RANGE = 7
 
 BAN_REASON_AUTO = 'Auto'
 
 IMAGE_THUMB_SIZE = (200, 150)
 
 TITLE_MAX_LENGTH = 200
 
 DEFAULT_MARKUP_TYPE = 'bbcode'
 
 # TODO This should be removed
 NO_IP = '0.0.0.0'
 
 # TODO Real user agent should be saved instead of this
 UNKNOWN_UA = ''
 
-REGEX_REPLY = re.compile(ur'\[post\](\d+)\[/post\]')
+REGEX_REPLY = re.compile(r'\[post\](\d+)\[/post\]')
 
 logger = logging.getLogger(__name__)
 
 
 class PostManager(models.Manager):
     def create_post(self, title, text, image=None, thread=None, ip=NO_IP,
                     tags=None):
         """
         Creates new post
         """
 
         posting_time = timezone.now()
         if not thread:
             thread = Thread.objects.create(bump_time=posting_time,
                                            last_edit_time=posting_time)
             new_thread = True
         else:
             thread.bump()
             thread.last_edit_time = posting_time
             thread.save()
             new_thread = False
 
         post = self.create(title=title,
                            text=text,
                            pub_time=posting_time,
                            thread_new=thread,
                            poster_ip=ip,
                            poster_user_agent=UNKNOWN_UA,  # TODO Get UA at
                            # last!
                            last_edit_time=posting_time)
 
         if image:
             post_image = PostImage.objects.create(image=image)
             post.images.add(post_image)
             logger.info('Created image #%d for post #%d' % (post_image.id,
                                                             post.id))
 
         thread.replies.add(post)
         if tags:
             map(thread.add_tag, tags)
 
         if new_thread:
             Thread.objects.process_oldest_threads()
         self.connect_replies(post)
 
         logger.info('Created post #%d with title %s' % (post.id,
                                                         post.get_title()))
 
         return post
 
     def delete_post(self, post):
         """
         Deletes post and update or delete its thread
         """
 
         post_id = post.id
 
         thread = post.get_thread()
 
         if post.is_opening():
             thread.delete()
         else:
             thread.last_edit_time = timezone.now()
             thread.save()
 
             post.delete()
 
         logger.info('Deleted post #%d (%s)' % (post_id, post.get_title()))
 
     def delete_posts_by_ip(self, ip):
         """
         Deletes all posts of the author with same IP
         """
 
         posts = self.filter(poster_ip=ip)
         map(self.delete_post, posts)
 
     def connect_replies(self, post):
         """
         Connects replies to a post to show them as a reflink map
         """
 
         for reply_number in re.finditer(REGEX_REPLY, post.text.raw):
             post_id = reply_number.group(1)
             ref_post = self.filter(id=post_id)
             if ref_post.count() > 0:
                 referenced_post = ref_post[0]
                 referenced_post.referenced_posts.add(post)
                 referenced_post.last_edit_time = post.pub_time
                 referenced_post.build_refmap()
                 referenced_post.save(update_fields=['refmap', 'last_edit_time'])
 
                 referenced_thread = referenced_post.get_thread()
                 referenced_thread.last_edit_time = post.pub_time
                 referenced_thread.save(update_fields=['last_edit_time'])
 
     def get_posts_per_day(self):
         """
         Gets average count of posts per day for the last 7 days
         """
 
         day_end = date.today()
         day_start = day_end - timedelta(POSTS_PER_DAY_RANGE)
 
         cache_key = CACHE_KEY_PPD + str(day_end)
         ppd = cache.get(cache_key)
         if ppd:
             return ppd
 
         day_time_start = timezone.make_aware(datetime.combine(
             day_start, dtime()), timezone.get_current_timezone())
         day_time_end = timezone.make_aware(datetime.combine(
             day_end, dtime()), timezone.get_current_timezone())
 
         posts_per_period = float(self.filter(
             pub_time__lte=day_time_end,
             pub_time__gte=day_time_start).count())
 
         ppd = posts_per_period / POSTS_PER_DAY_RANGE
 
         cache.set(cache_key, ppd)
         return ppd
 
 
 class Post(models.Model, Viewable):
     """A post is a message."""
 
     objects = PostManager()
 
     class Meta:
         app_label = APP_LABEL_BOARDS
         ordering = ('id',)
 
     title = models.CharField(max_length=TITLE_MAX_LENGTH)
     pub_time = models.DateTimeField()
     text = MarkupField(default_markup_type=DEFAULT_MARKUP_TYPE,
                        escape_html=False)
 
     images = models.ManyToManyField(PostImage, null=True, blank=True,
                                     related_name='ip+', db_index=True)
 
     poster_ip = models.GenericIPAddressField()
     poster_user_agent = models.TextField()
 
     thread_new = models.ForeignKey('Thread', null=True, default=None,
                                    db_index=True)
     last_edit_time = models.DateTimeField()
 
     referenced_posts = models.ManyToManyField('Post', symmetrical=False,
                                               null=True,
                                               blank=True, related_name='rfp+',
                                               db_index=True)
     refmap = models.TextField(null=True, blank=True)
 
     def __unicode__(self):
         return '#' + str(self.id) + ' ' + self.title + ' (' + \
                self.text.raw[:50] + ')'
 
     def get_title(self):
         """
         Gets original post title or part of its text.
         """
 
         title = self.title
         if not title:
             title = self.text.rendered
 
         return title
 
     def build_refmap(self):
         """
         Builds a replies map string from replies list. This is a cache to stop
         the server from recalculating the map on every post show.
         """
         map_string = ''
 
         first = True
         for refpost in self.referenced_posts.all():
             if not first:
                 map_string += ', '
             map_string += '<a href="%s">&gt;&gt;%s</a>' % (refpost.get_url(),
                                                            refpost.id)
             first = False
 
         self.refmap = map_string
 
     def get_sorted_referenced_posts(self):
         return self.refmap
 
     def is_referenced(self):
         return len(self.refmap) > 0
 
     def is_opening(self):
         """
         Checks if this is an opening post or just a reply.
         """
 
         return self.get_thread().get_opening_post_id() == self.id
 
     @transaction.atomic
     def add_tag(self, tag):
         edit_time = timezone.now()
 
         thread = self.get_thread()
         thread.add_tag(tag)
         self.last_edit_time = edit_time
         self.save(update_fields=['last_edit_time'])
 
         thread.last_edit_time = edit_time
         thread.save(update_fields=['last_edit_time'])
 
     @transaction.atomic
     def remove_tag(self, tag):
         edit_time = timezone.now()
 
         thread = self.get_thread()
         thread.remove_tag(tag)
         self.last_edit_time = edit_time
         self.save(update_fields=['last_edit_time'])
 
         thread.last_edit_time = edit_time
         thread.save(update_fields=['last_edit_time'])
 
     def get_url(self, thread=None):
         """
         Gets full url to the post.
         """
 
         cache_key = CACHE_KEY_POST_URL + str(self.id)
         link = cache.get(cache_key)
 
         if not link:
             if not thread:
                 thread = self.get_thread()
 
             opening_id = thread.get_opening_post_id()
 
             if self.id != opening_id:
                 link = reverse('thread', kwargs={
                     'post_id': opening_id}) + '#' + str(self.id)
             else:
                 link = reverse('thread', kwargs={'post_id': self.id})
 
             cache.set(cache_key, link)
 
         return link
 
     def get_thread(self):
         """
         Gets post's thread.
         """
 
         return self.thread_new
 
     def get_referenced_posts(self):
         return self.referenced_posts.only('id', 'thread_new')
 
     def get_text(self):
         return self.text
 
     def get_view(self, moderator=False, need_open_link=False,
                  truncated=False, *args, **kwargs):
         if 'is_opening' in kwargs:
             is_opening = kwargs['is_opening']
         else:
             is_opening = self.is_opening()
 
         if 'thread' in kwargs:
             thread = kwargs['thread']
         else:
             thread = self.get_thread()
 
         if 'can_bump' in kwargs:
             can_bump = kwargs['can_bump']
         else:
             can_bump = thread.can_bump()
 
         if is_opening:
             opening_post_id = self.id
         else:
             opening_post_id = thread.get_opening_post_id()
 
         return render_to_string('boards/post.html', {
             'post': self,
             'moderator': moderator,
             'is_opening': is_opening,
             'thread': thread,
             'bumpable': can_bump,
             'need_open_link': need_open_link,
             'truncated': truncated,
             'opening_post_id': opening_post_id,
         })
 
     def get_first_image(self):
         return self.images.earliest('id')
 
     def delete(self, using=None):
         """
         Deletes all post images and the post itself.
         """
 
         self.images.all().delete()
 
         super(Post, self).delete(using)

boards/tests.py

@@ -1,270 +1,270 b''
 # coding=utf-8
 import time
 import logging
 from django.core.paginator import Paginator
 
 from django.test import TestCase
 from django.test.client import Client
 from django.core.urlresolvers import reverse, NoReverseMatch
 from boards.abstracts.settingsmanager import get_settings_manager
 
 from boards.models import Post, Tag, Thread
 from boards import urls
 from boards import settings
 import neboard
 
 TEST_TAG = 'test_tag'
 
 PAGE_404 = 'boards/404.html'
 
 TEST_TEXT = 'test text'
 
 NEW_THREAD_PAGE = '/'
 THREAD_PAGE_ONE = '/thread/1/'
 THREAD_PAGE = '/thread/'
 TAG_PAGE = '/tag/'
 HTTP_CODE_REDIRECT = 302
 HTTP_CODE_OK = 200
 HTTP_CODE_NOT_FOUND = 404
 
 logger = logging.getLogger(__name__)
 
 
 class PostTests(TestCase):
 
     def _create_post(self):
         tag = Tag.objects.create(name=TEST_TAG)
         return Post.objects.create_post(title='title', text='text',
                                         tags=[tag])
 
     def test_post_add(self):
         """Test adding post"""
 
         post = self._create_post()
 
         self.assertIsNotNone(post, 'No post was created.')
         self.assertEqual(TEST_TAG, post.get_thread().tags.all()[0].name,
                          'No tags were added to the post.')
 
     def test_delete_post(self):
         """Test post deletion"""
 
         post = self._create_post()
         post_id = post.id
 
         Post.objects.delete_post(post)
 
         self.assertFalse(Post.objects.filter(id=post_id).exists())
 
     def test_delete_thread(self):
         """Test thread deletion"""
 
         opening_post = self._create_post()
         thread = opening_post.get_thread()
         reply = Post.objects.create_post("", "", thread=thread)
 
         thread.delete()
 
         self.assertFalse(Post.objects.filter(id=reply.id).exists())
 
     def test_post_to_thread(self):
         """Test adding post to a thread"""
 
         op = self._create_post()
         post = Post.objects.create_post("", "", thread=op.get_thread())
 
         self.assertIsNotNone(post, 'Reply to thread wasn\'t created')
         self.assertEqual(op.get_thread().last_edit_time, post.pub_time,
                          'Post\'s create time doesn\'t match thread last edit'
                          ' time')
 
     def test_delete_posts_by_ip(self):
         """Test deleting posts with the given ip"""
 
         post = self._create_post()
         post_id = post.id
 
         Post.objects.delete_posts_by_ip('0.0.0.0')
 
         self.assertFalse(Post.objects.filter(id=post_id).exists())
 
     def test_get_thread(self):
         """Test getting all posts of a thread"""
 
         opening_post = self._create_post()
 
         for i in range(0, 2):
             Post.objects.create_post('title', 'text',
                                      thread=opening_post.get_thread())
 
         thread = opening_post.get_thread()
 
         self.assertEqual(3, thread.replies.count())
 
     def test_create_post_with_tag(self):
         """Test adding tag to post"""
 
         tag = Tag.objects.create(name='test_tag')
         post = Post.objects.create_post(title='title', text='text', tags=[tag])
 
         thread = post.get_thread()
         self.assertIsNotNone(post, 'Post not created')
         self.assertTrue(tag in thread.tags.all(), 'Tag not added to thread')
         self.assertTrue(thread in tag.threads.all(), 'Thread not added to tag')
 
     def test_thread_max_count(self):
         """Test deletion of old posts when the max thread count is reached"""
 
         for i in range(settings.MAX_THREAD_COUNT + 1):
             self._create_post()
 
         self.assertEqual(settings.MAX_THREAD_COUNT,
                          len(Thread.objects.filter(archived=False)))
 
     def test_pages(self):
         """Test that the thread list is properly split into pages"""
 
         for i in range(settings.MAX_THREAD_COUNT):
             self._create_post()
 
         all_threads = Thread.objects.filter(archived=False)
 
         paginator = Paginator(Thread.objects.filter(archived=False),
                               settings.THREADS_PER_PAGE)
         posts_in_second_page = paginator.page(2).object_list
         first_post = posts_in_second_page[0]
 
         self.assertEqual(all_threads[settings.THREADS_PER_PAGE].id,
                          first_post.id)
 
 
 class PagesTest(TestCase):
 
     def test_404(self):
         """Test receiving error 404 when opening a non-existent page"""
 
         tag_name = u'test_tag'
         tag = Tag.objects.create(name=tag_name)
         client = Client()
 
         Post.objects.create_post('title', TEST_TEXT, tags=[tag])
 
         existing_post_id = Post.objects.all()[0].id
         response_existing = client.get(THREAD_PAGE + str(existing_post_id) +
                                        '/')
         self.assertEqual(HTTP_CODE_OK, response_existing.status_code,
                          u'Cannot open existing thread')
 
         response_not_existing = client.get(THREAD_PAGE + str(
             existing_post_id + 1) + '/')
         self.assertEqual(PAGE_404, response_not_existing.templates[0].name,
                          u'Not existing thread is opened')
 
         response_existing = client.get(TAG_PAGE + tag_name + '/')
         self.assertEqual(HTTP_CODE_OK,
                          response_existing.status_code,
                          u'Cannot open existing tag')
 
         response_not_existing = client.get(TAG_PAGE + u'not_tag' + '/')
         self.assertEqual(PAGE_404,
                          response_not_existing.templates[0].name,
                          u'Not existing tag is opened')
 
         reply_id = Post.objects.create_post('', TEST_TEXT,
                                             thread=Post.objects.all()[0]
                                             .get_thread())
         response_not_existing = client.get(THREAD_PAGE + str(
             reply_id) + '/')
         self.assertEqual(PAGE_404,
                          response_not_existing.templates[0].name,
                          u'Reply is opened as a thread')
 
 
 class FormTest(TestCase):
     def test_post_validation(self):
         # Disable captcha for the test
         captcha_enabled = neboard.settings.ENABLE_CAPTCHA
         neboard.settings.ENABLE_CAPTCHA = False
 
         client = Client()
 
         valid_tags = u'tag1 tag_2 тег_3'
         invalid_tags = u'$%_356 ---'
 
         response = client.post(NEW_THREAD_PAGE, {'title': 'test title',
                                                  'text': TEST_TEXT,
                                                  'tags': valid_tags})
         self.assertEqual(response.status_code, HTTP_CODE_REDIRECT,
                          msg='Posting new message failed: got code ' +
                              str(response.status_code))
 
         self.assertEqual(1, Post.objects.count(),
                          msg='No posts were created')
 
         client.post(NEW_THREAD_PAGE, {'text': TEST_TEXT,
                                       'tags': invalid_tags})
         self.assertEqual(1, Post.objects.count(), msg='The validation passed '
                                                       'where it should fail')
 
         # Change posting delay so we don't have to wait for 30 seconds or more
         old_posting_delay = neboard.settings.POSTING_DELAY
         # Wait fot the posting delay or we won't be able to post
         settings.POSTING_DELAY = 1
         time.sleep(neboard.settings.POSTING_DELAY + 1)
         response = client.post(THREAD_PAGE_ONE, {'text': TEST_TEXT,
                                                  'tags': valid_tags})
         self.assertEqual(HTTP_CODE_REDIRECT, response.status_code,
                          msg=u'Posting new message failed: got code ' +
                              str(response.status_code))
         # Restore posting delay
         settings.POSTING_DELAY = old_posting_delay
 
         self.assertEqual(2, Post.objects.count(),
                          msg=u'No posts were created')
 
         # Restore captcha setting
         settings.ENABLE_CAPTCHA = captcha_enabled
 
 
 class ViewTest(TestCase):
 
     def test_all_views(self):
         """
         Try opening all views defined in ulrs.py that don't need additional
         parameters
         """
 
         client = Client()
         for url in urls.urlpatterns:
             try:
                 view_name = url.name
                 logger.debug('Testing view %s' % view_name)
 
                 try:
                     response = client.get(reverse(view_name))
 
                     self.assertEqual(HTTP_CODE_OK, response.status_code,
                                      '%s view not opened' % view_name)
                 except NoReverseMatch:
                     # This view just needs additional arguments
                     pass
-                except Exception, e:
+                except Exception as e:
                     self.fail('Got exception %s at %s view' % (e, view_name))
             except AttributeError:
                 # This is normal, some views do not have names
                 pass
 
 
 class AbstractTest(TestCase):
     def test_settings_manager(self):
         request = MockRequest()
         settings_manager = get_settings_manager(request)
 
         settings_manager.set_setting('test_setting', 'test_value')
         self.assertEqual('test_value', settings_manager.get_setting(
             'test_setting'), u'Setting update failed.')
 
 
 class MockRequest:
     def __init__(self):
         self.session = dict()

boards/thumbs.py

@@ -1,219 +1,219 b''
 # -*- encoding: utf-8 -*-
 """
 django-thumbs by Antonio Melé
 http://django.es
 """
 from django.core.files.images import ImageFile
 from django.db.models import ImageField
 from django.db.models.fields.files import ImageFieldFile
 from PIL import Image
 from django.core.files.base import ContentFile
-import cStringIO
+import io
 
 
 def generate_thumb(img, thumb_size, format):
     """
     Generates a thumbnail image and returns a ContentFile object with the thumbnail
 
     Parameters:
     ===========
     img         File object
 
     thumb_size  desired thumbnail size, ie: (200,120)
 
     format      format of the original image ('jpeg','gif','png',...)
                 (this format will be used for the generated thumbnail, too)
     """
 
     img.seek(0) # see http://code.djangoproject.com/ticket/8222 for details
     image = Image.open(img)
 
     # get size
     thumb_w, thumb_h = thumb_size
     # If you want to generate a square thumbnail
     if thumb_w == thumb_h:
         # quad
         xsize, ysize = image.size
         # get minimum size
         minsize = min(xsize, ysize)
         # largest square possible in the image
         xnewsize = (xsize - minsize) / 2
         ynewsize = (ysize - minsize) / 2
         # crop it
         image2 = image.crop(
             (xnewsize, ynewsize, xsize - xnewsize, ysize - ynewsize))
         # load is necessary after crop
         image2.load()
         # thumbnail of the cropped image (with ANTIALIAS to make it look better)
         image2.thumbnail(thumb_size, Image.ANTIALIAS)
     else:
         # not quad
         image2 = image
         image2.thumbnail(thumb_size, Image.ANTIALIAS)
 
-    io = cStringIO.StringIO()
+    string_io = io.StringIO()
     # PNG and GIF are the same, JPG is JPEG
     if format.upper() == 'JPG':
         format = 'JPEG'
 
-    image2.save(io, format)
-    return ContentFile(io.getvalue())
+    image2.save(string_io, format)
+    return ContentFile(string_io.getvalue())
 
 
 class ImageWithThumbsFieldFile(ImageFieldFile):
     """
     See ImageWithThumbsField for usage example
     """
 
     def __init__(self, *args, **kwargs):
         super(ImageWithThumbsFieldFile, self).__init__(*args, **kwargs)
         self.sizes = self.field.sizes
 
         if self.sizes:
             def get_size(self, size):
                 if not self:
                     return ''
                 else:
                     split = self.url.rsplit('.', 1)
                     thumb_url = '%s.%sx%s.%s' % (split[0], w, h, split[1])
                     return thumb_url
 
             for size in self.sizes:
                 (w, h) = size
                 setattr(self, 'url_%sx%s' % (w, h), get_size(self, size))
 
     def save(self, name, content, save=True):
         super(ImageWithThumbsFieldFile, self).save(name, content, save)
 
         if self.sizes:
             for size in self.sizes:
                 (w, h) = size
                 split = self.name.rsplit('.', 1)
                 thumb_name = '%s.%sx%s.%s' % (split[0], w, h, split[1])
 
                 # you can use another thumbnailing function if you like
                 thumb_content = generate_thumb(content, size, split[1])
 
                 thumb_name_ = self.storage.save(thumb_name, thumb_content)
 
                 if not thumb_name == thumb_name_:
                     raise ValueError(
                         'There is already a file named %s' % thumb_name)
 
     def delete(self, save=True):
         name = self.name
         super(ImageWithThumbsFieldFile, self).delete(save)
         if self.sizes:
             for size in self.sizes:
                 (w, h) = size
                 split = name.rsplit('.', 1)
                 thumb_name = '%s.%sx%s.%s' % (split[0], w, h, split[1])
                 try:
                     self.storage.delete(thumb_name)
                 except:
                     pass
 
 
 class ImageWithThumbsField(ImageField):
     attr_class = ImageWithThumbsFieldFile
     """
     Usage example:
     ==============
     photo = ImageWithThumbsField(upload_to='images', sizes=((125,125),(300,200),)
     
     To retrieve image URL, exactly the same way as with ImageField:
         my_object.photo.url
     To retrieve thumbnails URL's just add the size to it:
         my_object.photo.url_125x125
         my_object.photo.url_300x200
     
     Note: The 'sizes' attribute is not required. If you don't provide it, 
     ImageWithThumbsField will act as a normal ImageField
         
     How it works:
     =============
     For each size in the 'sizes' atribute of the field it generates a 
     thumbnail with that size and stores it following this format:
     
     available_filename.[width]x[height].extension
 
     Where 'available_filename' is the available filename returned by the storage
     backend for saving the original file.
     
     Following the usage example above: For storing a file called "photo.jpg" it saves:
     photo.jpg          (original file)
     photo.125x125.jpg  (first thumbnail)
     photo.300x200.jpg  (second thumbnail)
     
     With the default storage backend if photo.jpg already exists it will use these filenames:
     photo_.jpg
     photo_.125x125.jpg
     photo_.300x200.jpg
     
     Note: django-thumbs assumes that if filename "any_filename.jpg" is available 
     filenames with this format "any_filename.[widht]x[height].jpg" will be available, too.
     
     To do:
     ======
     Add method to regenerate thubmnails
 
     
     """
 
     preview_width_field = None
     preview_height_field = None
 
     def __init__(self, verbose_name=None, name=None, width_field=None,
                  height_field=None, sizes=None,
                  preview_width_field=None, preview_height_field=None,
                  **kwargs):
         self.verbose_name = verbose_name
         self.name = name
         self.width_field = width_field
         self.height_field = height_field
         self.sizes = sizes
         super(ImageField, self).__init__(**kwargs)
 
         if sizes is not None and len(sizes) == 1:
             self.preview_width_field = preview_width_field
             self.preview_height_field = preview_height_field
 
     def update_dimension_fields(self, instance, force=False, *args, **kwargs):
         """
         Update original image dimension fields and thumb dimension fields
         (only if 1 thumb size is defined)
         """
 
         super(ImageWithThumbsField, self).update_dimension_fields(instance,
                                                                    force, *args,
                                                                    **kwargs)
         thumb_width_field = self.preview_width_field
         thumb_height_field = self.preview_height_field
 
         if thumb_width_field is None or thumb_height_field is None \
                 or len(self.sizes) != 1:
             return
 
         original_width = getattr(instance, self.width_field)
         original_height = getattr(instance, self.height_field)
 
         if original_width > 0 and original_height > 0:
             thumb_width, thumb_height = self.sizes[0]
 
             w_scale = float(thumb_width) / original_width
             h_scale = float(thumb_height) / original_height
             scale_ratio = min(w_scale, h_scale)
 
             if scale_ratio >= 1:
                 thumb_width_ratio = original_width
                 thumb_height_ratio = original_height
             else:
                 thumb_width_ratio = int(original_width * scale_ratio)
                 thumb_height_ratio = int(original_height * scale_ratio)
 
             setattr(instance, thumb_width_field, thumb_width_ratio)
             setattr(instance, thumb_height_field, thumb_height_ratio)
 
 
 from south.modelsinspector import add_introspection_rules
 add_introspection_rules([], ["^boards\.thumbs\.ImageWithThumbsField"])

boards/urls.py

@@ -1,84 +1,83 b''
 from django.conf.urls import patterns, url, include
 from boards import views
 from boards.rss import AllThreadsFeed, TagThreadsFeed, ThreadPostsFeed
 from boards.views import api, tag_threads, all_threads, \
     login, settings, all_tags, logout
 from boards.views.authors import AuthorsView
 from boards.views.delete_post import DeletePostView
 from boards.views.ban import BanUserView
 from boards.views.search import BoardSearchView
 from boards.views.static import StaticPageView
 from boards.views.post_admin import PostAdminView
 
 js_info_dict = {
     'packages': ('boards',),
 }
 
 urlpatterns = patterns('',
 
     # /boards/
     url(r'^$', all_threads.AllThreadsView.as_view(), name='index'),
     # /boards/page/
     url(r'^page/(?P<page>\w+)/$', all_threads.AllThreadsView.as_view(),
         name='index'),
 
     # login page
     url(r'^login/$', login.LoginView.as_view(), name='login'),
     url(r'^logout/$', logout.LogoutView.as_view(), name='logout'),
 
     # /boards/tag/tag_name/
     url(r'^tag/(?P<tag_name>\w+)/$', tag_threads.TagView.as_view(),
         name='tag'),
     # /boards/tag/tag_id/page/
     url(r'^tag/(?P<tag_name>\w+)/page/(?P<page>\w+)/$',
         tag_threads.TagView.as_view(), name='tag'),
 
     # /boards/thread/
     url(r'^thread/(?P<post_id>\w+)/$', views.thread.ThreadView.as_view(),
         name='thread'),
     url(r'^thread/(?P<post_id>\w+)/mode/(?P<mode>\w+)/$', views.thread.ThreadView
         .as_view(), name='thread_mode'),
 
     # /boards/post_admin/
     url(r'^post_admin/(?P<post_id>\w+)/$', PostAdminView.as_view(),
             name='post_admin'),
 
     url(r'^settings/$', settings.SettingsView.as_view(), name='settings'),
     url(r'^tags/$', all_tags.AllTagsView.as_view(), name='tags'),
-    url(r'^captcha/', include('captcha.urls')),
     url(r'^authors/$', AuthorsView.as_view(), name='authors'),
     url(r'^delete/(?P<post_id>\w+)/$', DeletePostView.as_view(),
             name='delete'),
     url(r'^ban/(?P<post_id>\w+)/$', BanUserView.as_view(), name='ban'),
 
     url(r'^banned/$', views.banned.BannedView.as_view(), name='banned'),
     url(r'^staticpage/(?P<name>\w+)/$', StaticPageView.as_view(),
         name='staticpage'),
 
     # RSS feeds
     url(r'^rss/$', AllThreadsFeed()),
     url(r'^page/(?P<page>\w+)/rss/$', AllThreadsFeed()),
     url(r'^tag/(?P<tag_name>\w+)/rss/$', TagThreadsFeed()),
     url(r'^tag/(?P<tag_name>\w+)/page/(?P<page>\w+)/rss/$', TagThreadsFeed()),
     url(r'^thread/(?P<post_id>\w+)/rss/$', ThreadPostsFeed()),
 
     # i18n
     url(r'^jsi18n/$', 'boards.views.cached_js_catalog', js_info_dict,
         name='js_info_dict'),
 
     # API
     url(r'^api/post/(?P<post_id>\w+)/$', api.get_post, name="get_post"),
     url(r'^api/diff_thread/(?P<thread_id>\w+)/(?P<last_update_time>\w+)/$',
         api.api_get_threaddiff, name="get_thread_diff"),
     url(r'^api/threads/(?P<count>\w+)/$', api.api_get_threads,
             name='get_threads'),
     url(r'^api/tags/$', api.api_get_tags, name='get_tags'),
     url(r'^api/thread/(?P<opening_post_id>\w+)/$', api.api_get_thread_posts,
             name='get_thread'),
     url(r'^api/add_post/(?P<opening_post_id>\w+)/$', api.api_add_post,
             name='add_post'),
 
     # Search
     url(r'^search/$', BoardSearchView.as_view(), name='search'),
 
 )

boards/utils.py

@@ -1,82 +1,78 b''
 """
 This module contains helper functions and helper classes.
 """
 import hashlib
 import time
 
 from django.utils import timezone
 
 from neboard import settings
 
 
 KEY_CAPTCHA_FAILS = 'key_captcha_fails'
 KEY_CAPTCHA_DELAY_TIME = 'key_captcha_delay_time'
 KEY_CAPTCHA_LAST_ACTIVITY = 'key_captcha_last_activity'
 
 
 def need_include_captcha(request):
     """
     Check if request is made by a user.
     It contains rules which check for bots.
     """
 
     if not settings.ENABLE_CAPTCHA:
         return False
 
     enable_captcha = False
 
     #newcomer
     if KEY_CAPTCHA_LAST_ACTIVITY not in request.session:
         return settings.ENABLE_CAPTCHA
 
     last_activity = request.session[KEY_CAPTCHA_LAST_ACTIVITY]
     current_delay = int(time.time()) - last_activity
 
     delay_time = (request.session[KEY_CAPTCHA_DELAY_TIME]
                   if KEY_CAPTCHA_DELAY_TIME in request.session
                   else settings.CAPTCHA_DEFAULT_SAFE_TIME)
 
     if current_delay < delay_time:
         enable_captcha = True
 
-    print 'ENABLING' + str(enable_captcha)
-
     return enable_captcha
 
 
 def update_captcha_access(request, passed):
     """
     Update captcha fields.
     It will reduce delay time if user passed captcha verification and
     it will increase it otherwise.
     """
     session = request.session
 
     delay_time = (request.session[KEY_CAPTCHA_DELAY_TIME]
                   if KEY_CAPTCHA_DELAY_TIME in request.session
                   else settings.CAPTCHA_DEFAULT_SAFE_TIME)
 
-    print "DELAY TIME = " + str(delay_time)
-
     if passed:
         delay_time -= 2 if delay_time >= 7 else 5
     else:
         delay_time += 10
 
     session[KEY_CAPTCHA_LAST_ACTIVITY] = int(time.time())
     session[KEY_CAPTCHA_DELAY_TIME] = delay_time
 
 
 def get_client_ip(request):
     x_forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR')
     if x_forwarded_for:
         ip = x_forwarded_for.split(',')[-1].strip()
     else:
         ip = request.META.get('REMOTE_ADDR')
     return ip
 
 
 def datetime_to_epoch(datetime):
     return int(time.mktime(timezone.localtime(
         datetime,timezone.get_current_timezone()).timetuple())
-               * 1000000 + datetime.microsecond)
  No newline at end of file
+               * 1000000 + datetime.microsecond)

neboard/settings.py

@@ -1,260 +1,260 b''
 # Django settings for neboard project.
 import os
 from boards.mdx_neboard import bbcode_extended
 
 DEBUG = True
 TEMPLATE_DEBUG = DEBUG
 
 ADMINS = (
     # ('Your Name', '[e-mail]'),
     ('admin', '[e-mail]')
 )
 
 MANAGERS = ADMINS
 
 DATABASES = {
     'default': {
         'ENGINE': 'django.db.backends.sqlite3', # Add 'postgresql_psycopg2', 'mysql', 'sqlite3' or 'oracle'.
         'NAME': 'database.db',                      # Or path to database file if using sqlite3.
         'USER': '',                      # Not used with sqlite3.
         'PASSWORD': '',                  # Not used with sqlite3.
         'HOST': '',                      # Set to empty string for localhost. Not used with sqlite3.
         'PORT': '',                      # Set to empty string for default. Not used with sqlite3.
 	'CONN_MAX_AGE': None,
     }
 }
 
 # Local time zone for this installation. Choices can be found here:
 # http://en.wikipedia.org/wiki/List_of_tz_zones_by_name
 # although not all choices may be available on all operating systems.
 # In a Windows environment this must be set to your system time zone.
 TIME_ZONE = 'Europe/Kiev'
 
 # Language code for this installation. All choices can be found here:
 # http://www.i18nguy.com/unicode/language-identifiers.html
 LANGUAGE_CODE = 'en'
 
 SITE_ID = 1
 
 # If you set this to False, Django will make some optimizations so as not
 # to load the internationalization machinery.
 USE_I18N = True
 
 # If you set this to False, Django will not format dates, numbers and
 # calendars according to the current locale.
 USE_L10N = True
 
 # If you set this to False, Django will not use timezone-aware datetimes.
 USE_TZ = True
 
 # Absolute filesystem path to the directory that will hold user-uploaded files.
 # Example: "/home/media/media.lawrence.com/media/"
 MEDIA_ROOT = './media/' 
 
 # URL that handles the media served from MEDIA_ROOT. Make sure to use a
 # trailing slash.
 # Examples: "http://media.lawrence.com/media/", "http://example.com/media/"
 MEDIA_URL = '/media/'
 
 # Absolute path to the directory static files should be collected to.
 # Don't put anything in this directory yourself; store your static files
 # in apps' "static/" subdirectories and in STATICFILES_DIRS.
 # Example: "/home/media/media.lawrence.com/static/"
 STATIC_ROOT = ''
 
 # URL prefix for static files.
 # Example: "http://media.lawrence.com/static/"
 STATIC_URL = '/static/'
 
 # Additional locations of static files
 # It is really a hack, put real paths, not related
 STATICFILES_DIRS = (
     os.path.dirname(__file__) + '/boards/static',
 
 #    '/d/work/python/django/neboard/neboard/boards/static',
     # Put strings here, like "/home/html/static" or "C:/www/django/static".
     # Always use forward slashes, even on Windows.
     # Don't forget to use absolute paths, not relative paths.
 )
 
 # List of finder classes that know how to find static files in
 # various locations.
 STATICFILES_FINDERS = (
     'django.contrib.staticfiles.finders.FileSystemFinder',
     'django.contrib.staticfiles.finders.AppDirectoriesFinder',
 )
 
 if DEBUG:
     STATICFILES_STORAGE = \
         'django.contrib.staticfiles.storage.StaticFilesStorage'
 else:
     STATICFILES_STORAGE = \
         'django.contrib.staticfiles.storage.CachedStaticFilesStorage'
 
 # Make this unique, and don't share it with anybody.
 SECRET_KEY = '@1rc$o(7=tt#kd+4s$u6wchm**z^)4x90)7f6z(i&55@o11*8o'
 
 # List of callables that know how to import templates from various sources.
 TEMPLATE_LOADERS = (
     'django.template.loaders.filesystem.Loader',
     'django.template.loaders.app_directories.Loader',
 )
 
 TEMPLATE_CONTEXT_PROCESSORS = (
     'django.core.context_processors.media',
     'django.core.context_processors.static',
     'django.core.context_processors.request',
     'django.contrib.auth.context_processors.auth',
     'boards.context_processors.user_and_ui_processor',
 )
 
 MIDDLEWARE_CLASSES = (
     'django.contrib.sessions.middleware.SessionMiddleware',
     'django.middleware.locale.LocaleMiddleware',
     'django.middleware.common.CommonMiddleware',
     'django.contrib.auth.middleware.AuthenticationMiddleware',
     'django.contrib.messages.middleware.MessageMiddleware',
     'boards.middlewares.BanMiddleware',
     'boards.middlewares.MinifyHTMLMiddleware',
 )
 
 ROOT_URLCONF = 'neboard.urls'
 
 # Python dotted path to the WSGI application used by Django's runserver.
 WSGI_APPLICATION = 'neboard.wsgi.application'
 
 TEMPLATE_DIRS = (
     # Put strings here, like "/home/html/django_templates" or "C:/www/django/templates".
     # Always use forward slashes, even on Windows.
     # Don't forget to use absolute paths, not relative paths.
     'templates',
 )
 
 INSTALLED_APPS = (
     'django.contrib.auth',
     'django.contrib.contenttypes',
     'django.contrib.sessions',
     # 'django.contrib.sites',
     'django.contrib.messages',
     'django.contrib.staticfiles',
     # Uncomment the next line to enable the admin:
     'django.contrib.admin',
     # Uncomment the next line to enable admin documentation:
     # 'django.contrib.admindocs',
     'django.contrib.humanize',
     'django_cleanup',
 
     # Migrations
     'south',
     'debug_toolbar',
 
     'captcha',
 
     # Search
     'haystack',
 
     'boards',
 )
 
 DEBUG_TOOLBAR_PANELS = (
     'debug_toolbar.panels.version.VersionDebugPanel',
     'debug_toolbar.panels.timer.TimerDebugPanel',
     'debug_toolbar.panels.settings_vars.SettingsVarsDebugPanel',
     'debug_toolbar.panels.headers.HeaderDebugPanel',
     'debug_toolbar.panels.request_vars.RequestVarsDebugPanel',
     'debug_toolbar.panels.template.TemplateDebugPanel',
     'debug_toolbar.panels.sql.SQLDebugPanel',
     'debug_toolbar.panels.signals.SignalDebugPanel',
     'debug_toolbar.panels.logger.LoggingPanel',
 )
 
 # TODO: NEED DESIGN FIXES
 CAPTCHA_OUTPUT_FORMAT = (u' %(hidden_field)s '
                          u'<div class="form-label">%(image)s</div>'
                          u'<div class="form-text">%(text_field)s</div>')
 
 # A sample logging configuration. The only tangible logging
 # performed by this configuration is to send an email to
 # the site admins on every HTTP 500 error when DEBUG=False.
 # See http://docs.djangoproject.com/en/dev/topics/logging for
 # more details on how to customize your logging configuration.
 LOGGING = {
     'version': 1,
     'disable_existing_loggers': False,
     'formatters': {
         'verbose': {
             'format': '%(levelname)s %(asctime)s %(module)s %(process)d %(thread)d %(message)s'
         },
         'simple': {
             'format': '%(levelname)s %(asctime)s [%(module)s] %(message)s'
         },
     },
     'filters': {
         'require_debug_false': {
             '()': 'django.utils.log.RequireDebugFalse'
         }
     },
     'handlers': {
         'console': {
             'level': 'DEBUG',
             'class': 'logging.StreamHandler',
             'formatter': 'simple'
         },
     },
     'loggers': {
         'boards': {
             'handlers': ['console'],
             'level': 'DEBUG',
         }
     },
 }
 
 HAYSTACK_CONNECTIONS = {
     'default': {
         'ENGINE': 'haystack.backends.whoosh_backend.WhooshEngine',
         'PATH': os.path.join(os.path.dirname(__file__), 'whoosh_index'),
     },
 }
 
 MARKUP_FIELD_TYPES = (
     ('bbcode', bbcode_extended),
 )
 
 THEMES = [
     ('md', 'Mystic Dark'),
     ('md_centered', 'Mystic Dark (centered)'),
     ('sw', 'Snow White'),
     ('pg', 'Photon Gray'),
 ]
 
 POPULAR_TAGS = 10
 
 ENABLE_CAPTCHA = False
 # if user tries to post before CAPTCHA_DEFAULT_SAFE_TIME. Captcha will be shown
 CAPTCHA_DEFAULT_SAFE_TIME = 30  # seconds
 POSTING_DELAY = 20  # seconds
 
 COMPRESS_HTML = True
 
 # Debug mode middlewares
 if DEBUG:
     MIDDLEWARE_CLASSES += (
-        'boards.profiler.ProfilerMiddleware',
+        #'boards.profiler.ProfilerMiddleware',
         'debug_toolbar.middleware.DebugToolbarMiddleware',
     )
 
     def custom_show_toolbar(request):
         return DEBUG
 
     DEBUG_TOOLBAR_CONFIG = {
         'INTERCEPT_REDIRECTS': False,
         'SHOW_TOOLBAR_CALLBACK': custom_show_toolbar,
         'HIDE_DJANGO_SQL': False,
         'ENABLE_STACKTRACES': True,
     }
 
     # FIXME Uncommenting this fails somehow. Need to investigate this
     #DEBUG_TOOLBAR_PANELS += (
     #    'debug_toolbar.panels.profiling.ProfilingDebugPanel',
     #)