Development for fun

Разработка и ремонт в квартире

2012-05-07T22:50:00.000+03:00

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

Книга Business of Software

2012-05-04T06:11:00.003+03:00

Благодаря майским праздникам удалось найти немного времени и прочесть книгу Business of Software. Автор книги - разработчик, основатель SourceGear, блоггер. Книга написана на основании наиболее популярных эссе из блога. Читается легко, интерестно, живо и с юмором. Расскрываются и обсуждаются вопросы, которые встречает каждый разработчик, желающий начать свое дело: выбор идеи, реализация, финансы, найм новых сотрудников, маркетинг, построение работы внутри команды. В книге много примеров. Практически к каждой обсуждаемой теме приводятся параллели из других областей.

Установка Ubuntu 12.04: жесткий диск + сетевая консоль

2012-05-03T06:57:00.000+03:00

Прошел почти год с публикации поста про установку Ubuntu с сетевой консоли. Несколько раз инсталляционные образы выручали, когда нужно было установить систему без монитора и клавиатуры. Но несколько дней назад понадобилось установить Ubuntu на компьютер, который планировалось использовать как небольшой сервер. Монитора и клавиатуры под рукой не оказалось, да и загрузка с USB Drive в BIOS выключена. Безвыходных ситуаций не бывает, поэтому и решение нашлось - установка Ubuntu 12.04 с жесткого диска.

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

Для этого необходимо:
- минимальный образ Ubuntu 12.04
- внешний карман для жесткого 3,5” диска. В моем случае использовался SunBright, поддерживающий как IDE так и SATA интерфейсы
- компьютер или лептоп с установленым Linux. В примерах ниже используется Ubuntu 12.04 Desktop
- VirtualBox, опционально, необходим для проверки работы и тестирования.

Из компьютера, на который планируется установка Ubuntu, необходимо извлечь жесткий диск и подключить через внешний карман c USB интерфейсом к компьютеру или лептопу с предустановленной Ubuntu. Если на жестком диске есть важные данные, лучше сделать их резервную копию. С помощью fdisk иди gparted http://gparted.sourceforge.net/ делается разбивка файловой системы. Для упрощения можно выделить два раздела: один для swap, другой для root (/). Для root выбираем ext4 файловую систему. Важно не забыть пометить root раздел как загрузочный (Boot).

Далее необходимо установить grub на новый раздел (/media/newroot -> /dev/sdb2):

# sudo grub-install --root-directory /media/newroot /dev/sdb

где /dev/sdb - диск на который будет установлен Grub. Необходимо быть очень аккуратным при выполнении команд, что бы не перезаписать существующие разделы на рабочем компьютере

Как результат, после выполнения команды на диске будет создана директория /boot/grub с множеством файлов, необходимых для работы grub. Для нас будет важен только файл /boot/grub/grub.cfg. Перед тем, как вносить изменения в конфигурационый файл, необходимо скопировать два файла linux и initrd.gz из образа для Ubuntu 12.04 (ubuntu-12.04-mini-i386.iso) в директорию /boot/newinstall. После этого пераписываем файл grub.cfg на /dev/sdb2, файлом:

set root=(hd0,2) # значение (hd0,2) необходимо переназначить в 
                 # зависимости от актуальной конфигурации 
linux /boot/newinstall/linux \
      locale=en_US  \
      console-setup/ask_detect=false \
      console-setup/layoutcode=ru \
      anna/choose_modules=network-console \
      network-console/password=r00tme \
      network-console/password-again=r00tme \
      debconf/priority=critical --
initrd /boot/newinstall/initrd.gz
boot

По сути, это все. Можно подключать диск компьютеру и выполнять загрузку. Если все хорошо, то буквально через пару минут вы сможете подключиться к новому серверу через ssh (login: installer, password: r00tme):

# ssh installer@<server_ip_address>

и продолжить инсталяцию.

Опционально. Перед установка жесткого диска в сервер, новую конфигурацию можно проверить с помощью VirtualBox. Дело в том, что VirtualBox позволяет работать с реальными разделами на жестких дисках через vmdk файлы. Для создания такого файла необходимо выполнить следующую команду:

# sudo vboxmanage internalcommands createrawvmdk -filename usb-hdd320.vmdk -rawdisk /dev/sdb 

RAW host disk access VMDK file usb-hdd320.vmdk created successfully.

Далее необходимо создать виртуальную машину для работы с жестким диском через vmdk файл

sudo vboxmanage createvm --name minilab --ostype Ubuntu --register
sudo vboxmanage modifyvm minilab --memory 512
sudo vboxmanage storagectl minilab --name "IDE Controller" --add ide
sudo vboxmanage storageattach minilab --storagectl "IDE Controller" --port=0 --device=0 --type hdd --medium /media/data/vm/usb-hdd320.vmdk

Запускается виртуальная машина minilab с помощью:

sudo vboxmanage startvm minilab

Если все хорошо, то через пару минут в окне виртульный машины вы увидите приглашение продолжить установку через сетевую консоль: ssh installer@<vm_ip_address>

Ссылки
VirtualBox headless setup
Автоматическая преднастроенная установка Ubuntu: isolinux и preseed
Preseed example, Ubuntu 12.04, installation guideline
Ubuntu 12.04 releases

Небольшой рубеж

2012-04-26T07:49:00.000+03:00

Это конечно не какое-то выдающееся событие, но все равно приятно

Изменения в rssfetch

2012-04-18T09:07:00.000+03:00

Опубликовал новую версию rssfetch http://code.google.com/p/sources-ownport/source/browse/rssfetch - загрузчик RSS лент с использованием Universal Feed Parser и KVLite2, используемый для периодической проверки наличия новых постов для выбранных RSS лент и хранение их в базе данных для последующей обработки.

Изменения:

rssfetch перешел на хранение RSS данных в PySimpleFeed формате. Это позволило значительно упростить и унифицировать структуру данных. Выигрыш от использования PySimpleFeed - экономия порядка 40% дисковой емкости. Для миграции старых данных с использованием нового формата необходимо воспользоваться скриптом migr.py.

Важно: Перед использование скрипта migr.py необходимо выполнять резераное хранение данных.
```
# python migr.py --migrate_to_simplefeed
```
используется единый формат представления даты и времени для полей entry.published, entry.updated, entry.edited. Для обновления существующих данных
```
# python migr.py --unify_datetime
```
при добавлении новых постов в базу данных добавляются поля entry.source.sha1 и entry.source.href, содержащие SHA1 хеш и ссылку на RSS ленту. Для добавления этих полей для существующих данных:
```
# python migr.py --update_source
```
для каждой ленты feed добавлены новые поля ‘last_updated’ и ‘posts_per_requrest’. Значение этих полей использутся для вычисления времени, когда необходимо выполнять запрос на наличие новых постов для каждой ленты.
исправлена проблема с хранением и передачей ETag
добавлена новая функциональность - вывод дополнительной информации о RSS лентах: порядковый номер ленты, SHA1 хеш от сссылки на ленту, диаграмма появления новых постов от времени, дата и время последней модификации по информации от сервера, дата и время последнего опроса rssfetch, значение ETag, ссылка на ленту, число постов в ответе сервера
PySimpleFeed удаляет поля со значением None
добавлена оптимизация запросов к серверам на наличие новых данных. При первом запуске rssfetch.py -u, за сутки, опрашиваются все ленты. Установлено органичение на опрос одной и той же ленты не чаще чем раз за интервал, установленый в параметре settings.TIME_INTERVAL. На основе истории предыдущих запросов прнимается решение о выполнении запроса к серверу, если за интервал времени от последнего опроса до текущего времени было опубликовано постов больше половины от общего количества постов, возвращаемых за один ответ от сервера. Для обновления матрицы распределения даты и времени постов необходимо выполнить команду
```
# python rssfetch.py --update_factor
```
в получаемых данных для некоторых лент поля entry.edited, entry.published, entry.updated не заполнены, это приводит к некорректному формированию матрицы распределения постов. Для того, чтобы минимизировать отклоннения, для постов которые не содержат данных полей rssfetch формирует поле entry.updated с указанием даты и времени опроса ленты
добавлена возможность выполнения оптимизации и изменения структуры полей для существующих постов. Зачастую при добавлении новых лент появляются и новые поля, которые ранее не были описаны в PySimpleFeed. Большинство из этих новых полей переносятся в “черный” список, т.к. не содежат полезной информации. Запуск
```
# python rssfetch.py --optimize_fields
```
позволяет привести посты всех лент к единому формату в случае внесения изменений в PySimpleFeed формате или если поля внесены в “черный” список

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

{u'entry.authors': {'count': 2070},
u'entry.comments': {'count': 1307},
u'entry.content.html': {'count': 1818},
u'entry.content.rights': {'count': 118},
u'entry.content.subtitle': {'count': 251},
u'entry.content.text': {'count': 168},
u'entry.content.xml': {'count': 2},
u'entry.edited': {'count': 125},
u'entry.language': {'count': 134},
u'entry.links': {'count': 3196},
u'entry.media.urls': {'count': 847},
u'entry.published': {'count': 4117},
u'entry.publisher': {'count': 118},
u'entry.source.href': {'count': 3196},
u'entry.source.sha1': {'count': 4305},
u'entry.summary': {'count': 4286},
u'entry.tags.scheme': {'count': 1286},
u'entry.tags.term': {'count': 3340},
u'entry.text': {'count': 47},
u'entry.title': {'count': 4279},
u'entry.updated': {'count': 917}}
Total feed entries: 4305

PySimpleFeed: компактное представление структуры RSS новостей

2012-03-31T08:03:00.000+03:00

В прошлом посте приводился пример вывода агрегированной структуры rss постов для нескольких десятков тысяч постов. Даже на таком сравнительно небольшом наборе данных становится понятно, насколько может быть разнообразна и избыточна структура RSS/Atom данных. Небольшая библиотека PySimpleFeed позволяет привести структуру данных, полученных с помощью feedparser.feed() к плоскому виду, убрать избыточноть, сократить число необходимых для анализа полей с нескольких сотен до десятков. Пример агрегированной структуры из прошлого поста с использование PySimpleFeed выглядит следующим образом:

{u'entry.authors': 18734,
 u'entry.comments': 7556,
 u'entry.content.html': 7647,
 u'entry.content.rights': 129,
 u'entry.content.subtitle': 256,
 u'entry.content.text': 166,
 u'entry.content.xml': 2,
 u'entry.edited': 239,
 u'entry.language': 354,
 u'entry.links': 18734,
 u'entry.media.urls': 18734,
 u'entry.published': 18492,
 u'entry.publisher': 129,
 u'entry.summary': 18658,
 u'entry.tags.scheme': 8045,
 u'entry.tags.term': 14142,
 u'entry.title': 18734,
 u'entry.updated': 1871}
Total feed entries: 18734

Примечание: напротив каждого поля указывается число повторений его в структуре для 18 тыс новостей

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

simple_feed = pysimplefeed.SimpleFeed(entry).handle()

По умолчанию, “черный” список полей можно не указывать, тогда при обработке будут использованы поля заданные в переменной pysimplefeed.BLACK_LIST_FIELDS.

Детально по каждому из полей, возвращаемых по SimpleFeed(...).handle()

entry.authors
список авторов новости. Для каждого автора формируется словарь из полей name (имя автора), href (ссылка на веб сайт), email. Заполняется в зависимости от информации содержашейся в исходных данных

entry.title
заголовок новости

entry.comments
ссылка на комментарии к новости

entry.content.subtitle
дополнительная информация для заголовка новости

entry.content.html
текст новости в формате HTML

entry.content.text
новость в тектовом формате

entry.content.xml
текст новости в формате XML

entry.content.rights
информация об авторских правах на новость

entry.edited
дата и время последней редакции

entry.language
язык на котором написана новость

entry.links
список ссылок. Первая ссылка simple_feed[u’entry.links’][0] содержит линк на саму новость. Может быть использована для проверки уникальности в базе данных

entry.media.urls
список ссылок на медиа данные: изображения, видео, аудо материалы

entry.published
дата и время публикации

entry.publisher
издатель

entry.summary
краткое описание новости

entry.tags.term
список тегов к новости

entry.tags.scheme
описание схем для тегов

entry.updated
дата и время обновления новости

Простое представление словарей со сложной структурой

2012-03-29T22:22:00.000+03:00

Словари со сложной внутренней структурой могут содержать различные типы данных от вложенных словарей до списков, содержащих опять же вложенные словари или другие, произвольные типы данных. Примером таких словарей является структура RSS ленты, возвращаемая библиотекой Universal Feed Parser по feedparser.parse(). Определение структуры с множественной вложеностью данных, а тем более сравнение структур между собой может быть достаточно сложной задачей. Для упрощения этих задач можно воспользоваться небольшой функцией, выполняющей преобразование вложенных структур к “плоскому” виду - словарю, содержащему в виде ключа информацию о вложенности данных, а в виде значения - сами данные.

def dict2flat(root_name, source, removeEmptyFields=False):
    ''' returns a simplified "flat" form of the complex hierarchical dictionary '''
    flat_dict = {}
    if isinstance(source, list):
        for i,e in enumerate(source):
            new_root_name = "%s[%d]" % (root_name,i)
            for k,v in dict2flat(new_root_name,e).items():
                flat_dict[k] = v
    elif isinstance(source, dict):
        for k,v in source.items():
            new_root_name = "%s.%s" % (root_name, k)
            for kk, vv in dict2flat(new_root_name,v).items():
                flat_dict[kk] = vv
    else:
        if source is not None:
            flat_dict[root_name] = source
    return flat_dict

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

Пример неполного вывода функции dict2flat(u‘entry’, entry) c агрегацией струкуры данных более сотни RSS лент выглядит следующим образом:

{u'entry.app_control': 1,
 u'entry.app_edited': 232,
 u'entry.author': 9059,
 u'entry.author_detail.email': 605,
 u'entry.author_detail.href': 1166,
 u'entry.author_detail.name': 8989,
 u'entry.authors[0].email': 338,
 u'entry.authors[0].href': 1166,
 u'entry.authors[0].name': 1600,
 u'entry.bitrate': 25,
 u'entry.comments': 7202,
 u'entry.comments_detail.value': 1,
 u'entry.content[0].base': 3330,
 u'entry.content[0].language': 404,
 u'entry.content[0].type': 3330,
 u'entry.content[0].value': 3330,
 u'entry.content[1].base': 77,
 u'entry.content[1].type': 77,
 u'entry.content[1].value': 77,
 u'entry.dc_date.taken': 420,
 u'entry.dc_relation': 124,
 u'entry.dc_source.url': 1877,
 u'entry.dc_tags': 3765,
 u'entry.dc_tags_detail.value': 1,
 u'entry.embed': 1005,
...
u'entry.link': 17885,
 u'entry.links[0].href': 17885,
 u'entry.links[0].rel': 17885,
 u'entry.links[0].style': 1,
 u'entry.links[0].target': 1,
 u'entry.links[0].title': 365,
 u'entry.links[0].type': 17826,
 u'entry.links[10].href': 2,
…
 u'entry.tags[0].label': 355,
 u'entry.tags[0].scheme': 7654,
 u'entry.tags[0].term': 13504,
 u'entry.tags[10].label': 5,
 u'entry.tags[10].scheme': 160,
 u'entry.tags[10].term': 450,
 u'entry.tags[11].label': 5,
 u'entry.tags[11].scheme': 151,
…

Напротив каждого поля указывается число повторений его в структуре данных для порядка 18 тыс. RSS новостей.

rssfetch, новые возможности

2012-03-11T08:38:00.000+02:00

Со времени публикации последнего поста “Загрузчик RSS лент (rssfetch)”, rssfetch обзавелся рядом дополнений и ноововведений:
- изменена структура помощи и работа с командной строкой
- добавлены функции логирования работы с возможностью вывода как на консоль, так и запись в файл
- добавлена возможность запуска как сервиса

Для вызова помощи достаточно указать аргумент -h или --help

$ python rssfetch.py --help
usage: rssfecth <options>
author: Andrey Usov <http://devel.ownport.net>, version: 0.2
Options:
 -h, --help   print this help
 -i, --import=<json_file> import feeds from json file
 -s, --show_feeds  show feeds details
 -l, --logfile   logging to file
 -u, --update_entries  run periodical feed entries update
 -d, --daemon   run periodical feed entries update as service

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

Ранее логирование выполнялось только на стандартный вывод, сейчас при указании ключа -i или --logfile вывод сообщений можно направить в файл

$ python rssfetch.py -u --logfile=rssfetch.log

Запуск обновлений постов можно выполнять двумя путями: как приложение или как сервис. При запуске как приложения, rssfetch будет выполняться свою работу до тех пор пока окно в котором он запущен rssfetch не будет закрыто или пока пользователь сам не остановит его работу нажатие Ctrl+C.

$ python rssfetch.py -u

При запуске rssfetсh как сервис такая зависимость исчезает.

$ python rssfetch.py -u -d -l rssfetch.log

Для того, чтобы запустить rssfetch как сервис необходимо в файле конфигурации settings.py прописать абсолютный путь к PID файлу - тестовый файл содержащий номер процесса rssfetch, формируется автоматически при запуске.

Для остановки процесса необходимо выполнить

$kill `cat rssfetch.pid`

Иногда не совсем удобно, когда запускаемые файлы и библиотеки для работы с приложением расположены в одной директории. Проще работать с один файлом. Тогда его можно перенести в bin директорию не боясь создать мешанину из скриптов и библиотек. Python поддерживает запуск приложения прямо из zip файла. Выполнив настройки rssfetch в settings.py файле можно запаковать все необходимые файлы в один архив rssfetch.zip. Список файлов ниже:

feedparser.py
kvlite2.py
rssfetch.py
settings.py
__main__.py

Теперь rssfetch можно запустить прямо из zip файла

$ python rssfetch.zip --help

usage: rssfecth <options>
author: Andrey Usov <http://devel.ownport.net>, version: 0.2
Options:
 -h, --help   print this help
 -i, --import=<json_file> import feeds from json file
 -s, --show_feeds  show feeds details
 -l, --logfile   logging to file
 -u, --update_entries  run periodical feed entries update
 -d, --daemon   run periodical feed entries update as service

Загрузить версию rssfetch 0.2 можно с http://code.google.com/p/sources-ownport/
Исходный код доступен в репозиториии http://code.google.com/p/sources-ownport/

Загрузчик RSS лент (rssfetch)

2012-03-09T09:22:00.001+02:00

Данным постом начинается небольшая серия статей по созданию загрузчика RSS лент с использованием Universal Feed Parser и KVLite2. Основная задача: периодическая проверка наличия новых постов для выбранных RSS лент и хранение их в базе данных для последующей обработки.

Для начала работы необходимо создать новую базу данных в MySQL - rssfetch и пользователя, который будет работать с этой базой данных - rssfetch.

mysql> create database rssfetch;
Query OK, 1 row affected (0.03 sec)
mysql> grant all privileges on rssfetch.* to 'rssfetch'@'localhost' identified by '<ваш пароль>';
Query OK, 0 rows affected (0.10 sec)

Название базы данных и имя пользователя могут быть произвольными. “rssfetch” взят как пример.

Для созданной базы данных и пользователя необходимо прописать настройки в файле конфигурации settings.py

FEEDS_URI = "mysql://rssfetch:<ваш пароль>@localhost/rssfetch.feeds"
ENTRIES_URI = "mysql://rssfetch:<ваш пароль>@localhost/rssfetch.entries"
USER_AGENT = 'rssfetcher/0.1'
SERVER_RESPONSE_TIMEOUT = 60    # time for waiting response from the server
TIME_INTERVAL = 1800 # seconds, 30 minutes. Waiting time for the next update

FEEDS_URI и ENTRIES_FEED параметры описывают параметры доступа к коллекциям RSS лент и постам.
USER_AGENT параметр позволяет изменить значение по умолчанию, определяемое в feedparser http://ru.wikipedia.org/wiki/User_Agent
SERVER_RESPONSE_TIMEOUT определяет в секундах время ожидания ответа от сервера
TIME_INTERVAL определяет в секундах время между циклами обновления RSS лент

Для начала работы rssfetch необходимо загрузить информацию о RSS лентах. Загрузка выполняется из JSON файла:

# python rssfetch.py import <json_file>

Формат файла имеет следующую структуру:

[
    {   "title": "MySQL Performance Blog",         
        "text": "MySQL Performance Blog. Percona's MySQL & InnoDB performance and scalability blog",         
        "xmlUrl": "http://www.mysqlperformanceblog.com/feed/",
        "htmlUrl": "http://www.mysqlperformanceblog.com/" }
]

Обязательным полем является xmlUrl, указывающее на RSS ленту. Оно определяет уникальность записей в базе данных. Повторная попытка импортировать в базу новую RSS ленту с уже существующим xmlUrl будет проигнорирована. Остальные поля являются вспомогательными и не влияют на работу rssfetch. Описание ленты не ограничено только этими полями, можно добавлять любые поля по необходимости. Данные по RSS лентам хранятся в таблице rssfetch.feeds

Для вывода списка импортированных RSS лент

# python rssfetch.py show_feeds
...
id: 108, key: fb4805703b327adbd176377a5fba6b6b3e129c8c
details: {u'xmlUrl': u'http://www.mysqlperformanceblog.com/feed/', u'text': u"MySQL Performance Blog. Percona's MySQL & InnoDB performance and scalability blog", u'htmlUrl': u'http://www.mysqlperformanceblog.com/', u'title': u'MySQL Performance Blog'}
...

id - порядковый номер RSS ленты в базе данных,
key - идентификатор RSS ленты, рассчитывается как функция sha1 от поля xmlUrl hashlib.sha1(feed['xmlUrl']).hexdigest()
details - детальное описание RSS ленты

Обновление данных для RSS лент выполняется с помощью команды

# python rssfetch.py update_entries
…
2012-03-09 08:02:22 feed: http://www.mysqlperformanceblog.com/feed/ (total: 10, new: 0)
…

После выполнения команды запускается периодический процесс обновления данных RSS лент в порядке их импорта в базу данных. Периодичность проверки новых постов определяется параметром settings.TIME_INTERVAL. Лог выполнения пишется в стандартный вывод. Для каждой ленты отображается краткая информация: дата и время обновления, ссылка на RSS ленту, общее число загруженных постов и количество новых.

rssfetch умеет оперировать значением ETag, позволяя тем самым более эффективно использовать ресурсы как сервера, так и пропускной способности канала между сервером и rssfetch. Значение ETag сохраняется после каждого обращения к серверу и при повторном обращении передается в запросе. Для корректной работы этой функциональности сервер должен уметь работать с полем ETag.

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

2012-03-09 08:02:22 rssfetch: total feeds: 109, new entries: 2, feeds update time 0:03:10.687371

Загрузить версию rssfetch 0.1 можно с http://code.google.com/p/sources-ownport/
Исходный код доступен в репозиториии http://code.google.com/p/sources-ownport/

Расширенный urlfetch

2012-03-04T09:38:00.000+02:00

О способах получения данных из интернет уже упоминалось несколько раз. Предыдущие примеры позволяли на базе простых функций, компонент или процессов загружать тестовую информации из интернет-ресурсов. Некоторые из них, позволяли просто загружать данные, другие выполнять загрузку последовательно на основании списка, некоторые параллельно. За время использования предыдущих версий стало понятно, что только отправка HTTP GET и получения данных не всегда является достаточным, а некоторых случаях просто не эффективно. Необходим подход позволяющий более эффективно осуществлять запросы с серверам и обрабатывать полученные данные. Решение пришло неожиданно и как это всегда бывает - лежало перед носом. Universal Feed Parser - это отличный модуль, написанный на python, позволяющий загружать и обрабатывать RSS ленты различных форматов.

Модуль urlfetch является пеработкой feedparser-а. Основной акцент делается на загрузку текстовых данных, поэтому код специфичный для работы с RSS/Atom лентами был убран. Из-за этого упростились многие функции, например, такие как определение кодировки данных на основании содержимого. Как и feedparser, так и urlfetch достаточно легок в использовании. Модуль не зависим от сторонних библиотек, поэтому может работать на базовом python версии 2.4 и выше (на python 3 не тестировался). Для экспериментов включена поддержка работы из командной строки:

#python urlfetch.py <URL>

Результатом выполнения будет вывод на экран словаря, содержащего две секции - полей заголовка (headers) и собственно само содержимое страницы (body). Для интеграции urlfetch в приложение используется единственная функция urlfetch.fetch()

def fetch(url, etag=None, modified=None, agent=None, referrer=None, handlers=[], request_headers={}, absolute_urls=False)

которая возвращает словарь, состоящий из заголовка и содержимого страницы. Описание и примеры использования приведены на wiki странице модуля urlfetch, поэтому ниже опишу лишь возможности реализованные в текущей версии:

поддержка ETag, позволяет использовать один из механизмов работы с кешем web страниц на стороне сервера, сохраняя пропускную способность и ресурсы сервера. Клиент посылая запрос с значением ETag поля, полученным в прошлом запросе, дает возможность серверу оценить необходимость отправки запрашиваемой информации повторно. Если данные на стороне сервера не изменились с последнего обращения, сервер возвращает ответ с HTTP 304 без передачи самого содержимого ресурса - указывая на то, что данные не изменены.
поддержка Last-Modified. Это второй механизм, поддерживаемый urlfetch для работы с кеширующими серверами. В отличии от ETag, передается дата и время последнего изменения ресурса.
поддержка User-Agent. По умолчанию urlfetch передает строку “UrlFetch/0.1 +http://code.google.com/p/sources-ownport”. Если вы встраиваете urlfetch в свое приложение, вы должны изменить значение User-Agent на свое, согласно правилам http://en.wikipedia.org/wiki/User_agent
поддержка HTTP Referrer, адрес web страницы с которой осуществлено обращение к запрашиваемой странице.
поддержка пользовательских обработчиков используемых в urllib2.build_opener
поддержка переопределения значений по умолчанию в HTTP запросах на пользовательские
автоматическое преобразование содержимого станицы в UTF-8 кодировку на основании информации переданной сервером в HTTP заголовке (content-type, charset)
возможность преобразование относительных ссылок внутри содержимого страницы на абсолютные, например ссылка “/2012/02/mysql.html” будет заменена на “http://devel.ownport.net/2012/02/mysql.html”

Исходный код модуля urlfetch доступен на http://code.google.com/p/sources-ownport/
Wiki страница с описанием работы
Изображение адресной строки взято с сайта www.freedigitalphotos.net, автор Salvatore Vuono

MySQL как база данных ключ/значение

2012-02-25T22:44:00.000+02:00

Специализированных решений для хранения ключ/значений достаточно много, достаточно взглянуть на страницу wikipedia NoSQL. С учетом того, что подход NoSQL относительно нов, по сравнению с реляционными базами данных, с каждым днем он набирает все больше и больше сторонников. К сожалению, не всегда есть возможность выделить отдельный сервер или установить необходимое программное обеспечения для работы с NoSQL базами данных. Но в то же время, базы данных MySQL доступны практически у любого хостинг-провайдера, есть сборки mysql не требующие установки, руководств и советов по mysql можно найти значительно больше, чем для любой другой базы данных. Попытки найти некий баланс привели к созданию небольшой библиотеки KVLite2.

KVLite2 - это небольшая обвертка на python (около 200 строк кода), позволяющая хранить данные ключ/значение в базе данных MySQL. Для работы достаточно одного файла kvlite2.py. По своей логике работы KVLite2 больше близка к MongoDB. Она оперирует документами и коллекциями документов. Ключи используются для быстрого доступа к документам. В посте не стану описывать принципы работы библиотеки, я постарался описать все важные аспекты и примеры работы в небольшом руководстве по работе с KVLite2 на Wiki проекта.

Важно: изначально планировалось использовать библиотеку cjson, как наиболее быструю в обработке JSON формата. Но в связи с обнаружнными ошибками в работе, использование cjson следует избегать и использовать стандартную библиотеку json.

Архитектура Disco

2012-02-23T22:05:00.001+02:00

Краткое описание Disco - MapReduce системы на базе Erlang и Python было дано в одном из предыдущих постов. Несколько слов об архитектуре.

Disco основана на архитектура главный-ведомый (master-slave).

Клиентские приложения передают системе задачи для выполнения через мастер-ноду (master)
Мастер-нода (master) получает задачи, добавляет их в очередь и запускает их на нодах кластера (slave), как только те становятся свободными.
Ведомые ноды кластера (slave) запускаются мастер-нодой, они активируют и осуществляют мониторинг всех процессов внутри ноды самостоятельно, без участия мастер-ноды
Рабочие процессы (worker) выполняют переданные мастер-нодой задачи. Местоположения результатов обработки данных передаются на мастер-ноду.
Disco старается обрабатывать данные локально - назначая задачи по обработке данных на те ноды, на которых эти данные расположены. HTTP сервер запущенный на каждой ноде позволяет получить доступ к данным для рабочих процессов, запущенных на других нодах. Это полезно в тех случаях, когда рабочий процесс, по неким причинам, не может быть запущен на той же ноде, где расположены данные.
Пользователь может ограничивать количество параллельно запущенных рабочих процессов равным числу процессоров, дисков ноды или определить произвольное число параллельных процессов.

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

Статья о Google MapReduce & Hadoop

2012-02-21T21:34:00.000+02:00

Интересная статья о технологиях, позволяющих организовать распределенное хранение и параллельную обработку больших объемов данных в крупномасштабных кластерных системах на базе технологий Google File System (GFS), Hadoop File System (HDFS), Google BigTable, HBase, модели программирования MapReduce, Apache Hadoop, Microsoft Dryad, Chubby, ZooKeeper.

Речь идет о петабайтах данных, для хранения и обработки которых необходимы значительные вычислительные ресурсы. В качестве таких ресурсов рассматриваются кластерные системы, состоящие из тысяч серверов. В подобных распределенных системах остро стоят вопросы обеспечения отказоустойчивости и бесперебойного функционирования сервисов хранения и обработки данных. В таких системах важной проблемой является создание высокоуровневой модели программирования процессов обработки данных. В статье приводится описание оригинальных технологий Google, а также проводится параллель с существующими open source проектами - аналогами данных технологий, Apache Hadoop. Материал статьи подготовлен в рамках Всероссийского конкурсного отбора обзорно-аналитических статей по приоритетному направлению "Информационно-телекоммуникационные системы".

Новые технологии распределенного хранения и обработки больших массивов данных. О.В. Сухорослов. Институт системного анализа РАН

Disco - mapreduce для распределенных вычислений

2012-02-19T13:50:00.001+02:00

Disco - это реализация технологии MapReduce для распределенный вычислений. Disco поддерживает выполнение параллельных вычислений большого объема данных, сохраненных на обычных компьютерах, включенных в кластер, реализуя идеи Google MapReduce, описанные в документе MapReduce: Simplified Data Processing on Large Clusters. Это делает Disco отличным решением для анализа и обработки больших объемов данных, не требующем дополнительных знаний в таких сложных распределенных технологиях как протоколы коммуникации, балансировка нагрузки, блокировка, распределения задач, отказоустойчивость.

Disco может быть использован для различных задач сбора, анализа данных, построения сложных вероятностных моделей, полнотекстовой индексации web-данных. И это лишь небольшой список примеров применения.

Ядро Disco написано на Erlang - языке программирования, разработанным специально для построения масштабируемых программных систем реального времени требующих высокой доступности. Пользователи Disco обычно пишут свои задачи на Python, позволяющем описывать сложные алгоритмы небольшим и легко читаемым кодом.

Ниже приведен рабочий пример кода для подсчета частоты использования слов в большом тексте.

from disco.core import Job, result_iterator
def map(line, params):
    for word in line.split():
        yield word, 1

def reduce(iter, params):
    from disco.util import kvgroup
    for word, counts in kvgroup(sorted(iter)):
        yield word, sum(counts)

if __name__ == '__main__':
    job = Job().run(input=["http://discoproject.org/media/text/chekhov.txt"],
                    map=map,
                    reduce=reduce)
    for word, count in result_iterator(job.wait(show=True)):
        print word, count

Дизайн Disco направлен на упрощение интеграции его в большие приложения, такие как web-сервисы. Существует возможность реализовать делегирование сложных вычислительных задач кластеру независимо от работы основного приложения. Disco предоставляет невероятно компактный Python API: как правило только две функции необходимы, map и reduce. REST Web API используется для управления задачами и web-интерфейса для мониторинга статуса работы системы.

Disco хорошо подходит для развертывания кластеров, построенных на основе обычных Linux серверов. Новая нода может быть добавлена в систему на лету, одним кликом через web-интерфейс. Если одна из нод выходит из строя, активные задачи автоматически перераспределяются между другими нодами без прерывания работы системы. Совместно с системой автоматической инсталляции FAI даже большие кластеры могут поддерживаться с минимальным количеством ручной работы. В качестве доказательства концепции, Центр разработки компании Nokia в Palo Alto обслуживает таким образом 800-ядерный Disco кластер.

Основные функциональности Disco

Масштабируемость на сотни процессоров и десятки тысяч параллельных задач
Используется для обработки наборов данных в десятки терабайт
Прост в использовании: обычные задачи содержат только две функции, написанные на python и два вызова к Disco API
Задачи могут быть адаптированы под любой язык программирования через простой внешний интерфейс, базирующийся на стандартных потоках ввода-вывода.
Входные данные могут быть представлены в любом формате, даже бинарные данные, такие как изображения. Данные могут быть размещены на любых ресурсах доступных через HTTP протокол или могут быть распределены на локальных дисках.
Отказоустойчивость: выход из строя ноды не приводит к прерыванию выполнения задач. Новые сервера могут быть добавлены на лету.
В дополнении к функциям map и reduce, есть дополнительно функции combiner и partitioner, а также функция input reader.
Легкость интеграции в большие приложения используя Disco модули и Web API
Поставляется со встроенной распределенной системой хранения Disco Distributed Filesystem и распределенной индексной подсистемой Discodex, позволяющей выполнять специальные запросы к терабайтным данным

Дата-центр Tulip Telecom India

2012-02-15T06:51:00.002+02:00

Tulip Telecom India разместила на youtube видео о их новом дата-центре. Согласно информации от IBM этот крупнейший в Индии и третий по величине в мире дата-центр был построен за 9 месяцев. Это очень хороший показатель.

- Общая площадь дата-центра 900,000 кв. м.
- Дизайн соответствует Tier-3 спецификации (TIA-942 стандарт) (*).
- Питание 66кВ с мощность 40 МВА со 100% резервированием
- Независимые внешние интерконнекты с различными интернет сервис провайдерам
- Изолированные помещения для установки серверов по 10,000 кв. м. на секцию
- Высокая энергоэффективность - PUE ~1.9 (**)
- 80,000 кв.м. выделено под офисные помещения
- Автоматизированная система управления зданием

(*) Tier 3 (N+1) - возможность проведения ремонтно-восстановительных работ (включая замену компонентов системы, добавление и удаление вышедшего из строя оборудования) без прерывания работы дата-центра; подается несколько вводов электропитания; инженерные системы работают в режимы active/standby - системы электропитания и охлаждения дублированы, однако активна всегда только одна система Tier data center — уровни надежности дата-центра

(**) PUE, Power usage effectiveness - коэффициент, показывающий насколько эффективно используется энергия для вычислительных систем, по отношению к инфраструктуре дата-центра (системы кондиционирования, ...).

Ссылки:
Дата-центр/Wikipedia
The Green Grid http://www.thegreengrid.org/

Книга "Introduction to Computing"

2012-02-13T21:29:00.001+02:00

Девид Эванс (David Evans), донент Университета Вирджиния по вычислительным системам опубликовал в Интернет свою книгу - Introduction to Computing. Explorations in Language, Logic, and Machines. В полном объеме книга доступна для скачивания в PDF формате, ее можно прочесть в онлайн, для любителей бумажных книг она доступна для заказа через Amazon или CreateSpace.

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

Визуализация данных с помощью graphviz

2012-02-07T07:20:00.000+02:00

В многих случаях информация намного лучше воспринимается, когда она представлена графически. Для случаев построения сложных схем, графическое представление информации - необходимое условие. Кто-то для этого использует PowerPoint, кто-то Visio, кто-то Dia. Не очень удобным является подход поддержки в актуальном виде схем, созданных с помощью этих приложений - требуется постоянное вовлечение человека. И как часто это бывает схемы или диаграммы часто не отображают реальную картину состояния дел. Graphviz позволяет решить некоторые из этих вопросов.

Graphviz - это открытое программное обеспечения для построение графов. Принцип работы достаточно прост: подготавливается описание графа в текстовом виде, далее с помощью утилит graphviz граф может быть преобразован в различные форматы от текстового представления до PDF документов. В основном работа выполняется в командной строке, но на сайте, в разделе Ресурсы можно найти много GUI приложений как платных так и бесплатных. Там же можно найти примеры использования graphviz в различных отраслях и сферах: инжиниринг, био-информатика, описание интерфейсов, программы искусственного интеллекта.

Пример простого графа:

digraph g {
    "process1" -> "process2" -> "process3";
}

С помощью ключевых слов node и edge можно управлять глобальными параметрами формой фигур, цветом, шрифтами, формами стрелок. Например:

digraph g {
    rankdir=LR;
    node [fontsize=8,fontname="Verdana",style="rounded",];
    "input1" [shape="plaintext",label="input"];
    "output1" [shape="plaintext",label="ouput"];
    "process1" [shape="rectangle",label="Process 1"];
    "process2" [shape="rectangle",label="Process 2"];
    "input1" -> "process1";
    "process1" -> "process2";
    "process2" -> "output1";
}

Атрибут rankdir позволяет изменить направление графа в LR (left-to-right). “node” определяет общие для всех нод параметры. Строка

"input1" [shape="plaintext",label="input"];

определяет входные данные: “input1” - идентификатор ноды, shape определяет какая форма будет использована для отображения, label http://www.graphviz.org/content/attrs#dlabel указывает на информацию, отображаемую в теле ноды. Для связки нод между собой используется “->”

В версиях graphviz, начиная с середины ноября 2003 года текстовые метки label поддерживают HTML подобные теги. Это позволяет строить более информативные графы.

digraph g {
    rankdir=TB;
    node [fontsize=8,fontname="Verdana",shape="rectangle",style="rounded",];
    edge [fontsize=8,fontname="Verdana",color="grey20",];
    "input1" [penwidth=0.1,label=<<table border="0"><tr><td bgcolor="grey" align="center"><font color="white">Input</font></td></tr><tr><td>path</td></tr></table>>];
    "treewalker" [label=<<table border="0"><tr><td bgcolor="grey18" align="center"><font color="white">treewalker</font></td></tr><tr><td>core3.processes.treewalker3</td></tr><tr><td>Scan files and directories</td></tr></table>>];
    "filehash" [label=<<table border="0"><tr><td bgcolor="grey18" align="center"><font color="white">filehash</font></td></tr><tr><td>core3.processes.filehash2</td></tr><tr><td>Calculate MD5 hash sum</td></tr></table>>];
    "printer" [label=<<table border="0"><tr><td bgcolor="grey18" align="center"><font color="white">printer</font></td></tr><tr><td>__main__.printer</td></tr><tr><td>Print out result on the screen</td></tr></table>>];

    "treewalker-filehash" [penwidth=0.1,label=<<table border="0"><tr><td bgcolor="grey" align="center"><font color="white">packet</font></td></tr><tr><td>path</td></tr></table>>];
    "filehash-printer" [penwidth=0.1,label=<<table border="0"><tr><td bgcolor="grey" align="center"><font color="white">packet</font></td></tr><tr><td>path</td></tr><tr><td>md5hashsum</td></tr></table>>];

    "input1" -> "treewalker" -> "treewalker-filehash" -> "filehash";
    "filehash" -> "filehash-printer" -> "printer";
}

Детальное описание по работе с graphviz можно найти по ссылкам ниже

Graphviz - Graph Visualization Software http://www.graphviz.org
Graphviz Node Shapes http://www.graphviz.org/content/node-shapes
Graphviz Color Names http://www.graphviz.org/doc/info/colors.html
Описание Graphviz на lib.custis.ru http://lib.custis.ru/Graphviz

Описание сложных типов данных для потоков

2012-02-03T07:16:00.001+02:00

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

Древовидные структуры данных в python удобно представлять в виде словарей (dictionary). Можно провести параллель структуры словаря python с JSON форматом. В обоих случаях для хранения данных используются схожие подходы. Для описания данных хранимых в JSON формате используется JSON Scheme. Принципы заложенные в этой спецификации можно использовать и для описания данных, хранимых в python словарях, а соответственно использовать для описания структуры данных пакетов pyflowctrl.

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

Базовая спецификация JSON Schema определяет 8 типов данных JSON объекта: Object, Array, String, Number, Integer, Boolean, Null, Any. Два из них вложенные типы - Object и Array, 5 атомарных и один тип Any, который может содержать любые значения, включая Null. Для описания используются строки: “object”, “array”, “string”, “number”, “integerer”,”boolean”,”null”,”any”. Например:

"module": {
    "type": "string",
    "title": "Module name",
     "required": "true",
    }

где атрибут type - описывает тип, title - краткое описание свойства объекта. Дополнительно к title можно указать атрибут description для более детального документирования свойтсва объекта. Атрибуты title и description - опциональны. По умолчанию принято, что все свойства в схеме опциональные. Если какое-то свойство должно быть обязательно определено, оно должно быть описано с помощью атрибута required.

Для описания структур, таких как массивы существует атрибут items, определяющий типы элементов в массиве.

"based_on": {
    "type": "array",
        "title": "list of bassed-on classes",
        "items": {
            "type": "string",
            "title": "Based-on class",
        }
},

Для описания объектов используется атрибуты object и properties

{
    "type": "object",
    "title": "Class of module",
    "properties:": {
        "name": {
            "type": "string",
            "title": "name of class",
            "required": "true",
        },
        "path": {
            "type": "string",
            "title": "path for class importing",
            "required": "true",
        },
}

Примеры, приведенные выше взяты из последней версии процесса PyMetaInfo

Ссылки:
JSON Scheme http://tools.ietf.org/html/draft-zyp-json-schema-03
JSON validator http://code.google.com/p/jsonvalidator/

Логотип: Salvatore Vuono / FreeDigitalPhotos.net

Небольшая книга о MongoDB

2012-01-29T07:03:00.000+02:00

It's not my fault the chapters are short, MongoDB is just easy to learn.

Эта книга была написана всего за 4-5 часов. Немного более 30 страниц. Описана только базовая функциональность MongoDB. Примеры приводятся для командной строки. Первое конфигурирование. Что такое NoSQL базы данных и их реализация в MongoDB. Как управлять данными: insert, find, update. Моделирование данных: no joins, массивы и встроенные документы, коллекции. Когда использовать MongoDB. MapReduce. Производительность и инструменты

Книга The Little MongoDB Book бесплатна и доступна на сайте автора

Другой взгляд на pyflowctrl

2012-01-26T08:47:00.000+02:00

Бывает так, что для того чтобы лучше понять как работает система, нужно привести примеры подобия с другими системами. Вчера, случайно наткнувшись на сайт компании Eagle Technologies, специализирующейся на системах автоматизации производств, понял, что работу pyflowctrl можно сравнить с поточным производством. Где в качестве как сырья, так и конечного изделия выступают данные.

На вход системы поступают “сырые” данные (Packet), требующие обработки. Проходя каждый процесс (Process) обработки, согласно определенной логики (ProcessFlow) над данными выполняются ряд манипуляций по обработке. Связь между процессами осуществляется с помощью потоков (Stream). Именно они служат конвейером, средством транспортировки данных (Packet) между процессами (Process). Точно также машина проходя по сборочному цеху преобразуется из простых металлоконструкций в законченное изделие.

Описание процесса pyflowctrl

2012-01-25T07:57:00.002+02:00

Реализация процесса (класс Process) в pyflowctrl не позволяет определить с помощью pymetainfo достаточную информацию о процессе, без дополнительного его описания. Получаемые метаданные избыточны и содержат специфичную для python внутреннюю реализацию. Пример вывода можно посмотреть в посте “Исследования python-кода”.

После анализа процессов предыдущих релизов pyflowctrl был сформирован черновой список, необходимой информации о процессе:

название процесса
краткое описание процесса
автор (-ы) кода процесса
ссылки, где код процесса можно скачать
зависимости с другими python модулями, библиотеками
список потоков (входных, выходных, отладки)
список функций с описанием

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

class Process(object):
    ''' Process '''
    
    __PROCESS__ = {
                    'name': 'Process',
                    'description': 'Basic process',
                    'author': '',
                    'url': '',
                    'depends on': '',
                    'io': {},
                }

Атрибут __PROCESS__ содержит словарь метаданных процесса, на основании которого базовый конструктор процесса выполняет создание экземпляра процесса. Наиболее важным является ключ “io”, определяющий словарь параметров потоков ввода/вывода. Пример __PROCESS__ на базе pymetainfo2.py:

__PROCESS__ = {
                    'name': 'PyMetaInfo',
                    'description': 'Extact metadata information about module/class. Customized for pyflowctrl.',
                    'author': 'Andrey Usov <http://devel.ownport.net>',
                    'url': 'http://pyflowctrl.googlecode.com/hg/pyflowctrl/core4/processes/pymetainfo2.py',
                    'io': {'input': {}, 'output': {}, },
                }

Сейчас, если запустить pymetainfo2.py и указать в качестве аргумента его собственный код, вывод будет иметь следующий вид:

$python examples/pymetainfo2.py pyflowctrl.core4.processes.pymetainfo2.PyMetaInfo

{'__namespaces': {},
 'meta': {'based_on': (<class 'pyflowctrl.core4.Process'>,),
          'classes': [('__class__', <type 'type'>, <type 'object'>)],
          'data': [('__PROCESS__',
                    {'author': 'Andrey Usov <http://devel.ownport.net>',
                     'description': 'Extact metadata information about module/class. Customized for pyflowctrl.',
                     'io': {'input': {}, 'output': {}},
                     'name': 'PyMetaInfo',
                     'url': 'http://pyflowctrl.googlecode.com/hg/pyflowctrl/core4/processes/pymetainfo1.py'})],
          'description': 'Extact metadata information about module/class ',
          'funcs': [('__init__', None),
                    ('get_classes', 'return list of classes '),
                    ('get_data', 'return data for object. filtered'),
                    ('get_elements',
                     "get list of object's elements by type"),
                    ('get_funcs', 'return list of functions, filtered'),
                    ('get_metadata', "get dictionary of object's metadata "),
                    ('get_modpkgs', "return list of module's packages "),
                    ('main', None),
                    ('remove_empty_meta', 'remove empty data '),
                    ('run_once',
                     'wrapper for main loop \n\nif packet is specified run_once return the result of processing\nif packet is not specified run_once return the status of process')],
          'name': 'PyMetaInfo',
          'type': <type 'type'>},
 'module': 'pyflowctrl.core4.processes.pymetainfo2.PyMetaInfo'}

Следует отметить, что с переходом на новый способ определения потоков ввода/вывода, возвращен, определенный в core3, подход доступа к потокам ввода/вывода.

получение пакета из входного потока packet = process1.io['input'].get()

запись пакета в поток вывода process1.io['output'].put(packet)

Иcследование python кода

2012-01-12T08:20:00.001+02:00

Интроспекция(англ. type introspection) в программировании — возможность в некоторых объектно-ориентированных языках определить тип и структуру объекта во время выполнения программы. Wikipedia. Для python эта возможность интегрирована в сам язык. Хороший пример интроспекции в python - встроенная система помощи. Для любого кода на python достаточно набрать в командной строке:

$ pydoc "module/class/function name"

как результат будет получено описание по модулю, классу или функции (см. примечание к посту ниже).

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

Процесс PyMetaInfo позволяет провести анализ кода переданного имени модуля и вернуть метаданные в виде словаря. Пример использования процесса приведен в коде examples/pymetainfo1.py. На вход процесса передается пакет, содержащий имя модуля packet.module:

$ python examples/pymetainfo1.py pyflowctrl
{'__namespaces': {},
 'meta': {'data': [('__author__', 'Andrey Usov ')],
          'description': 'Python Flow Control Library ',
          'module_packages': ['core4 (package)',
                              'examples (package)',
                              'libs (package)',
                              'processes (package)',
                              'streams (package)'],
          'name': 'pyflowctrl',
          'submodules': [('core4',
                          )],
          'type': },
 'module': 'pyflowctrl'}

На выходе получаем пакет с метаданными о библиотете. Пример вывода информации о процессе:

$ python examples/pymetainfo1.py pyflowctrl.core4.processes.pymetainfo1.PyMetaInfo
{'__namespaces': {},
 'meta': {'based_on': (,),
          'classes': [('__class__', , )],
          'data': [('__dict__',
                    dict_proxy({'__module__': 'pyflowctrl.core4.processes.pymetainfo1', 'get_elements': , 'get_classes': , 'get_modpkgs': , 'get_metadata': , 'main': , '__doc__': ' Extact metadata information about module/class ', '__init__': })),
                   ('__weakref__',
                    )],
          'description': 'Extact metadata information about module/class ',
          'funcs': [('__delattr__',
                     ),
      
                    . . .

                    ('get_classes', ),
                    ('get_elements',
                     ),
                    ('get_metadata',
                     ),
                    ('get_modpkgs', ),
                    ('main', ),
                    ('run_once', )],
          'name': 'PyMetaInfo',
          'type': },
 'module': 'pyflowctrl.core4.processes.pymetainfo1.PyMetaInfo'}

Информация в выводе достаточно избыточна для работы pyflowctrl, отсутствует информация о потоках. Так как потоки создаются в __init__(), провести анализ содержимого объекта без его создания не получится. Необходимо пересмотреть принципы создания процессов для того, что бы существовала возможность получения информации о потоках без создания самого процесса.

Примечание: документация в python формируется автоматически на основании анализа кода объекта. При вызове pydoc выполняет импорт кода и проводит анализ его структуры, извлекает документацию.

Новое ядро (сore4) для pyflowctrl

2012-01-08T07:03:00.000+02:00

Причины перехода на новое ядро в основном были описаны в предыдущем посте “Информационные пакеты в pyflowctrl”. Предыдущее ядро работу с пакетами не поддерживало, а плавно перейти на их поддержку не получалось. Кроме этого переход на новое ядро был обусловлен еще и давним желанием вывести работу над pyflowctrl в отдельный проект. Сейчас проект размещен на code.google.com.

В будущем на нем будут публиковаться изменения начиная с ветки core4. С переходом на новую версию изменена структура директорий проекта:

- core4.py перенесен в директорию core4 и__init__.py
- в директорию core4 добавлены под-директории processes/ для хранения кода процессов, streams/ для потоков, tests/ для тестов, examples/ для примеров работы с библиотекой, libs/ для хранения сторонних библиотек.

Изменения в логике работы core4 от core3 (core4 базируется на core3):

В классе Process изменены атрибуты доступа к входным/выходным потокам. Сейчас доступ к ним осуществляется с помощью атрибутов input/output, которые нужно явно описать для нового процесса

class TestProcess(Process):
    def __init__(self):
        super(TestProcess, self).__init__()
        self.input = Stream()
        self.output = Stream()

Пример определения основной функции процесса

def main(self):
    while True:
        try:
            packet = self.input.get()
        except EmptyStream:
            yield WAITING
            continue
        # основной код для работы с данными пакета 
        self.output.put(packet)
        yield PROCESSING

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

Основной единицей переноса данных между процессами является информационный пакет, класс Packet, см. “Информационные пакеты в pyflowctrl”

При создании пакета можно передавать “корневые ” переменные, которые он будет содержать

>>> p = Packet(counter=10, name=’test_process’)
>>> p.counter, p.name
10 test_process

В классе ProcessFlow упрощен механизм создания сети взаимодействия процессов - словарь с описанием:

network = {
    'processes': {
        'process1': TestProcess(),
        'process2': TestProcess(),
        'printer': Printer(),
    },
    'links': {
        # соединение между process1 и process2
        ('process1.output', 'process2.input', p1p2_handler), 
        # соединение между process2 и printer
        ('process2.output', 'printer.input', p2prn_handler),
    }
}

network[‘processes’] описывает процессы, участвующие в работе. Доступ к процессам осуществляется по их именам.

network[‘links’] описывает взаимодействие между процессами. Каждое соединение - это список из трех аргументов: источник данных, получатель данных, обработчик данных. Источник и получатель данных - это символьное описание, состоящее из имени процесса и имени потока. Обработчик данных позволяем изменить структуру пакета на этапе передачи его от процесса-источника до процесса-получателя. Это дает возможность адаптировать структуру пакета под нужды следующего процесса. Обработчик данных - это функция на вход которой поступает пакет и на выходе она должна возвращать его же, пример:

def p1p2_handler(packet):
    # process1 -> process2
    packet.set_namespace('test-env1')
    packet['test-env1'].name = packet.name
    packet['test-env1'].url = packet.url
    del packet.name
    del packet.url
    return packet

Если данные в обработке не нуждаются, то вместо обработчика данных передается None.

'links': {
        ('process1.output', 'process2.input', None),
}

Обработчики данных можно использовать также как функции-отладчики для вывода данных обменивающихся между процессами.

'links': {
        ('process1.output', 'process2.input', p1p2debug),
}

Загрузка сети network в ProcessFlow выполняется с помощью метода upload(network)

flow = ProcessFlow()
flow.upload(network)
for i in xrange(10):
    flow.pmap['process1'].input.put(Packet(counter=i))
flow.run()

Метод run() выполняет запуск сети в работу

Пример работы с core4 расположен в директории examples репозитория

Информационные пакеты в pyflowctrl

2012-01-07T07:15:00.000+02:00

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

Приведу пример диаграммы взаимодействия процессов одного из предыдущих постов - “Извлекаем ссылки из HTML страницы”

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

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

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

from pyflowctrl.core4 import Packet

p = Packet()
# “корневая” область
p.id = 1
p.url = 'http://example.com'
p.content = '<html><body>test 1</body></html>'
p.tags = ['html','body']

Процесс, получив пакет работает с его “корневыми” данными: принимает, обрабатывает, изменяют значения в существующих полях или создает новые. Важным моментом при таком подходе является необходимость избежания коллизии имен полей, используемых другими процессами и текущим процессом. Для решения этого вопроса в пакете можно создавать различные пространства имен (namespaces). Перед передачей пакета в процесс, данные, не относящиеся к текущему процессу переносятся из “корневой” области видимости в отдельное пространство имен.

# область имен “test-namespace”
p.set_namespace(“test-namespace”)
p[“test-namespace”].id = 10
p[“test-namespace”].url = 'http://example2.com'
p[“test-namespace”].content = '<html><body>test 2</body></html>'
p[“test-namespace”].tags = ['html','body']

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

Пространства имен в пакете можно создавать с помощью метода set_namespace(name), удалять del_namespace(name), выводить список namespaces().

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

Часто возникают ситуации, когда процесс при получении одного пакета, должен вернуть несколько. В этом случае, для сохранения данных из пространств имен входного пакета, процесс должен скопировать copy() исходный пакет и изменить в нем “корневые” поля.

Курс "Машинное обучение", впечатления

2011-12-20T07:18:00.001+02:00

На прошлой неделе закончился курс “Машинное обучение”. О нем я уже писал несколько месяцев назад, но напомню, это бесплатный online курс подготовленный профессором стенфордского университета Эндрю Энджи/Andrew Ng и его командой. Кратко темы курса:

- Supervised learning: linear regression, logistic regression, neural networks, SVMs
- Unsupervised learning: K-means, PCA, Anomaly detection
- Special applications/special tools: Recommended systems, large scale machine leanings
- Advice on building a machine learning system: bias/variance, regularization; deciding what to work in next: evaluation of learning algorithms, learning curves, error analysis, ceiling analysis.

Курс состоял их трех секций: лекции, теоретические вопросы, практические упражнения. Лекции можно было слушать/смотреть либо на сайте либо можно было скачать видеоматериалы и изучать их в не зависимости есть у вас доступ в Интернет или нет. В ходе лекции кроме объяснений теоретической части, приводилось много примеров. Это помогало лучше понять принципы и идеи использования различных подходов машинного обучения. Теоретическая часть хорошо сочеталась с вопросами к каждой теме. Буквально с первых занятий ушел некий “страх” ответить неправильно на вопросы или недобрать необходимых 5 баллов. Вопросы/ответы построены именно на то, чтобы в конечном счете лучше понять курс. Тесты можно было проходить по несколько раз. Для всех ответов правильных и неправильных давались краткие пояснения, почему это правильно или почему нет. Часто я проходил тесты по несколько раз именно для того, чтобы проверить правильно я понял материал или нет.

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

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

Курс очень понравился, даже есть некое чувство сожаления, что курс закончился. Но впереди новый год, и в следующем году университет Стендфорда подготовил ряд новых курсов: