Итак, опустим настройку и подключение Hibernate, предположим, что вы это уже сделали :). Быть может, напишу об этом позже. Требуется удалить из таблицы player (которая маппится с классом Player, естественно… или наоборот :) ) некоторые записи. Если мы знаем id игрока, тогда всё элементарно (как и в других случаях)):

Теперь рассмотрим случай, когда надо удалить много записей.

В ORM’е Hibernate несколько способов провернуть это. 1й — очевидный, с помощью createQuery выбрать все нужные записи HQL’ом и в цикле удалять по одной:

players_list = session.createQuery("FROM Player WHERE name = :name")\
    .setParameter("name", "Василий")\
    .list()
for player in players_list:
    session.delete(player)

Но это влечёт накладные расходы на получение всех нужных объектов, а затем удаление по одному, в таком случае мы выполним столько sql-запросов, сколько объектов загрузили, что может ухудшить производительность приложения. Для этого есть другой способ. Вот в общем то и он:

Вот таким способом можно избавиться от всех неугодных нам Василиев ;). Так же есть возможность воспользоваться сырым sql с помощью Session.createSQLQuery().

Ссылки:
Документация по Hibernate.

Кстати, мы уже затрагивали мельком тему ORM, но только для python. Можете посмотреть тут про SQLAlchemy.

Далее будет рассмотрен пример написания модуля на php с использованием ORM Doctrine для отправки личных сообщений между пользователей.

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

• id — id сообщения;
• uid_from — id отправившего пользователя;
• uid_to — id получателя;
• title — заголовок сообщения;
• text — текст сообщения;
• flag_unread — флаг нового сообщения;
• flag_del_from — признак удалённого сообщения из исходящих;
• flag_del_to — признак удалённого сообщения из входящих;
• date — дата отправки в формате unix timestamp;

На этом этап проектирования у меня закончился :). Теперь перейдём к технической стороне вопроса.

Качаем тот самый Doctrine (ссылка в конце поста), находим в архиве директорию, где лежит файл Doctrine.php и копируем всё содержимое этого каталога в отдельную папку в нашем проекте (я скопировал в doctrine). Следуя документации, создаём файл bootstrap.php в корне проекта с таким содержанием:

<?php
require_once(dirname(__FILE__) . '/doctrine/Doctrine.php');
spl_autoload_register(array('Doctrine', 'autoload'));
$manager = Doctrine_Manager::getInstance();
$manager->setAttribute(Doctrine::ATTR_MODEL_LOADING, Doctrine::MODEL_LOADING_CONSERVATIVE);
$manager->setAttribute(Doctrine::ATTR_AUTOLOAD_TABLE_CLASSES, true);
$manager->setAttribute(Doctrine::ATTR_EXPORT, Doctrine::EXPORT_ALL);
$manager->setAttribute(Doctrine::ATTR_VALIDATE, Doctrine::VALIDATE_ALL);
$manager->setAttribute(Doctrine::ATTR_QUOTE_IDENTIFIER, true);
$user = 'tst';
$password = 'tst';
$host = 'localhost';
$db = 'tst';
$dsn = "mysql://$user:$password@$host/$db";
$conn = Doctrine_Manager::connection($dsn);
Doctrine::loadModels('models');
?>

Тут настраивается подключение к БД и некоторые параметры («ленивый» способ загрузки моделей, валидация данных и т.п.). Последняя строчка указывает Doctrine где искать наши модели.

Теперь в корне проекта создаём папку models и в ней файл PrivateMessage.php. Учтите, что имя файла и класса, который описан в нём, должны совпадать. Вот как у меня выглядит этот файл:

<?php
class PrivateMessage extends Doctrine_Record
{
    public function setTableDefinition()
    {
        $this->hasColumn('uid_from', 'integer', 8, array(
				'unsigned' => true,
				'notnull' => true
			)
		);
        $this->hasColumn('uid_to', 'integer', 8, array(
				'unsigned' => true,
				'notnull' => true
			)
		);
        $this->hasColumn('title', 'string', 128);
        $this->hasColumn('text', 'string', 255);
        $this->hasColumn('flag_unread', 'boolean', array(
        		'default' => false,
				'notnull' => true
			)
		);
	$this->hasColumn('flag_del_from', 'boolean', array(
				'notnull' => true,
				'default' => false
			)
		);
	$this->hasColumn('flag_del_to', 'boolean', array(
				'notnull' => true,
				'default' => false
			)
		);
        $this->hasColumn('date', 'integer', 8, array(
        		'notnull' => true,
				'default' => time()
			)
		);
    }
}
?>

Тут мы не описали поле id, т.к. Doctrine создаст его автоматически, если не указано других первичных ключей (primary key). Так же в таблице не указаны индексов, что не есть хорошо. Неплохо было бы сделать их для полей uid_from и uid_to хотя бы. Но не сделаем, ибо лень, как-нибудь в другой раз ;-).

Следующим шагом создаём в корне проекта файл test.php, в котором будут описаны основные функции для работы с личными сообщениями и некоторый код для демонстрации функционала. Вот содержимое этого файла:

<?php
require_once('bootstrap.php');
$conn->export->exportClasses(array('PrivateMessage'));
#FIXME: Set current user ID from session.
$curr_uid = 1;
function get_messages($inbox, $uid) {
	/*
	 * If $inbox == true then returns inbox of user $uid,
	 * else returns outbox.
	 */
	if($inbox) {
		$q = 'pm.uid_to = ? AND pm.flag_del_to = ?';
	} else {
		$q = 'pm.uid_from = ? AND pm.flag_del_from = ?';
	}
	return Doctrine_Query::create()
    	->from('PrivateMessage pm')
    	->where($q, array($uid, 0))
    	->fetchArray();
}

function get_message($id, $uid) {
	$q = Doctrine_Query::create()
    	->from('PrivateMessage pm')
    	->where('pm.id = ? AND (pm.uid_from = ? OR pm.uid_to = ?)', array($id, $uid, $uid));
    	$q = $q->fetchArray();
    	if(count($q)) {
    		if($uid == $q[0]['uid_to'] && $q[0]['flag_unread']) {
    			Doctrine_Query::create()
				    ->update('PrivateMessage pm')
    				->set('pm.flag_unread', '?', false)
 			   		->where('pm.id = ?', $q[0]['id'])
 			   		->execute();
    		}
    		return $q[0];
    	} else {
    		return false;
    	}
}

function delete_messages($ids, $uid) {
	/*
	 * $ids - array of ids of messages, that will be deleted.
	 * $uid - current user id.
	 * P.S. Broken English - is the most popular language in the world ;-).
	 */
	foreach($ids as $id) {
		Doctrine_Query::create()
			->update('PrivateMessage pm')
			->set('pm.flag_del_to', '?', true)
 			->where('pm.id = ? AND pm.uid_to = ?', array($id, $uid))
 			->execute();
 		Doctrine_Query::create()
			->update('PrivateMessage pm')
			->set('pm.flag_del_from', '?', true)
 			->where('pm.id = ? AND pm.uid_from = ?', array($id, $uid))
 			->execute();
	}
	Doctrine_Query::create()
		->delete('PrivateMessage pm')
 		->where('pm.flag_del_from = 1 AND pm.flag_del_to = 1')
 		->execute();
}

function send_message($to, $title, $text, $uid) {
	$pm = new PrivateMessage();
	$pm->uid_from = $uid;
	$pm->uid_to = $to;
	$pm->title = $title;
	$pm->text = $text;
	$pm->flag_unread = true;
	// Если хранить в исходящих ненадо,
	// то можно установить следующий флаг в true.
	$pm->flag_del_from = false;
	$pm->flag_del_to = false;
	$pm->save();
}
?>






<?php
echo 'Current user:' . $curr_uid;
// Send message section.
if((int)@$_REQUEST['to'] && !@empty($_REQUEST['title']) && !@empty($_REQUEST['text'])) {
	send_message((int)$_REQUEST['to'], $_REQUEST['title'], $_REQUEST['text'], $curr_uid);
}
// End of send message section.

// Delete messages section.
if(@count($_REQUEST['del_messages'])) {
	echo '
';
	delete_messages($_REQUEST['del_messages'], $curr_uid);
	echo '
';

}

// End of delete messages section.
// Inbox section.

?>
Inbox:


<?php

$m = get_messages(true, $curr_uid);

foreach($m as $message) {

	// Mark as bold unread messages.

	if($message['flag_unread']) {

		$b_open = '';

		$b_close = '';

	} else {

		$b_open = '';

		$b_close = '';

	}

	// End mark.

	echo "

";

}

?>


Del
Message ID
Date
From
Title




$b_open$message[id]$b_close
$b_open" . date('d.m.y H:i', $message['date']) . "$b_close
$b_open$message[uid_from]$b_close
$b_open$message[title]$b_close







&lt?php

// End of inbox section.
// Outbox section.

?>
Outbox:

<?php

$m = get_messages(false, $curr_uid);

foreach($m as $message) {

	// Mark as bold unread messages.

	if($message['flag_unread']) {

		$b_open = '';

		$b_close = '';

	} else {

		$b_open = '';

		$b_close = '';

	}

	// End mark.

	echo "

";

}

?>


Del
Message ID
Date
To
Title




$b_open$message[id]$b_close
$b_open" . date('d.m.y H:i', $message['date']) . "$b_close
$b_open$message[uid_to]$b_close
$b_open$message[title]$b_close








?>

// End of outbox section.
// View message section.

if((int)@$_REQUEST['message_id']) {

	$m = get_message($_REQUEST['message_id'], $curr_uid);

	if($m !== false) {

		echo "

View message #$m[id]:";

		echo '

';

		echo "


From:
$m[uid_from]


To:
$m[uid_to]


Title:
$m[title]


Message:
$m[text]


";

	}

}

// End of view message section.
// Send message section.

echo "
New message:




From:
$curr_uid


To:




Title:




Message:







";

// End of send message section.

?>

$conn->export->exportClasses(array(‘PrivateMessage’)) — это строка создаст таблицу private_messaages, если таковой ещё нет. Так что можно её перенести в установочный скрипт, но поскольку у нас нет такого, то мы её оставим.
$curr_uid — эта переменная по идее должна браться из сессии. Как она должна называться в сессии я не знал, поэтому присвоил ей значение в коде 1.
get_messages($inbox, $uid) — возвращает все входящие сообщения пользователя $uid, если $inbox равна true, иначе — исходящие. Неплохо было бы добавить лимит на выборку записей (например, с 1й по 20ю, с 21й по 40ю), но поскольку этот модуль нигде применять не планирую, то и доделывать его нет желания. Если кому то надо — пишите в комменты ;-).
get_message($id, $uid) — возвращает сообщение $id, $uid передаётся во все функции для проверки принадлежности сообщений текущему пользователю. Ещё раз повторю, идентификатор ползьователя должен браться из сессии.
delete_messages($ids, $uid) — $ids — массив id’шников сообщений, которые надо удалить. Реально удаляются записи из БД только те, у которых flag_del_from и flag_del_to равны 0.
send_message($to, $title, $text, $uid) — $to — id получателя, $uid — отправителя, остально думаю понятно.
Дальше по коду идёт часть с html-выводом и обработкой переданных парамтеров, так что ничего интересного. Код по моему везде достаточно просто, так что подробно объяснять не стал. Если вопросы остались — в комменты.

P.S. Это моя первая попытка сделать что-либо с использованием Doctrine :).
Ссылки к статье:
http://ru.wikipedia.org/wiki/ORM — ORM;
http://www.doctrine-project.org/ — официальный сайт проекта Doctrine.

Для лучшего понимания советую прочитать этот пост.

Решим ту же самую задачу, что и в предыдущем посте, но несколько изменив условия. Итак, вот:

1. Главный поток запрашивает у пользователя md5-сумму какого-либо файла и директорию для поиска файла с такой же суммой. Получив эти параметры первый поток запускает 2й и продолжает свою работу (опять ожидает данных от пользователя).
2. Запущенный поток проверяет есть ли в БД приложения файл с таким хешом. Если есть — выводит результат, иначе, передаёт задания для 3го потока (путь) и по его завершении (задания, не потока ;-) ) заново проверяет БД. Выводит результат.
3. 3й поток хеширует все файлы с помощью md5 по указанному пути и результат записывает в базу данных.

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

Модуль для работы с базой данных не изменился (files.py), поменялся только task.py.

Вот логика работы приложения вкратце:

1. В конструкторе класса объявляем: очередь заданий taskQueue, замок globalTaskEventLock, событие globalTaskEvent — событие, которое будет оповещать потоки о том, что хеширование какой-либо папки закончено, массив localTaskEvent — в нём будут хранится события, которые отвечают за полное выполнение задания какого-то конкретного «ищущего» потока, и counter — счётчик «ищущих» потоков (за всё время работы приложения).

2. Метод runMainTask(s_hash, s_folder) — в параметрах передаётся искомый хеш и директория, в которой следует искать (при поиске в БД не учитывается). Запускает исполнение метода searchFile в отдельном потоке и увеличивает счётчик «ищущих» потоков на 1.

3. searchFile(s_hash, s_folder) - аргументы те же, что и у метода runMainTask. Проверяет наличие в базе данных искомого хеша. Если совпадения найдены — выводит их в консоль и завершает работу, иначе добавляет указанную директорию и имя потока, в котором выполняется (сам метод) в очередь заданий, так же добавляет в массив localTaskEvents пару thName => event, где thName — имя потока, а event — событие, наступление которого означает полное выполнения задания (вся папка прохеширована). Затем ждёт второго пришествия в бесконечном цикле события globalTaskEvents (оповещает о том, что хеши для всех файлов в какой-то папке посчитаны и добавлены в БД). При наступлении события проверяет БД, если совпадения найдены — выводит результат, удаляет своё событие из массива localTaskEvents и завершается, если нет — проверяет было ли вычислено его задание, если да — выводит, что ничего не нашёл, опять удаляет свои данные из localTaskEvent и завершается.

3. runHashTask() — исполняет код в бесконечном цикле. Получает имя потока и папку из очереди заданий. Проверяет в массиве localTaskEvents наличие события для имени потока, которое он получил. Если его нет — то поток уже завершился и удалил своё событие, тогда пытаемся получить следующее задание. Иначе — рекурсивно проходим по всем подпапкам и хешируем все файлы. После того, как в какой-то подпапке файлы прохешированы — результат добавляется в БД и с помощью globalTaskEvent оповещаются об этом все потоки. Когда задание завершено — пытаемся оповестить поток, чьё задание это было. При переходе к каждой новой подпапке проверяем надо ли считать ещё это задание или лучше перейти к следующему.

Вот, в общем то всё, таков мой план ;-).

Листинг нового класса:

#!/usr/local/bin/ python
# -*- coding: utf-8 -*-

import threading
import md5
import sqlalchemy
import os, sys
import files
import Queue

class MainTask():
    def __init__(self):
        self.taskQueue = Queue.Queue() # очередь заданий для вычисляющего потока
        self.globalTaskEventLock = threading.Lock()
        self.globalTaskEvent = threading.Event() # оповещение о конце вычислений какого-то задания
        self.localTaskEvents = {} # оповещение о конце вычислений задания какого-то конкретного потока
        self.computingThread = threading.Thread(target=self.runHashTask, name="ComputerThread") # создаём "вычисляющий поток"
        self.computingThread.start()
        self.counter = 0

    def runMainTask(self, s_hash, s_folder):
        c = str(self.counter)
        th1 = threading.Thread(target=self.searchFile, name="SearherThread #"+c, args=[s_hash,s_folder]) # создаём "ищущий" поток
        print "[MainThread]: *** starting SearcherThread #%s ***" % c
        th1.start()
        self.counter += 1
        return True

    def searchFile(self, s_hash, s_folder):
        thName = threading.currentThread().getName()
        q = self.searchInDB(s_hash)
        if q.count() > 0:
            print "[%s]: Found %d files in database:" % (thName, q.count())
            for f in q:
                print "[%s]: %s" % (thName, f.path)
            print "[%s]: *** thread finished ***" % thName
            return True
        print "[%s]: Files in database not found, start searching..." % thName

        self.localTaskEvents[thName] = threading.Event()
        self.taskQueue.put((thName, s_folder))

        while True:
            self.globalTaskEvent.wait()
            print "[%s]: Checking database..." % thName
            q = self.searchInDB(s_hash)
            if q.count() > 0:
                print "[%s]: Total found %d files:" % (thName, q.count())
                for f in q:
                    print "[%s]: %s" % (thName, f.path)
                self.localTaskEvents.pop(thName) # удаляем события для этого потока
                print "[%s]: *** thread finished ***" % thName
                return True
            elif self.localTaskEvents[thName].isSet():
                self.localTaskEvents.pop(thName)
                print "[%s]: Total found 0 files." % thName
                return True
            # сделано чтобы после одного события не цикл не проходил несколько раз
            self.globalTaskEventLock.acquire()
            self.globalTaskEventLock.release()

    def searchInDB(self, s_hash):
        s = files.Session()
        return s.query(files.Hash).filter(files.Hash.file_hash==s_hash)

    def runHashTask(self):
        computerThreadName = threading.currentThread().getName()
        while True:
            thName, s_folder = self.taskQueue.get()

            # проверяем надо ли ещё считать это задание
            if self.localTaskEvents.has_key(thName):
                print "[%s]: Computing %s's thread task..." % (computerThreadName, thName)

                s = files.Session()
                for root, dirs, fnames in os.walk(s_folder):
                    # опять проверяем актуальность задания
                    if not self.localTaskEvents.has_key(thName):
                        break

                    counter = 0
                    hashes = {}

                    for name in fnames:
                        q = s.query(files.Hash).filter(files.Hash.path==unicode(os.path.join(root, name), "koi8-r"))
                        if q.count() == 0:
                            h = ''
                            try:
                                f = open(os.path.join(root, name), "rb")
                            except:
                                print "[%s]: Error: Can't open file %s." % (computerThreadName, os.path.join(root, name))
                            else:
                                h = md5.new(f.read()).hexdigest()
                                hashes[unicode(os.path.join(root, name), "koi8-r")] = h
                                counter += 1
                            try:
                                f.close()
                            except:
                                pass
                    print "[%s]: Hashing %s finished..." % (computerThreadName, root)
                    if counter != 0:
                        files.add_hashes(hashes)
                        self.globalTaskEventLock.acquire()
                        self.globalTaskEvent.set()
                        self.globalTaskEvent = threading.Event() # создаём новый экземпляр события
                        self.globalTaskEventLock.release()

                # try - на случай, если поток уже завершился, удалив задание и событие
                try:
                    self.localTaskEvents[thName].set()
                except:
                    pass
                # добавлено на случай, если мы ищем в папке,
                # все файлы которой уже есть в БД,
                # иначе globalEvent не наступит ни разу
                self.globalTaskEventLock.acquire()
                self.globalTaskEvent.set()
                self.globalTaskEvent = threading.Event()
                self.globalTaskEventLock.release()

if __name__ == "__main__":
    mt = MainTask()

    # для теста ищем всё в одной папке - 3 файла + 1 несуществующий
    hashes = ("5f4dad3fbd8c6761f8ca218bd6d8e467", "500ead228d2ec9af9986a9f10ad13e84", "e1d0bced5b03d00b3d09710705eef3b5", "invalid hash", "2d3153b321a7ce6c2cd56af3231d79a4")
    folder = "/usr/home/lizzard/music/music/Roll"

    for h in hashes:
        mt.runMainTask(h, folder)

    # завершаем программу
    while threading.activeCount() > 2:
        pass
    print "[MainThread]: *** all computes finished ***"
    sys.exit(0)

Стоит отметить, что при преобразовании строк в юникод с помощью функции unicode стоит указать кодировку, специфичкескую для Вашей ОС (для windows — cp1251, freebsd — koi8-r).

Вот результат выполнения кода:

Конечно, при желании можно улучшить алгоритм, но как пример для изучения потоков в python’е, имхо, сойдёт ;-).

Исходники к статье в архиве — тут.

Ссылки к статье:
http://docs.python.org/library/threading.html — официальная документация python по модулю threading (англ.).

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

Для наглядности реализуем всё сначала без потоков. Создадим класс MainTask со следующими методами:

• runMainTask(self, sHash, sFolder)
• searchFile(self, s_hash, s_folder)
• runHashTask(self, s_folder, s_hash)

runMainTask — в общем то почти ничего не делает ;-). Запускает метод searchFile с соответствующими параметрами.

searchFile — проверяет БД на наличие искомого хеша, если записи нашлись — выводит их и завершается. Если записи не найдены — вызывает метод runHashTask, затем опять проверяет БД.

runHashTask — рекурсивно (т.е. включая подкаталоги) обходит переданный через параметры путь и хеширует файлы. Если во время обхода встречается искомый хеш — добавляет результат вычислений (все вычисленные хеши для файлов) в БД и завершается. Если хеш не был найден — делает то же самое (обновляет БД и завершает работу) ;-).

Для хранения результатов вычисления была выбрана база данных, чтобы не использовать какой-либо сервер был выбран SQLite (СУБД работает без сервера на основе файлов).

Для нашего приложения нужна всего одна табличка с двумя полями — «path» и «file_hash». Саму таблицу назовём «hashes». Поле «path» будет содержать полный путь к файлу включая его имя, а «file_hash» — хеш этого файла (неожиданный поворот событий? ;-) ).

Так же сразу я решил описать функцию add_hashes. Получает в качестве параметра словарь вида ["file0":"hash0", "file1":"hash1", ...] и пытается добавить его в БД.

Смотрим, что у нас получилось. Модуль для работы с базой данных (files.py):

import sqlalchemy as sa
from sqlalchemy.orm import mapper, sessionmaker

engine = sa.create_engine("sqlite:///hashes.db", echo=False)
metadata = sa.MetaData()

hashes_table = sa.Table("hashes", metadata,
                        sa.Column("path", sa.Text(convert_unicode=True), nullable=False, primary_key=True),
                        sa.Column("file_hash", sa.String(32, convert_unicode=True), nullable=False),
                       )

metadata.create_all(engine)

class Hash(object):
    def __init__(self, path='', file_hash=''):
        self.path      = path
        self.file_hash = file_hash
    def __repr__(self):
        return "" % (self.path, self.file_hash)

def add_hashes(files):
    session = Session()
    counter = 0
    try:
        for f in files:
            session.save_or_update(Hash(f, files[f]))
            counter += 1
        session.commit()
    except:
        print "Error. Can't add hashes into database."
    finally:
        return counter

mapper(Hash, hashes_table)
Session = sessionmaker(bind = engine)

Основной модуль (task_1.py):

import md5
import os, sys
import files

class MainTask():
    def __init__(self):
        self.sHash = ""
        self.sFolder = ""

    def runMainTask(self, sHash, sFolder):
        self.sHash = sHash
        self.sFolder = sFolder
        self.searchFile(self.sHash, self.sFolder)

    def searchFile(self, s_hash, s_folder):
        s = files.Session()
        q = s.query(files.Hash).filter(files.Hash.file_hash==s_hash)
        if q.count() > 0:
            print "Found files in database:"
            for f in q:
                print f.path
            return True
        else:
            print "Files in database not found, searching..."
            self.runHashTask(s_folder, s_hash)
        q = s.query(files.Hash).filter(files.Hash.file_hash==s_hash)
        if q.count() > 0:
            print "Total found %d files:" % q.count()
            for f in q:
                print f.path
        else:
            print "File with hash %s not found." % s_hash
        return True

    def runHashTask(self, s_folder, s_hash):
        hashes = {}
        s = files.Session()
        for root, dirs, fnames in os.walk(s_folder):
            for name in fnames:
                q = s.query(files.Hash).filter(files.Hash.path==os.path.join(root, name))
                if q.count() == 0:
                    h = ''
                    try:
                        f = open(os.path.join(root, name), "rb")
                    except:
                        print "Error: Can't open file %s." % os.path.join(root, name)
                    else:
                        h = md5.new(f.read()).hexdigest()
                        hashes[os.path.join(root, name)] = h
                    try:
                        f.close()
                    except:
                        pass
                    if h == s_hash:
                        files.add_hashes(hashes)
                        return True
        files.add_hashes(hashes)
        return True

if __name__ == "__main__":
    mt = MainTask()
    while True:
        shash   = unicode(raw_input("Enter file hash: "), "cp1251")
        sfolder = unicode(raw_input("Enter folder to search: "), "cp1251")
        if shash == "":
            raw_input("Press Enter to exit...")
            sys.exit(0)
        mt.runMainTask(shash, sfolder)

Теперь попробуем сделать всё то же самое, но используя потоки. Модуль для работы с БД менять не надо, все изменения коснутся только основного модуля.

runMainTask теперь должен вызывать исполнение метода searchFile в отдельном потоке (так же, как и searchFile должен вызывать runHashTask). Перед вызовом третьего потока мы используем блокировку (threading.Lock()), что не позволяет одновременно нескольким вторым потокам запустить третий.

Способ использования блокировок:

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

Порождение дочернего потока происходит с помощью класса Thread в модуле threading.

Описание использованных параметров класса Thread:

• target — указывает на имя функции (в данном случае метод класса), которую стоит выполнять в новом потоке
• name — имя порождаемого потока
• args — список аргументов, которые мы передаём в функцию, указанную в параметре target

Поток создаётся так:

Запускается на исполнение поток путём выозова метода start:

Метод join() ожидает завершения потока.

Ну, вроде бы теперь должно быть всё понятно. Посмотрим, что у нас должно получить в итоге:

# -*- coding: cp1251 -*-
import threading
import md5
import sqlalchemy
import os, sys
import files

class MainTask():
    def __init__(self):
        self.sHash = ""
        self.sFolder = ""
        self.__th2Lock = threading.Lock()

    def runMainTask(self, sHash, sFolder, c=0):
        c = str(c)
        self.sHash = sHash
        self.sFolder = sFolder
        #raw_input("1")
        th1 = threading.Thread(target=self.searchFile, name="th1_"+c, args=[self.sHash,self.sFolder,"th1_"+c])
        #raw_input("1")
        print "[MainThred]: *** starting th1_%s ***" % c
        th1.start()

    def searchFile(self, s_hash, s_folder, thName):
        s = files.Session()
        q = s.query(files.Hash).filter(files.Hash.file_hash==s_hash)
        if q.count() > 0:
            print "[%s]: Found %d files in database:" % (thName, q.count())
            for f in q:
                print "[%s]: %s" % (thName, f.path)
            print "[%s]: *** thread finished ***" % thName
            return True
        print "[%s]: Files in database not found, searching..." % thName
        ### START LOCK
        self.__th2Lock.acquire()
        th2 = threading.Thread(target=self.runHashTask, name="th2", args=[s_folder,s_hash])
        print "[%s]: *** starting th2 ***" % thName
        th2.start()
        th2.join()
        print "[%s]: *** th2 finished ***" % thName
        self.__th2Lock.release()
        ### END LOCK
        q = s.query(files.Hash).filter(files.Hash.file_hash==s_hash)
        if q.count() > 0:
            print "[%s]: Total found %d files:" % (thName, q.count())
            for f in q:
                print f.path
        else:
            print "[%s]: File with hash %s not found."  % (thName, s_hash)
        print "[%s]: *** thread finished ***" % thName
        return True

    def runHashTask(self, s_folder, s_hash):
        hashes = {}
        s = files.Session()
        for root, dirs, fnames in os.walk(s_folder):
            for name in fnames:
                q = s.query(files.Hash).filter(files.Hash.path==os.path.join(root, name))
                if q.count() == 0:
                    h = ''
                    try:
                        f = open(os.path.join(root, name), "rb")
                    except:
                        print "[th2]: Error: Can't open file %s." % os.path.join(root, name)
                    else:
                        h = md5.new(f.read()).hexdigest()
                        hashes[os.path.join(root, name)] = h
                    try:
                        f.close()
                    except:
                        pass
                    if h == s_hash:
                        files.add_hashes(hashes)
                        return True
        files.add_hashes(hashes)
        return True

if __name__ == "__main__":
    mt = MainTask()
    counter = 0
    while True:
        shash   = unicode(raw_input("[MainThread]: Enter file hash: "), "cp1251")
        sfolder = raw_input("[MainThread]: Enter folder to search: ")
        if shash == '':
            raw_input("[MainThread]: Press Enter to exit...")
            sys.exit(0)
        if sfolder == '':
            sfolder = '.'
        sfolder = unicode(os.path.abspath(sfolder), "cp1251")
        mt.runMainTask(shash, sfolder, str(counter))
        counter += 1

Вывод потоков может быть перемешан, но это сделано для наглядности.

Стоит так же отметить, что преобразование пути в кодировку utf8 вызвано проблемами с SQLAlchemy, как то он странно обрабатывает кодировку cp1251.

Если кто-то не знает как получить md5-хеш файла, вот пример:

import md5

f = open("path_to_file", "rb")
hash = md5.new(f.read()).hexdigest()
f.close()
print hash

Архив с исходниками тут. В архиве в корне — программа с использованием потоков, в папке line — без.

Ссылки к статье:
http://www.intuit.ru/department/pl/python/class/free/11/ — «Многопоточные вычисления».
http://keysolutions.ru/articles/osnovy-raboty-s-potokami-v-python — Сергей Шилов — «Основы работы с потоками в Python».

Итак, смотрим описание протокола. Для начала нам надо подключится к mrim.mail.ru на порт 2042 или 443 и адрес сервера агента и порт в обычном текстовом формате «ip:port». Затем надо отправить пакет MRIM_CS_HELLO. Как сказано в описании, заголовок пакета имеет следующий формат:

u_long	magic;
u_long	proto;
u_long	seq;
u_long	msg;
u_long	dlen;
u_long	from;
u_long	fromport;
u_char	reserved[16];

Размер u_long’а — 4 байта. Первое значение magic соответствует числу 0xDEADBEEF — своеобразный юмор разработчиков, если смотреть на это значение как на строку, то перевод будет что-то вроде «мёртвая говядина». Однако разработчики mail.ru пошли дальше, что бы нас ещё больше рассмешить они решили отправлять все числовые значения задом наперёд, т.е. нам надо записать в заголовок не 0xDEADBEEF, а 0xEFBEADDE (пишем последний байт — EF, предпоследний — BE и т.д.). Строковый переменные отправляются в нормальном порядке. Всё это можно узнать запустив какой-нибудь снифер и посмотрев, что шлёт официальный агент.
В итоге, что мы должны послать на сервер:

magic = 0xEFBEADDE (соответствует 0xDEADBEEF)
proto = 0x07000100 (первые два байта - старшая версия протокола, вторые - младшая, 0x00010007)
seq = 0x01000000 (соответствует 0x000001)
msg = 0x01100000 (MRIM_CS_HELLO - 0x00001001)
dlen = 0x00000000 (длинна данных)
from = 0x00000000 (ip адрес клиента, указывать не обязательно)
fromport = 0x000000 (порт клиента, указывать не обязательно)
reserved[16] = 0x00000000000000000000000000000000 (зарезервировано)

В ответ мы должны получить пакет с тем же номером последовательности (seq) и типом (msg) MRIM_CS_HELLO_ACK.

Оформим всё это в виде кода. Создаём файл packets.py в котором будут храниться определённые протоколом константы и класс packet с методами:

• setHost(host, port) для установки адреса и порта с которого происходит подключение к серверу (этот метод не очень то нужен);
• getPacket(msg) — устанавливает тип пакета равный MSG, увеличивает текущий номер последовательности на 1 и возвращает готовый пакет для отправки в текстовом формате;
• setPacket(p) — метод устанавливает из полученного пакета все свойства в классе, если в p содержится поле данных, то оно записывается в свойство data;
• addRawData(data) добавляет к свойству data переданный параметр data и обновляет значение длины данных;
• addLPSData(data) — добавляет к свойству data длину прикрепляемых данных (в обратном порядке, как и все числовые значения в протоколе) и сами данные;
• addULData(data) — прикрепляет «цифровые» данные к пакету в обратном порядке;
• clear() — сбрасывает свойства data, dlen, msg;
• __d2s(d) — переводит число d в строку для передачи через сокеты на сервер;
• __s2d(s) — обратный метода для __d2s(d);

Вот как всё это безобразие выглядит:

""" MRIM constants """
PROTO_VERSION_MAJOR             = 1
PROTO_VERSION_MINOR             = 12 #7
PROTO_VERSION                   = (PROTO_VERSION_MAJOR << 16) | PROTO_VERSION_MINOR
CS_MAGIC                        = 0xDEADBEEF

MRIM_CS_HELLO                   = 0x1001  # C -> S
MRIM_CS_HELLO_ACK               = 0x1002  # S -> C
MRIM_CS_LOGIN_ACK               = 0x1004  # S -> C
MRIM_CS_LOGIN_REJ               = 0x1005  # S -> C
MRIM_CS_PING                    = 0x1006  # C -> S
MRIM_CS_MESSAGE                 = 0x1008  # C -> S
MESSAGE_FLAG_OFFLINE            = 0x00000001
MESSAGE_FLAG_NORECV             = 0x00000004
MESSAGE_FLAG_AUTHORIZE          = 0x00000008  # X-MRIM-Flags: 00000008
MESSAGE_FLAG_SYSTEM             = 0x00000040
MESSAGE_FLAG_RTF                = 0x00000080
MESSAGE_FLAG_CONTACT            = 0x00000200
MESSAGE_FLAG_NOTIFY             = 0x00000400
MESSAGE_FLAG_MULTICAST          = 0x00001000
MAX_MULTICAST_RECIPIENTS        = 50
MESSAGE_USERFLAGS_MASK          = 0x000036A8  # Flags that user is allowed to set himself
MRIM_CS_MESSAGE_ACK             = 0x1009  # S -> C
MRIM_CS_MESSAGE_RECV            = 0x1011  # C -> S
MRIM_CS_MESSAGE_STATUS          = 0x1012  # S -> C
MESSAGE_DELIVERED               = 0x0000  # Message delivered directly to user
MESSAGE_REJECTED_NOUSER         = 0x8001  # Message rejected - no such user
MESSAGE_REJECTED_INTERR         = 0x8003  # Internal server error
MESSAGE_REJECTED_LIMIT_EXCEEDED = 0x8004  # Offline messages limit exceeded
MESSAGE_REJECTED_TOO_LARGE      = 0x8005  # Message is too large
MESSAGE_REJECTED_DENY_OFFMSG    = 0x8006  # User does not accept offline messages
MRIM_CS_USER_STATUS             = 0x100F  # S -> C
STATUS_OFFLINE                  = 0x00000000
STATUS_ONLINE                   = 0x00000001
STATUS_AWAY                     = 0x00000002
STATUS_UNDETERMINATED           = 0x00000003
STATUS_FLAG_INVISIBLE           = 0x80000000
MRIM_CS_LOGOUT                  = 0x1013  # S -> C
LOGOUT_NO_RELOGIN_FLAG          = 0x0010  # Logout due to double login
MRIM_CS_CONNECTION_PARAMS       = 0x1014  # S -> C
MRIM_CS_USER_INFO               = 0x1015  # S -> C
MRIM_CS_ADD_CONTACT             = 0x1019  # C -> S
CONTACT_FLAG_REMOVED            = 0x00000001
CONTACT_FLAG_GROUP              = 0x00000002
CONTACT_FLAG_INVISIBLE          = 0x00000004
CONTACT_FLAG_VISIBLE            = 0x00000008
CONTACT_FLAG_IGNORE             = 0x00000010
CONTACT_FLAG_SHADOW             = 0x00000020
MRIM_CS_ADD_CONTACT_ACK         = 0x101A  # S -> C
CONTACT_OPER_SUCCESS            = 0x0000
CONTACT_OPER_ERROR              = 0x0001
CONTACT_OPER_INTERR             = 0x0002
CONTACT_OPER_NO_SUCH_USER       = 0x0003
CONTACT_OPER_INVALID_INFO       = 0x0004
CONTACT_OPER_USER_EXISTS        = 0x0005
CONTACT_OPER_GROUP_LIMIT        = 0x6
MRIM_CS_MODIFY_CONTACT          = 0x101B  # C -> S
MRIM_CS_MODIFY_CONTACT_ACK      = 0x101C  # S -> C
MRIM_CS_OFFLINE_MESSAGE_ACK     = 0x101D  # S -> C
MRIM_CS_DELETE_OFFLINE_MESSAGE  = 0x101E  # C -> S
MRIM_CS_AUTHORIZE               = 0x1020  # C -> S
MRIM_CS_AUTHORIZE_ACK           = 0x1021  # S -> C
MRIM_CS_CHANGE_STATUS           = 0x1022  # C -> S
MRIM_CS_GET_MPOP_SESSION        = 0x1024  # C -> S
MRIM_CS_MPOP_SESSION            = 0x1025  # S -> C
MRIM_GET_SESSION_FAIL           = 0
MRIM_GET_SESSION_SUCCESS        = 1
MRIM_CS_WP_REQUEST              = 0x1029  # C->S
PARAMS_NUMBER_LIMIT             = 50
PARAM_VALUE_LENGTH_LIMIT        = 64
MRIM_CS_ANKETA_INFO                = 0x1028  # S->C
MRIM_ANKETA_INFO_STATUS_OK         = 1
MRIM_ANKETA_INFO_STATUS_NOUSER     = 0
MRIM_ANKETA_INFO_STATUS_DBERR      = 2
MRIM_ANKETA_INFO_STATUS_RATELIMERR = 3
MRIM_CS_MAILBOX_STATUS             = 0x1033
MRIM_CS_CONTACT_LIST2              = 0x1037  # S->C
GET_CONTACTS_OK                    = 0x0000
GET_CONTACTS_ERROR                 = 0x0001
GET_CONTACTS_INTERR                = 0x0002
CONTACT_INTFLAG_NOT_AUTHORIZED     = 0x0001
MRIM_CS_LOGIN2                     = 0x1038  # C -> S
MAX_CLIENT_DESCRIPTION             = 256

class packet:
  """ MRIM handler """
  magic     = CS_MAGIC
  proto     = PROTO_VERSION
  seq       = 0x00000000
  msg       = 0x00000000
  dlen      = 0x00000000
  from_addr = 0x00000000
  from_port = 0x00000000
  reserved  = 0x00000000
  data      = ""
  size      = 44

  def __init__(self):
    self.reserved  = self.__d2s(0x00000000, 16)  # 16 байт

  def setHost(self, host, port):
    self.from_host, self.from_port = host, port
    return True

  def getPacket(self, msg):
    self.seq += 1
    self.msg  = msg
    self.dlen = len(self.data)
    return self.__d2s(self.magic, 4) + self.__d2s(self.proto, 4) + \
      self.__d2s(self.seq, 4) + self.__d2s(self.msg, 4) + \
      self.__d2s(self.dlen, 4) + self.__d2s(self.from_addr, 4) + \
      self.__d2s(self.from_port, 4) + self.reserved + self.data

  def setPacket(self, p):
    if len(p) < 44:
      return False
    self.t = p
    self.magic     = self.__s2d(p[   :  4])
    self.proto     = self.__s2d(p[4  :  8])
    self.seq       = self.__s2d(p[8  : 12])
    self.msg       = self.__s2d(p[12 : 16])
    self.dlen      = self.__s2d(p[16 : 20])
    self.from_addr = self.__s2d(p[20 : 24])
    self.from_port = self.__s2d(p[24 : 28])
    self.reserved  = self.__s2d(p[28 : 44])
    if len(p[44 : ]):
      self.data    = self.__s2d(p[44 : ])
    else:
      self.data    = ""
    return True

  def addRawData(self, data):
    self.data += data
    self.dlen = len(self.data)
    return True

  def addLPSData(self, data):
    dlen = len(data)
    self.data += self.__d2s(dlen, 4)
    self.data += data
    self.dlen = len(self.data)
    return True

  def addULData(self, data):
    self.data += self.__d2s(data, 4)
    return True

  def clear(self):
    self.data = ""
    self.dlen = ""
    self.msg = ""

  def __d2s(self, d, size = 4):
    d = hex(d)[2 : ]
    if d[-1] == "L":
      d = d[ : -1]
    ln = len(d)
    if ln % 2:
      ln += 1
      d = "0" + d
    i = 0
    r = ""
    while i < ln:
      r = chr(int(d[i : i + 2], 16)) + r
      i += 2
    while len(r) < size:
      r += chr(0x00)
    return r

  def __s2d(self, s):
    r = ""
    i = len(s)
    while i:
      t = hex(ord(s[i - 1: i]))[2 : ]
      if len(t) < 2: t = "0" + t
      r += t
      i -= 1
    return int(r, 16)

Теперь создадим файл emails.py в котором у нас будут храниться функции, связанные с обработкой аккаунтов. Для хранения информации об аккаунтах я выбрал sqlite. На это меня побудило 2 причины: 1 — это удобно :), 2 — мне надо было разобраться особенностями работы с СУБД из-под python (в частности, надо было разобраться с sqlalchemy).

В emails.py у нас содержится описание таблицы с нашими аккаунтами, в которой будут следующие поля:

• login — собственно, сам email;
• password — пароль от него;
• limit — по умолчанию равен 50 — количество sms, которое можно отправить в сутки с аккаунта (mail.ru не позволяет больше);
• last_sms — время отправки последней sms, mail.ru запрещает слать sms чаще, чем раз в минуту;

А так же следующие функции:

• add_emails(emails, session) — открывает файл с мыльниками и паролями (разделены пробелами) и добавляет их в нашу базу, если таких аккаунтов там ещё нет, возвращает число добавленных аккаунтов;
• update_limits(session) — устанавливает лимит sms равный 50 у тех аккаунтов, у которых со времени последней отправки sms прошло больше суток;

Код у меня выглядит так:

import sqlalchemy as sa
from sqlalchemy.orm import mapper, sessionmaker
import time

engine = sa.create_engine("sqlite:///database.db", echo=False)
metadata = sa.MetaData()

emails_table = sa.Table("emails", metadata,
                        sa.Column("email", sa.String(convert_unicode=False), primary_key=True),
                        sa.Column("password", sa.String(convert_unicode=False), nullable=False),
                        sa.Column("limit", sa.Integer, nullable=False, default=50),
                        sa.Column("last_sms", sa.Integer, nullable=False, default=0)
                       )

metadata.create_all(engine)

class Email(object):
  def __init__(self, email, password, limit = 50, last_sms = 0):
    self.email      = email
    self.password   = password
    self.limit      = limit
    self.last_sms   = last_sms

  def __repr__(self):
    return "" % (self.email, self.password, self.limit, self.last_sms)

def add_emails(emails, session):
  try:
    femails = open(emails, "r")
  except:
    print "Error. Can't open file %s." % emails
    return False
  try:
    counter = 0
    for e in femails:
      login, password = e.strip("\r\n").split(" ", 1)
      c = session.query(Email).filter(Email.email == login).count()
      if not c:
        session.add(Email(login, password))
        counter += 1
    session.commit()
  except:
    femails.close()
    print "Error. Unknow exception :-(."
    return False
  femails.close()
  return counter

def update_limits(session):
  e = session.query(Email).filter(Email.last_sms <= int(time.mktime(time.localtime()) - 86400))
  for email in e:
    email.limit = 50
  session.commit()

mapper(Email, emails_table)
Session = sessionmaker(bind = engine)

Теперь пришло время заняться самим клиентом. Создаём очередной файл clnt.py и описываем в нём класс со следующими методами:

• connect() — создание сокета и подключение к серверу;
• hello() — отправка MRIM_CS_HELLO и получение в ответ MROM_CS_HELLO_ACK;
• auth(login, passwd) — отправка запроса на авторизацию;
• sendSMS(number, text) — отправить sms на номер number. Стоит отметить, что тип пакета с sms — 0×00001039, сам пакет имеет следующий формат — UL 0×00000000 LPS +71234567890, LPS текст sms, где +71234567890 — номер на который мы отправляем сообщение. Так же ещё одна особенность — если среди наших контактов в агенте нет ни одного с указанным номером телефона, то сообщения не будут доходить;
• send(msg) — пишет msg в уже открытый сокет;
• get() — читает из сокета и возвращает результат;
• close() — закрывает сокет
• start(login, passwd) — вызывает последовательно все необходимые методы для подключения к серверу;
• __init__(rhost, rport) — конструктор, ему передаётся ip-адрес и порт к которому будет производиться подключение;

# -*- coding: cp1251 -*-

import socket
import os
import urllib
from packets import *

class clnt:
  rhost = ""
  rport = 0
  sock = False
  ping = 0
  packet = False
  rcvd_packet = False

  def __init__(self, rhost, rport):
    self.rhost, self.rport = rhost, rport
    self.packet = p_header()
    self.rcvd_packet = p_header()

  def connect(self):
    # Создаём сокет и подключаемся
    self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    try:
      self.sock.connect((self.rhost, self.rport))
      addr, port = self.sock.getsockname()
      self.packet.setHost(addr, port)
    except:
      print "\nError. Connection to server %s:%d failed." % (self.rhost, self.rport)
      return False
    return True

  def start(self, login, passwd):
    if not self.connect(): return False
    if not self.hello(): return False
    if not self.auth(login, passwd): return False

    return True

  def hello(self):
    self.send(self.packet.getPacket(MRIM_CS_HELLO))
    #print "Sent MRIM_CS_HELLO."
    try:
      self.rcvd_packet.setPacket(self.get())
      if self.rcvd_packet.msg == MRIM_CS_HELLO_ACK:
        #print "Recieved MRIM_CS_HELLO_ACK.",
        self.ping = self.rcvd_packet.data
        #print "Ping timeout %ds." % self.ping
      else:
        print "\nError. Not recieved MRIM_CS_HELLO_ACK."
        return False
    except:
      print "\nError. Not recieved MRIM_CS_HELLO_ACK."
      return False
    return True

  def auth(self, login, passwd):
    self.packet.clear()
    self.packet.addLPSData(login)
    self.packet.addLPSData(passwd)
    self.packet.addULData(STATUS_ONLINE)
    self.packet.addLPSData("STATUS_ONLINE")
    self.packet.addLPSData("FreeAgent v 0.1")
    print "Trying to authorize as %s..." % login,
    try:
      self.send(self.packet.getPacket(MRIM_CS_LOGIN2))
    except:
      print "\nError. Can't send MRIM_CS_LOGIN2."
      return False
    try:
      self.rcvd_packet.setPacket(self.get())
    except:
      print "\nError. Not recievd answer from server."
      return False
    if self.rcvd_packet.msg == MRIM_CS_LOGIN_ACK:
      print "success!"
      return True
    else:
      print "error :-(."
      return False

  def sendSMS(self, number, text):
    ftext = ""
    ftext = text
    self.packet.clear()
    self.packet.addULData(0x0)
    self.packet.addLPSData(number)
    self.packet.addLPSData(ftext)
    print "Sending to %s: %s..." % (number, text),
    try:
      self.send(self.packet.getPacket(0x00001039))
    except:
      print "\nError. Can't send sms"
      return False
    print "Ok!"
    return True

  def send(self, msg):
    try:
      self.sock.send(msg)
    except:
      print "\nError. Can't send data."
      return False
    return True

  def get(self):
    return self.sock.recv(4096)

  def close(self):
    self.sock.close()
    return True

Все основные функции и классы написаны, осталось их только использовать. Создаём главный файл sms.py.
Первое, что мы в нём делаем — это «обновляем» лимиты в 50 сообщений в сутки, далее проверяем количество аргументов командной строки, если оно равно трём, то считаем, что нам переданы номер, на который надо отправить sms, и текст (т.е. программа была запущена так: sms.py +71234567890 «testovoe soobshenie»), иначе входим в интерактивный режим.
Следующий шаг — пытаемся подключиться к адресу «http://mrim.mail.ru:2042″ и узнать адрес сервера к которому нам рекомендуют подключаться на данный момент.
Выбираем из нашей БД список ящиков, у которых не превышен лимит, упорядочиваем (по возрастанию) по дате отправки последнего сообщения и отправляем sms с 1го, уменьшая лимит этого ящика на 1. Если со времени последней отправки sms не прошла ещё 61 секунда, то перед отправкой ждём.

# -*- coding: cp1251 -*-

from clnt import *
import sys
import time
import urllib
from emails import *
import os

session = Session()
update_limits(session)

if len(sys.argv) == 3:
  number = sys.argv[1]
  text = sys.argv[2]
else:
  while True:
    action = raw_input("Select action:\n1 - add emails from file\n2 - send sms\n")
    if action == "1":
      ef = raw_input("Enter file name: ")
      print "%d new emails added." % add_emails(ef, session)
    elif action == "2":
      number = raw_input("Enter phone number: ")
      text = raw_input("Enter SMS text: ")
      break
    else:
      print "Invalid action!"

try:
  saddr = urllib.urlopen("http://mrim.mail.ru:2042").readlines()
  saddr = saddr[0]
  shost, sport = saddr[:-1].split(":")
  sport = int(sport)
except:
  print "\nError. Can't connect to mrim.mail.ru."
  sys.exit(0)

emails = session.query(Email).filter(Email.limit > 0).order_by(Email.last_sms)
if not emails.count():
  print "Sorry, all limits exceeded."
  sys.exit(0)
if emails[0].last_sms > (int(time.mktime(time.localtime()) - 61)):
  print "Waiting %d seconds." % (61 - (int(time.mktime(time.localtime())) - emails[0].last_sms))
  time.sleep(61 - (int(time.mktime(time.localtime())) - emails[0].last_sms))
c = clnt(shost, sport)
if not c.start(str(emails[0].email), str(emails[0].password)):
  print "Error."
  sys.exit(0)
c.sendSMS(number, text)
emails[0].last_sms = int(time.mktime(time.localtime()))
emails[0].limit -= 1
session.commit()
c.close()
session.commit()

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

Ссылки к статье:
http://agent.mail.ru/ru/developers/protocol.html — описание протокола агента.
http://sqlalchemy.org — официальный сайт sqlalchemy.
http://www.arechisoft.com/ — пакетный снифер EtherSnoop.
http://yo.jabber.ru/files/mrim/ — Mrim — это Jabber-транспорт для IM-сервиса компании Mail.Ru написанный на python.