def applySettingsLocale(self, key) : if key == "application/locale/force_main_lang" : force_main_lang = self.__settings.value("application/locale/force_main_lang").toString() if force_main_lang != self.mainLang() : self.__locale = ( Qt.QLocale() if force_main_lang.isEmpty() else Qt.QLocale(force_main_lang) ) self.localeChangedSignal(self.__locale.name()) Logger.debug(Qt.QString("Accepted new locale \"%1\"").arg(self.__locale.name()))
class Smartcommand: def __init__(self, daemon, smartcmd_id = 0): self.logger = Logger(False, LOG_FILE); self.logger.info('Started SMARTCMD'); self.smartcmd_id = smartcmd_id; self.sql = MasterSql(); self.daemon = daemon; def launch_smartcmd(self, json_obj, connection): if (self.smartcmd_id == 0): self.logger.error('Invalid Smartcommand'); return; query = 'SELECT room_device_id, option_id, option_value, time_lapse FROM smartcommand_elems WHERE smartcommand_id ="'+ str(self.smartcmd_id) +'" ORDER BY exec_id'; res = self.sql.mysql_handler_personnal_query(query); delay_color = 0; for r in res: obj = {}; obj['sync'] = 0; data = {}; data['room_device_id'] = r[0]; data['option_id'] = r[1]; data['value'] = r[2]; obj['data'] = data; obj['packet_type'] = 'smartcmd_launch'; delay = r[3]; if (data['option_id'] == 392 or data['option_id'] == 393 or data['option_id'] == 394): delay_color = delay_color + 1; if (delay > 0 and delay_color <= 1): time.sleep(delay); if (delay_color >= 3): delay_color = 0; self.daemon.send_to_device(obj, connection);
def loadInfo(self, dict_name) : dict_name = str(dict_name) dict_file_name = Utils.joinPath(Const.AllDictsDirPath, dict_name) dict_file = Qt.QFile(dict_file_name) dict_file_stream = Qt.QTextStream(dict_file) if not dict_file.open(Qt.QIODevice.ReadOnly) : Logger.warning(Qt.QString("Cannot open dict file \"%1\" for reading info").arg(dict_file_name)) return self.__info_cache_dict[dict_name] = {} for all_tags_list_item in AllTagsList : self.__info_cache_dict[dict_name][all_tags_list_item] = Qt.QString() while not dict_file_stream.atEnd() : Qt.QCoreApplication.processEvents(Qt.QEventLoop.ExcludeUserInputEvents) line = dict_file_stream.readLine() if line.isEmpty() : continue if line[0] != "#" and line.contains(" ") : break if line[0] == "#" : line.remove(0, 1) line = line.trimmed() key = MiscTag for key_item in self.__info_cache_dict[dict_name].keys() : tag = Qt.QString(key_item+":") if line.startsWith(tag) : line = line.remove(0, tag.length()).simplified() key = str(key_item) break if not self.__info_cache_dict[dict_name][key].isEmpty() : self.__info_cache_dict[dict_name][key].append("<br>") self.__info_cache_dict[dict_name][key].append(line) dict_file.close() ### self.__info_cache_dict[dict_name][FileSizeTag] = Qt.QString().setNum(dict_file.size() / 1024) lang_codes_dict = LangsList.langCodes() direction_regexp = Qt.QRegExp("((..)-(..))") if direction_regexp.exactMatch(self.__info_cache_dict[dict_name][DirectionTag]) : icon_width = icon_height = Qt.QApplication.style().pixelMetric(Qt.QStyle.PM_SmallIconSize) self.__info_cache_dict[dict_name][DirectionTag] = ( Qt.QString("<img src=\"%3\" width=\"%1\" height=\"%2\"> » <img src=\"%4\" width=\"%1\" height=\"%2\">" " %5 » %6 (%7)").arg(icon_width).arg(icon_height) .arg(IconsLoader.iconPath(Utils.joinPath("flags", direction_regexp.cap(2)))) .arg(IconsLoader.iconPath(Utils.joinPath("flags", direction_regexp.cap(3)))) .arg(LangsList.langName(direction_regexp.cap(2), lang_codes_dict)) .arg(LangsList.langName(direction_regexp.cap(3), lang_codes_dict)) .arg(direction_regexp.cap(1)) ) for tag_key in self.__info_cache_dict[dict_name].keys() : if self.__info_cache_dict[dict_name][tag_key].isEmpty() : self.__info_cache_dict[dict_name][tag_key] = tr("Unavailable")
def init(): global colorPairs Logger.put('%d color pairs supported.' % (curses.COLOR_PAIRS)) Logger.put('curses.hasColors() = %d' % (curses.has_colors())) if (colorPairs != None): Logger.put('Colors.init() called more than once!') return if (curses.COLOR_PAIRS < 64): Logger.put('Cannot start unless there is support for 64 color pairs or more!') Logger.put('Your system has: %d pairs.' % (curses.COLOR_PAIRS)) sys.exit(1) pairCount = 1 colorPairs = {} for c1 in colors: colorPairs[c1] = {} for c2 in colors: # if (c2 == WHITE and c1 == BLACK): # continue #Logger.put('%s & %s = %d' % (colorValueToName[c2], colorValueToName[c1], pairCount)) curses.init_pair(pairCount, c2, c1) colorPairs[c1][c2] = pairCount pairCount = pairCount + 1 colorPairs[BLACK][WHITE] = 0
class Engine: def __init__(self): self.logger = Logger() def start(self,sock): (peerIP,peerPort) = sock.getpeername() while True: # Receive message from boss try: msg = sock.recv(1024).strip() self.logger.log("DEBUG","Boss said: {0}".format(msg)) if msg.upper() == "BYE": sock.sendall("[echo]:Bye") sock.close() sock.sendall("[echo]:{0}".format(msg)) except socket.error: self.logger.log("INFO","Bye! Master({0}:{1})".format(peerIP,peerPort)) sock.close() break
def __init__(self, keyspace="Twitter",column_family=None): if(not column_family): logger.subsection("ERROR: no column family specified") return self.keyspace = keyspace self.column_family = column_family return
def taskComplete(self, nodeUUID, jobUUID, task_nr, client_info): """ Mark task as DONE """ render_server = master.Master().getRenderServer() node = render_server.getNode(nodeUUID) if node is None: return False if not node.hasTask(jobUUID, task_nr): # Active task mistmatch. Happens after jobs after network # lags and jobs reassignment Logger.log(('Attempt to copmlete task {0} of job {1}' + 'from wrong node {1} (ip {2})') . format(task_nr, jobUUID, nodeUUID, client_info['address'][0])) return False # Unassign task from node node.unassignTask(jobUUID, task_nr) job = render_server.getJob(jobUUID) if job is None: return False return render_server.taskComplete(job, task_nr)
class IP_IRManager: def __init__(self): self.logger = Logger(False, LOG_FILE); self.sql = MasterSql(); def send_to_gc(self, json_obj, dev, hostame): ir_addr = dev['addr_dst']; tcp_ip = dev['addr']; tcp_port = int(dev['plus1']); if not tcp_port: tcp_port = int(TCP_PORT); request = str(ir_addr); request += '\r'; data = ''; try: s = socket.socket(socket.AF_INET, socket.SOCK_STREAM); s.connect((tcp_ip, tcp_port)); s.send(request.encode()); data = s.recv(BUFFER_SIZE).decode(); s.close(); except Exception as e: self.logger.error(e); self.logger.info("Received Global Cache data :" + str(data));
def executeSeisSolgen( self, i_pathToSeisSolGen, i_commandLineParameters ): l_bashCommand = i_pathToSeisSolGen + ' ' + i_commandLineParameters l_logger.log('generating matrix kernels using '+l_bashCommand, 2) l_bashProcess = subprocess.Popen(l_bashCommand.split(), cwd='.', stdout=subprocess.PIPE, stderr=subprocess.STDOUT) l_logger.log( l_bashProcess.communicate()[0], 3)
def monitor_loop(): """Capture any incoming messages and log to CSV file""" radio.receiver() while True: # See if there is a payload, and if there is, process it if radio.is_receive_waiting(): trace("receiving payload") payload = radio.receive() try: decoded = OpenThings.decode(payload) now = time.time() except OpenThings.OpenThingsException as e: warning("Can't decode payload:" + str(e)) continue OpenThings.showMessage(decoded, timestamp=now) # Any device that reports will be added to the non-persistent directory Registry.update(decoded) ##trace(decoded) Logger.logMessage(decoded) # Process any JOIN messages by sending back a JOIN-ACK to turn the LED off if len(decoded["recs"]) == 0: # handle messages with zero recs in them silently print("Empty record:%s" % decoded) else: # assume only 1 rec in a join, for now if decoded["recs"][0]["paramid"] == OpenThings.PARAM_JOIN: mfrid = OpenThings.getFromMessage(decoded, "header_mfrid") productid = OpenThings.getFromMessage(decoded, "header_productid") sensorid = OpenThings.getFromMessage(decoded, "header_sensorid") Messages.send_join_ack(radio, mfrid, productid, sensorid)
def do_parse_recent(regex, date_str): Logger.debug('do parse: ' + regex + " - " + date_str) now = datetime.date.today() delta = datetime.timedelta(days=7) start = now - delta (day1, ndays) = calendar.monthrange(start.year, start.month) return (start.year, start.month, start.day, now.year, now.month, now.day)
def __init__(self, core): self.core = core Logger.info(logger, 'Module loaded.') if not self.core.files: Logger.error(logger, "Error connect to files manager in core!")
def logParams(self, name): sep = '' paramsOut = Logger.logFile(name + 'Params') contextsOut = Logger.logFile(name + 'Contexts') for featureCounter in self.featureCounters: if isinstance(featureCounter, KNFeatureChain) or \ isinstance(featureCounter, KNFeatureGrid): featureCounter.logParams(paramsOut, contextsOut) continue featureName = featureCounter.feature.name contexts = sorted(featureCounter.contextCounts.iteritems(), key=lambda (key, count): (count, key), reverse=True) for key,count in contexts: if count > 0: contextsOut.log(featureName + '\t' + _contextToStr(key) + '\t' + str(count)) counts = sorted(featureCounter.counts.iteritems(), key=lambda (key, count): (key[0], count, key[1]), reverse=True) for key,count in counts: if count > 0: paramsOut.log(featureName + '\t' + _contextToStr(key[0]) + '\t' + _contextToStr(key[1]) + '\t' + str(count)) self.mixer.logParams(name) paramsOut.close() contextsOut.close()
def withdraw(req, arg): """%withdraw <address> [amount] - Sends 'amount' coins to the specified dogecoin address. If no amount specified, sends the whole balance""" if len(arg) == 0: return req.reply(gethelp("withdraw")) acct = Irc.account_names([req.nick])[0] if not acct: return req.reply_private("You are not identified with freenode services (see /msg NickServ help)") if Transactions.lock(acct): return req.reply_private("Your account is currently locked") if len(arg) == 1: amount = max(Transactions.balance(acct) - 1, 1) else: try: amount = parse_amount(arg[1], acct, all_offset = -1) except ValueError as e: return req.reply_private(str(e)) to = arg[0] if not Transactions.verify_address(to): return req.reply_private(to + " doesn't seem to be a valid dogecoin address") token = Logger.token() try: tx = Transactions.withdraw(token, acct, to, amount) req.reply("Coins have been sent, see http://dogechain.info/tx/%s [%s]" % (tx, token)) except Transactions.NotEnoughMoney: req.reply_private("You tried to withdraw Ɖ%i (+Ɖ1 TX fee) but you only have Ɖ%i" % (amount, Transactions.balance(acct))) except Transactions.InsufficientFunds: req.reply("Something went wrong, report this to mniip [%s]" % (token)) Logger.irclog("InsufficientFunds while executing '%s' from '%s'" % (req.text, req.nick))
def post(self): result = {'status': False} Logger.debug('in register') try: user_id = self.get_argument('user_id', '').lower() user_name = self.get_argument('user_name', '').lower() password = self.get_argument('password', '') lang = self.get_argument('lang', 'zh-CN') Logger.debug('user_id:' + user_id + ', user_name:' + user_name + ', password:'******'' or user_name == '' or password == '': self.write(json.dumps(result)) return user = MongoHelper.get_user_by_id(user_id) if user is not None: self.write(json.dumps(result)) return user = {'user_id': user_id, 'user_name': user_name, 'password': password, 'lang': lang} server = MongoHelper.allocate_user_server() user['server'] = server user['token'] = Utils.generate_access_token(user_id) MongoHelper.register_user(user) MongoHelper.increase_server_usage(server, 1) result['status'] = True user["_id"] = ''; result['user'] = user result['token'] = user['token'] result['server'] = user['server'] Utils.create_face_group(user_id) finally: self.write(json.dumps(result))
def writeFile(self, location, datName, dict): """ Is called when you want the objec to write out a dictionary of values to the specified datFile Args: | location (String): The absolute location specified from the Worker/Engine as to where the datFile is to be written | datName (String): Name for the Datfile | dict (Dictionary): Takes a dictionary of q, i, errors """ self.location = location self.datName = datName self.data = dict #Used for checking if the folder exists.. will be used later in engine if not os.path.exists(self.location): os.makedirs(self.location) loc = self.location+self.datName f = open(loc, 'w') f.write(self.datName + "\n") formatting = '%'+str(4 + self.accuracy)+'s %'+str(6 + self.accuracy)+'s %'+str(6 + self.accuracy)+'s \n' f.write(formatting % ('q', 'I', 'Err')) #Needed for string formatting for i in range(len(self.data['q'])): formatting = '%'+str(8 + self.accuracy)+'.'+str(self.accuracy)+'f %'+str(6 + self.accuracy)+'.'+str(self.accuracy)+'f %'+str(6 + self.accuracy)+'.'+str(self.accuracy)+'f \n' f.write(formatting % (self.data['q'][i], self.data['i'][i], self.data['errors'][i])) f.close() Logger.logger(self.datName, "DatFile Written")
def post(self): result = {'status': False} Logger.debug('in payment') try: user_id = self.get_argument('user_id', '') token = self.get_argument('token', '') plan = self.get_argument('plan','') Logger.info('userid: ' + user_id + ', token:' + token + ', plan:' + plan) if user_id == '': Logger.debug('user id null') return user = MongoHelper.get_user_by_id(user_id) if user is None: Logger.debug('user none') return if token is not user['token']: self.write(json.dumps(result)) Logger.debug('token wrong') return result['quota'] = Utils.update_user_payment(user_id, plan) result['status'] = True finally: self.write(json.dumps(result))
class IP_IRManager: ## The constructor. def __init__(self): ## Logger object for formatting and printing logs self.logger = Logger(False, LOG_FILE) ## SQL object for managing database self.sql = MasterSql() ## Sends a packet to global cache. # # @param json_obj Not used here. # @param dev Object containing the device informations to who send the packet. # @param hostname Not used here. # @return None def send_to_gc(self, json_obj, dev, hostname): ir_addr = dev["addr_dst"] tcp_ip = dev["addr"] tcp_port = int(dev["plus1"]) if not tcp_port: tcp_port = int(TCP_PORT) request = str(ir_addr) request += "\r" data = "" try: s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.connect((tcp_ip, tcp_port)) s.send(request.encode()) data = s.recv(BUFFER_SIZE).decode() s.close() except Exception as e: self.logger.error(e) self.logger.debug("Received Global Cache data :" + str(data))
def vectorizeMatrix( i_pathToDenseMatrix, i_baseName, i_pathToOutputDirectory, i_drawPlots ): l_logger.log('vectorizing: '+ i_pathToDenseMatrix, 2) # read matrix l_denseMatrix = mmread( i_pathToDenseMatrix ) # create list for the vectorized result. l_vectorMatrix = list() # do the vectorization for l_i in xrange(len(l_denseMatrix[:,0])): l_logger.log('current column: ' + str(l_i), 3) l_vectorMatrix.append( computeCoveringIntervals(l_denseMatrix[:,l_i], 4) ) # write vectorized matrix to disk writeSparseVectorizedMatrices( l_denseMatrix, transpose(l_vectorMatrix), i_baseName+'_vec', i_pathToOutputDirectory) # draw plots if i_drawPlots: l_matrixConverter.plotSparsityPattern( l_denseMatrix, i_baseName, i_pathToOutputDirectory ) plotVectorization( l_vectorMatrix, i_baseName, i_pathToOutputDirectory )
def privmsg(self, targ, text, priority = None): Logger.log("c", self.instance + ": %s <- %s " % (targ, text)) for i in xrange(0, len(text), 350): if priority: Irc.instance_send(self.instance, ("PRIVMSG", targ, text[i:i+350]), priority = priority) else: Irc.instance_send(self.instance, ("PRIVMSG", targ, text[i:i+350]))
def InitGL(self): self.custom_init() Logger.trace("info", "EchoesGLCanvas.InitGL()") # set viewing projection # done in OnSize # model projection mode glMatrixMode(GL_MODELVIEW) glClearDepth(1.0) glEnable(GL_DEPTH_TEST) glEnable(GL_NORMALIZE) glEnable(GL_COLOR_MATERIAL) glEnable(GL_BLEND) glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) glShadeModel(GL_SMOOTH) glHint(GL_LINE_SMOOTH_HINT, GL_NICEST) glEnable(GL_LINE_SMOOTH) glEnable(GL_LIGHTING) glEnable(GL_LIGHT0) self.setLight(0.8) self.targetLightLevel = 0.8 self.lineWidthRange = glGetIntegerv(GL_LINE_WIDTH_RANGE) try: self.lineWidthRange[1] except IndexError: Logger.warning( "*** HACK *** setting lineWidthRange manually") self.lineWidthRange = [1, 10]
def waitForStatusLineUpdateConfirmation(self, inputHandler = None): if (inputHandler == None): inputHandler = InputHandler.SingletonKeyboardInputHander(self.screen) promptMessage = 'PRESS A KEY' promptMessageLength = len(promptMessage) y = self.getTerminalHeight() - 1 x = self.getTerminalWidth() - self.maxSideBarLen - 1 promptMessageAttr = Colors.BLINK | Colors.getPairNumber('BLACK', 'YELLOW') self.screen.addnstr(y, x, promptMessage, promptMessageAttr) self.draw() curses.flash() #Visual bell keyPressed = inputHandler.waitForKey() Logger.put(' key found: %s' % (str(keyPressed))) self.resetStatusLinesAppended() #erase the prompt message self.screen.addnstr(y, x, ' ' * promptMessageLength, promptMessageAttr) self.draw()
def OnEndScenario(self, evt): self.scenario = None if evt.name == "Intro" or evt.name == "BubbleWorld" or "Garden" in evt.name: # Introduce a new transition bubble except in the Intro scene trans_bubble = None if evt.name == "Intro": for id,object in self.objects.items(): if isinstance(object, objects.Bubbles.EchoesBubble): trans_bubble=object break for id, object in self.sceneElements.items(): if isinstance(object, environment.Menu.UserMenu): object.remove(False) if not trans_bubble: trans_bubble = objects.Bubbles.EchoesBubble(self.app, True, fadeIn=True, fadingFrames=100) trans_bubble.setStartPos((0,0,0)) trans_bubble.interactive = False trans_bubble.colour = "red" trans_bubble.moving = True trans_bubble.setTargetPos((self.orthoCoordWidth, self.orthoCoordWidth / self.aspectRatio, self.orthoCoordDepth)) trans_bubble.removeAtTargetPos = True trans_bubble.removeAction = "PublishScenarioEnded" trans_bubble.callback = evt.callback trans_bubble.removeActionArgs = evt.name else: Logger.warning("Unknown scenario in endScenario: " + evt.name) evt.callback.ice_response() self.renderPiavca = False self.currentScene = None
def OnRemoveObject(self, evt): if int(evt.objId) in self.app.canvas.objects: o = self.app.canvas.objects[int(evt.objId)] o.remove() else: Logger.warning("No object " + evt.objId + " in world, not removing") evt.callback.ice_response()
def get_images_by_tags_array(user_id, tags_list, image): Logger.debug("get_images_by_tags_array: " + str(tags_list)) image_res = [] for tags in tags_list: img_list = get_image_by_tags(user_id, tags) image_res.append(set(img_list)) image_res.append(set(image)) Logger.debug("get_images_by_tags_array set list: " + str(image_res)) # [[set(), set()...]] inter_sec = [] if len(image_res) > 1: for i in range(1, len(image_res) + 1): inter = [] for i in combinations(image_res, i): res = set.intersection(*i) inter.append(res) inter_sec.append(inter) else: inter_sec = [image_res] final_list = [] inter_sec.reverse() image_pool = set() for i in inter_sec: for s in i: if not s in final_list: insert_set = s - (s & image_pool) if insert_set: final_list.append(insert_set) image_pool = image_pool | s return final_list
def _nick(instance, source, newnick): nick = Irc.get_nickname(source) for channel in Global.account_cache: if nick in Global.account_cache[channel]: Global.account_cache[channel][newnick] = Global.account_cache[channel][nick] Logger.log("w", "%s -> %s in %s" % (nick, newnick, channel)) del Global.account_cache[channel][nick]
def get_similar_tags(user_id, input_tags): filename = get_user_path(user_id) + "/" + "image_indexer.dat" stored_tags = mc.get(user_id + "_image") if not stored_tags: if not os.path.exists(filename): stored_tags = [[], []] else: with open(filename, "rb") as fp: stored_tags = pickle.load(fp) if stored_tags is None: return None Logger.debug("indexer keys: " + str(stored_tags[0])) result = [] for input_tag in input_tags: rate_index = [] tag_list = [] for stored_tag in stored_tags[0]: rate = fuzz.ratio(input_tag, stored_tag) if rate >= 80: tag_list.insert(bisect.bisect(rate_index, rate), stored_tag) bisect.insort(rate_index, rate) result.append(tag_list) return result
def connect_instance(instance): Logger.log("c", instance + ": Connecting") try: host = random.choice(socket.gethostbyname_ex(Config.config["host"])[2]) sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) if Config.config.get("ssl", None): sock = ssl.wrap_socket(sock, ca_certs = Config.config["ssl"]["certs"], cert_reqs = ssl.CERT_REQUIRED) sock.connect((host, Config.config["port"])) sock.settimeout(0.1) except socket.error as e: type, value, tb = sys.exc_info() Logger.log("me", "ERROR while connecting " + instance) Logger.log("me", repr(e)) Logger.log("me", "".join(traceback.format_tb(tb))) del Global.instances[instance] threading.Thread(target = reconnect_later, args = (60, instance)).start() return writer = threading.Thread(target = writer_thread, args = (instance, sock)) reader = threading.Thread(target = reader_thread, args = (instance, sock)) Global.instances[instance].reader_dying.clear() Global.instances[instance].reader_dead.clear() Global.instances[instance].writer_dying.clear() Global.instances[instance].writer_dead.clear() Global.instances[instance].lastsend = time.time() writer.start() reader.start() Logger.log("c", instance + ": Initiating authentication") instance_send(instance, ("CAP", "REQ", "sasl"), lock = False) instance_send(instance, ("NICK", instance), lock = False) instance_send(instance, ("USER", Config.config["user"], "*", "*", Config.config["rname"]), lock = False)
def applyUserStyleCss(self, send_signal_flag) : user_style_css_file_path = self.userStyleCssPath() user_style_css_file = Qt.QFile(user_style_css_file_path) user_style_css_file_stream = Qt.QTextStream(user_style_css_file) if not user_style_css_file.exists() : if user_style_css_file.open(Qt.QIODevice.WriteOnly) : Logger.debug(Qt.QString("Created empty CSS file \"%1\"").arg(user_style_css_file_path)) else : Logger.warning(Qt.QString("Cannot open CSS file \"%1\" for reading").arg(user_style_css_file_path)) user_style_css_file.close() if self.__user_style_css_watcher.files().count() < 1 : self.__user_style_css_watcher.addPath(user_style_css_file_path) if user_style_css_file.open(Qt.QIODevice.ReadOnly) : Logger.debug(Qt.QString("Apply user CSS from \"%1\"").arg(user_style_css_file_path)) user_style_css = Qt.QString("%1\n%2\n").arg(DefaultCss).arg(user_style_css_file_stream.readAll()) user_style_css.remove(Qt.QRegExp("/\\*([^*]|\\*[^/]|\\n)*\\*/")) user_style_css_file.close() if self.__css.trimmed() != user_style_css.trimmed() : self.__css = user_style_css if send_signal_flag : Logger.debug("CSS has been updated") self.cssChangedSignal() else : Logger.warning(Qt.QString("Cannot open CSS file\"%1\" for reading").arg(user_style_css_file_path))
def update_image_indexer(user_id, img): filename = get_user_path(user_id) + "/" + "image_indexer.dat" indexer = mc.get(user_id + "_image") if not indexer: if not os.path.exists(filename): indexer = {} else: with open(filename, "rb") as fp: indexer = pickle.load(fp) if indexer is None: return for tag in img["tags"]: if indexer[0].count(tag) is 0: indexer[0].append(tag) indexer[1].append([img["image_name"]]) else: tag_index = indexer[0].index(tag) indexer[1][tag_index].append(img["image_name"]) with open(filename, "wb") as fp: pickle.dump(indexer, fp) mc.set(user_id + "_image", indexer) Logger.debug("image indexer updated: " + str(indexer))
# Copyright (C) 2017 Siavoosh Payandeh Azad, Stephen Oyeniran # for each new function we start from empty set! import Logger import sys import copy import itertools import time import package package.generate_folders(package.generated_files_folder) sys.stdout = Logger.Logger(package.generated_files_folder) if "-sp" in sys.argv[1:]: saf_output_patterns_file_name = package.generated_files_folder + "/" + "SAF" + sys.argv[ sys.argv.index('-sp') + 1] else: saf_output_patterns_file_name = package.generated_files_folder + "/" + "SAFpatterns.txt" def check_if_sufficient(function_dict, function_id_1, function_id_2, list_patterns, debug, verbose): or_op = "0" * package.data_width if debug: print "\t--------------------" print "\tchecking if sufficient number of ones reached!" print "\t\tline\top1\t\top2\t\tfunc_1 \t\t func_2\t\txor(1,2)\tand(1,xor)\tor(prev_or,and)" print "\t\t" + "------------------------------------------" * 3 for i in list_patterns: xor_op = format( int(function_dict[i][function_id_1], 2) ^ int(function_dict[i][function_id_2], 2),
def _updateVtecRecords(self, vtecRecords, newRecords, issueTime): '''Merges the previous active table and new records into a new table. Keyword Arguments: vtecRecords -- list of dictionaries representing existing vtecRecords, non-consolidated form. newRecords -- list of dictionaries representing new vtecRecords to be merged, non-consolidated form. issueTime -- time of issuance, in units of milliseconds since epoch of Jan 1 1970 at 0000z. Returns a tuple of 3 values: updated table -- merged results purged records -- vtecRecords that were purged changeFlag -- True if anything has changed. ''' updatedTable = [] changedFlag = False #delete "obsolete" records from the old table. vts = VTECTableSqueeze(issueTime) vtecRecords, tossRecords = vts.squeeze(vtecRecords) for r in tossRecords: r['state'] = "Purged" del vts if len(tossRecords): changedFlag = True #expand out any 000 UGC codes, such as FLC000, to indicate all #zones. We do this by finding existing records with the 'id' #that matches. newRecExpanded = [] compare1 = ['phen', 'sig', 'officeid', 'etn'] for newR in newRecords: if newR['id'][3:6] == "000": for oldR in vtecRecords: if self.vtecRecordCompare(oldR, newR, compare1) and \ oldR['id'][0:2] == newR['id'][0:2] and \ (oldR['act'] not in ['EXP', 'CAN', 'UPG'] or \ oldR['act'] == 'EXP' and oldR['endTime'] > issueTime): newE = copy.deepcopy(newR) newE['id'] = oldR['id'] newRecExpanded.append(newE) else: newRecExpanded.append(newR) newRecords = newRecExpanded # match new records with old records, with issue time is different # years and event times overlap. Want to reassign ongoing events # from last year's issueTime to be 12/31/2359z, rather than the # real issuetime (which is this year's). cyear = time.gmtime(issueTime)[0] #current year issuance time lastYearIssueTime = time.mktime((cyear-1, 12, 31, 23, 59, 0, -1, -1, -1)) compare = ['phen', 'sig', 'officeid', 'etn'] for newR in newRecords: for oldR in vtecRecords: if self.vtecRecordCompare(oldR, newR, compare): oldYear = time.gmtime(oldR['issueTime'])[0] newYear = time.gmtime(newR['issueTime'])[0] if oldYear < newYear and self._vtecRecordsOverlap(oldR, newR): LogStream.logVerbose("Reset issuance time to last year:", "\nNewRec: ", self.printEntry(newR), "OldRec: ", self.printEntry(oldR)) newR['issueTime'] = lastYearIssueTime LogStream.logVerbose("Changed To:", self.printEntry(newR)) # split records out by issuance year for processing newRecDict = {} #key is issuance year oldRecDict = {} years = [] for newR in newRecords: issueYear = time.gmtime(newR['issueTime'])[0] records = newRecDict.get(issueYear, []) records.append(newR) newRecDict[issueYear] = records if issueYear not in years: years.append(issueYear) for oldR in vtecRecords: issueYear = time.gmtime(oldR['issueTime'])[0] records = oldRecDict.get(issueYear, []) records.append(oldR) oldRecDict[issueYear] = records if issueYear not in years: years.append(issueYear) # process each year compare = ['id', 'phen', 'sig', 'officeid'] for year in years: newRecords = newRecDict.get(year,[]) oldRecords = oldRecDict.get(year,[]) # now process the old and new records for oldR in oldRecords: keepflag = True for newR in newRecords: if newR['act'] == "ROU": continue if self.vtecRecordCompare(oldR, newR, compare): #we don't keep older records with same etns if newR['etn'] == oldR['etn']: keepflag = False #don't bother keeping this record break #higher etns elif newR['etn'] > oldR['etn']: #only keep older etns if end time hasn't passed #or old record is UFN and CAN: ufn = oldR.get('ufn', 0) if issueTime > oldR['endTime'] or \ (oldR['act'] == "CAN" and ufn) or \ oldR['act'] in ['EXP','UPG','CAN']: keepflag = False break #lower etns, ignore (keep processing) if not keepflag: oldR['state'] = "Replaced" changedFlag = True updatedTable.append(oldR) #always add in the new records (except for ROU) compare = ['id', 'phen', 'sig', 'officeid', 'etn'] for year in newRecDict.keys(): newRecords = newRecDict[year] for newR in newRecords: if newR['act'] != "ROU": #for COR, we need to find the original action, and #substitute it. if newR['act'] == "COR": for rec in updatedTable: if self.vtecRecordCompare(rec, newR, compare): LogStream.logVerbose(\ "COR record matched with:", "\nNewRec: ", self.printEntry(newR), "OldRec: ", self.printEntry(rec), "\nReassign action to: ", rec['act']) newR['act'] = rec['act'] break #due to above code, this should never execute if newR['act'] == "COR": LogStream.logProblem("COR match not found for:\n", self.printEntry(newR), "\nRecord discarded.") if newR['act'] != "COR": updatedTable.append(newR) changedFlag = True return updatedTable, tossRecords, changedFlag
def ingestVTEC(self, vtecAnalyzedRecords, vtecRecords, issueTime): '''Performs the ingester operation for VTEC codes. Keyword Arguments: vtecAnalyzedRecords -- List of dictionaries representing calculated vtec records to be merged into the vtecRecords. Non-consolidated by id. vtecRecords -- List of dictionaries representing already issued vtec records from the database. Non-consolidated by id issueTime -- current time for processing records, same as issuance time. Units are milliseconds since epoch of Jan 1 1970 0000z. Affects purging of old records. Returns a dictionary containing the following elements, which are generally vtecRecords based on action performed: updatedVtecRecords -- vtecRecords merge final results replacedRecords -- vtecRecords that were replaced decodedRecords -- vtecRecords that were decoded (incoming analyzed) otherRecords -- other vtecRecords not affected purgedRecords -- vtecRecords that were purged changedFlag -- indicates whether any records were changed ''' LogStream.logDebug("Ingest VTEC...............") # ensure we have an issueTime in the records, and a 'state' for rec in vtecAnalyzedRecords: rec['issueTime'] = issueTime rec['state'] = 'Decoded' #add in the Previous state to the existing vtec records for r in vtecRecords: r['state'] = "Previous" #perform the merging updatedTable, purgeRecords, changedFlag = \ self._updateVtecRecords(vtecRecords, vtecAnalyzedRecords, issueTime) replaced = [r for r in updatedTable if r['state'] == "Replaced"] decoded = [r for r in updatedTable if r['state'] == "Decoded"] other = [r for r in updatedTable if r['state'] not in ['Replaced', 'Decoded']] self._vtecRecords = [r for r in updatedTable if r['state'] not in ['Replaced', 'Purged']] #strip out the "state" field for r in self._vtecRecords: del r['state'] # return the information about changes d = {} d['updatedVtecRecords'] = self._vtecRecords d['replacedRecords'] = replaced d['decodedRecords'] = decoded d['otherRecords'] = other d['purgedRecords'] = purgeRecords d['dbChanged'] = changedFlag LogStream.logDebug("Updated VTEC Records:\n", self.printVtecRecords( self._vtecRecords, combine=True)) LogStream.logDebug("Replaced VTEC Records:\n", self.printVtecRecords( replaced, combine=True)) LogStream.logDebug("Decoded VTEC Records:\n", self.printVtecRecords( decoded, combine=True)) LogStream.logDebug("Purged VTEC Records:\n", self.printVtecRecords( purgeRecords, combine=True)) return d
def usage(): '''Prints bot usage''' print("Schedule Bot by piLigrym and Reni Min.\n\nUsage:\n" "python schedule.py -c '<config_path>'\n\nOptions:\n\n" "-h, --help\t-\thelp\n-c, --config\t-\tPath to configuration file") if __name__ == '__main__': try: opts, args = getopt.getopt(sys.argv[1:], "hc:", ["help", "config="]) except getopt.GetoptError as err: print(str(err)) usage() sys.exit(2) config = None for o, a in opts: if o in ("-h", "--help"): usage() sys.exit() elif o in ("-c", "--config"): config = a else: assert False, "unhandled option" BotConfig(config) bot = ScheduleBot(Updater(BotConfig.token)) addHandlers(bot) try: bot.run() except: Logger.log(traceback.format_exc())
# See the License for the specific language governing permissions and # limitations under the License. import time import Constants import Logger import Style import Utils from AbstractTreeWidget import AbstractTreeWidget from AbstractWidgetItem import AbstractWidgetItem from ItemDelegate import JobThinProgressBarDelegate from Manifest import QtCore, QtGui, QtWidgets, opencue from MenuActions import MenuActions logger = Logger.getLogger(__file__) COLUMN_COMMENT = 1 COLUMN_EAT = 2 COLUMN_MAXRSS = 13 FONT_BOLD = QtGui.QFont("Luxi Sans", -1, QtGui.QFont.Bold) def getEta(stats): if stats.runningFrames: remaining = (((stats.pendingFrames - 1) * stats.avgFrameSec) + stats.highFrameSec) if remaining: return Utils.secondsToHHHMM(remaining / stats.runningFrames) return "-"
class VmfShell(object): """ Interative shell to Vmfcat. The shell can be use to build a VMF message. """ CMD_SAVE = 'save' CMD_LOAD = 'load' CMD_SEARCH = 'search' CMD_SET = 'set' CMD_SHOW = 'show' CMD_HEADER = 'header' CMD_HELP = 'help' CMD_QUIT = 'quit' PROMPT = "<<< " def __init__(self, _output=sys.stdout): """ Initializes the user interface by defining a Logger object and defining the standard output. """ self.output = _output self.logger = Logger(_output, _debug=True) def start(self): """ Starts the main loop of the interactive shell. """ # Command entered by the user cmd = "" self.logger.print_info( "Type 'help' to show a list of available commands.") while (cmd.lower() != VmfShell.CMD_QUIT): try: self.output.write(VmfShell.PROMPT) user_input = sys.stdin.readline() tokens = user_input.rstrip().split() cmd = tokens[0] if (cmd.lower() == VmfShell.CMD_QUIT): pass elif (cmd.lower() == VmfShell.CMD_HELP): if (len(tokens) == 1): self.logger.print_info("{:s} <field>|all".format( VmfShell.CMD_SHOW)) self.logger.print_info("{:s} <field> <value>".format( VmfShell.CMD_SET)) self.logger.print_info( "{:s} [field] {{bin, hex}}".format( VmfShell.CMD_HEADER)) self.logger.print_info("{:s} <field>".format( VmfShell.CMD_HELP)) self.logger.print_info("{:s} <field>".format( VmfShell.CMD_SEARCH)) self.logger.print_info("{:s} <file>".format( VmfShell.CMD_SAVE)) self.logger.print_info("{:s} <file>".format( VmfShell.CMD_LOAD)) self.logger.print_info("{:s}".format( VmfShell.CMD_QUIT)) else: param = tokens[1] if (param in Params.__dict__.keys()): help_msg = Params.parameters[param]['help'] self.logger.print_info(help_msg) if (len(Params.parameters[param]['choices']) > 0): choices_msg = ', '.join([ choice for choice in Params.parameters[param]['choices'] ]) self.logger.print_info( "Available values: {:s}".format( choices_msg)) else: self.logger.print_error( "Unknown parameter/option: {:s}.".format( param)) elif (cmd.lower() == VmfShell.CMD_SHOW): # # Displays the value of the given field # if (len(tokens) == 2): param = tokens[1] if (param in Params.parameters.keys()): value = Params.__dict__[param] if (isinstance(value, int)): value = "0x{:02x}".format(value) self.logger.print_info("{} = {}".format( param, value)) elif param.lower() == "all": for p in Params.parameters.keys(): value = Params.__dict__[p] self.logger.print_info("{} = {}".format( p, value)) else: self.logger.print_error( "Unknown parameter/option {:s}.".format(param)) else: self.logger.print_error("Usage: {s} <field>".format( VmfShell.CMD_SHOW)) elif (cmd.lower() == VmfShell.CMD_SET): # # Sets a field with the given value # # TODO: Issues with parameters with boolean values if (len(tokens) >= 3): param = tokens[1] value = ' '.join(tokens[2:]) if (param in Params.__dict__.keys()): if (Params.parameters[param]["choices"]): if (value in Params.parameters[param] ["choices"]): Params.__dict__[param] = value new_value = Params.__dict__[param] self.logger.print_success( "{:s} = {:s}".format(param, new_value)) else: self.logger.print_error( "Invalid value ({:s}) for field {:s}.". format(value, param)) self.logger.print_info( "Values for field are : {:s}.".format( ','.join( str(Params.parameters[param] ["choices"])))) else: Params.__dict__[param] = value new_value = Params.__dict__[param] self.logger.print_success("{:s} = {:s}".format( param, new_value)) else: self.logger.print_error( "Unknown parameter {:s}.".format(param)) else: self.logger.print_error( "Usage: {:s} <field> <value>".format( VmfShell.CMD_SET)) elif (cmd.lower() == VmfShell.CMD_HEADER): field = "vmfversion" fmt = "bin" if (len(tokens) >= 2): field = tokens[1] if (len(tokens) == 3): fmt = tokens[2] vmf_factory = Factory(_logger=self.logger) vmf_message = vmf_factory.new_message(Params) vmf_elem = vmf_message.header.elements[field] if (isinstance(vmf_elem, Field)): vmf_value = vmf_elem.value elif (isinstance(vmf_elem, Group)): vmf_value = "n/a" else: raise Exception( "Unknown type for element '{:s}'.".format(field)) vmf_bits = vmf_elem.get_bit_array() output = vmf_bits if (fmt == "bin"): output = vmf_bits.bin if (fmt == "hex"): output = vmf_bits.hex self.logger.print_success("{}\t{}\t{}".format( field, vmf_value, output)) elif (cmd.lower() == VmfShell.CMD_SEARCH): keyword = ' '.join(tokens[1:]).lower() for p in Params.parameters.keys(): help = Params.parameters[p]['help'] if (p.lower() == keyword or keyword in help.lower()): self.logger.print_success("{:s}: {:s}".format( p, help)) elif (cmd.lower() == VmfShell.CMD_SAVE): if len(tokens) == 2: file = tokens[1] tmpdict = {} for param in Params.parameters.keys(): value = Params.__dict__[param] tmpdict[param] = value with open(file, 'w') as f: json.dump(tmpdict, f) self.logger.print_success( "Saved VMF message to {:s}.".format(file)) else: self.logger.print_error( "Specify a file to save the configuration to.") elif (cmd.lower() == "test"): if (len(tokens) == 2): vmf_params = tokens[1] else: vmf_params = '0x4023' s = BitStream(vmf_params) bstream = BitStream('0x4023') vmf_factory = Factory(_logger=self.logger) vmf_message = vmf_factory.read_message(bstream) elif (cmd.lower() == VmfShell.CMD_LOAD): if len(tokens) == 2: file = tokens[1] with open(file, 'r') as f: param_dict = json.load(f) for (param, value) in param_dict.iteritems(): Params.__dict__[param] = value self.logger.print_success( "Loaded VMF message from {:s}.".format(file)) else: self.logger.print_error( "Specify a file to load the configuration from.") else: self.logger.print_error( "Unknown command {:s}.".format(cmd)) except Exception as e: self.logger.print_error("An exception as occured: {:s}".format( e.message)) traceback.print_exc(file=sys.stdout)
# not use this file except in compliance with the License. You may obtain # a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. import Logger from Component import (ComponentBase, RuntimeComponent, UninstallComponent, InstallComponent) LOG = Logger.getLogger("install.quantum") class QuantumUninstaller(UninstallComponent): def __init__(self, *args, **kargs): pass class QuantumInstaller(InstallComponent): def __init__(self, *args, **kargs): pass class QuantumRuntime(RuntimeComponent): def __init__(self, *args, **kargs): pass
def __init__(self): music_logger = Logger.Logger('music_all.log', 'debug') music_logger.logger.debug('This is a test log.')
def __init__(self): self._DirectNotify__categories = {} self.logger = Logger.Logger() self.streamWriter = None
hasMore = False #定义配置文件 basePath = "/home/xiaolvquan/xiaolvquan/cron-job" logPath = "/home/xiaolvquan/xiaolvquan/cron-job/logs" globalConfFile = "%s/conf/global.conf" % basePath globalConf = ParseConf.ParseConf(globalConfFile) #获取 api 参数 appKey = globalConf.readGet('jdUnionApi', 'appKey') appSecret = globalConf.readGet('jdUnionApi', 'appSecret') hostUrl = globalConf.readGet('jdUnionApi', 'hostUrl') #获取数据库配置 mdb = MySqlConnection.MySqlConnection() #md5 转换 md5 = lambda pwd: hashlib.md5(pwd).hexdigest() currentDay = time.strftime('%Y-%m-%d', time.localtime(time.time())) log = Logger.Logger(logPath + "/fetchOrders_" + currentDay + ".log", level='debug') unionTagPinGou = ['00000100', '00000111'] def getSign(parameters): """ 签名 @param parameters dict: uri请求参数(包含除signature外的公共参数) """ if "signature" in parameters: parameters.pop("signature") # NO.1 参数排序 _my_sorted = sorted(parameters.items(), key=lambda parameters: parameters[0]) # NO.2 排序后拼接字符串 canonicalizedQueryString = '' for (k, v) in _my_sorted:
''' Created on Jun 30, 2011 @author: benjaminjcampbell ''' import collections import Logger log = Logger.Logger() createdBy = 'COConver Utility' import clr clr.AddReference('CruiseDAL') clr.AddReference('System') from System import Array from System import Object from CruiseDAL import DAL def toFloat(val): return float(val) if val else 0.0 #utility method for getting float values from metakit #used for catching obviously corrupt values #e(epsilon) is the smallest a value can be, before it is considered 0 #max is the largest value we can reasonably expect
async def on_guild_join(guild): db.create_guild(guild.id, guild.name, guild.owner.id) await Logger.info("%s joined a new guild: %s" % (client.user.name, paint.color(guild.name + " (%s)" % guild.id, "white"))) @client.event async def on_guild_remove(guild): db.delete_guild(guild.id) await Logger.info("%s left a guild: %s" % (client.user.name, paint.color(guild.name + " (%s)" % guild.id, "white"))) try: client.loop.run_until_complete(client.start(config.CONFIG["TOKEN"])) except ConnectionResetError: Logger.warn("Connection reset by peer... Everything should still be fine") except discord.LoginFailure: print( "It seems like no %s was given or it was incorrect. Please check the %s!" % (paint.color("Discord Bot Token", "red"), paint.color("CONFIG.json", "blue"))) client.loop.run_until_complete(client.logout()) except KeyboardInterrupt: client.loop.run_until_complete(client.logout()) finally: client.loop.close() print("\nShutting down...")
from URL import * from cStringIO import StringIO import re import Template import TimeClock import Logger log = Logger.getLogger() class Response: def __init__(self, decoder=None): self.rawbody = None self.body = None self.headers = None self.info = None self.url = None self.code = None self.tree = None self.decoder = decoder # Lazy decoding def make_sure(self): if self.body == None and self.decoder != None: self.body = self.decoder(self.rawbody)
# not use this file except in compliance with the License. You may obtain # a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. from Shell import (execute) import Logger from Exceptions import (ProcessExecutionError) LOG = Logger.getLogger("install.pip") INSTALL_CMD = ['pip', 'install'] UNINSTALL_CMD = ['pip', 'uninstall'] def install(pips): if (not pips or len(pips) == 0): return actions = list() pipnames = sorted(pips.keys()) for name in pipnames: pipfull = name pipinfo = pips.get(name) if (pipinfo and pipinfo.get('version')): version = str(pipinfo.get('version'))
def __init__(self): self.v self.api self.log = Logger.Logger("DogeCopterLog.txt")
# -*- coding: utf-8 -*- import BD as banco_dados from Emails import * from PortalCassi import * from Logger import * logger = Logger(__name__) class Recursar(object): def EfetuarRecursos(self): banco_dados.Conectar() try: comando_sql = 'SELECT DISTINCT RF.NUM_CARTA_REMESSA \ FROM CAS_RECURSOS_GLOSAS RG \ , CAS_RETORNOS_FINANCEIROS RF \ WHERE RG.SEQ_RETORNO_FINANCEIRO = RF.SEQ_RETORNO_FINANCEIRO \ AND RG.STATUS_RECURSO = \'P\'' banco_dados.Executar(comando_sql) cartas_remessas = banco_dados.BuscarTodos() if len(cartas_remessas) != 0: portal_cassi = PortalCassi() try: portal_cassi.Inicializar() portal_cassi.Logar() for carta_remessa in cartas_remessas:
def _init(): Logger.log("is DataManager.init()") initDataFileDic()
# Messages from messages import ACCESS_WITHOUT_START from messages import EXCEPTION_TRIGGERED_MESSAGE from messages import EXCEPTION_CAUSING_MESSAGE # Modules import telepot import Logger logger = Logger.Logger() paybot = telepot.Bot("692962436:AAHOeT1VqRcAboPEBEaJjYKRfvJ9Mj9xCMw") def parse_handler(user_id, username, message): ''' Passes on the user request to the specific controller ARGUMENTS: message: string RETURN TYPE: void ''' # Initialisation of bot command = message.split(' ')[0][1:] arguments = message.split(' ')[1:] if len(message.split(' ')) > 1 else None # Logging logger.command_run(message, username, user_id) try: if command == "time": paybot.sendMessage(user_id, getTime(), parse_mode='Markdown') else:
import itertools import pika from sklearn.externals import joblib from bayes.bayes_train import get_words, bernousNB_save_path, isChat from Logger import * ''' 从文件读取模型并进行分类,打开socket,接收消息 ''' AnswerDict = [] intentionList = [] ask_sentenses_length = 5 # 当未包含关键字,且问话>5个字时,认为需要转接人工了 # 日志 semantics_logfile = 'D:/data/daotai_semantics.log' semantics_log = Logger(semantics_logfile, level='info') def loadAnswers(): with open("../kdata/intention_answer.txt", encoding="utf-8", errors="ignore") as fo: for line in fo.readlines(): arr = line.strip().split("\t") AnswerDict[arr[0]] = arr[2] intentionList.append(arr[0]) print("load answers finished") def getAnswer(intention): result_list = AnswerDict[intention].split("|")
# License for the specific language governing permissions and limitations # under the License. # TestSuite import traceback from QueueHandler import QueueHandler from Message import MessageObj from DataMgr import DataMgr from User import UserObj from config import * import Logger import atexit logger = Logger.Logging('logging') def wait_for_sent_finnished(qh): import time while qh.qsize > 0: time.sleep(1) def test_suite1(): logger.info('***START OF TEST***') try: import random import time import string dm = DataMgr()
import Logger logger = Logger.Logger(log_file="output.txt") with Logger.context_logger(logger): # redirect stdout to logger object print("output from main process") Logger.run_subprocess(["python3", "example_to_subprocess.py"])
async def get_ticker_websocket(self, market): try: currency1 = market.get_currency1() currency2 = market.get_currency2() async with websockets.connect(self.websocket_address) as websocket: json_ticker_subscriber = json.dumps( {"type": "subscribe", "product_ids": [currency1 + "-" + currency2], "channels": ["ticker"]}) if self.debug: print("json_ticker_subscriber --> : "+json_ticker_subscriber) await websocket.send(json_ticker_subscriber) info_json = await websocket.recv() if self.debug: print("info_json <--: "+info_json) # receiving initial data temp_str = info_json[info_json.find("best_bid") + 11:] bid_rate = temp_str[:temp_str.find(",") - 1] if self.debug: print("bid_rate: " + bid_rate) temp_str = info_json[info_json.find("best_ask") + 11:] ask_rate = temp_str[:temp_str.find(",") - 1] if self.debug: print("ask_rate: " + ask_rate) market.set_top_bid_order_rate(bid_rate) market.set_top_ask_order_rate(ask_rate) subscribed_json = await websocket.recv() if self.debug: print("subscribed_json <--: " + subscribed_json) while True: update_json = await websocket.recv() self.last_answer = update_json if self.debug: print("update_json: " + update_json) first_find = update_json[update_json.find("best_bid") + 11:] bid_rate = first_find[:first_find.find(",")-1] if self.debug: print("bid_rate: " + bid_rate) third_find = update_json[update_json.find("best_ask") + 11:] ask_rate = third_find[:third_find.find(",")-1] if self.debug: print("ask_rate: " + ask_rate) third_find = update_json[update_json.find("time") + 7:] timestamp = third_find[:third_find.find(",") - 1] if self.debug: print("timestamp: " + timestamp) time = timestamp[timestamp.find("T") + 1:] if self.debug: print("time: " + time) market.set_top_bid_order_rate(bid_rate) market.set_top_ask_order_rate(ask_rate) market.set_top_bid_order_timestamp(time) market.set_top_ask_order_timestamp(time) except websockets.exceptions.ConnectionClosed as exc: print(self.last_answer) Logger.log_error(str(datetime.datetime.now())+" "+self.stock_name + " error code: " + str(exc.code) + ", reason: " + str(exc.reason) + ", _cause_ : "+str(exc.__cause__)) self.iteration = self.iteration + 1 print("Restarting...") Coinbase_GDAXMarketThread = \ Threading.WebSocketThread(self.iteration, "Thread: " + market.get_market_name() + str(self.iteration), self.iteration, self, market) Coinbase_GDAXMarketThread.start()
import Logger from DataManager import DataManager import os logger_name = "UpdateDBClasses" Logger.setup(logger_name) file_path = os.path.join(os.path.abspath(os.path.dirname(__file__)), "Generated/DatabaseClasses.py") manager = DataManager(logger_name, email=False) manager.update_classes_file(file_path)
def OnChange(self, event): Logger.info("Change password!") currentpw = self.currentpwText.GetValue() newpw = self.newpwText.GetValue() checknewpw = self.checknewpwText.GetValue() if currentpw == u'' or newpw == u'' or checknewpw == u'': Util.MessageBox(self, u'密码不能为空。', u'错误', wx.OK | wx.ICON_ERROR | wx.BORDER_DOUBLE) Logger.info("The password is None!") return elif currentpw != Session.Password: Util.MessageBox(self, u'当前密码输入错误。', u'错误', wx.OK | wx.ICON_ERROR | wx.BORDER_DOUBLE) Logger.info("The current password is wrong!") return elif len(newpw) < 6 or len(newpw) > 14 or re.search( r"\W", newpw) or newpw.isalpha() or newpw.isdigit(): Util.MessageBox(self, u'您输入的新密码不符合规则,请重新输入。', u'错误', wx.OK | wx.ICON_ERROR | wx.BORDER_DOUBLE) Logger.info("The new password doesn't conform to the rules!") return elif newpw != checknewpw: Util.MessageBox(self, u'两次输入的新密码不一致。', u'错误', wx.OK | wx.ICON_ERROR | wx.BORDER_DOUBLE) Logger.info("New passwords is not equally!") return try: havclient.user_update_own_password(FirstUser['firstuser'], currentpw, checknewpw) self.Flag = True Logger.info("The password is update successful!") Util.MessageBox(self, u'修改成功!\n请输入新的密码重新登录!', u'成功', wx.OK | wx.ICON_INFORMATION) self.Destroy() except: Util.MessageBox(self, u'修改失败!', u'错误', wx.OK | wx.ICON_ERROR) Logger.info("The password is update failing!")
import WeatherGetter import Logger class Scheduler: def __init__(self): self.todo_queue = queue.Queue(0) self.schedule = BlockingScheduler() # 获取数据 self.schedule.add_job(lambda: DataChecker.add_to_queue(self.todo_queue, WeatherGetter.get_now), 'interval', seconds=1195) self.schedule.add_job(lambda: DataChecker.add_to_queue(self.todo_queue, WeatherGetter.get_air), 'interval', seconds=3610) # 跟其他人错开10秒 self.schedule.add_job(lambda: DataChecker.add_to_queue(self.todo_queue, WeatherGetter.get_lifestyle), 'cron', hour='8,11,18', minute='01,21,41') # 每天的8, 11, 18点左右求一次 self.schedule.add_job(lambda: DataChecker.add_to_queue(self.todo_queue, WeatherGetter.get_sun_and_moon), 'cron', hour=4, minute=3) # 错开3分钟 # 写入sql self.schedule.add_job(lambda: DataChecker.write_sql(self.todo_queue, DBWriter.insert), 'interval', seconds=3620) # 分割日志 self.schedule.add_job(Logger.cut_log, 'cron', hour=0, minute=0) DBWriter.init() sch = Scheduler() Logger.get_logger('Manager')\ .info('Init System successfully! WeatherGetter Beta 1.0 now ready to run! Github@Origami404!') sch.schedule.start() Logger.get_logger('Manager').info('System close.')
RABBIT: [ joinpths(STACK_CONFIG_DIR, "pkgs", 'rabbitmq.json'), ], } #subdirs of a components dir TRACE_DIR = "traces" APP_DIR = "app" CONFIG_DIR = "config" #our ability to create regexes #which is more like php, which is nicer #for modifiers... REGEX_MATCHER = re.compile("^/(.*?)/([a-z]*)$") LOG = Logger.getLogger("install.util") def execute_template(*cmds, **kargs): if (not cmds or len(cmds) == 0): return params_replacements = kargs.pop('params') ignore_missing = kargs.pop('ignore_missing', False) outs = dict() for cmdinfo in cmds: cmd_to_run_templ = cmdinfo.get("cmd") cmd_to_run = list() for piece in cmd_to_run_templ: if (params_replacements and len(params_replacements)): cmd_to_run.append( param_replace(piece,
def run(self, tarfile, targets): # Create SOURCES dir and copy opkg tarball to it sourcedir = self.getMacro('%{_sourcedir}') if not os.path.exists(sourcedir): os.makedirs(sourcedir) Logger().debug("Copying %s to %s" % (tarfile, sourcedir)) shutil.copy(tarfile, sourcedir) # Create SPECS dir and create spec file specdir = self.getMacro('%_specdir') if not os.path.exists(specdir): os.makedirs(specdir) specfile = os.path.join(specdir, "opkg-%s.spec" % self.opkgName) if os.path.exists(specfile): os.remove(specfile) if self.opkgDesc.arch == "all": specfile = os.path.join(self.getMacro('%_specdir'), "opkg-%s.spec" % self.opkgName) else: specfile = os.path.join(self.getMacro('%_specdir'), "opkg-%s.spec.tmp" % self.opkgName) finalspec = os.path.join(self.getMacro('%_specdir'), "opkg-%s.spec" % self.opkgName) Tools.cheetahCompile( RpmSpec(self.opkgDesc, self.dist), os.path.join(Config().get(self.configSection, "templatedir"), "opkg.spec.tmpl"), specfile) # GV: I am not familiar enough with Cheetah to trick the spec file on # the fly so i do it here manually. The idea is to remove the BuildArch # line in the spec file when the package is not noarch Logger().debug("Arch: %s" % self.opkgDesc.arch) if self.opkgDesc.arch == "any": Logger().debug( "Modifying the spec file for the creation of arch dependent RPMs" ) cmd = "/bin/sed s/BuildArch/\#BuildArch/g < " + specfile + " > " + finalspec Logger().info("Executing %s" % (cmd)) os.system(cmd) os.remove(specfile) specfile = finalspec cmd = "cp " + specfile + " /tmp" os.system(cmd) # Build targets if 'source' in targets: if Tools.command("%s --clean -bs %s" % (self.buildCmd, specfile), "./"): Logger().info("Source package succesfully generated in %s" % self.getMacro('%_srcrpmdir')) else: Logger().error("Source package generation failed") raise SystemExit(1) if 'binary' in targets: if Tools.command("%s --clean -bb %s" % (self.buildCmd, specfile), "./"): Logger().info("Moving generated files to %s" % self.dest_dir) for file in glob.glob( os.path.join(self.getMacro('%_rpmdir'), "*/opkg-%s*.rpm" % self.opkgName)): Logger().info("Moving files: %s" % file) shutil.move(file, self.dest_dir) else: Logger().error("Binary package generation failed") raise SystemExit(1)
def __init__(self, globalWorkingDir, localWorkingDir, pilotJob=None, rank=None, nonMPIMode=False, outputDir=None, dumpEventOutputs=False): threading.Thread.__init__(self) self.globalWorkingDir = globalWorkingDir self.localWorkingDir = localWorkingDir self.currentDir = None # database backend self.db = Database.Backend(self.globalWorkingDir) # logger self.tmpLog = Logger.Logger(filename='Yoda.log') # communication channel self.comm = Interaction.Receiver(rank=rank, nonMPIMode=nonMPIMode, logger=self.tmpLog) self.rank = self.comm.getRank() self.tmpLog.info("Global working dir: %s" % self.globalWorkingDir) self.initWorkingDir() self.tmpLog.info("Current working dir: %s" % self.currentDir) self.failed_updates = [] self.outputDir = outputDir self.dumpEventOutputs = dumpEventOutputs self.pilotJob = pilotJob self.cores = 10 self.jobs = [] # jobs which needs more than one rank self.jobRanks = [] self.totalJobRanks = 0 # jobs which needs less than one rank self.jobRanksSmallPiece = [] self.totalJobRanksSmallPiece = 0 self.rankJobsTries = {} # scheduler policy: self.bigJobFirst = True self.lastRankForBigJobFirst = int(self.getTotalRanks() * 0.9) self.readyEventRanges = [] self.runningEventRanges = {} self.finishedEventRanges = [] self.readyJobsEventRanges = {} self.runningJobsEventRanges = {} self.finishedJobsEventRanges = {} self.stagedOutJobsEventRanges = {} self.updateEventRangesToDBTime = None self.jobMetrics = {} self.jobsTimestamp = {} self.jobsRuningRanks = {} self.originSigHandler = {} for sig in [ signal.SIGTERM, signal.SIGQUIT, signal.SIGSEGV, signal.SIGXCPU, signal.SIGUSR1, signal.SIGBUS ]: self.originSigHandler[sig] = signal.getsignal(sig) signal.signal(signal.SIGTERM, self.stop) signal.signal(signal.SIGQUIT, self.stop) signal.signal(signal.SIGSEGV, self.stop) signal.signal(signal.SIGXCPU, self.stopYoda) signal.signal(signal.SIGUSR1, self.stopYoda) signal.signal(signal.SIGBUS, self.stopYoda)
def run(self, tarfile, targets): sourcedir = os.path.join( self.dest_dir, "opkg-%s-%s" % (self.opkgName, self.opkgDesc.getVersion('upstream'))) # Rename tar to follow Debian non-native package rule debtarfile = os.path.join( self.dest_dir, "opkg-%s_%s.orig.tar.gz" % (self.opkgName, self.opkgDesc.getVersion('upstream'))) os.rename(tarfile, debtarfile) # Uncompress tar if os.path.exists(sourcedir): Tools.rmDir(sourcedir) if not Tools.untar(debtarfile, self.dest_dir): Logger().error("Error while extracting tar file: %s" % debtarfile) raise SystemExit(1) # Create debian dir debiandir = os.path.join(sourcedir, "debian") os.makedirs(debiandir) # Compile template files debDesc = DebDescription(self.opkgDesc, self.dist) templateDir = os.path.abspath(Config().get(self.configSection, "templatedir")) tmplList = [ os.path.join(templateDir, t) for t in Tools.ls(templateDir) ] Logger().debug("Templates: %s" % tmplList) for template in tmplList: if re.search("\.tmpl", template): (head, tail) = os.path.split(template) (base, ext) = os.path.splitext(tail) Tools.cheetahCompile(debDesc, template, os.path.join(debiandir, base)) else: shutil.copy(template, debiandir) Logger().info("Copy %s to %s" % (template, debiandir)) # GV: For the rules file, we need to do some simple updates and # I do not know cheetah enough to do that quickly... there we # execute a sed command (yes, it is far from perfect). rulescript = debiandir + "/rules" cmd = "/bin/sed s/OPKGNAME/" + self.opkgName + "/g < " + debiandir + "/rules.in > " + rulescript Logger().info("Executing %s" % (cmd)) os.system(cmd) os.chmod(rulescript, 0744) for part in ['api', 'server', 'client']: fl = debDesc.getPackageFiles(part) installFile = os.path.join(debiandir, debDesc.getInstallFile(part)) filelist = open(installFile, "a") for f in fl: filelist.write("%s /%s/\n" % (f['sourcedest'], f['dest'])) filelist.close() # Build targets cmd = "%s -rfakeroot -sa" % self.buildCmd if 'source' in targets and 'binary' in targets: opts = "" elif 'source' in targets: opts = "-S" elif 'binary' in targets: opts = "-B" if Tools.command("%s %s" % (cmd, opts), sourcedir): Logger().info("Packages succesfully generated") else: Logger().error("Packages generation failed") raise SystemExit(1)
def antPage(self): try: # channel c = Channel() _val = ( 'http://www.ly.com/scenery/scenerysearchlist_22_0__0_0_0_0_0_0_0.html', 1) c.antChannelList(_val) channels = c.channel_list if channels and len(channels) > 0: Common.log('# add channels num: %d' % len(channels)) self.mysqlAccess.insertTCChannel(channels) else: Common.log('# not get channels...') except Exception as e: Common.log('# TCSpotChannel antpage error: %s' % e) Common.traceback_log() if __name__ == '__main__': loggername = 'channel' filename = 'add_channel_%s' % (time.strftime("%Y%m%d%H", time.localtime())) Logger.config_logging(loggername, filename) j = TCSpotChannel() Common.log('TCSpotChannel start') j.antPage() time.sleep(1) Common.log('TCSpotChannel end')