예제 #1
0
 def edit(self,widget):
     self.treeView.set_model(self.create_model())
     model=self.treeView.get_model()
     edit.edit(self.fname)
     #print 1
     
     update_list.main(self.fname)
       
     self.treeView.set_model(self.create_model())
     model=self.treeView.get_model()
     '''print 1
     for i in model:
         for j in i:
           print j,
         print
     print 2
     '''
     self.graphs(1)
     self.graphs(2)
     stats.update(self.fname)
     stats.treeView.set_model(stats.create_model(self))
     try:
       viewer.update(self,'')
       viewer.treeView.set_model(viewer.create_model(self))
     except AttributeError:
       pass
예제 #2
0
 def changed_item_years(self,widget):
     #activated when combobox value holding years is changed
   
     #creates a file(if not present) and opens it and reads its contents
     self.fname=app.data_location+str(widget.get_active_text())+'_'+self.combobox.get_active_text()
     f=open(self.fname,'a')
     f.close()
     f=open(self.fname,'r')
     x=f.readlines()
     f.close()
     #print 1
     update_list.main(self.fname)
     
     try:
       self.treeView.set_model(self.create_model())
       #model=self.treeView.get_model()
     except AttributeError:
       pass
     self.graphs(1)
     self.graphs(2)
     stats.update(self.fname)
     stats.treeView.set_model(stats.create_model(self))
     try:
       viewer.update(self,'')
       viewer.treeView.set_model(viewer.create_model(self))
     except AttributeError:
       pass
예제 #3
0
파일: vkbot.py 프로젝트: kalinochkind/vkbot
    def replyAll(self, gen_reply, include_read=False):
        self.tm.gc()
        self.banned_list = []
        if include_read:
            self.users.gc()
            if self.whitelist:
                messages = self.api.messages.getDialogs(unread=(0 if self.whitelist_includeread else 1), count=20)
                self.whitelist_includeread = False
            else:
                messages = self.api.messages.getDialogs(unread=1, count=200)
            try:
                messages = messages['items'][::-1]
            except TypeError:
                logging.warning('Unable to fetch messages')
                return
            self.loadUsers(messages, lambda x: x['message']['user_id'])
            self.loadUsers(messages, lambda x: x['message']['chat_id'], confs=True)
            for msg in sorted(messages, key=lambda m: m['message']['id']):
                cur = msg['message']
                if cur['out']:
                    continue
                if self.last_message_id and cur['id'] > self.last_message_id:
                    continue
                self.replyOne(cur, gen_reply, 'getDialogs')
            stats.update('banned_messages', ' '.join(map(str, sorted(self.banned_list))))

        else:
            messages = self.longpollMessages()
            self.loadUsers(messages, lambda x: x['user_id'])
            self.loadUsers(messages, lambda x: x['chat_id'], confs=True)
            for cur in sorted(messages, key=lambda m: m['id']):
                self.last_message_id = max(self.last_message_id, cur['id'])
                self.replyOne(cur, gen_reply)
예제 #4
0
    def finish(self):
        worldData = self.w.to_dict()
        worldData['id'] = self.game_id
        worldData['time'] = -1
        self.mc[self.game_id].update({}, worldData, upsert=True)
        print 'FINISHING'

        models = self.models
        testmode = self.testmode
        nrobots = self.nrobots
        procs = self.procs
        tournament = self.tournament

        alive = [model for model in models.values() if model.alive]
        if not testmode and len(alive)==1:
            model = alive[0]
            print 'WINNER:', model.name
            winner = model
            model._kills = nrobots-1
        elif not testmode:
            winner = None
            if self.rnd >= conf.maxtime*60:
                print 'Battle stopped after maximum time:', conf.maxtime, 'seconds.'
            else:
                print 'Battle stopped after', int(self.rnd/60), 'seconds.'
            print 'STILL ALIVE:'
            for model in alive:
                print '   ', model.name
        else:
            winner = None

        for robotname, model in models.items():
            print robotname, 'caused', model._damage_caused, 'damage'
            if robotname in procs:
                line = 'FINISH\n'
                proc = procs[robotname]
                proc.stdin.write(line)
                proc.stdin.flush()
                proc.stdin.close()
                proc.stdout.close()
                del procs[robotname]

            if winner is None and model.alive:
                model._kills = nrobots - len(alive)

            if model == winner:
                win = 1
            else:
                win = 0

            if not testmode:
                stats.update(model.kind, win, nrobots-1, model._kills,
                                model._damage_caused)

            if tournament is not None:
                stats.tournament_update(tournament, model.kind, model.name, win,
                                                nrobots-1, model._kills,
                                                model._damage_caused)
예제 #5
0
    def __init__(self, username='', password='', get_dialogs_interval=60):

        self.delay_on_reply = config.get('vkbot_timing.delay_on_reply', 'i')
        self.chars_per_second = config.get('vkbot_timing.chars_per_second',
                                           'i')
        self.same_user_interval = config.get('vkbot_timing.same_user_interval',
                                             'i')
        self.same_conf_interval = config.get('vkbot_timing.same_conf_interval',
                                             'i')
        self.forget_interval = config.get('vkbot_timing.forget_interval', 'i')
        self.delay_on_first_reply = config.get(
            'vkbot_timing.delay_on_first_reply', 'i')
        self.stats_dialog_count = config.get('stats.dialog_count', 'i')
        self.no_leave_conf = config.get('vkbot.no_leave_conf', 'b')

        self.api = vkapi.VkApi(username,
                               password,
                               ignored_errors=ignored_errors,
                               timeout=config.get(
                                   'vkbot_timing.default_timeout', 'i'),
                               token_file=accounts.getFile('token.txt'),
                               log_file=accounts.getFile('inf.log')
                               if args.args['logging'] else '',
                               captcha_handler=createCaptchaHandler())
        stats.update('logging', bool(self.api.log_file))
        # hi java
        self.users = UserCache(
            self.api, self.fields + ',' +
            FriendController.requiredFields(_getFriendControllerParams()),
            config.get('cache.user_invalidate_interval', 'i'))
        self.confs = ConfCache(
            self.api, config.get('cache.conf_invalidate_interval', 'i'))
        self.vars = json.load(open('data/defaultvars.json', encoding='utf-8'))
        self.vars['default_bf'] = self.vars['bf']['id']
        self.initSelf(True)
        self.guid = int(time.time() * 5)
        self.last_viewed_comment = stats.get('last_comment', 0)
        self.good_conf = {}
        self.tm = ThreadManager()
        self.last_message = MessageCache()
        if os.path.isfile(accounts.getFile('msgdump.json')):
            try:
                data = json.load(open(accounts.getFile('msgdump.json')))
                self.last_message.load(data['cache'])
                self.api.longpoll = data['longpoll']
            except json.JSONDecodeError:
                logging.warning('Failed to load messages')
            os.remove(accounts.getFile('msgdump.json'))
        else:
            logging.info('Message dump does not exist')
        self.bad_conf_title = lambda s: False
        self.admin = None
        self.banned_list = []
        self.message_lock = threading.Lock()
        self.banned = set()
        self.receiver = MessageReceiver(self.api, get_dialogs_interval)
        self.receiver.longpoll_callback = self.longpollCallback
예제 #6
0
파일: vkbot.py 프로젝트: dinamsky/PyVKBot
 def replyAll(self, gen_reply):
     self.tm.gc()
     self.banned_list = []
     messages = self.receiver.getMessages()
     self.loadUsers(messages, lambda x: x['user_id'])
     self.loadUsers(messages, lambda x: x['chat_id'] + CONF_START)
     for cur in messages:
         self.replyOne(cur, gen_reply)
     if self.receiver.used_get_dialogs:
         stats.update('banned_messages', ' '.join(map(str, sorted(self.banned_list))))
예제 #7
0
    def finish(self):
        print 'FINISHING'

        models = self.models
        testmode = self.testmode
        ntanks = self.ntanks
        procs = self.procs
        tournament = self.tournament

        alive = [model for model in models.values() if model.alive]
        if not testmode and len(alive)==1:
            model = alive[0]
            print 'WINNER:', model.name
            winner = model
            model._kills = ntanks-1
        elif not testmode:
            winner = None
            if self.rnd >= conf.maxtime*60:
                print 'The battle finished after maximum time:', conf.maxtime, 'seconds.'
            else:
                print 'The battle finished after', int(self.rnd/60), 'seconds.'
            print 'STILL ALIVE:'
            for model in alive:
                print '   ', model.name
        else:
            winner = None

        for tankname, model in models.items():
            print tankname, 'caused', model._damage_caused, 'damage'
            if tankname in procs:
                line = 'FINISH\n'
                proc = procs[tankname]
                proc.stdin.write(line)
                proc.stdin.flush()
                proc.stdin.close()
                proc.stdout.close()
                del procs[tankname]

            if winner is None and model.alive:
                model._kills = ntanks - len(alive)

            if model == winner:
                win = 1
            else:
                win = 0

            if not testmode:
                stats.update(model.kind, win, ntanks-1, model._kills,
                                model._damage_caused)

            if tournament is not None:
                stats.tournament_update(tournament, model.kind, model.name, win,
                                                ntanks-1, model._kills,
                                                model._damage_caused)
예제 #8
0
    def filterComments(self, test):
        data = self.api.notifications.get(start_time=self.last_viewed_comment +
                                          1,
                                          count=100)['items']
        to_del = set()
        to_bl = set()
        self.loadUsers(data, lambda x: x['feedback']['from_id'], True)
        for rep in data:
            if rep['date'] != 'i':
                self.last_viewed_comment = max(self.last_viewed_comment,
                                               int(rep['date']))

            def _check(s):
                if 'photo' in s:
                    return s['photo']['owner_id'] == self.self_id
                if 'video' in s:
                    return s['video']['owner_id'] == self.self_id
                if 'post' in s:
                    return s['post']['to_id'] == self.self_id

            if rep['type'].startswith('comment_') or (
                    rep['type'].startswith('reply_comment')
                    and _check(rep['parent'])) or rep['type'] == 'wall':
                txt = html.escape(rep['feedback']['text'])
                res = 'good'
                frid = int(rep['feedback']['from_id'])
                if self.users[frid]['blacklisted']:
                    res = 'blacklisted'
                    log.write(
                        'comments',
                        self.loggableName(frid) + ' (blacklisted): ' + txt)
                    self.deleteComment(rep)
                    to_bl.add(frid)
                elif test(txt):
                    res = 'bad'
                    log.write('comments', self.loggableName(frid) + ': ' + txt)
                    self.deleteComment(rep)
                    to_del.add(frid)
                elif 'attachments' in rep['feedback'] and any(
                        i.get('type') in ['video', 'link']
                        for i in rep['feedback']['attachments']):
                    res = 'attachment'
                    log.write('comments',
                              self.loggableName(frid) + ' (attachment)')
                    self.deleteComment(rep)
                self.logSender(
                    'Comment {} (by %sender%) - {}'.format(txt, res),
                    {'user_id': frid})
        stats.update('last_comment', self.last_viewed_comment)
        for i in to_bl:
            self.blacklist(i)
        return to_del
예제 #9
0
    def changed_item(self,widget):
        #activated when combobox value holding months is changed
        #self.yy='2012'
        a= widget.get_active_text()
        
        try:
          #print type(self.combobox2.get_active_text())
          self.fname=app.data_location+self.combobox2.get_active_text()+'_'+a
          #print self.fname
          
          f=open(self.fname,'a')
          f.close()
          f=open(self.fname,'r')
          x=f.readlines()
          f.close()
        #print 1
          update_list.main(self.fname)
        except AttributeError:
          f=open(app.data_location+str(self.yy)+'_'+str(self.months[self.mm]),'a')
          f.close()
          update_list.main(app.data_location+str(self.yy)+'_'+self.combobox.get_active_text())
          pass
        
        try:
          self.treeView.set_model(self.create_model())
          #model=self.treeView.get_model()
        except AttributeError:
          pass
        
        #del self.line
        self.graphs(1)
        self.graphs(2)
        
        try:
          stats.update(self.fname)
          stats.treeView.set_model(stats.create_model(self))
        
        
          viewer.update(self,self.fname)
          viewer.treeView.set_model(viewer.create_model(self))
        except AttributeError:
          pass

        
        
        
      
          viewer.treeView.set_model(viewer.create_model(self))
        except AttributeError:
          pass
예제 #10
0
파일: vkbot.py 프로젝트: kalinochkind/vkbot
    def filterComments(self, test):
        data = self.api.notifications.get(start_time=self.last_viewed_comment + 1, count=100)['items']
        to_del = set()
        to_bl = set()
        self.loadUsers(data, lambda x: x['feedback']['from_id'], True)
        for rep in data:
            if rep['date'] != 'i':
                self.last_viewed_comment = max(self.last_viewed_comment, int(rep['date']))
                stats.update('last_comment', self.last_viewed_comment)

            def _check(s):
                if 'photo' in s:
                    return s['photo']['owner_id'] == self.self_id
                if 'video' in s:
                    return s['video']['owner_id'] == self.self_id
                if 'post' in s:
                    return s['post']['to_id'] == self.self_id

            if rep['type'].startswith('comment_') or rep['type'].startswith('reply_comment') and _check(rep['parent']):
                txt = html.escape(rep['feedback']['text'])
                res = 'good'
                if self.users[rep['feedback']['from_id']]['blacklisted']:
                    res = 'blacklisted'
                    log.write('comments', self.loggableName(rep['feedback']['from_id']) + ' (blacklisted): ' + txt)
                    self.deleteComment(rep)
                    to_bl.add(rep['feedback']['from_id'])
                elif test(txt):
                    res = 'bad'
                    log.write('comments', self.loggableName(rep['feedback']['from_id']) + ': ' + txt)
                    self.deleteComment(rep)
                    to_del.add(rep['feedback']['from_id'])
                elif 'attachments' in rep['feedback'] and any(i.get('type') in ['video', 'link'] for i in rep['feedback']['attachments']):
                    res = 'attachment'
                    log.write('comments', self.loggableName(rep['feedback']['from_id']) + ' (attachment)')
                    self.deleteComment(rep)
                self.logSender('Comment {} (by %sender%) - {}'.format(txt, res), {'user_id': rep['feedback']['from_id']})
        for i in to_bl:
            self.blacklist(i)
        return to_del
예제 #11
0
def main():
    if not pygame.font:
        print 'Warning, fonts disabled'
        return
    if not pygame.mixer:
        print 'Warning, sound disabled'

    pygame.font.init()
    music = pygame.mixer.music

    if config.music:
        try:
            music.load(os.path.join('data', 'music.ogg'))
        except:
            print "No music"
            config.music = False

    pygame.init()
    screen = pygame.display.set_mode(config.size)
    pygame.display.set_caption('SpaceFight')
    pygame.mouse.set_visible(0)

    background = pygame.image.load(os.path.join('data', \
                                                'background.png')).convert()

    screen.blit(background, (0, 0))
    pygame.display.flip()

    clock = pygame.time.Clock()
    spawn = True
    lastCast = pygame.time.get_ticks()
    lastPowerUp = pygame.time.get_ticks()
    enemies = pygame.sprite.RenderPlain(Ufo())
    fighter = Fighter(enemies)
    fighterGroup = pygame.sprite.RenderPlain(fighter)
    powerups = pygame.sprite.RenderPlain(choice(config.powerups)(fighter))

    if config.music:
        music.set_volume(0.8)
        music.play(-1)

    while 1:
        clock.tick(50)

        for event in pygame.event.get():
            if event.type == QUIT:
                return
            elif event.type == KEYDOWN:
                if event.key == K_ESCAPE or event.key == K_q:
                    return
                #######################################################
                #                         DEBUG                       #
                #######################################################
                elif event.key == K_s:
                    enemies.add(Ufo())
                    lastCast = pygame.time.get_ticks()
                elif event.key == K_p:
                    powerups.add(choice(config.powerups)(fighter))
                    lastPowerUp = pygame.time.get_ticks()
                #######################################################
                elif event.key == K_SPACE:
                    fighter.shotType = fighter.shootRocket
                    fighter.shooting = True
                elif event.key == K_c:
                    fighter.shotType = fighter.shootSuperChicken
                    fighter.shooting = True
                elif event.key == K_UP or event.key == K_l:
                    fighter.shotType = fighter.shootLaser
                    fighter.shooting = True
                elif event.key == K_RIGHT:
                    fighter.dx = min(fighter.speed, fighter.maxspeed)
                elif event.key == K_LEFT:
                    fighter.dx = -min(fighter.speed, fighter.maxspeed)
                elif event.key == K_f:
                    pygame.display.toggle_fullscreen()
            elif event.type == KEYUP:
                if event.key == K_RIGHT and fighter.dx > 0:
                    fighter.dx = 0
                elif event.key == K_LEFT and fighter.dx < 0:
                    fighter.dx = 0
                elif event.key == K_SPACE and fighter.shotType == fighter.shootRocket:
                    fighter.shooting = False
                elif (event.key == K_UP  or event.key == K_l) and fighter.shotType == fighter.shootLaser:
                    fighter.shooting = False
                elif event.key == K_c and fighter.shotType == fighter.shootSuperChicken:
                    fighter.shooting = False


        if pygame.time.get_ticks() - lastCast >= config.levels[stats.level['level']]['spawnSpeed'] and stats.level['spawned'] < config.levels[stats.level['level']]['spawns']:
            enemies.add(Ufo())
            lastCast = pygame.time.get_ticks()
            stats.level['spawned'] += 1

        if pygame.time.get_ticks() - lastPowerUp >= config.levels[stats.level['level']]['powerUpSpeed']:
            powerups.add(choice(config.powerups)(fighter))
            lastPowerUp = pygame.time.get_ticks()

        if stats.level['spawned'] == config.levels[stats.level['level']]['spawns']:
            # spawn endboss
            pass


        screen.blit(background, (0, 0))
        stats.update()
        fighterGroup.update()
        fighterGroup.draw(screen)
        powerups.update()
        powerups.draw(screen)
        enemies.update()
        enemies.draw(screen)
        pygame.display.flip()
예제 #12
0
def processFile(bench, result, tool):
    stats = {"tool": tool, "ans": "", "time": "", "mem": "", "inst": ""}
    if result is None:
        stats.update({"ans": "ERR"})
        return {bench: stats}, stats
    if tool == "JPF":
        for r in result.splitlines():
            if 'no errors detected' in r:
                #stat('Result-JPF', 'SAFE')
                stats.update({"ans": "SAFE"})
            if 'elapsed time' in r:
                t = r.split()
                time = t[len(t) - 1]
                stats.update({"time": str(time)})
            if 'max memory' in r:
                t = r.split()
                mem = t[len(t) - 1]
                stats.update({"mem": str(mem)})
            if 'instructions' in r:
                t = r.split()
                ins = t[len(t) - 1]
                stats.update({"inst": str(ins)})
            if 'java.lang.AssertionError' in r:
                #stat('Result-JPF', 'CEX')
                stats.update({"ans": "CEX"})
    elif tool == "Z3" or tool == "ELD":
        if "checker says true" in result:
            #if tool == "Z3": stat('Result-Z3', 'SAFE')
            #if tool == "ELD": stat('Result-ELDARICA', 'SAFE')
            stats.update({"ans": "SAFE"})
        if "checker says false" in result:
            #if tool == "Z3": stat('Result-Z3', 'CEX')
            #if tool == "ELD": stat('Result-ELDARICA', 'CEX')
            stats.update({"ans": "CEX"})
    return {bench: stats}, stats
예제 #13
0
def processFile(bench, result, tool):
    stats = {"tool": tool, "ans":"", "time":"", "mem":"", "inst":""}
    if result is None:
        stats.update({"ans":"ERR"})
        return {bench:stats}, stats
    if tool == "JPF":
        for r in result.splitlines():
            if 'no errors detected' in r:
                #stat('Result-JPF', 'SAFE')
                stats.update({"ans":"SAFE"})
            if 'elapsed time' in r:
                t = r.split()
                time = t[len(t)-1]
                stats.update({"time":str(time)})
            if 'max memory' in r:
                t = r.split()
                mem = t[len(t)-1]
                stats.update({"mem":str(mem)})
            if 'instructions' in r:
                t = r.split()
                ins = t[len(t)-1]
                stats.update({"inst":str(ins)})
            if 'java.lang.AssertionError' in r:
                #stat('Result-JPF', 'CEX')
                stats.update({"ans":"CEX"})
    elif tool == "Z3" or tool == "ELD":
        if "checker says true" in result:
            #if tool == "Z3": stat('Result-Z3', 'SAFE')
            #if tool == "ELD": stat('Result-ELDARICA', 'SAFE')
            stats.update({"ans":"SAFE"})
        if "checker says false" in result:
            #if tool == "Z3": stat('Result-Z3', 'CEX')
            #if tool == "ELD": stat('Result-ELDARICA', 'CEX')
            stats.update({"ans":"CEX"})
    return {bench:stats}, stats
예제 #14
0
    def finish(self, update_stats=True):
        print 'FINISHING'
        if hasattr(self, '_FINISHED'):
            print 'ALREADY FINISHED'
            return
        self._FINISHED = True

        models = self.models
        testmode = self.testmode
        nrobots = self.nrobots
        procs = self.procs
        tournament = self.tournament

        alive = [model for model in models.values() if model.alive]
        if not testmode and len(alive)==1:
            model = alive[0]
            print 'WINNER:', model.name
            winner = model
            model._outlasted = nrobots-1
        elif not testmode:
            winner = None
            if self.rnd >= conf.maxtime*60:
                print 'Battle stopped after maximum time:', conf.maxtime, 'seconds.'
            else:
                print 'Battle stopped after', int(self.rnd/60), 'seconds.'
            print 'STILL ALIVE:'
            for model in alive:
                print '   ', model.name
        else:
            print 'Test mode ended'
            winner = None

        for robotname, model in models.items():
            print robotname, 'caused', model._damage_caused, 'damage'
            if robotname in procs:
                line = 'FINISH\n'
                proc = procs[robotname]
                proc.stdin.write(line)
                proc.stdin.flush()
                proc.stdin.close()
                proc.stdout.close()
                del procs[robotname]

            if winner is None and model.alive:
                model._outlasted = nrobots - len(alive)

            if model == winner:
                win = 1
            else:
                win = 0

            if update_stats and not testmode:
                stats.update(model.kind, win, nrobots-1, model._outlasted,
                                model._damage_caused, model._kills)

            if update_stats and tournament is not None:
                stats.tournament_update(tournament,
                                            model.kind, model.name, win,
                                            nrobots-1, model._outlasted,
                                            model._damage_caused,
                                            model._kills)
예제 #15
0
def writeNoadd():
    with open(accounts.getFile('noadd.txt'), 'w') as f:
        f.write('\n'.join(map(str, sorted(noadd))))
    stats.update('ignored', len(noadd))
예제 #16
0
def appendNoadd(users):
    noadd.update(users)
    with open(accounts.getFile('noadd.txt'), 'a') as f:
        f.write('\n' + '\n'.join(map(str, sorted(users))))
    stats.update('ignored', len(noadd))
예제 #17
0
 def graphs(self,option):        
     # when option==1, the first graph, self.a is redrawn
     # when option==2, the second graph, self.c is redrawn
   #self.f.text(0.5,0.92,'',fontsize=14)
   #self.f.text(0.5,0.92,self.combobox.get_active_text()+' '+self.combobox2.get_active_text(),fontsize=14,horizontalalignment='center')
   
   #print self.get_suptitle()
   matplotlib.rc('xtick', labelsize=11) 
   matplotlib.rc('ytick', labelsize=11) 
   try:
     if option==1:
       self.a = self.f.add_subplot(221)
       self.a.patch.set_color('black')
       self.a.patch.set_alpha(0.05)
       #print self.a.get_yticks()
       self.a.yaxis.grid('True')
       #print self.combobox.get_active_text()
       self.a.set_xlabel(self.combobox.get_active_text()+' '+self.combobox2.get_active_text(),fontsize=12)
       #print self.a.get_xlabel()
       self.a.set_ylabel('Daily Expense',fontsize=12)
       model=self.treeView.get_model()
       total_list=[0]
       counter=0 
       for i in model:
         for j in i:
           counter+=1
           if counter%7==0:
             total_list.append(j)
           #print j, type(j),
         #print '\n' 
       #print range(len(total_list))
       #print total_list
       if max(total_list)==0:
         M=1
       else:
         M=max(total_list)+0.1*max(total_list)
       self.a.set_ylim(0,M)
       self.a.set_xlim(1,len(total_list)-1)
       days=[]
       for i in range(len(total_list)):
         if i%2!=0:
           days.append(i)
       self.a.set_xticks(days)
       self.a.set_xticklabels(days,fontsize=9)
       
       #print total_list, len(total_list)        
       #total_list.append(100)
       while len(self.line1)!=0:
         l=self.line1.pop(0)
         l.remove()
       total_list.append(0)
       #self.a.set_antialiased(False)
       #print total_list
       self.line1=self.a.fill(total_list,'blue',alpha=0.6)
       self.canvas.draw()
       
     
       #print line
       
       
       self.b=self.f.add_subplot(222)
       self.b.patch.set_color('black')
       self.b.patch.set_alpha(0.05)
       self.b.yaxis.grid('True')
       self.b.set_xlabel('Categories',fontsize=12)
       self.b.set_ylabel('Category Expense',fontsize=12)
       total_list=[0]
       counter=0
       #print 1
       stats.update(self.fname)
       counter=0
       cat=[]
       for i in stats.create_model(self):
         for j in i:
           counter+=1
           if counter%2==0:
             total_list.append(j)
           else:
             cat.append(j)
       
       del total_list[-1]
       del cat[-1]
       #print cat
       #print total_list
       #print 'sfdf'
       if max(total_list)==0:
         M=1
       else:
         M=max(total_list)+0.1*max(total_list)
       self.b.set_ylim(0,M)
       self.b.set_xlim(0.5,5.5)
       self.b.set_xticks([1,2,3,4,5])
       self.b.set_xticklabels(cat,fontsize=9)
       
       #print total_list, len(total_list)        
       #total_list.append(100)
       
       
       while len(self.line1b)!=0:
         l2=self.line1b.pop(0)
         l2.remove()
         
       #self.line1b=[]
       #print 3
       total_list.append(0)
       #self.a.set_antialiased(False)
       #print total_list
       self.line1b=self.b.fill(total_list,'yellow',alpha=0.6)
       self.canvas.draw()
       
       
       
     
     else:
       
       self.c = self.f.add_subplot(212)        
       self.c.patch.set_color('black')
       self.c.patch.set_alpha(0.05)
       self.c.yaxis.grid('True')
       self.c.set_xlabel(self.combobox2.get_active_text(),fontsize=12)
       self.c.set_ylabel('Monthly Expense',fontsize=12)
       
       self.c.set_xlim(0,13)
       self.c.set_xticks(range(1,13))
       #self.c.set_xticks(range(5))
       #for i in max(monthly_totals_list):
         
       #print self.c.get_yticks()
       
       self.c.set_xticklabels(self.months,fontsize=11)
       year=self.combobox2.get_active_text()
       monthly_totals_list=[0]
       
       for i in range(12):
         cost=0
         s=year+'_'+str(self.months[i])
         #print s
         try:
           f=open(app.data_location+s,'r')
           s=f.readlines()
           f.close()
           
           #print 0
           for i in s:
             #print i[19:22]
             #print i
             cost+=float(i[19:27].strip())
             #print cost,
           
         except IOError:
           #print 2
           pass
         #print cost
         monthly_totals_list.append(cost)
       #print 
       
       if max(monthly_totals_list)==0:
         M=1
       else:
         M=max(monthly_totals_list)+0.1*max(monthly_totals_list)
       self.c.set_ylim(0,M)
       
       while len(self.line2)!=0:
         l=self.line2.pop(0)
         l.remove()
       monthly_totals_list.append(0)
       self.line2=self.c.fill(monthly_totals_list,'green',alpha=0.6)
       self.canvas.draw()
       
       ##print line
     
     
   except AttributeError:
     pass
예제 #18
0
def update():
    """Update global game stats."""
    stats.update(bottle.request.forms)
    return [ "OK" ]
예제 #19
0
파일: inf.py 프로젝트: rezvorck/vkbot
def main_loop():
    try:
        if timeto('setonline', setonline_interval):
            vk.setOnline()
        if timeto('filtercomments', filtercomments_interval):
            noaddUsers(vk.filterComments(lambda s: getBotReplyComment(s)), reason='bad comment')
        if timeto('unfollow', unfollow_interval):
            noaddUsers(vk.unfollow(), reason='deleted me')
        if timeto('addfriends', addfriends_interval):
            vk.addFriends(reply, testFriend)
        if includeread_interval >= 0:
            vk.replyAll(reply)
        else:
            vk.replyAll(lambda x: None)
            time.sleep(1)
        if timeto('stats', stats_interval):
            vk.initSelf(True)
            stats.update('ignored', len(friend_controller.noadd))
            stats.update('blacklisted', vk.blacklistedCount())
            count, dialogs, confs, invited = vk.lastDialogs()
            if count is not None:
                vk.loadUsers(dialogs, lambda x: x[0])
                dialogs = [[uid, vk.printableName(uid, '{name}', conf_fmt='Conf "%s"' % confs.get(uid).replace('{', '{{').replace('}', '}}')), cnt, invited.get(uid)]
                           for uid, cnt in dialogs if uid > 0]
                stats.update('dialogs', count)
                stats.update('dialogs_list', dialogs)
                stats.update('phone', vk.vars['phone'])
                stats.update('bf', vk.printableSender({'user_id': vk.vars['bf']['id']}, True))
                stats.update('overload', vk.tracker.overload())
        if timeto('groupinvites', groupinvites_interval):
            vk.acceptGroupInvites()
        bot.reloadIfChanged()
    except Exception as e:
        logging.exception('global {}: {}'.format(e.__class__.__name__, str(e)))
        time.sleep(2)
예제 #20
0
파일: inf.py 프로젝트: rezvorck/vkbot
    srv.addHandler('stem', lambda x: bot.interact('stem ' + x, False))
    srv.addHandler('ignore', ignoreHandler)
    srv.addHandler('unignore', unignoreHandler)
    srv.addHandler('ban', banHandler)
    srv.addHandler('unban', unbanHandler)
    srv.addHandler('reload', reloadHandler)
    srv.addHandler('isignored', isignoredHandler)
    srv.addHandler('leave', leaveHandler)
    srv.addHandler('banlist', banlistHandler)
    srv.addHandler('ignlist', ignlistHandler)
    srv.listen()
    logging.info('Running TCP server on port ' + config.get('server.port'))

friend_controller = vkbot.createFriendController()
friend_controller.writeNoadd()
stats.update('started', time.time())

def main_loop():
    try:
        if timeto('setonline', setonline_interval):
            vk.setOnline()
        if timeto('filtercomments', filtercomments_interval):
            noaddUsers(vk.filterComments(lambda s: getBotReplyComment(s)), reason='bad comment')
        if timeto('unfollow', unfollow_interval):
            noaddUsers(vk.unfollow(), reason='deleted me')
        if timeto('addfriends', addfriends_interval):
            vk.addFriends(reply, testFriend)
        if includeread_interval >= 0:
            vk.replyAll(reply)
        else:
            vk.replyAll(lambda x: None)