Esempio n. 1
0
		def queueRecvData(self, data):
			self.recvLock.acquire()
			self.frameBuffer.append(data)
			log(self, "received data from %s" % self.sid, 3)
			#log(self, "buffered frame: %s" % repr(data), 4)
			self.recvLock.release()
			self.waitLock.set()
Esempio n. 2
0
    def addBlog(self, title, cover_img_url, content, category, tag, user_id):
        '''

        :param title:
        :param content:
        :param category:
        :param tag:
        :return:
        '''
        title = title.replace('\'', '"')
        content = content.replace('\'', '"')
        if type(tag) is list:
            tag = ','.join(tag)
        sql = '''insert into blog(title, cover_img_url, content, category, tag, manager_id) values(%s, %s, %s, %s, %s, %s)'''
        try:
            self.cursor.execute(
                sql, (title, cover_img_url, content, category, tag, user_id))
            self.db.commit()
            # tag_id = self.cursor.lastrowid
            return True
        except Exception as e:
            msg = 'On line {} - {}'.format(sys.exc_info()[2].tb_lineno, e)
            log('mysqlModel.addBlog').logger.error(msg)
            self.db.rollback()
            return False
Esempio n. 3
0
    def updateBlog(self, id, title, cover_img_url, content, category, tag,
                   user_id):
        '''

        :param id:
        :param title:
        :param cover_img_url:
        :param content:
        :param category:
        :param tag:
        :return:
        '''
        title = title.replace('\'', '"')
        content = content.replace('\'', '"')
        sql = '''update blog set title='{title}', content='{content}', cover_img_url='{cover_img_url}', category='{category}', tag='{tag}' where id={id} and manager_id={user_id} '''.format(
            id=id,
            title=title,
            cover_img_url=cover_img_url,
            category=category,
            tag=tag,
            content=content,
            user_id=user_id)
        try:
            self.cursor.execute(sql)
            self.db.commit()
            return True
        except Exception as e:
            msg = 'On line {} - {}'.format(sys.exc_info()[2].tb_lineno, e)
            log('mysqlModel.updateBlog').logger.error(msg)
            self.db.rollback()
            return False
Esempio n. 4
0
 def deleteCategory(self, category_id, user_id):
     '''
     @description: 
     @param {type} 
     @return: 
     '''
     sql = '''delete from category where id=%s and manager_id=%s ''' % (
         category_id, user_id)
     sql_tag = '''delete from tag where category_id=%s and manager_id=%s ''' % (
         category_id, user_id)
     sql_category_name = '''select name from category where id={category_id} '''.format(
         category_id=category_id)
     sql_blog = '''update blog set visible=0 where category='%s' and manager_id={user_id} '''.format(
         category_id=category_id, user_id=user_id)
     try:
         self.cursor.execute(sql_category_name)
         one = self.cursor.fetchone()
         category_name = one[0]
         self.cursor.execute(sql)
         self.db.commit()
         self.cursor.execute(sql_tag)
         self.db.commit()
         self.cursor.execute(sql_blog % category_name)
         self.db.commit()
         return True
     except Exception as e:
         msg = 'On line {} - {}'.format(sys.exc_info()[2].tb_lineno, e)
         log('mysqlModel.deleteCategory').logger.error(msg)
         self.db.rollback()
         return False
Esempio n. 5
0
	def deactivateCB(self, msg, source):
		log("deactivating")
		for track in LiveUtils.getTracks():
			for slot in track.clip_slots:
				if slot.clip != None:
					slot.clip.muted = True
		log("deactivated")
 def getNextExecutedTrade(self,
                          direction,
                          tcond=tradeCondition.REGULAR.value):
     emptyOrderBookSide = False
     tradeVolume = self.getTradeSize()
     if (direction == Direction.DOWN):
         tradePrice = self.bid
         if (tradeVolume > self.bidSize):
             # Cleared out the book on this side - need to generate a new quote line.
             emptyOrderBookSide = True
         else:
             # Reduce the available shares on this side of the book.
             self.bidSize = self.bidSize - tradeVolume
     else:
         tradePrice = self.ask
         if (tradeVolume > self.askSize):
             # Cleared out the book on this side - need to generate a new quote line.
             emptyOrderBookSide = True
         else:
             # Reduce the available shares on this side of the book.
             self.askSize = self.askSize - tradeVolume
     log(
         "trading %s at $%s for %s shares" %
         (self.ticker, tradePrice, tradeVolume), LogLevel.DEBUG)
     self.lastPrice = tradePrice
     self.lastSize = tradeVolume
     self.lastTradeCondition = tcond
     return (tradeVolume, tradePrice, emptyOrderBookSide)
Esempio n. 7
0
    def refresh_state(self):
        log("Refreshing state")
        self.add_clip_listeners()
        self.add_mixer_listeners()
        self.add_scene_listeners()
        self.add_tempo_listener()
        self.add_overdub_listener()
        self.add_tracks_listener()
        self.add_device_listeners()
        self.add_transport_listener()

        trackNumber = 0
        clipNumber = 0
       
        for track in self.song().tracks:
            bundle = OSC.OSCBundle()
            bundle.append("/live/name/track", (trackNumber, str(track.name)))
            for clipSlot in track.clip_slots:
                if clipSlot.clip != None:
                    bundle.append("/live/name/clip", (trackNumber, clipNumber, str(clipSlot.clip.name), clipSlot.clip.color))
                clipNumber = clipNumber + 1
            clipNumber = 0
            trackNumber = trackNumber + 1
            self.oscEndpoint.sendMessage(bundle)
        
        self.trBlock(0, len(self.song().tracks))
Esempio n. 8
0
 def process_(message):
     try:
         temp = message.getContent()
         # 判断第一个字是否是“绑”
         if temp[0] == u"绑":
             fromQQ = str(message.getPersonQQ())
             # msg为一卡通账号
             msg = temp[2:]
             log(moduleName=BindCardModule.name,
                 level="info",
                 content=str(fromQQ) + " " + msg)
             # 判断当前QQ账号是否已经绑定过
             if getinfo(fromQQ)[0] == 0:
                 # 判断当前一卡通是否在all_info.txt内
                 if insertinfo(fromQQ, msg):
                     message.setContent(u"绑定成功!")
                     send(message, True)
                 else:
                     message.setContent(u"请检查您的一卡通账号!")
                     send(message, True)
             else:
                 message.setContent(u"您已注册!")
                 send(message, True)
         else:
             return
     except Exception as e:
         if isinstance(e, Block):
             raise Block()
         log(moduleName=BindCardModule.name,
             level="error",
             content=e.message)
         return
Esempio n. 9
0
    def slot_changed(self):
        slot_index = self.track.playing_slot_index
        self.playing_scene_index = slot_index
        #if slot_index == -2:  #no slot playing
        #log("Playing Slot Index: " + str(slot_index))

        #  CLEAN UP ANY OLD LISTENERS
        if len(self.clip_listener) > 0:
            for old_clip in self.clip_listener:
                if old_clip.playing_position_has_listener(
                        self.clip_listener[old_clip]) == 1:
                    old_clip.remove_playing_position_listener(
                        self.clip_listener[old_clip])
            self.clip_listener = {}

        #MAKE SURE WE HAVE A CLIP AND ASSIGN A PLAYING POSITION LISTENER TO IT
        slot = self.track.clip_slots[slot_index]
        if slot.has_clip:
            clip = slot.clip
            callback = lambda: self.playing_position()
            dir(clip)
            if self.clip_listener.has_key(clip) != 1:
                self.clip_listener[clip] = callback
                clip.add_playing_position_listener(callback)
                log(str(clip.name))
                #copy the triggers onto the clip we're watching
                self.active_triggers = triggers.copy()
        else:
            log("No Clip Playing in Track " + str(self.trackID))
            self.clip_listener = {}
Esempio n. 10
0
def eval_alone(config):
    data = model_data.read_data(config.data, config, read_train=False)
    data = data.test
    seq_rnn_model = SequenceRNNModel(config.n_input_fc, config.num_views, config.n_hidden, config.decoder_embedding_size, config.num_classes+1, config.n_hidden,
                                     batch_size=data.size(),
                                     is_training=False,
                                     use_lstm=config.use_lstm,
                                     use_attention=config.use_attention,
                                     use_embedding=config.use_embedding, num_heads=config.num_heads)
    seq_rnn_model.build_model("train")
    tf_config = tf.ConfigProto()
    tf_config.gpu_options.allow_growth = True
    with tf.Session(config=tf_config) as sess:
    #config.gpu_options.per_process_gpu_memory_fraction = 0.3
        saver = tf.train.Saver()
        saver.restore(sess, get_modelpath(config.weights))
        acc, loss, predictions, labels = _test(data, seq_rnn_model, sess)
    log(config.log_file, "TESTING ACCURACY {}".format(acc))
    
    predictions = [x-1 for x in predictions]  
    labels = [x-1 for x in labels]
    
    import Evaluation_tools as et
    eval_file = os.path.join(config.log_dir, '{}.txt'.format(config.name))
    et.write_eval_file(config.data, eval_file, predictions, labels, config.name)
    et.make_matrix(config.data, eval_file, config.log_dir)    
Esempio n. 11
0
def checkPump():
    log("checking if time to recycle pump")
    now_time = datetime.datetime.now().strftime('%H:%M')
    if now_time == morning or now_time == lunch or now_time == afternoon or now_time == dinner or now_time == night:
        pump(True)
        sleep(runtime)
        pump(False)
Esempio n. 12
0
def open_pavucontrol():
    '''
    Uses subprocess to open the PulseAudio Volume Control application.
    :return: No return value.
    '''
    log(INFO, "open_pavucontrol", "Opening pavucontrol")
    returned_value = sp.Popen("pavucontrol", shell=True, stdout=sp.PIPE)
Esempio n. 13
0
    def is_mounted(self, mount_point):
        log(6, "is_mounted")
        # TODO: we should cache this once we start
        # looking for mount errors

        try:
            fh = open("/proc/mounts", "r")
            for line in fh:
                test_mount_point = line.split()[1]

                try:
                    if os.path.samefile(mount_point, test_mount_point) == True:
                        return True
                except OSError, ex:
                    # Permission denied.  Happens if we compare the file
                    # with a mountpoint we don't have permission to.
                    # The only instance I know where this is possible
                    # is with fuse mountpoints where allow_root is not
                    # enabled

                    # 13 = Permission denied
                    if ex.errno != 13:
                        # reraise the error
                        raise
        finally:
            fh.close()

        return False
Esempio n. 14
0
def process_module_list(input_list):
    '''
    This function is passed a string input from "pactl list modules short" and organizes it as needed.
    :param input_list: A string with at least 1 line, and at least 2 different items separated by tabs.
    :return: A list of shortened names of applicable modules.
    '''
    processed_list = process_list(input_list)
    devices = []
    for item in processed_list:
        if len(item) < 2:
            log(WARNING, "process_module_list",
                "Module with less than 2 items found: \"" + str(item) + "\"")
        # If the item is some sort of null sink (because it could be made via this program):
        elif item[1] == "module-null-sink":
            temp = process_module(item, "sink_name")
            devices.append(temp)
        # If the item is some sort of loopback (because it could be made via this program):
        elif item[1] == "module-loopback":
            temp = process_module(item, "sink", "source")
            devices.append(temp)
        # If the item is some sort of null source (because it could be made via this program):
        elif item[1] == "module-null-source":
            temp = process_module(item, "source_name")
            devices.append(temp)
        # If the item is some sort of remapped source (because it could be made via this program):
        elif item[1] == "module-remap-source":
            temp = process_module(item, "source_name", "master")
            devices.append(temp)
        else:
            # If its not any of the modules listed above, this program doesnt care about it.
            pass
    return devices
Esempio n. 15
0
def test(config):
    is_training = False
    with tf.device('/gpu:0'):
        pointclouds_pl, labels_pl = MODEL.placeholder_inputs(
            config.batch_size, config.num_points)
        is_training_pl = tf.placeholder(tf.bool, shape=())
        # simple model
        pred, end_points = MODEL.get_model(pointclouds_pl,
                                           is_training_pl,
                                           NUM_CLASSES=config.num_classes)
        loss = MODEL.get_loss(pred, labels_pl, end_points)
        # Add ops to save and restore all the variables.
        saver = tf.train.Saver()

    # Create a session
    tf_config = tf.ConfigProto()
    tf_config.gpu_options.allow_growth = True
    tf_config.allow_soft_placement = True
    tf_config.log_device_placement = True
    sess = tf.Session(config=tf_config)
    ld = config.log_dir
    ckptfile = os.path.join(ld, config.snapshot_prefix + str(config.weights))
    saver.restore(sess, ckptfile)
    log(config.log_file, "Model restored.")

    ops = {
        'pointclouds_pl': pointclouds_pl,
        'labels_pl': labels_pl,
        'is_training_pl': is_training_pl,
        'pred': pred,
        'loss': loss
    }

    eval_one_epoch(config, sess, ops)
Esempio n. 16
0
 def add_object(self, instance):
     # find all the functions in the object
     for member in inspect.getmembers(instance):
         if inspect.ismethod(member[1]):
             log(6, "XMLRPC Server Registered %s.%s" % \
                     (instance.__class__.__name__, member[0]))
             self.functions[member[0]] = member[1]
Esempio n. 17
0
 def process(message):
     session = Session()
     try:
         if SendBlessingModule.checkTime():
             waitqq = redisConnection.lpop(REDIS_BLESSING_WAITING_QUEUE)
             if not waitqq:
                 return
             blessQuery = session.query(BlessingModal).order_by(func.rand()).limit(1).first()
             if blessQuery:
                 log(moduleName=SendBlessingModule.name,content=message.getContent())
                 renderblessing = renderBlessing.RenderBlessing(int(waitqq[1:]), blessQuery.fromqq, blessQuery.content)
                 url = renderblessing.render().get_url()
                 message = Message()
                 if waitqq[0]=="0":
                     message.setTargetQQ(SMALLWEI_QQ)
                 else:
                     message.setTargetQQ(SMALLWEI2016_QQ)
                 message.setSubType(1)
                 message.setPersonQQ(int(waitqq[1:]))
                 message.setContent(SendBlessingModule.BLESSING_REPLY.format(url,
                                                                             SendBlessingModule.BLESSING_TITLE,
                                                                             SendBlessingModule.BLESSING_CONTENT,
                                                                             SendBlessingModule.BLESSING_LOGO))
                 send(message,True)
             else:
                 return
         else:
             return
     except Exception as e:
         if isinstance(e,Block):
             raise Block()
         log(moduleName=SendBlessingModule.name,level="error",content=e.message)
         return
     finally:
         session.close()
Esempio n. 18
0
	def handleMsg(self, connection, cmd, msg):
		if(cmd == 30 and connection.authLevel > 0): # send chat
			log(self, "relaying chat from from %s to skype: %s" % (connection, msg[2:]), 2)
			self.chat.SendMessage(msg[2:])
			return # break here so that we don't get echo
		# messages that we don't handle get passed to the usual handler
		CC_Server.handleMsg(self, connection, cmd, msg)
Esempio n. 19
0
    def propose_wall(self, game, player):
        best_total = -99
        game_event = GameEvent("SPACE")

        for x in range(9):
            for y in range(9): 
                side = "TOP"
                log("propose_wall ", x, y, side)
                placed = game.place_wall(player, x, y, side)
                if placed:
                    total = self.evaluate_game(game, player)
                    player.unplayed_wall_count = player.unplayed_wall_count + 1
                    game.unset_wall(game.board, x, y, side)
                    if total > best_total:
                        best_total = total
                        game_event.x = x
                        game_event.y = y
                        game_event.section = side
                        game_event.move_mode = "WALL"
                side = "BOTTOM"
                log("propose_wall ", x, y, side)
                placed = game.place_wall(player, x, y, side)
                if placed:
                    total = self.evaluate_game(game, player)
                    player.unplayed_wall_count = player.unplayed_wall_count + 1
                    game.unset_wall(game.board, x, y, side)
                    if total > best_total:
                        best_total = total
                        game_event.x = x
                        game_event.y = y
                        game_event.section = side 
                        game_event.move_mode = "WALL"
                side = "LEFT"
                log("propose_wall ", x, y, side)
                placed = game.place_wall(player, x, y, side)
                if placed:
                    total = self.evaluate_game(game, player)
                    player.unplayed_wall_count = player.unplayed_wall_count + 1
                    game.unset_wall(game.board, x, y, side)
                    if total > best_total:
                        best_total = total                        
                        game_event.x = x
                        game_event.y = y
                        game_event.section = side
                        game_event.move_mode = "WALL"
                side = "RIGHT"
                log("propose_wall ", x, y, side)
                placed = game.place_wall(player, x, y, side)
                if placed:
                    total = self.evaluate_game(game, player)
                    player.unplayed_wall_count = player.unplayed_wall_count + 1
                    game.unset_wall(game.board, x, y, side)
                    if total > best_total:
                        best_total = total
                        game_event.x = x
                        game_event.y = y
                        game_event.section = side
                        game_event.move_mode = "WALL"
        log("propose_wall event=", game_event)
        return (best_total, game_event)
Esempio n. 20
0
 def addReply(self,
              comment_id,
              user_id,
              content,
              manager_id,
              blog_id,
              replied_id=None,
              replied_user_id=None):
     '''
     '''
     sql = '''insert into reply(comment_id, user_id, content, replied_id, replied_user_id) values(%s, %s, %s, %s, %s)'''
     try:
         self.cursor.execute(
             sql,
             (comment_id, user_id, content, replied_id, replied_user_id))
         self.db.commit()
         reply_id = self.cursor.lastrowid
         reply_message = self.getReply(reply_id=reply_id,
                                       manager_id=manager_id)
         if self.updateCommentReplyCount(
                 manager_id=manager_id, comment_id=comment_id,
                 method='add') and self.updateBlogCommentCount(
                     manager_id=manager_id, blog_id=blog_id):
             if reply_message is not None:
                 return reply_message
         else:
             return None
     except Exception as e:
         msg = 'On line {} - {}'.format(sys.exc_info()[2].tb_lineno, e)
         log('mysqlModel.addReply').logger.error(msg)
         self.db.rollback()
         return None
Esempio n. 21
0
 def _run(self, testId=None):
     self.id = testId
     setUpTestId = (testId or 'root') + '-setUp'
     if not self.isRoot():
         self.setLog("setUp")
     if self.children:
         for kid in self.children:
             self.test(0, kid)
     else:
         try:
             try:
                 self.setUp()
             except:
                 desc = self.classDesc() + ' - setUp'
                 xInfo = self.__excInfo()
                 log(
                     2,
                     'test %s setUp: error ===================================='
                     % desc)
                 self.info.result.addSetUpError(setUpTestId, desc, xInfo)
                 self.setUpFailed = True
             try:
                 self.run()
             finally:  # KeyboardInterrupt must only be here...
                 if not self.isRoot():
                     self.setLog('tearDown')
                 self.tearDown()
         except:
             print 'Error running test suite'
             traceback.print_exc()
             xInfo = self.__excInfo()
             self.logStack(xInfo)
Esempio n. 22
0
    async def display_prefix(self, channel, new_prefix=False):
        description = f"**{self.name}'s {'New ' if new_prefix else ''}Prefix:** `{self.prefix}`\n\n"

        description += f"`{self.prefix} prefix <new_prefix>`" if not new_prefix else ''

        await simple_bot_response(channel, description=description)
        log("prefix", f"{'New Prefix: ' if new_prefix else ''}{vars(self)}")
Esempio n. 23
0
 def getReplyList(self, manager_id, sort_by='update_time'):
     '''
     '''
     sql = '''select a.id, a.comment_id, a.replied_id, a.replied_user_id, a.user_id, a.content,
                 b.nickname as reply_nickname, 
                 c.nickname as user_nickname,
                 a.like_count,
                 e.title,
                 a.update_time,
                 d.content as comment_content,
                 e.id as blog_id,
                 c.picture as picture,
                 c.author as user_admin
                 from reply a left join user b on a.replied_user_id = b.id
                 join user c on a.user_id = c.id
                 join comment d on a.comment_id = d.id
                 join blog e on d.blog_id = e.id
                 where e.manager_id = {manager_id}; '''.format(
         manager_id=manager_id)
     try:
         self.cursor.execute(sql)
         results = self.cursor.fetchall()
         if not results or len(results) <= 0:
             return None
         reply_list = []
         for res in results:
             temp = {}
             temp['id'] = res[0]
             temp['comment_id'] = res[1]
             temp['replied_id'] = res[2]
             if res[6] == None:
                 temp['reply_nickname'] = ''
             else:
                 temp['reply_nickname'] = res[6]
             temp['user_id'] = res[4]
             temp['user_nickname'] = res[7]
             temp['content'] = res[5]
             temp['like_count'] = res[8]
             temp['title'] = res[9]
             temp['update_time'] = res[10].strftime('%Y-%m-%d %H:%M:%S')
             temp['comment_content'] = res[11]
             temp['blog_id'] = res[12]
             temp['user_picture'] = res[13]
             temp['user_admin'] = res[14]
             reply_list.append(temp)
         if sort_by == 'update_time':
             reply_list = sorted(reply_list, key=lambda x: x['update_time'])
             reply_list.reverse()
         elif sort_by == 'id':
             reply_list = sorted(reply_list, key=lambda x: x['id'])
             reply_list.reverse()
         elif sort_by == 'like_count':
             reply_list = sorted(reply_list, key=lambda x: x['like_count'])
             reply_list.reverse()
         return reply_list
     except Exception as e:
         msg = 'On line {} - {}'.format(sys.exc_info()[2].tb_lineno, e)
         log('mysqlModel.getReplyList').logger.error(msg)
         self.db.rollback()
         return None
Esempio n. 24
0
def __get_web_page(url):
    resp = requests.get(url, cookies={'over18': '1'}, verify=True)
    if resp.status_code != 200:
        log(getframeinfo(currentframe()), 'Invalid url:', resp.url)
        return None
    else:
        return resp.text
Esempio n. 25
0
 def getComment(self, comment_id, manager_id):
     '''
     sort_by: 'update_time', 'blog_id', 'id'
     '''
     sql = '''select a.id, a.blog_id, a.user_id, c.nickname, a.content, a.like_count, a.reply_count, a.update_time, b.title, c.picture as user_picture, c.author as user_admin
     from comment a join blog b on a.blog_id=b.id
     join user c on a.user_id=c.id
     where b.manager_id={manager_id} and a.id={comment_id} '''.format(
         manager_id=manager_id, comment_id=comment_id)
     try:
         self.cursor.execute(sql)
         res = self.cursor.fetchone()
         if not res:
             return None
         temp = {}
         temp['id'] = res[0]
         temp['blog_id'] = res[1]
         temp['user_id'] = res[2]
         temp['nickname'] = res[3]
         temp['content'] = res[4]
         temp['like_count'] = res[5]
         temp['reply_count'] = res[6]
         temp['update_time'] = res[7].strftime('%Y-%m-%d %H:%M:%S')
         temp['blog_title'] = res[8]
         temp['user_picture'] = res[9]
         temp['user_admin'] = res[10]
         temp['reply_list'] = []
         return temp
     except Exception as e:
         msg = 'On line {} - {}'.format(sys.exc_info()[2].tb_lineno, e)
         log('mysqlModel.getComments').logger.error(msg)
         self.db.rollback()
         return None
Esempio n. 26
0
    def deleteBlog(self, blog_id, user_id):
        '''

        :param blog_id:
        :param user_id:
        :return:
        '''
        sql_exist = 'select * from blog where id=%s and manager_id=%s ' % (
            blog_id, user_id)
        sql = '''delete from blog where id=%s and manager_id=%s ''' % (blog_id,
                                                                       user_id)
        try:
            self.cursor.execute(sql_exist)
            one = self.cursor.fetchone()
            if one and len(one) > 0:
                self.cursor.execute(sql)
                self.db.commit()
                return True
            else:
                return False
        except Exception as e:
            msg = 'On line {} - {}'.format(sys.exc_info()[2].tb_lineno, e)
            log('mysqlModel.deleteBlog').logger.error(msg)
            self.db.rollback()
            return False
    def on_request(self, ch, method, props, body):

        validRequestTypes = ['shutdown', 'change_frequency']
        request = json.loads(body)
        if (request['type'] in validRequestTypes):
            response = {'status': 'true'}
        else:
            response = {'status': 'false'}
            return

        ch.basic_publish(exchange='',
                         routing_key=props.reply_to,
                         properties=pika.BasicProperties(
                             correlation_id=props.correlation_id),
                         body=json.dumps(response))
        ch.basic_ack(delivery_tag=method.delivery_tag)

        if (request['type'] == 'shutdown'):
            log("Received RPC shutdown instruction", LogLevel.INFO)
            self.onExit()
            self.stop_callback()
        if (request['type'] == 'change_frequency'):
            log("Received Frequency change to %s" % (request['frequency']))
            frequency = request['frequency']
            self.change_freq_callback(frequency)
        else:
            pass
Esempio n. 28
0
    def update_display(self):
        """
        This function is run every 100ms, so we use it to initiate our Song.current_song_time
        listener to allow us to process incoming OSC commands as quickly as possible under
        the current listener scheme.
        """
        ######################################################
        # START OSC LISTENER SETUP
              
        if self.basicAPI == 0:
            # By default we have set basicAPI to 0 so that we can assign it after
            # initialization. We try to get the current song and if we can we'll
            # connect our basicAPI callbacks to the listener allowing us to 
            # respond to incoming OSC every 60ms.
            #
            # Since this method is called every 100ms regardless of the song time
            # changing, we use both methods for processing incoming UDP requests
            # so that from a resting state you can initiate play/clip triggering.

            try:
                doc = self.song()
            except:
                log('could not get song handle')
                return
            try:
                self.basicAPI = LiveOSCCallbacks.LiveOSCCallbacks(self._LiveOSC__c_instance, self.oscEndpoint)
                # Commented for stability
                self.time = 0
                doc.add_current_song_time_listener(self.current_song_time_changed)
            except Exception, e:
                self.oscEndpoint.send('/remix/echo', 'setting up basicAPI failed: %s' % e)
                log('setting up basicAPI failed: %s' % e);
                return
Esempio n. 29
0
 def deleteComment(self, comment_id, user_id, blog_id, manager_id):
     '''
     
     '''
     ###删除评论
     ###删除该评论下的回复
     sql = '''delete from comment where id={comment_id} and blog_id={blog_id} and user_id={user_id} '''.format(
         comment_id=comment_id, blog_id=blog_id, user_id=user_id)
     sql_reply = '''delete from reply where comment_id={comment_id} '''.format(
         comment_id=comment_id)
     try:
         self.cursor.execute(sql)
         self.db.commit()
         self.cursor.execute(sql_reply)
         self.db.commit()
         ###更新博客评论数
         if self.updateBlogCommentCount(manager_id=manager_id,
                                        blog_id=blog_id):
             return True
         else:
             return False
     except Exception as e:
         msg = 'On line {} - {}'.format(sys.exc_info()[2].tb_lineno, e)
         log('mysqlModel.deleteComment').logger.error(msg)
         self.db.rollback()
         return False
Esempio n. 30
0
    def addTag(self, category, tag, user_id):
        '''

        :param category:
        :param tag:
        :return:
        '''
        category_id = self.getCategoryId(category=category, user_id=user_id)
        if category_id is None:
            return False
        sql_exist = '''select * from tag where tag='{tag}' and category_id={category_id} and manager_id={user_id}; '''.format(
            tag=tag, category_id=category_id, user_id=user_id)
        self.cursor.execute(sql_exist)
        one = self.cursor.fetchone()
        if one is not None:
            return True
        sql = '''insert into tag(tag, category_id, manager_id) VALUES(%s, %s, %s) '''
        try:
            self.cursor.execute(sql, (tag, category_id, user_id))
            self.db.commit()
            # tag_id = self.cursor.lastrowid
            return True
        except Exception as e:
            msg = 'On line {} - {}'.format(sys.exc_info()[2].tb_lineno, e)
            log('mysqlModel.addTag').logger.error(msg)
            self.db.rollback()
            return False
Esempio n. 31
0
 def configure_by_ssh(ips):
     ports = ([
         8888, 8889, 29000, 28000, 28500, 22000, 25000, 21100,
         28600, 25123, 27501
     ] + [
         9000 + i
         for i in range(nb_cws_per_instance * nb_cws_instances)
     ] + [26000 + shard for shard in range(20)] +
              [21000 + shard for shard in range(20)])
     public_ip = ips['public']
     private_ip = ips['private']
     log('success', 'Configuring instance %s by SSH...' % ip)
     command_1 = 'ssh -o "StrictHostKeyChecking no" -i "{pem}.pem" ec2-user@{ip} "{command}"'.format(
         pem=self.state_dict['keypair_name'],
         ip=public_ip,
         command=("sudo yum update -y && " +
                  "sudo yum install -y docker && " +
                  "sudo service docker start && " +
                  "sudo usermod -a -G docker ec2-user && " +
                  "exit"))
     command_2 = 'ssh -o "StrictHostKeyChecking no" -i "{pem}.pem" ec2-user@{ip} "{command}"'.format(
         pem=self.state_dict['keypair_name'],
         ip=public_ip,
         command=(
             'docker login -u \\"{u}\\" -p \\"{p}\\"'.format(
                 u=docker_login, p=docker_password) + " && " +
             "docker run -d --privileged --net=host " +
             " ".join("-p {p}:{p}".format(ip=private_ip, p=port)
                      for port in ports) + " " +
             "-e CMS_contest=%d " % cms_contest +
             "totorigolo/cms_cb"))
     os.system(command_1)
     os.system(command_2)
     log('success', 'Instance %s configured by SSH.' % public_ip)
Esempio n. 32
0
def checkWaterQuality():
    ser.flushInput()
    ser.flushOutput()
    log("check water quality time")
    now_time = datetime.datetime.now().strftime('%H:%M')
    time_list = now_time.split(':')
    time_list = [int(i) for i in time_list]

    if time_list[0] == int(morning.split(':')[0]) - 2 or time_list[0] == int(
            dinner.split(':')[0]) - 2:
        log("adjust water quality", "debug")
        checkSensors()
        sleep(5)
        ec = getEC()
        sleep(5)
        if EC_MIN < ec < EC_MAX:
            log("ec value is in range")
            result = True
        elif ec < EC_MIN:
            log("ec value is below range")
            addA()
            sleep(30)
            addB()
            sleep(30)
        elif ec > EC_MAX:
            log("ec value is above range")
            addWater(True)
            sleep(30)
            addWater(False)

        sleep(120)
Esempio n. 33
0
def addWater(switch):
    if switch:
        log("send add water START to serial")
        writeToSerial('won')
    else:
        log("send add water STOP to serial")
        writeToSerial('wof')
Esempio n. 34
0
		def send(self, data):
			self.sendLock.acquire()
			self.sendBuffer.write(data)
			if(self.sendSock):
				self.flush()
			else:
				log(self, "buffered send to: %s" % self.sid, 3)
			self.sendLock.release()
 def add_track_device_listeners(self,tid,track):
     cbt = lambda :self.track_device_listener(tid,track)
     
     if self.mlisten["devices"].has_key(track) != 1:
         self.mlisten["devices"][track] = cbt
     
     track.add_devices_listener(cbt)
     log("Added device listener in track " + str(tid));
Esempio n. 36
0
 def find_connected_spaces(self, graph, victory_row):
     log("find_connected_spaces for row ", victory_row)
     if victory_row == 8:
         space_distances = self.space_distances_p1
     else:
         space_distances = self.space_distances_p2
     connected_spaces = space_distances.keys()
     return connected_spaces
Esempio n. 37
0
	def csi_dispatch(self):
		if(self.privateMarker in privateMarkers \
		and self.char in privateMarkers[self.privateMarker]):
			params = [int(i) if len(i) > 0 else 0 for i in self.paramStr.split(';')]
			cmdName = privateMarkers[self.privateMarker][self.char]
			self.putCommand(Command(cmdName, params))
		else:
			log(self, 'Unrecognized CSI code: %r' % self.debugStr)
Esempio n. 38
0
 def output_graph(self, graph):
     for x in range(9):
         for y in range(9):
             space = self.get(x, y)
             if graph.has_key(space):
                 log(x, y, "->", graph[space])
             else:
                 log(x, y, "->", None)
Esempio n. 39
0
	def handleOutput(self, stream):
		parser = CommandParser(stream)
		while True:
			command = parser.getCommand()
			if(command == None):
				return
			log(self, "cmd: %r" % command, 4)
			self.terminal.handleCmd(command)
Esempio n. 40
0
	def esc_dispatch(self):
		cmd = self.privateMarker + self.char
		if(cmd in escapeCodeStrings):
			self.putCommand(Command(escapeCodeStrings[cmd], None))
		elif(cmd[0] in escapeCodeStrings):
			self.putCommand(Command(escapeCodeStrings[cmd[0]], [cmd[1]]))
		else:
			log(self, 'Unrecognized ESC code: %r' % self.debugStr)
Esempio n. 41
0
 def find_shortest_path(self, player, board):
     log("find_shortest_path for " + str(player))
     graph = board.create_graph()
     start = player.position
     end = board.get(0, player.win_row)
     path = []
     shortest_path = self.find_shortest_path2(graph, start, end, path)
     return shortest_path
Esempio n. 42
0
		def setSendSock(self, sock):
			self.sendLock.acquire()
			self.sendSock = sock
			log(self, "got send sock for %s" % self.sid, 3)
			if(self.sendBuffer.tell()):
				self.flush()
			self.lastResponseTime = time.time()
			self.sendLock.release()
Esempio n. 43
0
		def sendUserData(self, target):
			self.accessLock.acquire()
			log(self, "sending user data to %s" % target.msg(), 3)
			message = "200" # user data list msg
			for connection in self.connections:
				message += "|%s|%s|%s" % (connection.addr[1], connection.font, connection.avatar)
			target.send(message)
			self.accessLock.release()
Esempio n. 44
0
 def update_one(self, col_name: str, _id: str, segments, pos) -> None:
     result = self.db[col_name].update_one(
         {'_id': _id}, {'$set': {
             'segments': segments,
             'pos': pos
         }})
     log(getframeinfo(currentframe()), 'Update result : ',
         result.matched_count)
 def __call__(self, *args, **kwargs):
     args[0].stop()
     args[0].start()
     log(moduleName=RemoteTerminalModule.name,
         content="[stop]" + args[0].name)
     log(moduleName=RemoteTerminalModule.name,
         content="[start]" + args[0].name)
     return True
Esempio n. 46
0
def send(message, blocked=False):
    log(moduleName="Sender", content=message.getJsonStr())
    redisConnection.rpush(switchoutqueue(message.getTargetQQ()),
                          message.getDataStream())
    if blocked:
        raise Block()
    else:
        return
Esempio n. 47
0
	def handleInput(self, sock, stream):
		self.terminal.sendInit(sock)
		while True:
			char = chr(int(sock.recvFrame()))
			if(char == '\r'):
				char = '\n'
			log(self, "recvd: %r" % char, 4)
			stream.write(char)
			stream.flush()
Esempio n. 48
0
		def flush(self):
			self.sendBuffer.seek(0)
			try:
				HTTP_Server.writeHTTP(self.sendSock, 200, {}, "%s\r\n%s" % (self.sid, self.sendBuffer.read()))
			except:
				log(self, "error flushing http send: %s" % self.sid)
			self.sendBuffer = StringIO()
			self.sendSock = None
			log(self, "sent data to: %s" % self.sid, 3)
Esempio n. 49
0
 def is_connected(self, space, victory_row):
     log("is_connected")
     connected = False
     graph = self.graph
     connected_spaces = self.find_connected_spaces(graph, victory_row)
     if space in connected_spaces:
         connected = True
     del connected_spaces[:]
     return connected
Esempio n. 50
0
	def dispatch(self, message, source):
		"""Sends decoded OSC data to an appropriate calback"""
		address = message[0]
		try:
			self.callbacks[address](message, source)
		except Exception, e:
			log("Callback failed: %s" % e)
			import traceback
			trace = traceback.format_exc()
			log(trace)
Esempio n. 51
0
	def broadcast(self, msg):
		lost = []
		for sock in self.connections:
			try:
				sock.send(msg)
			except:
				lost.append(sock)
		for sock in lost:
			self.connections.remove(sock)
			log(self, "Removed connection: %r" % sock)
Esempio n. 52
0
def sendChanMsg(s, chan, message):
    try:
        messageTemp = ("PRIVMSG #" + str(chan.strip()) + " :" + message)
        s.send(messageTemp.strip() + "\r\n")
        sleep(0.5)
        time = datetime.now().strftime('%d-%m-%Y %H:%M:%S')
        toLog = "Forcebotti: " + message.decode('utf8')
        log(toLog, chan)
    except:
        print "sendmessage error"
Esempio n. 53
0
def sendMessage(s, message):
    try:
        sleep(0.1)
        messageTemp = "PRIVMSG #" + str(CHANNEL) + " :" + str(message)
        s.send(messageTemp + "\r\n")
        time = datetime.now().strftime('%d-%m-%Y %H:%M:%S')
        toLog = "Forcebotti: " + message.decode('utf8')
        log(toLog, CHANNEL)
    except:
        print "sendmessage error"
 def build_midi_map(self, midi_map_handle):
     #self.refresh_state()
     """parameter=InputControlElement(MIDI_CC_TYPE,1,8)"""
     """self.parameter=self.song().tracks[0].devices[0].parameters[5].value
     channel=0
     cc=8
     Live.MidiMap.map_midi_cc(midi_map_handle, parameter, channel, cc, Live.MidiMap.MapMode.absolute, True)
     Live.MidiMap.forward_midi_cc(self._LiveOSC__c_instance.handle(), midi_map_handle, channel, cc)"""
     log("entro a build midi map")
     self.add_device_listeners()
Esempio n. 55
0
	def __init__(self):
		CC_Server.__init__(self)
		skypePrefs = {
			"room_id": '#mattwitkowski/$cbd88fa129f3d1f0', \
		}
		self.prefs.update(skypePrefs)
		self.skype = Skype4Py.Skype(Events=self)
		for chat in self.skype.Chats:
			if(chat.Name == self.prefs["room_id"]):
				self.chat = chat
		log(self, "listening to %s" % self.prefs["room_id"])
Esempio n. 56
0
		def recv(self, count):
			data = ''
			while(len(data) < count):
				chunk = self.sock.recv(count)
				if(not chunk):
					return ''
				data += chunk
				data = data.replace('\x00', '')
				data = data.replace('\xFF', '')
			log(self, "recieved data from WebSocket: %r" % data, 4)
			return data
Esempio n. 57
0
		def newSession(self, sock, addr):
			self.accessLock.acquire()
			newSID = addr[1]
			newSession = HTTP_Server.HTTP_Session(newSID)
			self.sessions.append(newSession)
			pingThread = threading.Thread(None, self.pingLoop, "pingLoop", (newSession,))
			pingThread.setDaemon(1)
			pingThread.start()
			self.accessLock.release()
			log(self, "new http session: %s" % newSID, 3)
			return newSession
Esempio n. 58
0
 def __init__(self, c_instance):
     self._LiveOSC__c_instance = c_instance
   
     self.basicAPI = 0       
     self.oscEndpoint = RemixNet.OSCEndpoint()
     self.oscEndpoint.send('/remix/oscserver/startup', 1)
     
     log("LiveOSC initialized")
     
     # Visible tracks listener
     if self.song().tracks_has_listener(self.refresh_state) != 1:
         self.song().add_tracks_listener(self.refresh_state)
Esempio n. 59
0
 def add_clip_listeners(self):
     self.rem_clip_listeners()
 
     tracks = self.getslots()
     for track in range(len(tracks)):
         for clip in range(len(tracks[track])):
             c = tracks[track][clip]
             if c.clip != None:
                 self.add_cliplistener(c.clip, track, clip)
                 log("ClipLauncher: added clip listener tr: " + str(track) + " clip: " + str(clip));
             
             self.add_slotlistener(c, track, clip)
Esempio n. 60
0
    def clip_changestate(self, clip, x, y):
        log("Listener: x: " + str(x) + " y: " + str(y));

        playing = 1
        
        if clip.is_playing == 1:
            playing = 2
            
        if clip.is_triggered == 1:
            playing = 3
            
        self.oscEndpoint.send('/live/clip/info', (x, y, playing))