Небольшие отличия есть, а именно — мы получаем данные из Twitter API в формате JSON (используется библиотека simplejson), а не в XML, как это было в PHP версии. Можно без проблем использовать и XML, просто с JSON мне удобнее работать.

Аналогично реализовано кеширование твитта в локальный файл и обновление через определенный промежуток времени.

Код, вся дополнительная информация в комментариях:

from django.conf import settings
from time import time
import urllib, os, simplejson

class Twitter:
  """
  Скачиваем последнее сообщение из Twitter пользователя.

  Требуется:
  - библиотека simplejson (http://pypi.python.org/pypi/simplejson/)
  - библиотека urllib
  - библиотека os
  - метод time.time()

  Необходимо в settings.py добавить переменные:

  TWITTER_ACCOUNT = 'Skaizer' # Логин пользователя, чью ленту будем читать.
  TWITTER_CACHE_PERIOD = 3600 # Частота обновления кеша в миллисекундах, когда 0, кеш игнорируется.
  TWITTER_CACHE_FILE = 'last_twitt.txt'; # Имя файла, куда будем дампить кеш. Строится путь относительно MEDIA_ROOT.

  """
  def __init__(self):
    self.twitt_file = getattr(settings,'MEDIA_ROOT','./') + getattr(settings,'TWITTER_CACHE_FILE','last_twitt.txt')
    self.cache_period = getattr(settings,'TWITTER_CACHE_PERIOD',0)
    self.username = getattr(settings,'TWITTER_ACCOUNT',None)

  def returnLastTwitt(self):
    """
    Возвращаем кеш, если он имеется, и по времени существует не менее установленного в конфигах периода.
    Иначе возвращаем сообщение из инета.
    """
    if self.cache_period !=0:
      if os.path.exists(self.twitt_file):
        if self.cache_period > self.getCacheDateDiff():
          return self.getLastFromCache()
    return self.getLastFromWeb()

  def getLastFromWeb(self):
    """
    Скачивает твиттер ленту в Интернет и выбирает последнее сообщение
    """
    feed = 'http://twitter.com/statuses/user_timeline/' + self.username + '.json';
    feed_obj  = simplejson.loads(urllib.urlopen(feed).read())
    last_twitt = feed_obj[0]['text']
    self.cache_twitt(last_twitt.encode("utf_8"))
    return last_twitt

  def cache_twitt(self, msg):
    """
    Записывает последний твитт в локальный файл
    """
    handle = open(self.twitt_file,'w')
    handle.write(msg)
    handle.close()

  def getCacheDateDiff(self):
    """
    Считает, как давно был создан файл кеша в миллисекундах.
    """
    diff = float(time()) - float(os.path.getmtime(self.twitt_file))
    return diff

  def getLastFromCache(self):
    """
    Возвращает закешированное сообщение из файла.
    """
    handle = open(self.twitt_file,'r')
    cached_twitt = handle.read()
    handle.close()
    return cached_twitt

  def getLast(self):
    if not self.username:
      return False
    return self.returnLastTwitt()

Вот так класс используется:

def last_twitt():
    t = Twitter()
    return {
      'last_twitt' : t.getLast(),
    }

Все просто, без заморочек, пользуйтесь на здоровье.

PS: Кстати у нас новый осенний логотип, очень симпатично получилось на наш взгляд.

Интересно почитать:

• Как добавить разные иконки к пунктам меню, используя только CSS

{% if some_val > 4 %}
<p>Истина</p>
{% else %}
<p>Ложь</p>
{% endif %}

вызывают ошибку.

В поисках решения я нагуглил библиотеку, разработанную Джеймсом Беннеттом (James Bennett) — django-template-utils.

Для использования достаточно добавить библиотеку в Python окружение, можно посредством установки:

tar zxvf template_utils-0.4p2.tar.gz
cd template_utils-0.4p2
python setup.py install

А можно просто добавить приложение в INSTALLED_APPS проекта.

В результате вам будут доступны функции сравнения значений, и другие полезные возможности в шаблонах Django.

Например проверка значения на условие «меньше или равно 4х»:

{% load comparison %}
{% if_less_or_equal some_val 4 %}
<p>Истина</p>
{% else %}
<p>Ложь</p>
{% endif_less_or_equal %}

Ссылка на библиотеку: django-template-utils.googlecode.com.

Разрабатывая интерфейс управления личной информацией необходимо было решить задачу: при загрузке пользователем собственной фотографии, ее размер должен быть не более некоторых значений, определенных настройками системы, если фото больше, то необходимо произвести ресайз с сохранением пропорций.

В этой статья я представлю наше решение поставленной задачи. Возможно, оно окажется не оптимальным, поэтому с удовольствием выслушаю ваши комментарии!

Django, ресайз изображений

Функция ресайза изображения. Автоматически изменяет размер, сохраняя пропорции:

def imageResize(data, output_size):
  """
  Resize image for thumbnails and preview
  data — image for resize
  output_size — turple, contains width and height of output image, for example (200, 500)
  """

  from PIL import Image

  image = Image.open(data)
  m_width = float(output_size[0])
  m_height = float(output_size[1])
  if image.mode not in ('L', 'RGB'):
    image = image.convert('RGB')
  w_k = image.size[0]/m_width
  h_k = image.size[1]/m_height
  if output_size < image.size:
    if w_k > h_k:
      new_size = (m_width, image.size[1]/w_k)
    else:
      new_size = (image.size[0]/h_k, m_height)
  else:
    new_size = image.size
  return image.resize(new_size,Image.ANTIALIAS)

Например, при максимально возможных размерах изображения 200×500 px, загружая изображения на 1024×768 px, новые изображения будут — 200×150 px.

Далее перекрываем стандартный джанговский models.ImageField, расширяя метод save_form_data, в котором и будем производить ресайз:

class AvatarImageField(models.ImageField):
  def save_form_data(self, instance, data):
    from StringIO import StringIO
    from django.core.files.uploadedfile import SimpleUploadedFile, UploadedFile

    if data and isinstance(data, UploadedFile):
      image = imageResize(data, settings.AVATAR_SIZE)
      new_image = StringIO()
      image.save(new_image, 'JPEG', quality=85)
      data = SimpleUploadedFile(data.name, new_image.getvalue(), data.content_type)

      # Удаление старого файла
      previous = u'%s%s' % (settings.MEDIA_ROOT, instance.avatar)
      if os.path.isfile(previous):
        os.remove(previous)
      # -
    super(AvatarImageField, self).save_form_data(instance, data)

Определяем функцию, которая будет возвращать путь к директории сохранения файла, а так же имя файла. Она будет возвращать нужный путь для upload_to файлового поля. В нашем случае имя файла генерируется некоторой хэш-функцией:

  def make_upload_path(instance, filename, prefix = False):
    # Переопределение имени загружаемого файла.
    from utils.hashfunc import get_hash

    filename = 'a_' + get_hash('md5') + '.jpg'
    return u"%s/%s" % (settings.AVATAR_UPLOAD_DIR, filename)

И, собственно, сама модель данных, поле avatar определяется нашим перекрытым классом AvatarImageField, следовательно, наследует всю его функциональность:

class Avatars(models.Model):
  user = models.ForeignKey(User, unique=True)
  avatar = AvatarImageField(
    upload_to=make_upload_path,
    null = False,
    blank = False,
    )

Готово. Теперь все загружаемые изображение, превышающие определенные в системе размеры будут ресайзиться, сохраняя пропорции.

С удовольствием готов ответить на вопросы, а так же выслушать конструктивную критику этого метода!

Говорим спасибо

Выражаю благодарность Ивану Сагалаеву за его ресурс о программировании в целом и в частности на Python. На этапе ознакомления с Django почти с не покидали его страницы.

Почему я решил изучить данный алгоритм? Сам я являюсь SEO-шником, занимаюсь продвижением сайтов и так далее… Соответственно, моя работа заключается в изменении выдачи поисковой системы по определенному запросу. Но проработав более года в этом направлении меня заинтересовала внутренняя часть поисковых систем. Как они борются с поисковым спамом, как ранжируют документы и т.д. Поиск нечетких дубликатов позволяет поисковой системе исключить из выдачи клоны или частично похожие страницы (под словом частично я подразумеваю некоторое значение, при котором в конкретной поисковой системе два документа будут определяться как почти одинаковыми).

Одним из таких алгоритмов является «Алгоритм Шинглов» (шингл на английском означает чешуйка).

Немного теории

Поиск нечетких дубликатов позволяет предположить, являются ли два объекта частично одинаковыми или нет. Под объектом могут пониматься текстовые файлы и другие типы данных. Мы будем работать с текстом, но поняв, как работает алгоритм, вам не составит труда перенести мою реализацию на необходимые вам объекты.

Обратите внимание, задачей не стоит определить абсолютное значение схожести объектов, а так же выделения в каждом из объектов схожих частей. Нам необходимо только предположить, являются ли объекты почти дубликатами или нет.

Где может применяться данный алгоритм?

Как я уже писал выше, он может быть применен в поисковой системе для очистки поисковой выдачи. Так же данный алгоритм может использоваться для кластеризации документов по их схожести.

Почти одинаковый текст

Рассмотрим задачу алгоритма на примере текста. Допустим, мы имеем файл с текстом в 8 абзацев. Делаем его полную копию, а затем переписываем только последний абзац. 7 из 8 абзацев второго файла являются полной копией оригинала.

Другой пример, посложнее. Если мы в копии оригинального текста перепишем каждое 5-6е предложение, то текст по-прежнему будет являться почти дублем.

Представим, что мы имеем большой форум или портал, где контент составляется пользователями. Как показали наблюдения, пользователи имеют привычку заниматься копи-пастом, и кражей контента, лишь немного изменив его. На нашем сайте имеется поисковый механизм. Пользователь вводит какой-либо запрос, и на первых позициях получает десяток текстов, которые отличаются только одним или двумя предложениями. Естественно ему не интересно просматривать их все, и он понимает, что поисковая система работает некорректно.

Поступим логичнее. В поисковой выдаче вместо десятка практически одинаковых документов покажем один из них, например, наиболее релевантный запросу, а ниже дадим ссылочку на список так же найденных страниц, похожих на него.

И таким образом, при наличии множества почти одинакового текста мы распределим его на группы и предоставим пользователю ссылку на эти группы, вместо того, чтобы сваливать все в кучу.

Как работает алгоритм Шинглов?

Итак, мы имеем 2 текста и нам нужно предположить, являются ли они почти дубликатами. Реализация алгоритма подразумевает несколько этапов:

• канонизация текстов;
• разбиение текста на шинглы;
• нахождение контрольных сумм;
• поиск одинаковых подпоследовательностей.

Теперь поконкретнее. В алгоритме шинглов реализовано сравнение контрольных сумм текстов. В своей реализации я использую CRC32, но применимы и другие, например SHA1 или MD5 и т.д. Как известно, контрольные суммы статических функций очень чувствительны к изменениям. Например, контрольные суммы двух следующих текстов будут в корне отличаться:

• Текст: «My war is over.» Контрольная сумма: 1759088479
• Текст: «My war is over!» Контрольная сумма: -127495474

Как сказал Джон Рэмбо: «My war is over». Но сказать он это мог по-разному, громко восклицая или тихо шепча, так и у нас, отличие второй фразы от первой заключается всего лишь в восклицательном знаке в конце фразы, но как видим, контрольные суммы абсолютно разные.

При поиске почти дубликата нас не интересуют всякие там восклицательные знаки, точки, запятые и т.д. Нас интересуют только слова (не союзы, предлоги и т.д., а именно слова).

Следовательно, ставится задача: очистить текст от ненужных нам знаков и слов, которые не несут смысла при сравнении, это и называется «привести текст к канонической форме».

Итак, нам необходимо создать набор символов, которые нужно исключить из обоих текстов, т.е. приведения его к форме, пригодной для нашего сравнения.

Давайте что-нибудь напрограммируем. Допустим, мы имеем два текста, занесем их в 2 переменных: source1 и source2. Нужно их почистить от ненужных символов и слов. Определим наборы стоп-слов и стоп-символов.

stop_symbols = '.,!?:;-\n\r()'

stop_words = (u'это', u'как', u'так',
  u'и', u'в', u'над',
  u'к', u'до', u'не',
  u'на', u'но', u'за',
  u'то', u'с', u'ли',
  u'а', u'во', u'от',
  u'со', u'для', u'о',
  u'же', u'ну', u'вы',
  u'бы', u'что', u'кто',
  u'он', u'она')

В стоп-символы мы включили знаки препинаний, знаки переноса строки и табуляции. В стоп-лова мы включили союзы, предлоги и прочие слова, которые при сравнении не должны влиять на результат.

Создадим функцию, которая будет производить канонизацию текста:

def canonize(source):
  stop_symbols = '.,!?:;-\n\r()'

  stop_words = (u'это', u'как', u'так',
    u'и', u'в', u'над',
    u'к', u'до', u'не',
    u'на', u'но', u'за',
    u'то', u'с', u'ли',
    u'а', u'во', u'от',
    u'со', u'для', u'о',
    u'же', u'ну', u'вы',
    u'бы', u'что', u'кто',
    u'он', u'она')

  return ( [x for x in [y.strip(stop_symbols) for y in source.lower().split()] if x and (x not in stop_words)] )

Функция canonize очищает текст от стоп-символов и стоп-слов, приводит все символы строки к нижнему регистру и возвращает список, оставшихся после чистки слов.

Вообще, приведение текста к единой канонической форме не ограничено действиями, которые я описал. Можно, например, каждое из существительных приводить к единственному числу, именительному падежу и т.д., для этого нужно подключать морфологические анализаторы русского языка (или других языков, где необходимы эти действия).

Итак, тексты у нас очищены от всего лишнего. Теперь необходимо разбить каждый из них на подпоследовательности — шинглы. На практике я применяю подпоследовательности длинной в 10 слов. Из выделенных нами шинглов далее будут находиться контрольные суммы.

Разбиение на шинглы будет происходить внахлест через одно слово, а не встык, т.е., имеем текст:

«Разум дан человеку для того, чтобы он разумно жил, а не для того только, чтобы он понимал, что он неразумно живет.»© В. Г. Белинский

После обработки нашей функцией текст примет следующий вид:

разум дан человеку того чтобы разумно жил того только чтобы понимал неразумно живет

Это и есть каноническая форма. Теперь нужно разбить ее на шинглы длиной в 10 слов. Так как шинглы составляются внахлест, то всего шинглов len(source)-(shingleLen-1), т.е. количество слов в тексте минус длина шинглов плюс 1.

Шинглы будут выглядеть следующим образом:

• Sh1 = разум дан человеку того чтобы разумно жил того только чтобы
• Sh2 = дан человеку того чтобы разумно жил того только чтобы понимал
• Sh3 = человеку того чтобы разумно жил того только чтобы понимал неразумно
• Sh4 = того чтобы разумно жил того только чтобы понимал неразумно живет

Напишем функцию, которая производит разбиение текста на шинглы:

def genshingle(source):
  shingleLen = 10 #длина шингла
  out = []
  for i in range(len(source)-(shingleLen-1)):
    out.append (' '.join( [x for x in source[i:i+shingleLen]] ).encode('utf-8'))

  return out

Но так как нас интересую именно контрольные суммы шинглов, то соответственно изменим нашу функцию. Мы будем использовать алгоритм хэширования CRC32, подключим библиотеку binascii, которая содержит в себе нужный нам метод. Измененная функция:

def genshingle(source):
import binascii
shingleLen = 10 #длина шингла
out = []
for i in range(len(source)-(shingleLen-1)):
out.append (binascii.crc32(' '.join( [x for x in source[i:i+shingleLen]] ).encode('utf-8')))

return out

Наш пример выдаст следующие наборы контрольных сумм:

[1313803605, -1077944445, -2009290115, 1772759749]

Таким образом, через наши 2 функции нужно прогнать 2 сравниваемых текста и мы получим 2 множества контрольных сумм шинглов, теперь необходимо найти их пересечения.

def compaire (source1,source2):
  same = 0
  for i in range(len(source1)):
    if source1[i] in source2:
    same = same + 1

  return same*2/float(len(source1) + len(source2))*100

Вот и все, функция нам вернет процент схожести двух текстов.

Скомпонованный код

# -*- coding: UTF-8 -*-
if __name__ == '__build__':
    raise Exception

def canonize(source):
        stop_symbols = '.,!?:;-\n\r()'

        stop_words = (u'это', u'как', u'так',
        u'и', u'в', u'над',
        u'к', u'до', u'не',
        u'на', u'но', u'за',
        u'то', u'с', u'ли',
        u'а', u'во', u'от',
        u'со', u'для', u'о',
        u'же', u'ну', u'вы',
        u'бы', u'что', u'кто',
        u'он', u'она')

        return ( [x for x in [y.strip(stop_symbols) for y in source.lower().split()] if x and (x not in stop_words)] )

def genshingle(source):
    import binascii
    shingleLen = 10 #длина шингла
    out = []
    for i in range(len(source)-(shingleLen-1)):
        out.append (binascii.crc32(' '.join( [x for x in source[i:i+shingleLen]] ).encode('utf-8')))

    return out

def compaire (source1,source2):
    same = 0
    for i in range(len(source1)):
        if source1[i] in source2:
            same = same + 1

    return same*2/float(len(source1) + len(source2))*100

def main():
    text1 = u'' # Текст 1 для сравнения
    text2 = u'' # Текст 2 для сравнения

    cmp1 = genshingle(canonize(text1))
    cmp2 = genshingle(canonize(text2))

    print compaire(cmp1,cmp2)

# Start program
main()

Я показал именно реализацию ядра алгоритма, но его можно дорабатывать до бесконечности, увеличивая его производительность и точность сравнения.

Сам по себе алгоритм достаточно ресурсоемкий, поэтому не помешает для него создать механизм кеширования, который будет особенно актуален для сравнения наборов файлов, чтобы не высчитывать контрольные суммы каждый раз.

Так же, для увеличения производительности при обработке больших объемов текста можно сравнивать не все полученные контрольные суммы, а только те, которые, например, делятся на 25, или любое целое число в пределах от 10 до 40. Как показали тесты, это дает значительный(!) прирост скорости и не сильно уменьшает точность, но только при обработке больших объемов.

Существуют модифицированные версии «Алгоритма шинглов» — «Алгоритм супершинглов» и «Алгоритма мегашинглов», их реализацию я представлю позже.

Скачать алгоритм шинглов на Python.

Материалы по теме:

• Сравнительный анализ методов определения нечетких дубликатов для Web-документов Зеленков Ю.Г, Сегалович И.В. 2007
• Как работают поисковые системы Сегалович И.В.

Спонсор поста: Агентство «Web++» — продвижение и создание сайтов в Волгограде.