Chatbot Corvus

Corvus27_config.cfg

[daemon]
daemontimeout: 60

[db]
host:localhost
user:root
passwd:123
dbname:arh

Corvus27_Corvus.py

# -*- coding: utf-8 -*-
import MySQLdb
import time
import random
import re

import os, logging, tempfile, ConfigParser, sys

class Corvus:
    def __init__(self):
        config = ConfigParser.ConfigParser()
        config.read(os.path.dirname(__file__) + '/config.cfg')
        self.daemonTimeout = int(config.get('daemon', 'daemonTimeout'))
        self.db_host   = config.get('db', 'host')
        self.db_user   = config.get('db', 'user')
        self.db_passwd = config.get('db', 'passwd')
        self.db_dbname = config.get('db', 'dbname')
        self.base_chance    = int(config.get('corvus', 'base_chance'))
        self.second_chance  = int(config.get('corvus', 'second_chance'))

        # log init
        logging.basicConfig(filename = tempfile.gettempdir() + '/Corvus.log',
                            level = logging.DEBUG,
                            format = '%(asctime)s %(levelname)s: %(message)s',
                            datefmt = '%Y-%m-%d %I:%M:%S')
        logging.info('Daemon start')

    def IsCorvusUsage(self,s_shout):
        stroka = unicode(s_shout,'utf-8')
        regexp = u'Корв|Corv'
        res = re.search(regexp,stroka,re.IGNORECASE | re.UNICODE)

        # print s_shout

        return not res == None

    def CorvusMustPost(self):
        # return True

        self.cur.execute('SELECT s_user, s_shout FROM arhinfernoshout WHERE s_private=-1 ORDER BY s_time DESC LIMIT 22')
        result = self.cur.fetchall()
        intRandLimit = self.base_chance
        i = 0
        IsUsage = False
        IsLast  = False
        IsCorv  = False

        for row in result:
            i=i+1;
            IsCorv = IsCorv or row[0]==1;

            # print row[1]
            if row[0]==1:
                intRandLimit = intRandLimit+self.second_chance

            if i==1 and row[0]==1:
                IsLast = True

            if not IsCorv:
                if self.IsCorvusUsage(row[1]):
                    IsUsage = True

            if IsUsage and not IsLast:
                intRandLimit = 0;
                break

        if IsLast:
            intRandLimit=intRandLimit*100

        # print intRandLimit
        return random.randint(0,intRandLimit)==0

    def CorvusSay(self, s_shout,s_me):
        strShout = str(s_shout)
        strMe    = str(s_me)
        strTime  = str(time.time())

        # print strShout

        self.cur.execute('insert into arhinfernoshout (s_user, s_time, s_shout, s_me, s_private) values (1, %s, %s, %s, -1)',(strTime,strShout,strMe,))

    def CorvusPhrase(self):
        self.cur.execute('SELECT s_shout,s_me FROM Corvus WHERE s_private=-1 ORDER BY RAND() LIMIT 1')
        return self.cur.fetchall()



    def CorvusBot(self):
        self.con = MySQLdb.connect(host=self.db_host, user=self.db_user, passwd=self.db_passwd, db=self.db_dbname)
        self.cur = self.con.cursor()
        self.cur.execute('SET NAMES `utf8`')

        if self.CorvusMustPost():
            result = self.CorvusPhrase()
            Corvus.CorvusSay(self,result[0][0],result[0][1])

    def getDaemonTimeout(self):
        return self.daemonTimeout

if __name__ == '__main__':
    c = Corvus()
    c.CorvusBot()

Corvus27_CorvusDaemon.py

import daemon
import sys, time, tempfile
import Corvus

class CorvusDaemon(daemon.Daemon):
    def run(self):
        c = Corvus.Corvus()
        while True:
            c.CorvusBot()
            time.sleep(c.getDaemonTimeout())
            # print 'i am alive'

if __name__ == '__main__':
    pidFile = tempfile.gettempdir() + '/Corvus.pid'
    daemon = CorvusDaemon(pidFile)
    if len(sys.argv) == 2:
        if 'start' == sys.argv[1]:
            print 'Daemon starting..'
            daemon.start()
            print 'Daemon started!'
        elif 'stop' == sys.argv[1]:
            print 'Daemon stopping..'
            daemon.stop()
            print 'Daemon stopped!'
        elif 'restart' == sys.argv[1]:
            print 'Daemon restarting..'
            daemon.restart()
            print 'Daemon restarted!'
        else:
            print 'Unknown command'
            sys.exit(2)
        sys.exit(0)
    else:
        print 'usage: %s start|stop|restart' % sys.argv[0]
        sys.exit(2)

Corvus27_daemon.py

#!/usr/bin/env python
#http://www.jejik.com/articles/2007/02/a_simple_unix_linux_daemon_in_python/

import sys, os, time, atexit
from signal import SIGTERM

class Daemon:
    """
    A generic daemon class.

    Usage: subclass the Daemon class and override the run() method
    """
    def __init__(self, pidfile, stdin='/dev/null', stdout='/dev/null', stderr='/dev/null'):
        self.stdin = stdin
        self.stdout = stdout
        self.stderr = stderr
        self.pidfile = pidfile


    def daemonize(self):
        """
        do the UNIX double-fork magic, see Stevens' "Advanced
        Programming in the UNIX Environment" for details (ISBN 0201563177)
        http://www.erlenstar.demon.co.uk/unix/faq_2.html#SEC16
        """
        try:
            pid = os.fork()
            if pid > 0:
                # exit first parent
                sys.exit(0)
        except OSError, e:
            sys.stderr.write("fork #1 failed: %d (%s)\n" % (e.errno, e.strerror))
            sys.exit(1)

        # decouple from parent environment
        os.chdir("/")
        os.setsid()
        os.umask(0)

        # do second fork
        try:
            pid = os.fork()
            if pid > 0:
                # exit from second parent
                sys.exit(0)
        except OSError, e:
            sys.stderr.write("fork #2 failed: %d (%s)\n" % (e.errno, e.strerror))
            sys.exit(1)

        # redirect standard file descriptors
        # sys.stdout.flush()
        # sys.stderr.flush()
        # si = file(self.stdin, 'r')
        # so = file(self.stdout, 'a+')
        # se = file(self.stderr, 'a+', 0)
        # os.dup2(si.fileno(), sys.stdin.fileno())
        # os.dup2(so.fileno(), sys.stdout.fileno())
        # os.dup2(se.fileno(), sys.stderr.fileno())

        # write pidfile
        atexit.register(self.delpid)
        pid = str(os.getpid())
        file(self.pidfile,'w+').write("%s\n" % pid)

    def delpid(self):
        os.remove(self.pidfile)

    def start(self):
        """
        Start the daemon
        """
        # Check for a pidfile to see if the daemon already runs

        try:
            pf = file(self.pidfile,'r')
            pid = int(pf.read().strip())
            pf.close()
        except IOError:
            pid = None

        if pid:
            message = "pidfile %s already exist. Daemon already running?\n"
            sys.stderr.write(message % self.pidfile)
            sys.exit(1)

        # Start the daemon
        self.daemonize()
        self.run()

    def stop(self):
        """
        Stop the daemon
        """
        # Get the pid from the pidfile
        try:
            pf = file(self.pidfile,'r')
            pid = int(pf.read().strip())
            pf.close()
        except IOError:
            pid = None

        if not pid:
            message = "pidfile %s does not exist. Daemon not running?\n"
            sys.stderr.write(message % self.pidfile)
            return # not an error in a restart

        # Try killing the daemon process
        try:
            while 1:
                os.kill(pid, SIGTERM)
                time.sleep(0.1)
        except OSError, err:
            #FIX for Ru_ru locale
            # Anton Fischer <a.fschr@gmail.com>
            #err = str(err)
            #if err.find("No such process") > 0:
                if os.path.exists(self.pidfile):
                    os.remove(self.pidfile)
            #else:
            #    print str(err)
            #    sys.exit(1)

    def restart(self):
        """
        Restart the daemon
        """
        self.stop()
        self.start()

    def run(self):
        """
        You should override this method when you subclass Daemon. It will be called after the process has been
        daemonized by start() or restart().
        """