Development for fun

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

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 форму.

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

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

Книги по MongoDB

2011-10-31T19:15:00.001+02:00

MongoDB: The Definitive Guide
Kristina Chodorow & Mike Dirolf

Книга раскрывает как MongoDB может помочь в управлении данными при разработке веб-приложений. Раскрываются как базовые принципы так и сложные примеры использования документо-ориентированных баз данных. Объясняется почему MongoDB является масштабируемой, высокопроизводительной и надежной базой данных. Авторитетное введение, написанное двумя инженерами компании 10gen , представляет собой руководство как для разработчиков так и для системных администраторов.

MongoDB in Action
Kyle Banker

MongoDB in Action - это полное руководство по MongoDB для разработчиков приложений. Книга начинается с объяснения, что делает MongoDB уникальным решением и описывает идеальные случаи применения. Обучение построено на основе примеров применения MongoDB для электронной коммерции, социальных сетей, аналитических и других приложений.

Scaling MongoDB
Kristina Chodorow

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

50 Tips and Tricks for MongoDB Developers
Kristina Chodorow

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

The Definitive Guide to MongoDB: The NoSQL Database for Cloud and Desktop Computing
Peter Membry, Eelco Plugge, & Tim Hawkins

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

MongoDB and Python: Patterns and processes for the popular document-oriented database
Niall O'Higgins

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

MongoDB for Web Development
Mitch Pirtle

Митчел Пиртл хорошо известен как автор книги The Definitive Guide to Joomla. Он обладает богатым опытом работы с высоко-нагруженными веб сайтами, он так же был вовлечен в многие стартапы, некоторые из которых достигли заметных успехов. Митчел выступал на конференциях по всему миру с темами от технологий с открытым исходным кодом для предприятий до конвергенции систем управления контентом с социальными медиа и экстремальным методами масштабирования для веб-разработок.

Курс "Машинное обучение"

2011-10-02T12:45:00.000+03:00

Бесплатный курс "Машинное обучение", доступный в онлайн можно пройти по адресу http://openclassroom.stanford.edu/. В курсе расскрываются несколько наиболее широко используемых методов машинного обучения, которые можно реализовать самостоятельно и попробовать их на практике. Также будут показаны практические приемы и методы, позволяющие обучающим алгоритмам работать эффективнее. Акцент делается больше на понимание самих принципов машинного обучения, чем на предоставление математических выкладок. Знание программирования, основ линейной алгебры, теории вероятности приветствуется.

Курс читает Андрю Энджи (Andrew Ng), профессор Стенфордского университета.

P.S. Сейчас отрыта бесплатная регистрации на этот же курс (с расширенными возможностями) на сайте http://www.ml-class.org/

Книга "Flow-Based Programming: A New Approach to Application Development"

2011-09-28T06:22:00.001+03:00

Работая на проектом pyflowctrl всегда хотелось найти книгу, которая могла бы стать своего рода источником знаний для проекта. Книгой, раскрывающей многие аспекты работы, принципы, подходы программирования на уровне процессов и взаимодействия между ними. Похоже такая книга найдена - Flow-Based Programming: A New Approach to Application Development. Автор книги Паул Морримон долгое время работал в IBM, занимался разработкой компиляторов, баз данных, обработки текстовых данных, разработки приложений преимущественно в банковской сфере. В 1978 году была опубликована статья Пола "Data Stream Linkage Mechanism" раскрывающая принципы программирования потоков данных.

Первое и второе издание книги доступно в бумажном виде на Amazon, а также на CreateSpace. В электронном виде первое издание книги доступно на сайте Flow-Based Programming

PyCon Ukraine 2011

2011-09-27T06:44:00.002+03:00

22-23 октября в Киеве пройдет вторая ежегодная конференция PyCon. В этом году планируется провести двухдневную конференцию в два потока — включая доклады, мастер-классы, панельные дискуссии и lighting talks. Кроме того, будет проведена «recruiting session» — у желающих будет возможность больше узнать о украинских компаниях, которые разрабатывают на питоне, об их проектах и побеседовать с их представителями.

Среди докладчиков ожидаются:

Игорь Почечуев, Василий Дижак, Тарас Мурашко, Игорь Давыденко, Андрей Светлов, Павел Коломиец, Александр Соловьев, Роман Ворушин (Киев, Украина)
Александр Бойко (Харьков, Украина)
Александр Лябах (Днепропетровск, Украина)
Михаил Кашкин (Одесса, Украина)
Александр Литовченко (Донецк, Украина)
Юрия Юревич (Омск, Россия)
Армин Ронахер (Armin Ronacher, Австрия)
Ендрю Годвин (Andrew Godwin, Великобритания)
Мартин Шустрик (Martin Sustrik, Словакия)
Анжей Млечко (Andrzej Mleczko, Италия)
Маттео Босколо (Matteo Boscolo, Италия)
Ожидаются подтверждения участия от Тарека Заде (Tarek Ziade) и Luke Kenneth Casson Leighton.

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

Зарегестрироваться можно на сайте http://ua.pycon.org

Заметки про управление потоками данных, часть вторая

2011-09-26T05:32:00.001+03:00

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

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

Процессы А,B и C - это компоненты исполняющие код. O1, O2 и два IN порта используется для соединения (M и N) соответствующих процессов. Процессы В и С могут выполнять один и тот же код, поэтому каждый процесс должен содержать свою независимую область памяти, управляющие блоки. Процессы могут иметь один и тот же код и использовать одни и те же номера портов в рамках самого процесса, т.к. имена портов используются только для соединения компонентов на уровне сети.

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

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

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

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

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

Ссылки:
http://en.wikipedia.org/wiki/Flow-based_programming
Patterns in Flow-Based Programming
Flow-based programming and system design

Заметки "Управление потоками данных"

2011-09-23T06:30:00.001+03:00

Заметки представленные ниже все лишь мой свободный перевод, а правильнее сказать мое понимание концепций первой части статьи на Wikipedia “Flow-based programming”. Перевод далек от оригинала, текст был специально изменен. Задача была не сколько перевести, сколько понять принципы.

Введение

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

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

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

Процессы обмениваются данными на основании предопределенного количества соединений. Именованные порты процессов используются при определении соединений. Имя порту назначается при формировании сети. Порты могут быть простыми, предназначенные для передачи однотипных значений или сложными, предназначенные для обмена структур данных: массивов, словарей. Блоки данных упаковывается в информационные пакеты. Информационный пакет может быть адресован как самому процессу так и быть транзитным, предназначенным другому процессу. Функции сортировки, объединения, агрегации данных, … могут быть представлены в виде “черных” ящиков - комбинации портов с асинхронными процессами.

Более чем один процесс может выполнять один и тот де код.

Асинхронная природа процессов позволяет обрабатывать данные и возвращать результат до тех пор, пока поступают данные на вход процесса. Это позволяет эффективно использовать ресурсы процессора(-ов).

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

Презентация фреймворка PyF в основе которого лежит поточное программирование (к сожалению качество видео оставляет желать лучшего)

Ссылки
Flow-based programming, 2nd edition ebook
http://en.wikipedia.org/wiki/Flow-based_programming
http://en.wikipedia.org/wiki/Dataflow_programming
http://wiki.python.org/moin/FlowBasedProgramming
http://en.wikipedia.org/wiki/Distributed_data_flow

Khan Academy

2011-09-13T06:31:00.000+03:00

В разработке рано или поздно возникает необходимость реализации некоего алгоритма в основе которого могут лежать понимание теории множеств, векторов, графов, манипулирования данных в матрицах или просчет вероятностных характеристик. Хорошо, если принципы работы алгоритма описаны на родном языке. Хуже, когда на другом - могут возникнуть сложности языкового барьера. Для решения этого вопроса можно воспользоваться Khan Academy.

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

Книга "Data-Intensive Text Processing with MapReduce"

2011-08-27T20:36:00.003+03:00

Совершенно случайно наткнулся на сайт Джими Лин, соавтора книги Data-Intensive Text Processing with MapReduce. MapReduce является моделью программирования для распределенной обработки больших массивов данных на кластерах, основанных на обычных компьютерах. Модель представляет легкие для понимания абстракции для разработки масштабируемых алгоритмов, в то время как фреймворк обрабатывает детали на системном уровне от синхронизации до отказоустойчивости. В книге рассматриваются MapReduce алгоритмы на примере обработки текстовых данных, извлечения информации, машинного обучения.

Книга в электронном виде доступна на сайте автора или ее можно заказать в бумажном переплете на сайте Amazon.com Data-Intensive Text Processing with MapReduce (Synthesis Lectures on Human Language Technologies)

Преобразование xml в словарь

2011-08-21T21:21:00.002+03:00

Несколько дней назад мне потребовалось обработать несколько тысяч небольших (от нескольких килобайт до 3 Мб) xml файлов, содержащих различные статистические данные. В чистом виде работать с xml файлами не очень удобно. Гораздо проще, когда сложные структуры такие как данные в xml файлах представлены в виде словаря. Процесс xml2dict предназначен как раз для таких задач.

На вход процесса input подаются данные в виде списка из имени xml файла и его содержимого. На выходе получаем список состоящий из имени файла и словаря, данные которого соответствуют входному xml файлу. Парсинг исходных данных выполняется с помощью входящей в стандартный пакет python библиотеки cElementTree. В связи с тем, что для обработки используется DOM подход, данные XML файла загружаются в память целиком. Нужно быть аккуратным при работе с большими объемами данных.

Пример исходных данных (xml_data):

<?xml version="1.0"?>
<MeasurementData>
  <Setup  startTime="2011-06-24T02:45:00.000-04:00:00" interval="15">
    <Result>
      <Object>
        	<DN><![CDATA[platform1]]></DN>
      </Object>
      <Target measurementType="CPULoad">
        <cpuAverageLoad>65</cpuAverageLoad>
        <cpuPeakLoad>87</cpuPeakLoad>
        <memFree>344985</memFree>
        <memUsed>1456239</memUsed>
        <sysAvailability>54</sysAvailability>
        <sysUptime>569</sysUptime>
      </Target>
    </Result>
  </Setup>
</MeasurementData>

Пример использования процесса xml2dict

import pprint
from processes.xml2dict1 import xml2dict
x2d = xml2dict()
pprint.pprint(x2d.run_once(data=(None, xml_data)))

На выходе процесса получаем следующий словарь

(None,
 {'MeasurementData': {'Setup': {'@interval': '15',
                                '@startTime': '2011-06-24T02:45:00.000-04:00:00',
                                'Result': {'Object': {'DN': {'$': 'platform1'}},
                                           'Target': {'@measurementType': 'CPULoad',
                                                      'cpuAverageLoad': {'$': '65'},
                                                      'cpuPeakLoad': {'$': '87'},
                                                      'memFree': {'$': '344985'},
                                                      'memUsed': {'$': '1456239'},
                                                      'sysAvailability': {'$': '54'},
                                                      'sysUptime': {'$': '569'}}}}}})

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

x2d = xml2dict(remove_xmlns=False)

Процесс xml2dict

P.S. Небольшой юбилей - 100й пост

Новое ядро (core3) для pyflowctrl

2011-08-15T06:30:00.000+03:00

Время показало, что версия ядра core2.py имеет недостатки, ограничивающие выполнение ряда операций над данными. Разберем текущую схему реализации:

Если у процесса есть входной поток, процесс ожидает поступление из него данных. Отсутствие данных на входе приводит к формированию исключения EmptyStream, и следом за ним исключения StopIteration. Согласно специфики реализации ProcessFlow на базе core2, это событие приведет к останову процесса и некорректной работе для случаев, когда предыдущие в цепочке процессы могут не возвращать данные.

Например:

В этом случае, как только на процесс Output не поступят данные, процесс завершит свою работу. Это приведет к ситуации, когда Generator и Filter еще будут работать, а вывод результата будет уже невозможен из-за останова процесса Output.

Необходим новый подход в управлении потоков как данных, так и процессов. Исходная схема для нового ядра core3:

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

При создании процесс имеет статус NOT_STARTED. После первой итерации, если данных во входном потоке нет, он переходит в статус WAITING. При получении данных и и их обработке, статус процесса меняется на PROCESSING. Когда все процессы переходят в состояние WAITING, работа ProcessFlow завершается.

Пример метода main() для процесса на базе нового ядра core3:

def main(self):
    while True:
        try:
            data = self.io['input'].get()
        except EmptyStream:
            yield WAITING
            continue
        
        self.io['output'].put(handle_data(data))
        yield PROCESSING

Часть процессов уже переведена на работу с core3:

Остальные будут переводиться по мере необходимости.

Introduction to Artificial Intelligence

2011-08-05T11:17:00.001+03:00

A free, online version of "Introduction to Artificial Intelligence", taught by Sebastian Thrun and Peter Norvig. A syllabus and more information about the Stanford course is available here.

The class runs from Sept 26 through Dec 16, 2011. While this class is being offered online, it is also taught at Stanford University, where it continues to be a popular intro-level class on AI. For the online version, the instructors aim to offer identical materials, assignments, and exams, and to use the same grading criteria. Both instructors will be available for online discussions.

A high speed internet connection is recommended as most of the course content will be video based. Access to a copy of Artificial Intelligence: A Modern Approach is also suggested.

Course Description
This course is 10 weeks long. The in-class version starts Tue, Sept 27. The online version begins Mon, Oct 2, 2011. The course consists of
Approximately 20 lectures. Each lecture includes quizzes that we ask you to do, but which are not counted towards the final grade of this class. Instead, you can see the right answer to each quizz right after submitting your answers.

Approximately 8 homework assignments. Those are just like our quizzes, and if you do well in the quizzes, you should do well in the assignments. However, we won't show you the correct answer only with a few days delay, to discourage cheating.
One midterm and one final exam. These are like extended quizzes, covering all subject areas of the course discussed so far. The exams will also check your general knowledge about topics covered in the reading materials (the book).

The central objective is to teach basic methods in AI, and to convey enthusiasm for the field. AI has emerged as one of the most impactful disciplines in science and technology. Google, for example, is massively run on AI. Students passing this course should be proficient basic methods of AI, and have a broad overview of the field.q

Course registration

Обработка текста, часть третья

2011-08-05T07:09:00.001+03:00

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

Рассмотрим использование процесса на примере: с выхода процесса Text2Dict был получен словарь с параметрами:

block = ('msg#1',
    { 
        'datetime': '11/08/02 12:54:03',
        'ip address': 'C0A80101',
        'details': 'No access to IP address',
        'info': '...',
    }
)

Предположим, что для дальнейшей работы с этими данными необходимо преобразовать: datetime представить в виде объекта datetime, IP адрес из hex перевести в более привычный вид и сохранить в новом поле ‘ip address (dec)’, поле details нужно оставить без изменений, а поле info удалить.

from pprint import pprint
from datetime import datetime
from processes.textprocessing1 import DictProcessing

def ip_hex2dec(h):
    ''' convert hex ip address to decimal '''
    return '%d.%d.%d.%d' % (int(h[0:2],16), int(h[2:4],16),
                            int(h[4:6],16), int(h[6:8],16))

dict_rules = (
    ('datetime','datetime', lambda d: datetime.strptime(d,'%y/%m/%d %H:%M:%S')),
    ('ip address', 'ip address (dec)', ip_hex2dec),
    ('info', None, None),
)

dp = DictProcessing(rules=dict_rules)
pprint(dp.run_once(block))

В качестве параметра для обработки словаря block в процесс DictProcessing передается список правил по преобразованию полей. Каждое правило состоит из трех полей: исходное имя поля, результирующее имя поля, функция преобразования. Разберем каждое правило более подробно

('datetime','datetime', lambda d: datetime.strptime(d,'%y/%m/%d %H:%M:%S')),

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

('ip address', 'ip address (dec)', ip_hex2dec),

значение IP адреса из поля ‘ip address’ с помощью функции ip_hex2dec() преобразуется к виду X.X.X.X и сохраняется в новом поле ‘ip address (dec)’. Поле ‘ip address’ не удаляется.

('info', None, None),

для удаления info достаточно указать, что результирующее имя поля и функция преобразования определены как None.

Если поле не указывается в правилах преобразования, оно остается без изменений.

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

('text', 'text', remove_spaces),  # удаление лишних пробелов
('text', 'text', conv2uppercase),  # все символы в тексте будут 
                                   # представлены заглавными буквами

Обработка текста, часть вторая

2011-08-03T06:45:00.001+03:00

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

В качестве примера используем текстовый блок (block) содержащий следующую информацию:

POST /xmlrpc.php HTTP/1.1
User-Agent: wp-iphone/1.0
Content-Type: text/xml
Content-Length: 2963
Accept: */*
Accept-Language: en-us
Accept-Encoding: gzip, deflate
Connection: keep-alive
Host: example.com

Для удобства дальнейшей обработки преобразуем этот блок в словарь параметров с помощью Text2Dict

from pprint import pprint
from processes.textprocessing1 import Text2Dict

dict_selectors = {
    'method':           r'(?m)^(\w+) .+? HTTP/\d\.\d$',
    'url':              r'(?m)^\w+ (.+?) HTTP/\d\.\d$',
    'http':             r'(?m)^\w+ .+? (HTTP/\d\.\d)$',
    'user-agent':       r'(?m)^User-Agent: (.+?)$',
    'content-type':     r'(?m)^Content-Type: (.+?)$',
    'content-length':   r'(?m)^Content-Length: (\d+)$',
    'accept':           r'(?m)^Accept: (.+?)$',
    'accept-language':  r'(?m)^Accept-Language: (.+?)$',
    'accept-encoding':  r'(?m)^Accept-Encoding: (.+?)$',
    'connection':       r'(?m)^Connection: (.+?)$',
    'host':             r'(?m)^Host: (.+?)$',
}

t2d = Text2Dict(selectors=dict_selectors)
pprint(t2d.run_once(('block#1',block)))

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

Метод run_once() с указанными параметрами (‘block#1’, block) позволяет передать на вход процесса исходные данные, выполнить одну итерацию и вернуть результат. Без указанных параметров код выглядел бы следующим образом:

t2d.io[‘input’].put((‘block#1’, block))
t2d.run_once()
pprint(t2d.io[‘output’].get())

В результате выполнения скрипта, получаем словарь параметров текстового блока

('block#1',
    {'accept': '*/*',
    'accept-encoding': 'gzip, deflate',
    'accept-language': 'en-us',
    'connection': 'keep-alive',
    'content-length': '2963',
    'content-type': 'text/xml',
    'host': 'example.com',
    'http': 'HTTP/1.1',
    'method': 'POST',
    'url': '/xmlrpc.php',
    'user-agent': 'wp-iphone/1.0'})

Обработка текста, часть первая

2011-07-31T07:52:00.000+03:00

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

Зачастую данные представленные в виде некоторой структуры повторяются для описания различных событий внутри одного текстового файла. В данном случае для извлечения структур данных можно воспользоваться двумя процессами TextSplit и TextSelector из небольшой библиотеки textprocessing для pyflowctrl

TextSplit

позволяет данные поступающие во входной поток разделять на основании некоторого разделителя. В качестве разделителя может выступать как один символ, так и несколько. Регулярные выражения не поддерживаются. Например, в текстовом файле сообщения разделены двойным EOL (end of line) ‘\n\n’

from processes.filereader1 import FileReader
from processes.textprocessing1 import TextSplitter 
from processes.stdoutprinter1 import Printer

flow = ProcessFlow()
id_reader = flow.new(FileReader())
id_tsplit = flow.new(TextSplitter(separator='\n\n'))
id_print = flow.new(Printer())

# FileReader -> TextSplitter 
flow.link({'sid': id_reader, 'son': 'output', 'tid': id_tsplit, 'tin': 'input'})
# TextSplitter -> Printer
flow.link({'sid': id_tsplit, 'son': 'output', 'tid': id_print, 'tin': 'input'})

flow.pmap[id_reader].io['input'].put('/media/data/traces/wireshark/camel.log')
flow.run()

TextSelector

позволяет извлекать из текста данные, на основании регулярных выражений. Может быть удобен в случаях, когда из текстовых данных нужно выбрать определенный блок данных. Можно выполнить разделение однотипных данных, поставив каждому выбранному блоку в соответствие свой поток. Например, есть HTML страница содержащая информацию о погоде. Вместо парсинга всего документа можно выделить только данные, относящиеся к погоде и заключенные в ‘<div class="weather-info">’ и '</div>'

from processes.filereader1 import FileReader
from processes.textprocessing1 import TextSelector
from processes.stdoutprinter1 import Printer

weather_info_selectors = {
    'weather-info': r'<div class="weather-info">(.+?)</div>',
}

flow = ProcessFlow()
id_reader = flow.new(FileReader())
id_tselect = flow.new(TextSelector(selectors=weather_info_selectors))
id_print = flow.new(Printer())

# FileReader -> TextSelector
flow.link({'sid': id_reader, 'son': 'output', 'tid': id_tselect, 'tin': 'input'})
# TextSelector -> Printer
flow.link({'sid': id_tselect, 'son': 'weather-info', 'tid': id_print, 'tin': 'input'})

flow.pmap[id_reader].io['input'].put('/media/data/weather/weather-info.20110731.html')
flow.run()

html2txt: очистка html документа от тегов

2011-07-26T06:17:00.000+03:00

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

#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# html2txt
#
import re

def html2txt(html):
    """Convert the html to raw txt """
    content = html

    p = re.compile('(<p.*?>)|(<tr.*?>)', re.I)
    t = re.compile('<td.*?>', re.I)
    comm = re.compile('<!--.*?-->', re.M)
    tags = re.compile('<.*?>', re.M)
    abbrv = re.compile('&[#\w\d]+;')    
    
    # replace abbreviation by space
    content = abbrv.sub(' ', content) 
    # remove returns time this compare to split filter join
    content = content.replace('\n', '') 
    # replace p and tr by \n
    content = p.sub('\n', content)
    # replace td by \t
    content = t.sub('\t', content) 
    # remove comments
    content = comm.sub('', content) 
    # remove all remaining tags
    content = tags.sub('', content) 
    # remove running spaces this remove the \n and \t
    content = re.sub('\ +', ' ', content) 
    return content

Ссылки
html2text, http://www.aaronsw.com/2002/html2text/

Расчет контрольных сумм файлов

2011-07-23T09:31:00.000+03:00

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

Существует множество исходных данных, которым соответствуют одинаковые хеш-коды. Такие ситуации называются коллизиями. В зависимости от поставленной задачи необходимо внимательно подходить к выбору функций. Процесс FileHash позволяет делать расчет хеш-кодов для файлов используя хеш-функции, включенные в стандартную поставку python: md5, sha1, sha224, sha256, sha384, sha512.

Пример использования процесса FileHash:

from core2 import EmptyStream, ProcessFlow
from processes.treewalker1 import TreeWalker
from processes.filehash1 import FileHash
from processes.stdoutprinter1 import Printer

flow = ProcessFlow()
id_walker = flow.new(TreeWalker())
id_hash = flow.new(FileHash(algorithm='md5'))
id_print = flow.new(Printer())

flow.link({'sid': id_walker, 'son': 'output', 'tid': id_hash, 'tin': 'input'})
flow.link({'sid': id_hash, 'son': 'output', 'tid': id_print, 'tin': 'input'})

flow.pmap[id_walker].io['input'].put('/media/photos/')
flow.run()

Приведенный выше пример очень похож на пример из предыдущего поста “Работа с текстовыми файлами небольшого объема”. С небольшим отличием - вместо FileReader используется процесс FileHash. Выбор алгоритма хеш-функции осуществляется с помощью algorithm, который может принимать значения md5, sha1, sha224, sha256, sha384, sha512. Результатов выполнения данного скрипта будет вывод на консоль пар значений для файлов из исходной директории: путь к файлу и его контрольная сумма.

Полезные ссылки:
Cryptographic hash function, http://en.wikipedia.org/wiki/Cryptographic_hash_function

Работа с текстовыми файлами небольшого объема

2011-07-22T06:41:00.001+03:00

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

В входной поток ‘input’ процесса, FileReader передается путь к файлу. Процесс проверяет существует ли данный файл. В случае успеха, в выходной поток ‘output’ передается список из двух значений: путь к файлу и содержимое самого файла. В случае, если файл не существует информация об этом заносится в поток ошибок ‘error’.

Например необходимо вывести на экран содержимое всех файлов из директории /data/log/:

from core2 import EmptyStream, ProcessFlow
from processes.treewalker1 import TreeWalker
from processes.filereader1 import FileReader
from processes.stdoutprinter1 import Printer

flow = ProcessFlow()
id_tw = flow.new(TreeWalker())
id_fr = flow.new(FileReader())
id_print = flow.new(Printer())

flow.link({'sid': id_tw, 'son': 'output', 'tid': id_fr, 'tin': 'input'})
flow.link({'sid': id_fr, 'son': 'output', 'tid': id_print, 'tin': 'input'})

flow.pmap[id_tw].io['input'].put('/data/logs/')
flow.run()

Создается поток процессов flow = ProcessFlow(), добавляются три процесса:

TreeWalker, для получения списка файлов из директорий
FileReader, для чтения содержимого файлов
Printer, вывод содержимого файлов в стандартный вывод (stdout)

Входные и выходные потоки процессов объединяются между собой с помощью flow.link(). На вход процесса TreeWalker передается исходная директория. flow.run() запускает на выполнение поток процессов.