System modeling

import argparse, sys, random, time
from functools import wraps

class Eint(int):
    def __init__(self, number):
        super(Eint, self).__init__(number)
        self.digits = []
        for i in range(0,6):
            self.digits.append(number % 10)
            number /= 10
        self.digits.reverse()

class Checker(object):
    def __init__(self):
        self.lucky_tests = [self.__lucky_test_0]
        self.special_tests = [
            self.__special_test_0,
            self.__special_test_1,
            self.__special_test_2,
            self.__special_test_3,
            self.__special_test_4,
            self.__special_test_5,
            self.__special_test_6,
            self.__special_test_7,
            self.__special_test_8,
            self.__special_test_9
        ]
        self.n = 10

    def __check_test_list(self, number, test_list):
        for index, test in enumerate(test_list):
            if test(number): return True
        return False

    def is_lucky(self, number):
        return self.__check_test_list(number, self.lucky_tests)

    def is_special(self, number):
        return self.__check_test_list(number, self.special_tests[9:])

    def __lucky_test_0(self, n):
        return sum(n.digits[3:]) == sum(n.digits[:3]) == self.n

    def __special_test_0(self, n):
        for i in range(0,6):
            if n.digits.count(n.digits[i]) > 1: return False
        return True

    def __special_test_1(self, n):
        for i in range(0,4):
            if n.digits[i:i+3].count(n.digits[i]) == 3: return True
        return False

    def __special_test_2(self, n):
        for i in range(0,6):
            if n.digits.count(n.digits[i]) > 3: return True
        return False

    def __special_test_3(self, n):
        return abs(sum(n.digits[3:]) - sum(n.digits[:3])) == 1

    def __special_test_4(self, n):
        for i in range(0,5):
            if n.digits[i] >= n.digits[i+1]: return False
        return True

    def __special_test_5(self, n):
        for i in range(0,5):
            if n.digits[i] < n.digits[i+1]: return False
        return True

    def __special_test_6(self, n):
        for i in range(0,5):
            if n.digits[i] == '1' and n.digits[i+1] == '3': return True
        return False

    def __special_test_7(self, n):
        return sum(n.digits[3:]) == 13 or sum(n.digits[:3]) == 13

    def __special_test_8(self, n):
        for i in range(0,6):
            if n.digits[i] & 1 == 0: return False
        return True

    def __special_test_9(self, n):
        for i in range(0,6):
            if n.digits[i] & 1 == 1 or n.digits[i] == 0: return False
        return True

class timed(object):
    def __init__(self, desc):
        self.desc = desc

    def __call__(self, func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            start = time.time()
            ret = func(*args, **kwargs)
            print self.desc.format(time.time() - start)
            return ret

        return wrapper

def counter(generator):
    @wraps(generator)
    def wrapper(iterations=1000000):
        s, l, c = 0, 0, Checker()
        for i in range(0, iterations):
            n = generator(i)
            s += int(c.is_special(n))
            l += int(c.is_lucky(n))
        print 'Special: {0:.6f}, lucky: {1:.6f}'.format(s / 1000000.00, l / 1000000.0)

    return wrapper

@timed('Determination processing time: {0:.4f}')
@counter
def determinate(i):
    return Eint(i)

@timed('Imitation processing time: {0:.4f}')
@counter
def imitation(i):
    return Eint(random.randint(0,999999))

def minimum():
    pass # TODO: implement

def main(argv):
    p = argparse.ArgumentParser('Lab #1')
    s = p.add_subparsers(dest='model')
    d = s.add_parser('d')
    i = s.add_parser('i')
    i.add_argument('-n', '--number', dest='n', type=int, nargs='?', help='number of tickets')
    p = p.parse_args()

    if p.model == 'd': determinate()
    elif p.model == 'i':
        if p.n is None: minimum()
        else: imitation(p.n)

if __name__ == '__main__':
    main(sys.argv)