Added image duplicate check

boards/migrations/0019_auto__add_field_post_image_hash.py

@@ -0,0 +1,86 b''
+# -*- coding: utf-8 -*-
+from south.utils import datetime_utils as datetime
+from south.db import db
+from south.v2 import SchemaMigration
+from django.db import models
+
+
+class Migration(SchemaMigration):
+
+    def forwards(self, orm):
+        # Adding field 'Post.image_hash'
+        db.add_column(u'boards_post', 'image_hash',
+                      self.gf('django.db.models.fields.CharField')(default='', max_length=36),
+                      keep_default=False)
+
+
+    def backwards(self, orm):
+        # Deleting field 'Post.image_hash'
+        db.delete_column(u'boards_post', 'image_hash')
+
+
+    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', [], {}),
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'image': ('boards.thumbs.ImageWithThumbsField', [], {'max_length': '100', 'blank': 'True'}),
+            'image_hash': ('django.db.models.fields.CharField', [], {'max_length': '36'}),
+            'image_height': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
+            'image_pre_height': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
+            'image_pre_width': ('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']"}),
+            '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'},
+            'archived': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            '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']
  No newline at end of file

boards/migrations/0020_image_hashes.py

@@ -0,0 +1,91 b''
+# -*- coding: utf-8 -*-
+import hashlib
+
+from south.utils import datetime_utils as datetime
+from south.db import db
+from south.v2 import DataMigration
+from django.db import models
+
+class Migration(DataMigration):
+
+    def forwards(self, orm):
+        # Note: Don't use "from appname.models import ModelName". 
+        # Use orm.ModelName to refer to models in this application,
+        # and orm['appname.ModelName'] for models in other applications.
+        for post in orm.Post.objects.filter(image_width__gt=0):
+            md5 = hashlib.md5()
+            for chunk in post.image.chunks():
+                md5.update(chunk)
+            image_hash = md5.hexdigest()
+            post.image_hash = image_hash
+            post.save()
+
+    def backwards(self, orm):
+        "Write your backwards methods here."
+
+    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', [], {}),
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'image': ('boards.thumbs.ImageWithThumbsField', [], {'max_length': '100', 'blank': 'True'}),
+            'image_hash': ('django.db.models.fields.CharField', [], {'max_length': '36'}),
+            'image_height': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
+            'image_pre_height': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
+            'image_pre_width': ('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']"}),
+            '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'},
+            'archived': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            '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/forms.py

@@ -1,285 +1,301 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 _
-import time
+
 from boards.mdx_neboard import formatters
 from boards.models.post import TITLE_MAX_LENGTH
-from boards.models import User
+from boards.models import User, Post
 from neboard import settings
 from boards import utils
 import boards.settings as board_settings
 
 ATTRIBUTE_PLACEHOLDER = 'placeholder'
 
 LAST_POST_TIME = 'last_post_time'
 LAST_LOGIN_TIME = 'last_login_time'
 TEXT_PLACEHOLDER = _('''Type message here. You can reply to message >>123 like
  this. 2 new lines are required to start new paragraph.''')
 TAGS_PLACEHOLDER = _('tag1 several_words_tag')
 
+ERROR_IMAGE_DUPLICATE = _('Such image was already posted')
+
+LABEL_TITLE = _('Title')
+LABEL_TEXT = _('Text')
+
 
 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 class="form-input">'
                        '%(field)s'
                        '</div>'
                        '%(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)
 
 
 class PostForm(NeboardForm):
 
     title = forms.CharField(max_length=TITLE_MAX_LENGTH, required=False,
-                            label=_('Title'))
+                            label=LABEL_TITLE)
     text = forms.CharField(
         widget=FormatPanel(attrs={ATTRIBUTE_PLACEHOLDER: TEXT_PLACEHOLDER}),
-        required=False, label=_('Text'))
+        required=False, label=LABEL_TEXT)
     image = forms.ImageField(required=False, label=_('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']
         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 Post.objects.filter(image_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
 
         if 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 < settings.POSTING_DELAY:
                 error_message = _('Wait %s seconds after last posting') % str(
                     settings.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)
 
     tags = forms.CharField(
         widget=forms.TextInput(attrs={ATTRIBUTE_PLACEHOLDER: TAGS_PLACEHOLDER}),
         max_length=100, label=_('Tags'))
 
     def clean_tags(self):
         tags = self.cleaned_data['tags']
 
         if tags:
             if 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 ModeratorSettingsForm(SettingsForm):
 
     moderate = forms.BooleanField(required=False, label=_('Enable moderation '
                                                           'panel'))
 
 
 class LoginForm(NeboardForm):
 
     user_id = forms.CharField()
 
     session = None
 
     def clean_user_id(self):
         user_id = self.cleaned_data['user_id']
         if user_id:
             users = User.objects.filter(user_id=user_id)
             if len(users) == 0:
                 raise forms.ValidationError(_('No such user found'))
 
         return user_id
 
     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['user_id'] = self.error_class([error_message])
 
                 can_post = False
 
         if can_post:
             self.session[LAST_LOGIN_TIME] = time.time()
 
     def clean(self):
         if not self.session:
             raise forms.ValidationError('Humans have sessions')
 
         self._validate_login_speed()
 
         cleaned_data = super(LoginForm, self).clean()
 
         return cleaned_data

boards/locale/ru/LC_MESSAGES/django.po

@@ -1,355 +1,359 b''
 # SOME DESCRIPTIVE TITLE.
 # Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER
 # This file is distributed under the same license as the PACKAGE package.
 # FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
 #
 msgid ""
 msgstr ""
 "Project-Id-Version: PACKAGE VERSION\n"
 "Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2014-01-13 10:53+0200\n"
+"POT-Creation-Date: 2014-01-15 10:46+0200\n"
 "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
 "Language-Team: LANGUAGE <[e-mail]>\n"
 "Language: ru\n"
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"
 "Content-Transfer-Encoding: 8bit\n"
 "Plural-Forms: nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n"
 "%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);\n"
 
 #: authors.py:5
 msgid "author"
 msgstr "автор"
 
 #: authors.py:6
 msgid "developer"
 msgstr "разработчик"
 
 #: authors.py:7
 msgid "javascript developer"
 msgstr "разработчик javascript"
 
 #: authors.py:8
 msgid "designer"
 msgstr "дизайнер"
 
-#: forms.py:18
+#: forms.py:21
 msgid ""
 "Type message here. You can reply to message >>123 like\n"
 " this. 2 new lines are required to start new paragraph."
 msgstr ""
 "Введите сообщение здесь. Вы можете ответить на сообщение >>123 вот так. 2 "
 "переноса строки обязательны для создания нового абзаца."
 
-#: forms.py:20
+#: forms.py:23
 msgid "tag1 several_words_tag"
 msgstr "тег1 тег_из_нескольких_слов"
 
-#: forms.py:77
+#: forms.py:25
+msgid "Such image was already posted"
+msgstr "Такое изображение уже было загружено"
+
+#: forms.py:27
 msgid "Title"
 msgstr "Заголовок"
 
-#: forms.py:80
+#: forms.py:28
 msgid "Text"
 msgstr "Текст"
 
-#: forms.py:81
+#: forms.py:89
 msgid "Image"
 msgstr "Изображение"
 
-#: forms.py:84
+#: forms.py:92
 msgid "e-mail"
 msgstr ""
 
-#: forms.py:95
+#: forms.py:103
 #, python-format
 msgid "Title must have less than %s characters"
 msgstr "Заголовок должен иметь меньше %s символов"
 
-#: forms.py:104
+#: forms.py:112
 #, python-format
 msgid "Text must have less than %s characters"
 msgstr "Текст должен быть короче %s символов"
 
-#: forms.py:115
+#: forms.py:123
 #, python-format
 msgid "Image must be less than %s bytes"
 msgstr "Изображение должно быть менее %s байт"
 
-#: forms.py:142
+#: forms.py:158
 msgid "Either text or image must be entered."
 msgstr "Текст или картинка должны быть введены."
 
-#: forms.py:155
+#: forms.py:171
 #, python-format
 msgid "Wait %s seconds after last posting"
 msgstr "Подождите %s секунд после последнего постинга"
 
-#: forms.py:171 templates/boards/tags.html:6 templates/boards/rss/post.html:10
+#: forms.py:187 templates/boards/tags.html:6 templates/boards/rss/post.html:10
 msgid "Tags"
 msgstr "Теги"
 
-#: forms.py:179
+#: forms.py:195
 msgid "Inappropriate characters in tags."
 msgstr "Недопустимые символы в тегах."
 
-#: forms.py:207 forms.py:228
+#: forms.py:223 forms.py:244
 msgid "Captcha validation failed"
 msgstr "Проверка капчи провалена"
 
-#: forms.py:234
+#: forms.py:250
 msgid "Theme"
 msgstr "Тема"
 
-#: forms.py:239
+#: forms.py:255
 msgid "Enable moderation panel"
 msgstr "Включить панель модерации"
 
-#: forms.py:254
+#: forms.py:270
 msgid "No such user found"
 msgstr "Данный пользователь не найден"
 
-#: forms.py:268
+#: forms.py:284
 #, python-format
 msgid "Wait %s minutes after last login"
 msgstr "Подождите %s минут после последнего входа"
 
 #: templates/boards/404.html:6
 msgid "Not found"
 msgstr "Не найдено"
 
 #: templates/boards/404.html:12
 msgid "This page does not exist"
 msgstr "Этой страницы не существует"
 
 #: templates/boards/archive.html:9 templates/boards/base.html:51
 msgid "Archive"
 msgstr "Архив"
 
 #: templates/boards/archive.html:39 templates/boards/posting_general.html:64
 msgid "Previous page"
 msgstr "Предыдущая страница"
 
 #: templates/boards/archive.html:68
 msgid "Open"
 msgstr "Открыть"
 
 #: templates/boards/archive.html:74 templates/boards/post.html:37
 #: templates/boards/posting_general.html:103 templates/boards/thread.html:69
 msgid "Delete"
 msgstr "Удалить"
 
 #: templates/boards/archive.html:78 templates/boards/post.html:40
 #: templates/boards/posting_general.html:107 templates/boards/thread.html:72
 msgid "Ban IP"
 msgstr "Заблокировать IP"
 
 #: templates/boards/archive.html:87 templates/boards/post.html:53
 #: templates/boards/posting_general.html:116
 #: templates/boards/posting_general.html:180 templates/boards/thread.html:81
 msgid "Replies"
 msgstr "Ответы"
 
 #: templates/boards/archive.html:96 templates/boards/posting_general.html:125
 #: templates/boards/thread.html:138 templates/boards/thread_gallery.html:58
 msgid "images"
 msgstr "изображений"
 
 #: templates/boards/archive.html:97 templates/boards/thread.html:137
 #: templates/boards/thread_gallery.html:57
 msgid "replies"
 msgstr "ответов"
 
 #: templates/boards/archive.html:116 templates/boards/posting_general.html:203
 msgid "Next page"
 msgstr "Следующая страница"
 
 #: templates/boards/archive.html:121 templates/boards/posting_general.html:208
 msgid "No threads exist. Create the first one!"
 msgstr "Нет тем. Создайте первую!"
 
 #: templates/boards/archive.html:130 templates/boards/posting_general.html:235
 msgid "Pages:"
 msgstr "Страницы: "
 
 #: templates/boards/authors.html:6 templates/boards/authors.html.py:12
 msgid "Authors"
 msgstr "Авторы"
 
 #: templates/boards/authors.html:25
 msgid "Distributed under the"
 msgstr "Распространяется под"
 
 #: templates/boards/authors.html:27
 msgid "license"
 msgstr "лицензией"
 
 #: templates/boards/authors.html:29
 msgid "Repository"
 msgstr "Репозиторий"
 
 #: templates/boards/base.html:14
 msgid "Feed"
 msgstr "Лента"
 
 #: templates/boards/base.html:31
 msgid "All threads"
 msgstr "Все темы"
 
 #: templates/boards/base.html:36
 msgid "Tag management"
 msgstr "Управление тегами"
 
 #: templates/boards/base.html:38
 msgid "Settings"
 msgstr "Настройки"
 
 #: templates/boards/base.html:50 templates/boards/login.html:6
 #: templates/boards/login.html.py:21
 msgid "Login"
 msgstr "Вход"
 
 #: templates/boards/base.html:53
 #, python-format
 msgid "Speed: %(ppd)s posts per day"
 msgstr "Скорость: %(ppd)s сообщений в день"
 
 #: templates/boards/base.html:55
 msgid "Up"
 msgstr "Вверх"
 
 #: templates/boards/login.html:15
 msgid "User ID"
 msgstr "ID пользователя"
 
 #: templates/boards/login.html:24
 msgid "Insert your user id above"
 msgstr "Вставьте свой ID пользователя выше"
 
 #: templates/boards/posting_general.html:97
 msgid "Reply"
 msgstr "Ответ"
 
 #: templates/boards/posting_general.html:142
 #, python-format
 msgid "Skipped %(count)s replies. Open thread to see all replies."
 msgstr "Пропущено %(count)s ответов. Откройте тред, чтобы увидеть все ответы."
 
 #: templates/boards/posting_general.html:214
 msgid "Create new thread"
 msgstr "Создать новую тему"
 
 #: templates/boards/posting_general.html:218 templates/boards/thread.html:115
 msgid "Post"
 msgstr "Отправить"
 
 #: templates/boards/posting_general.html:222
 msgid "Tags must be delimited by spaces. Text or image is required."
 msgstr ""
 "Теги должны быть разделены пробелами. Текст или изображение обязательны."
 
 #: templates/boards/posting_general.html:225 templates/boards/thread.html:119
 msgid "Text syntax"
 msgstr "Синтаксис текста"
 
 #: templates/boards/settings.html:14
 msgid "User:"
 msgstr "Пользователь:"
 
 #: templates/boards/settings.html:16
 msgid "You are moderator."
 msgstr "Вы модератор."
 
 #: templates/boards/settings.html:19
 msgid "Posts:"
 msgstr "Сообщений:"
 
 #: templates/boards/settings.html:20
 msgid "First access:"
 msgstr "Первый доступ:"
 
 #: templates/boards/settings.html:22
 msgid "Last access:"
 msgstr "Последний доступ: "
 
 #: templates/boards/settings.html:31
 msgid "Save"
 msgstr "Сохранить"
 
 #: templates/boards/tags.html:27
 msgid "No tags found."
 msgstr "Теги не найдены."
 
 #: templates/boards/thread.html:19 templates/boards/thread_gallery.html:20
 msgid "Normal mode"
 msgstr "Нормальный режим"
 
 #: templates/boards/thread.html:20 templates/boards/thread_gallery.html:21
 msgid "Gallery mode"
 msgstr "Режим галереи"
 
 #: templates/boards/thread.html:28
 msgid "posts to bumplimit"
 msgstr "сообщений до бамплимита"
 
 #: templates/boards/thread.html:109
 msgid "Reply to thread"
 msgstr "Ответить в тему"
 
 #: templates/boards/thread.html:139 templates/boards/thread_gallery.html:59
 msgid "Last update: "
 msgstr "Последнее обновление: "
 
 #: templates/boards/rss/post.html:5
 msgid "Post image"
 msgstr "Изображение сообщения"
 
 #: templates/boards/staticpages/banned.html:6
 msgid "Banned"
 msgstr "Заблокирован"
 
 #: templates/boards/staticpages/banned.html:11
 msgid "Your IP address has been banned. Contact the administrator"
 msgstr "Ваш IP адрес был заблокирован. Свяжитесь с администратором"
 
 #: templates/boards/staticpages/help.html:6
 #: templates/boards/staticpages/help.html:10
 msgid "Syntax"
 msgstr "Синтаксис"
 
 #: templates/boards/staticpages/help.html:11
 msgid "2 line breaks for a new line."
 msgstr "2 перевода строки создают новый абзац."
 
 #: templates/boards/staticpages/help.html:12
 msgid "Italic text"
 msgstr "Курсивный текст"
 
 #: templates/boards/staticpages/help.html:13
 msgid "Bold text"
 msgstr "Полужирный текст"
 
 #: templates/boards/staticpages/help.html:14
 msgid "Spoiler"
 msgstr "Спойлер"
 
 #: templates/boards/staticpages/help.html:15
 msgid "Link to a post"
 msgstr "Ссылка на сообщение"
 
 #: templates/boards/staticpages/help.html:16
 msgid "Strikethrough text"
 msgstr "Зачеркнутый текст"
 
 #: templates/boards/staticpages/help.html:17
 msgid "You need to new line before:"
 msgstr "Перед этими тегами нужна новая строка:"
 
 #: templates/boards/staticpages/help.html:18
 msgid "Comment"
 msgstr "Комментарий"
 
 #: templates/boards/staticpages/help.html:19
 msgid "Quote"
 msgstr "Цитата"

boards/models/post.py

@@ -1,371 +1,386 b''
 from datetime import datetime, timedelta
 from datetime import time as dtime
 import os
 from random import random
 import time
 import math
 import re
+import hashlib
+
 from django.core.cache import cache
 from django.core.paginator import Paginator
 
 from django.db import models
 from django.http import Http404
 from django.utils import timezone
 from markupfield.fields import MarkupField
 
 from neboard import settings
 from boards import thumbs
 
 MAX_TITLE_LENGTH = 50
 
 APP_LABEL_BOARDS = 'boards'
 
 CACHE_KEY_PPD = 'ppd'
 
 POSTS_PER_DAY_RANGE = range(7)
 
 BAN_REASON_AUTO = 'Auto'
 
 IMAGE_THUMB_SIZE = (200, 150)
 
 TITLE_MAX_LENGTH = 50
 
 DEFAULT_MARKUP_TYPE = 'markdown'
 
 NO_PARENT = -1
 NO_IP = '0.0.0.0'
 UNKNOWN_UA = ''
 ALL_PAGES = -1
 IMAGES_DIRECTORY = 'images/'
 FILE_EXTENSION_DELIMITER = '.'
 
 SETTING_MODERATE = "moderate"
 
 REGEX_REPLY = re.compile('>>(\d+)')
 
 
 class PostManager(models.Manager):
 
     def create_post(self, title, text, image=None, thread=None,
                     ip=NO_IP, tags=None, user=None):
         """
         Create new post
         """
 
         posting_time = timezone.now()
         if not thread:
             thread = Thread.objects.create(bump_time=posting_time,
                                            last_edit_time=posting_time)
         else:
             thread.bump()
             thread.last_edit_time = posting_time
             thread.save()
 
         post = self.create(title=title,
                            text=text,
                            pub_time=posting_time,
                            thread_new=thread,
                            image=image,
                            poster_ip=ip,
                            poster_user_agent=UNKNOWN_UA,  # TODO Get UA at
                            # last!
                            last_edit_time=posting_time,
                            user=user)
 
         thread.replies.add(post)
         if tags:
             linked_tags = []
             for tag in tags:
                 tag_linked_tags = tag.get_linked_tags()
                 if len(tag_linked_tags) > 0:
                     linked_tags.extend(tag_linked_tags)
 
             tags.extend(linked_tags)
             map(thread.add_tag, tags)
 
         self._delete_old_threads()
         self.connect_replies(post)
 
         return post
 
     def delete_post(self, post):
         """
         Delete post and update or delete its thread
         """
         
         thread = post.thread_new
 
         if thread.get_opening_post() == self:
             thread.replies.delete()
 
             thread.delete()
         else:
             thread.last_edit_time = timezone.now()
             thread.save()
 
             post.delete()
 
     def delete_posts_by_ip(self, ip):
         """
         Delete all posts of the author with same IP
         """
 
         posts = self.filter(poster_ip=ip)
         map(self.delete_post, posts)
 
     # TODO Move this method to thread manager
     def get_threads(self, tag=None, page=ALL_PAGES,
                     order_by='-bump_time', archived=False):
         if tag:
             threads = tag.threads
 
             if not threads.exists():
                 raise Http404
         else:
             threads = Thread.objects.all()
 
         threads = threads.filter(archived=archived).order_by(order_by)
 
         if page != ALL_PAGES:
             threads = Paginator(threads, settings.THREADS_PER_PAGE).page(
                     page).object_list
 
         return threads
 
     # TODO Move this method to thread manager
     def _delete_old_threads(self):
         """
         Preserves maximum thread count. If there are too many threads,
         archive the old ones.
         """
 
         threads = self.get_threads()
         thread_count = threads.count()
 
         if thread_count > settings.MAX_THREAD_COUNT:
             num_threads_to_delete = thread_count - settings.MAX_THREAD_COUNT
             old_threads = threads[thread_count - num_threads_to_delete:]
 
             for thread in old_threads:
                 thread.archived = True
                 thread.last_edit_time = timezone.now()
                 thread.save()
 
     def connect_replies(self, post):
         """
         Connect 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.save()
 
     def get_posts_per_day(self):
         """
         Get average count of posts per day for the last 7 days
         """
 
         today = datetime.now().date()
         ppd = cache.get(CACHE_KEY_PPD + str(today))
         if ppd:
             return ppd
 
         posts_per_days = []
         for i in POSTS_PER_DAY_RANGE:
             day_end = today - timedelta(i + 1)
             day_start = today - timedelta(i + 2)
 
             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_days.append(float(self.filter(
                 pub_time__lte=day_time_end,
                 pub_time__gte=day_time_start).count()))
 
         ppd = (sum(posts_per_day for posts_per_day in posts_per_days) /
                len(posts_per_days))
         cache.set(CACHE_KEY_PPD, ppd)
         return ppd
 
 
 class Post(models.Model):
     """A post is a message."""
 
     objects = PostManager()
 
     class Meta:
         app_label = APP_LABEL_BOARDS
 
     # TODO Save original file name to some field
     def _update_image_filename(self, filename):
         """Get unique image filename"""
 
         path = IMAGES_DIRECTORY
         new_name = str(int(time.mktime(time.gmtime())))
         new_name += str(int(random() * 1000))
         new_name += FILE_EXTENSION_DELIMITER
         new_name += filename.split(FILE_EXTENSION_DELIMITER)[-1:][0]
 
         return os.path.join(path, new_name)
 
     title = models.CharField(max_length=TITLE_MAX_LENGTH)
     pub_time = models.DateTimeField()
     text = MarkupField(default_markup_type=DEFAULT_MARKUP_TYPE,
                        escape_html=False)
 
     image_width = models.IntegerField(default=0)
     image_height = models.IntegerField(default=0)
 
     image_pre_width = models.IntegerField(default=0)
     image_pre_height = models.IntegerField(default=0)
 
     image = thumbs.ImageWithThumbsField(upload_to=_update_image_filename,
                                         blank=True, sizes=(IMAGE_THUMB_SIZE,),
                                         width_field='image_width',
                                         height_field='image_height',
                                         preview_width_field='image_pre_width',
                                         preview_height_field='image_pre_height')
+    image_hash = models.CharField(max_length=36)
 
     poster_ip = models.GenericIPAddressField()
     poster_user_agent = models.TextField()
 
     thread = models.ForeignKey('Post', null=True, default=None)
     thread_new = models.ForeignKey('Thread', null=True, default=None)
     last_edit_time = models.DateTimeField()
     user = models.ForeignKey('User', null=True, default=None)
 
     referenced_posts = models.ManyToManyField('Post', symmetrical=False,
                                               null=True,
                                               blank=True, related_name='rfp+')
 
     def __unicode__(self):
         return '#' + str(self.id) + ' ' + self.title + ' (' + \
                self.text.raw[:50] + ')'
 
     def get_title(self):
         title = self.title
         if len(title) == 0:
             title = self.text.rendered
 
         return title
 
     def get_sorted_referenced_posts(self):
         return self.referenced_posts.order_by('id')
 
     def is_referenced(self):
         return self.referenced_posts.all().exists()
 
     def is_opening(self):
         return self.thread_new.get_replies()[0] == self
 
+    def save(self, *args, **kwargs):
+        """
+        Save the model and compute the image hash
+        """
+
+        if not self.pk and self.image:
+            md5 = hashlib.md5()
+            for chunk in self.image.chunks():
+                md5.update(chunk)
+            self.image_hash = md5.hexdigest()
+        super(Post, self).save(*args, **kwargs)
+
 
 class Thread(models.Model):
 
     class Meta:
         app_label = 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):
         """
         Get a sorted tag list
         """
 
         return self.tags.order_by('name')
 
     def bump(self):
         """
         Bump (move to up) thread
         """
 
         if self.can_bump():
             self.bump_time = timezone.now()
 
     def get_reply_count(self):
         return self.replies.count()
 
     def get_images_count(self):
         return self.replies.filter(image_width__gt=0).count()
 
     def can_bump(self):
         """
         Check if the thread can be bumped by replying
         """
 
         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 delete thread and all its posts
         """
 
         if self.replies.count() > 0:
             self.replies.all().delete()
 
         self.delete()
 
     def get_last_replies(self):
         """
         Get 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)
                 last_replies = self.replies.all().order_by('pub_time')[
                                reply_count - reply_count_to_show:]
 
                 return last_replies
 
     def get_replies(self):
         """
         Get sorted thread posts
         """
 
         return self.replies.all().order_by('pub_time')
 
     def add_tag(self, tag):
         """
         Connect thread to a tag and tag to a thread
         """
 
         self.tags.add(tag)
         tag.threads.add(self)
 
     def get_opening_post(self):
         """
         Get first post of the thread
         """
 
         return self.get_replies()[0]
 
     def __unicode__(self):
         return str(self.get_replies()[0].id)
 
     def get_pub_time(self):
         """
         Thread does not have its own pub time, so we need to get it from
         the opening post
         """
 
         return self.get_opening_post().pub_time

boards/thumbs.py

@@ -1,216 +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
 
 
 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()
     # PNG and GIF are the same, JPG is JPEG
     if format.upper() == 'JPG':
         format = 'JPEG'
 
     image2.save(io, format)
     return ContentFile(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"])