class Audit(object): """ A class for handling audit information """ def __init__(self, db, enabled=True): self.db = db self.enabled = enabled self.log = Logger(system=self) self.action_ids = { "GET_PROFILE": 0, "GET_CONTRACT": 1, "GET_LISTINGS": 2, # Click Store tab "GET_FOLLOWING": 3, "GET_FOLLOWERS": 4, "GET_RATINGS": 5 } def record(self, guid, action_id, contract_hash=None): if self.enabled is not True: return self.log.info("Recording Audit Event [%s]" % action_id) if action_id in self.action_ids: self.db.audit_shopping.set(guid, self.action_ids[action_id], contract_hash) else: self.log.error("Could not identify this action id")
def run_daemons(self): cli = subprocess.Popen("CLI", stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE) Logger.log("Клиент запущен") srv = subprocess.Popen("SRV", stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE) Logger.log("Сервер запущен")
def run(self, options): """ Runs the application. 'options' contains the CLI options dictionary. """ # Setup logging if options.debug: Logger.set_log_level(Logger.DEBUG) # Load configuration self.config = ConfigParser.RawConfigParser() self.config.read(options.config) MidiEngine.initialize() Logger.debug("Command line options: %s" % (options)) self.setup() if options.list_devices: self.list_devies() elif options.interactive: self.interactive_mode() else: self.loop()
def __set_state(self, state): self.__state = state Logger.debug("Switching to state %s" % (self.state_names[self.__state])) if self.__state == self.STATE_NORMAL: self.__update_levels(127, 0, 0) self.send_ctrl('master', 127) time.sleep(self.SWITCH_INTERVAL) self.send_ctrl('send1', 0) self.send_ctrl('send2', 0) elif self.__state == self.STATE_MUTE: self.__update_levels(0, 0, 0) self.send_ctrl('master', 0) self.send_ctrl('send1', 0) self.send_ctrl('send2', 0) elif self.__state == self.STATE_FX1: self.__update_levels(0, 127, 0) self.send_ctrl('send1', 127) time.sleep(self.SWITCH_INTERVAL) self.send_ctrl('master', 0) self.send_ctrl('send2', 0) elif self.__state == self.STATE_FX2: self.__update_levels(0, 0, 127) time.sleep(self.SWITCH_INTERVAL) self.send_ctrl('send2', 127) self.send_ctrl('master', 0) self.send_ctrl('send1', 0) self.send_ctrl('selector', (self.__state / 3.0) * 127.0)
def save(relation): if ArtistRelationFactory.__use_db: artistA = relation.artistA.key() artistB = relation.artistB.key() if artistA > artistB: artistC = artistB artistB = artistA artistA = artistC ArtistRelationFactory.__db.execute( u"REPLACE INTO artist_relation "\ "(artistA, artistB, relation) VALUES (?, ?, ?)", ( artistA, artistB, Binary(pickle.dumps(relation, -1)))) ArtistRelationFactory.__db.commit() elif TrackRelationFactory.__use_fs: pathA = join(ArtistRelationFactory.__path, relation.artistA.key()) fileA = u"%s.pkl" % join(pathA, relation.artistB.key()) pathB = join(ArtistRelationFactory.__path, relation.artistB.key()) fileB = u"%s.pkl" % join(pathB, relation.artistA.key()) if not isdir(pathA): makedirs(pathA) if not isdir(pathB): makedirs(pathB) if fileA > fileB: fileC = fileB fileB = fileA fileA = fileC ArtistRelationFactory._save(relation, fileA) if fileA != fileB: if exists(fileB): remove(fileB) try: link(fileA, fileB) except OSError: Logger.error(u"Failed to link %s to %s" % (fileA, fileB)) relation.lastmodified = getmtime(fileA)
class Server(object): def __init__(self,host=None,port=None): set = Settings() self.logger = Logger() if host or port == None : host = set.get_item('core','server_host') port = set.get_item('core','server_port') self.host = host self.port = port Pyro4.config.HMAC_KEY = set.get_item('core','hmac_phrase') if is_ip_set(self.host): self.daemon = VinllaDaemon( host = self.host, port = self.port ) else : self.logger.critical( "[Server] Server can't bind to address %s, Node Manager not detect this IP belonging this Server" % self.host ) sys.exit() def hook_object(self,obj,id=None): if id == None : id = obj.__class__.__name__ self.uri = self.daemon.register(obj,objectId=id) def run(self): self.logger.success( "[Server] Node Manager Server successfuly run at %s" % (self.daemon.locationStr) ) self.daemon.requestLoop()
class PeerFactory(ClientFactory): def __init__(self, params, user_agent, inventory, subscriptions, bloom_filter, disconnect_cb, blockchain, download_listener): self.params = params self.user_agent = user_agent self.inventory = inventory self.subscriptions = subscriptions self.bloom_filter = bloom_filter self.cb = disconnect_cb self.protocol = None self.blockchain = blockchain self.download_listener = download_listener bitcoin.SelectParams(params) self.log = Logger(system=self) def buildProtocol(self, addr): self.protocol = BitcoinProtocol(self.user_agent, self.inventory, self.subscriptions, self.bloom_filter, self.blockchain, self.download_listener) return self.protocol def clientConnectionFailed(self, connector, reason): self.log.warning("Connection failed, will try a different node") self.cb(self) def clientConnectionLost(self, connector, reason): self.cb(self)
class ToolsLib(object): log = None artifactPath = "install" def __init__(self): self.log = Logger() def findFile(self, needle, extension): # Find the zip file (We have to find like this because the date changes) found = False for file in os.listdir(self.artifactPath): if string.find(file, needle) >= 0 and re.search(extension + "$", file, re.IGNORECASE): found = True break; if not found: self.log.debug("files=%s" % ','.join(os.listdir(self.artifactPath))) raise Exception("Unable to find a zip file that has [%s] in the name with [%s] extension" % (needle, extension)) # Get the name of the file minus the extension reobj = re.compile(r"(?P<filename>.*?)(?P<ext>\.[0-9a-z]*$)", re.IGNORECASE) return reobj.search(file).group("filename")
def __init__(self, name=None, parent=None, Psize=20, Qsize=20, daemons=True): Logger.__init__(self, name, parent) self._daemons = daemons self.localThreadId = 0 self.workers = [] self.jobs = Queue(Qsize) self.size = Psize self.accept = True
def __init__(self, pool, name=None, daemon=True): name = name or self.__class__.__name__ Thread.__init__(self, name=name) Logger.__init__(self, name, pool) self.daemon = daemon self.pool = pool self.cmd = "" self.busy = False
def by_key(key): if RatingFactory.__lib.has_key(key): return RatingFactory.__lib[key] Logger.debug(u"Rating.by_key((%s, %s, %s, %s, %s, %s, %s, %s, %s)): create from key" % ( key[0], key[1], key[2], key[3], key[4], key[5], key[6], key[7], key[8])) return RatingFactory.get(key[0], key[1], key[2], key[3], key[4], key[5], key[6], key[7], key[8])
def __receive(self, input, msg): # Filter message if it does not belong to the configured MIDI channel if msg.getChannel() != self.channel: return Logger.debug("[%s] Received message: %s" % (self.name, MidiEngine.dump_msg(msg))) # Dispatch received message if self.receive: self.receive(self, msg)
def update(self, diff, new, factor=1.0): if diff > 0.0: self.lastplayed = now() if new: self.track_cnt += 1 diff += 0.5 self.track_rating += diff if self.track_cnt > 0: self.rating = self.track_rating / self.track_cnt Logger.info(u"updated rating: %s" % self)
def update(self, diff, new, factor=1.0): if new: self.track_cnt += 1 diff += 0.5 self.track_rating += diff if self.track_cnt > 0: self.rating = self.track_rating / self.track_cnt Logger.info(u"updated rating: %s" % self) ArtistRelationFactory.save(self)
def load(input): for i in range(len(Factories.__lib)): Logger.debug(u"Factories.load(): loading %s" % i) k = pickle.load(input) if k != i: # FIXME: we should die here Logger.error(u"Factories.load(): key mismatch %d vs %d" % (i, k)) Factories.__lib[k].setstate(pickle.load(input))
class BanScore(object): def __init__(self, peer_ip, multiplexer, ban_time=86400): self.peer_ip = peer_ip self.multiplexer = multiplexer self.ban_time = ban_time self.scores = { PING: 0, STUN: 0, STORE: 0, INV: 0, VALUES: 0, } self.scoring_loop = task.LoopingCall(self.adjust_scores) self.scoring_loop.start(30) self.log = Logger(system=self) def process_message(self, message): if message.command == PING: self.scores[PING] += 1 if self.scores[PING] > 4: self.ban(PING) elif message.command == STUN: self.scores[STUN] += 1 if self.scores[STUN] > 1: self.ban(STUN) elif message.command == HOLE_PUNCH: if self.peer_ip[0] != SEED_NODE[0] or self.peer_ip[0] != SEED_NODE_TESTNET[0]: self.ban(HOLE_PUNCH) elif message.command == STORE: args = tuple(message.arguments) for arg in args: self.scores[STORE] += len(arg) if self.scores[STORE] > 1000000: self.ban(STORE) elif message.command == INV: self.scores[INV] += 30 if self.scores[INV] > 120: self.ban(INV) elif message.command == VALUES: self.scores[VALUES] += 30 if self.scores[VALUES] > 120: self.ban(VALUES) def ban(self, message_type): self.log.warning("Banned %s. Reason: too many %s messages." % (self.peer_ip[0], Command.Name(message_type))) self.multiplexer.ban_ip(self.peer_ip[0]) self.multiplexer[self.peer_ip].shutdown() reactor.callLater(self.ban_time, self.multiplexer.remove_ip_ban, self.peer_ip[0]) def adjust_scores(self): for k, v in self.scores.items(): if v > 0: if k == STORE: self.scores[k] = v - 350 else: self.scores[k] = v - 1
def on_server_added_act(self, data): Logger.log("Подключен сервер '{ip}'".format(ip = data['ip'])) self.servers[data['id']] = { 'ip': data['ip'], 'sent': 0, 'last_index': 0, 'color': QColor.fromHsv(random.randint(0, 359), 220, 190), } self.tableView_client.add_row(data['ip'])
def dns_discovery(testnet=False): log = Logger(system="Discovery") addrs = [] for seed in TESTNET3_SEEDS if testnet else MAINNET_SEEDS: answers = dns.resolver.query(seed) for addr in answers: addrs.append((str(addr), 18333 if testnet else 8333)) log.info("DNS discovery returned %s peers" % len(addrs)) return addrs
def __init__(self): QMainWindow.__init__(self) self.setupUi(self) if not os.path.exists("DOWNLOADS_PATH"): os.makedirs("DOWNLOADS_PATH") if not os.path.exists("TORRENTS_PATH"): os.makedirs("TORRENTS_PATH") r = self.geometry() r.moveCenter(QApplication.desktop().availableGeometry().center()) self.setGeometry(r) if ("DO_LOGIN"): self.show_login_form() self.actions = { PACKAGE_SENT_ACT: self.on_package_sent_act, PACKAGE_RECEIVED_ACT: self.on_package_received_act, SERVER_ADDED_ACT: self.on_server_added_act, CLIENT_ADDED_ACT: self.on_client_added_act, SERVER_REMOVED_ACT: self.on_server_removed_act, CLIENT_REMOVED_ACT: self.on_client_removed_act, ANSWER_ACT: self.on_answer_act, FILE_RECEIVED_ACT: self.on_file_received_act, } self.cli_thread = Thread(CLI_SOCK_PATH) self.srv_thread = Thread(SRV_SOCK_PATH) self.cli_thread.msg_came.connect(self.handle_cli_backend_message) self.srv_thread.msg_came.connect(self.handle_srv_backend_message) self.cli_thread.error_came.connect(self.handle_cli_error) self.srv_thread.error_came.connect(self.handle_srv_error) self.cli_thread.start() self.srv_thread.start() self.tableView_main.rowSelected.connect(self.on_main_table_row_changed) self.tableView_main.rowDoubleClicked.connect(self.on_row_double_clicked) self.timer = QTimer(self) self.connect(self.timer, SIGNAL("timeout()"), self.on_timer) self.timer.start(100) self.timer_iteration = 0 self.transmissions = {} self.expected_response = 0 Logger.log("Старт приложения") if ("DAEMONIZE"): self.run_daemons() self.load_torrents()
def data_tran(message): connection = pika.BlockingConnection(pika.ConnectionParameters(host="127.0.0.1")) channel = connection.channel() channel.exchange_declare(exchange="logs", type="fanout") channel.basic_publish(exchange="logs", routing_key="", body=message) print " [x] Sent %r" % (message,) Logger.info("Collect & Send message to master") connection.close()
def __init__(self, name, input, output, channel): Logger.debug("[%s] Initializing channel: input='%s', output='%s, channel=%d" % (name, input, output, channel)) self.name = name self.input = MidiEngine.get_input_by_name(input) self.output = MidiEngine.get_output_by_name(output) self.channel = channel self.receive = None if self.input: self.input.receive = self.__receive
def on_actionStart_transmission_triggered(self): key = self.tableView_main.current_row if not key: return s = self.transmissions[key] if not s['finished']: Logger.log("Отправлен запрос на получение файла '{name}'" \ .format(name = s['filename'])) self.cli_thread.send_message({'action': START_TRM_ACT, 'hsum': key, 'filename': s['filename'], 'filesize': str(s['filesize'])})
def __switch(self, fx): self.__state[fx] = not self.__state[fx] Logger.debug("Switching state of fx%d to %d" % (fx, self.__state[fx])) if self.__state[fx]: value = 127 else: value = 0 self.send_ctrl(['fx1', 'fx2', 'fx3', 'fx4'][fx], value) self.set_led(['led1', 'led2', 'led3', 'led4'][fx], self.__state[fx])
def on_actionCreate_transmission_triggered(self): fname = QFileDialog.getOpenFileName(self, 'Open file to create a torrent', '~') if fname: hsum = hashlib.md5(open(fname, "rb").read()).hexdigest() if not os.path.exists("TORRENTS_PATH/" + hsum): self.create_torrent_file(ntpath.basename(fname), os.path.getsize(fname), hsum, fname) self.load_torrent(fname = "TORRENTS_PATH/" + hsum) else: Logger.log("Торрент файл {0} уже существует".format(fname)) QMessageBox.information(self, 'Ошибка', 'Торрент файл уже существует', QMessageBox.Ok)
def __getattr__(self, item): Logger.info(item) item = re.split('_', item) module_name, mthd = item[0], '_'.join(item[1:]) class_name = module_name.capitalize() + 'Controller' module = __import__('controllers.%s' % module_name) instance = getattr(getattr(module, module_name), class_name)() return getattr(instance, mthd)
def on_file_received_act(self, data): s = data['hsum'] struct = self.transmissions[s] Logger.log("Файл '{name}' был полностью получен".format(name = struct['filename'])) self.create_torrent_file(struct['filename'], struct['filesize'], data['hsum'], "DOWNLOADS_PATH/" + struct['filename']) self.load_torrent(fname = "TORRENTS_PATH/" + s, add_row = False) struct['sent'] = -1 struct['active'] = 0 struct['finished'] = 1 self.on_main_table_row_changed(s)
def create_torrent_file(self, filename, filesize, hsum, fname = None): if type(filesize) != str: filesize = str(filesize) struct = {'filesize': filesize, 'hsum': hsum, 'filename': filename} if fname: struct['default_path'] = fname fname = "TORRENTS_PATH/" + hsum Logger.log("Был создан торрент файл для файла '{name}'" \ .format(name = filename)) with open(fname, 'wb') as f: pickle.dump(struct, f, 0)
def update(self, play, factor=1.0): if self.ratingref.playfactor == 0.0 and self.ratingref.skipfactor == 0.0: new = True old_rating = 0.5 else: new = False old_rating = self.rating self.ratingref = self.ratingref.update(play, factor) self.rating = self.ratingref.rating self.artist.update((self.rating - old_rating), new, factor) Logger.info(u"updated rating: %s" % self)
class SMTPNotification(object): """ A class for sending SMTP notifications """ def __init__(self, db): self.db = db self.server = 'localhost:25' self.sender = 'OpenBazaar' self.recipient = '' self.username = None self.password = None self.log = Logger(system=self) self.get_smtp_settings() def get_smtp_settings(self): settings = self.db.settings.get() self.server = settings[15] self.sender = settings[16] self.recipient = settings[17] self.username = settings[18] self.password = settings[19] def send(self, subject, body): settings = self.db.settings.get() is_enabled = True if settings[14] == 1 else False if is_enabled: # Construct MIME message msg = MIMEMultipart('alternative') msg['Subject'] = subject msg['From'] = self.sender msg['To'] = self.recipient html_body = MIMEText(body, 'html') msg.attach(html_body) try: server = smtplib.SMTP(self.server) server.starttls() # Authenticate if username/password set if self.username and self.password: server.login(self.username, self.password) server.sendmail(self.sender, self.recipient, msg.as_string()) except SMTPAuthenticationError as e: self.log.error(e) print e server.quit()
class HeartbeatFactory(protocol.ClientFactory): def __init__(self, libbitcoin_client): self.libbitcoin_client = libbitcoin_client self.log = Logger(system=self) def buildProtocol(self, addr): self.protocol = HeartbeatProtocol(self.libbitcoin_client) return self.protocol def clientConnectionFailed(self, connector, reason): self.libbitcoin_client.connected = False self.log.critical("Libbitcoin server offline")
def main(): # Create Model, Criterion and State model, criterion, state = create_model(args) print("=> Model and criterion are ready") # Create Dataloader if not args.test_only: train_loader = get_train_loader(args) val_loader = get_test_loader(args) print("=> Dataloaders are ready") # Create Logger logger = Logger(args, state) print("=> Logger is ready") # Create Trainer trainer = Trainer(args, model, criterion, logger) print("=> Trainer is ready") if args.test_only: test_summary = trainer.test(0, val_loader) print("- Test: Acc %6.3f " % (test_summary['acc'])) else: start_epoch = logger.state['epoch'] + 1 print("=> Start training") # test_summary = trainer.test(0, val_loader) for epoch in range(start_epoch, args.n_epochs + 1): train_summary = trainer.train(epoch, train_loader) test_summary = trainer.test(epoch, val_loader) logger.record(epoch, train_summary, test_summary, model) logger.final_print()
def __init__(self): # author database: self.connection = db.Connection(config.authordb["host"], config.authordb["db"], config.authordb["user"], config.authordb["password"], config.authordb["schema"]) # Creates any missing tables that are expected to exist in the application database. # Does NOT verify whether the current columns are accurate. with self.connection.db.cursor() as cursor: helpers.Make_tables(cursor) # PROD DATABASE with article info: self.PROD = db.Connection(config.rxdb["host"], config.rxdb["db"], config.rxdb["user"], config.rxdb["password"], config.rxdb["schema"]) # Requests HTML configuration self.session = HTMLSession(mock_browser=False) self.session.headers['User-Agent'] = config.user_agent self.log = Logger()
def init_task_sceduling(self, taskinfo, run_date): try: con = MySQLdb.connect(host=self.mysqlinfo["host"], port=string.atoi(self.mysqlinfo["port"]), user=self.mysqlinfo["user"], passwd=self.mysqlinfo["passwd"], db=self.mysqlinfo["dbname"]) cursor = con.cursor() for task_id in taskinfo.keys(): values = [ run_date, task_id, False, True, ] sql = "insert into task_sceduling(run_date,task_id,runstatus,ifnormal ) values(%s,%s,%s,%s)" cursor.execute(sql, values) con.commit() except Error, e: Logger.error("mysql error insert_task_log" + e.args[0].__str__() + ":" + e.args[1].__str__()) print "mysql error insert_task_log %d: %s" % (e.args[0], e.args[1])
def __init__(self, browser): self._logger = Logger(__file__) # baidu search website self.baidu = "https://www.baidu.com" #cap["phantomjs.page.settings.loadImages"] = True #cap["phantomjs.page.settings.disk-cache"] = True #cap["phantomjs.page.settings.userAgent"] = "Mozilla/5.0 (X11; Linux x86_64; rv:50.0) Gecko/20100101 Firefox/50.0" #self.browser = webdriver.PhantomJS(desired_capabilities=cap) #self.browser = webdriver.PhantomJS() if not browser: ## get the Firefox profile object profile = FirefoxProfile() ## Disable CSS. We can not disable this then get images from baidu #profile.set_preference('permissions.default.stylesheet', 2) ## Disable images #profile.set_preference('permissions.default.image', 2) ## Disable Flash profile.set_preference('dom.ipc.plugins.enabled.libflashplayer.so', 'false') self.browser = webdriver.Firefox(profile) else: self.browser = browser
def __init__(self, console, otp_key, parent=None): super(Form, self).__init__(parent) self.console = console self.otp_key = otp_key self.logger = Logger('Rule', Logger.INFO) self.setWindowTitle("PttOTP 驗證視窗") self.setWindowIcon(util.load_icon(config.icon_small)) self.setWindowFlags(Qt.WindowStaysOnTopHint) rule_text = ''' 1. 請開啟 google authenticator 掃描以下圖片 2. 於下方輸入框輸入 google authenticator 顯示的驗證碼 ''' rule_text = rule_text.strip() layout = QVBoxLayout() for rule_line in rule_text.split('\n'): layout.addWidget(QLabel(rule_line)) label = QLabel() label.setPixmap(QPixmap('./temp.png')) layout.addWidget(label) button_layout = QHBoxLayout() self.otp_edit = QLineEdit() button_layout.addWidget(self.otp_edit) ok_button = QPushButton("驗證") ok_button.clicked.connect(self.click_verify) button_layout.addWidget(ok_button) layout.addLayout(button_layout) self.setLayout(layout) self.ok = False
def keyClose(all_list): '''一键全关只能关闭电脑,然后关闭投影,间隔4分钟后,最后继电器''' Logger.getLog().logger.info("关闭电脑") commonData.SENDSIG.sendText("关闭电脑") for c in commonData.TERM_DICT['comput']: # checksocket = socket.socket() # checksocket.settimeout(2) # intstatus = checksocket.connect_ex((c['IP'], 5800)) # if(intstatus == 0 or intstatus==10061): # ComputService.wake_upfromJd(c['ip2'],c['port2'],c['addr'],c['road']) ComputService.shutComput(c['IP'], 'shutdown -s -f -t 00') time.sleep(0.4) time.sleep(30) Logger.getLog().logger.info("关闭投影") commonData.SENDSIG.sendText("关闭投影") for i in range(0, 2): for ty in commonData.TERM_DICT['touying']: Logger.getLog().logger.info('关闭投影机' + ty['IP']) # TouyingService.comm(ty['IP'], 4196,bytes.fromhex('02 50 4F 46 03')) TouyingService.Pjlink(ty['IP'], b'%1POWR 0\r') time.sleep(0.5) Logger.getLog().logger.info('等待50秒') time.sleep(300) Logger.getLog().logger.info("关闭电源") commonData.SENDSIG.sendText("关闭电源") for i in range(0, 2): for d in range(len(commonData.JD_DICT['devices'])): dev = commonData.JD_DICT['devices'][d]['device'] for t in dev: ip = t['ip'] port = t['port'] addr = t['addr'] road = t['road'] - 1 if not (addr == 1 and road == 7): cmod = JDService.getSingleCommand( hex(addr), hex(road), '0000') JDService.sendCommand(ip, port, cmod) time.sleep(0.3)
def __init__(self, embedding_len, lr=1., momentum=.9, batch_size=50, window_size=2, epoch=1, use_cuda=False, embedding_path=None, verbose=1, tensorboard=False, wordlist_path=None, log_folder='runs', use_nce=False): super(CBOW, self).__init__() self.embedding_len = embedding_len self.lr = lr self.momentum = momentum self.epoch = epoch self.use_cuda = use_cuda self.embedding_path = embedding_path self.logger = Logger(verbose) self.tensorboard = tensorboard self.use_nce = use_nce if self.tensorboard: from tensorboardX import SummaryWriter self.writer = SummaryWriter(log_folder) self.loader = Loader(for_embedding=True, window_size=window_size, batch_size=batch_size, logger=self.logger, wordlist_file=wordlist_path) self.vocab_size = self.loader.get_vocab_size() self._build_model()
def sub(name, i): """ 绩效扣分 :param name: 姓名 :param i: 扣分数量 :return: """ name = nameToPin.get(name) obj = None count_path = os.path.join(base_path, src_path, "count.txt") with open(count_path, 'r') as f: obj = f.readline() if obj is not None and obj != "": obj = eval(obj) if obj.get(name) is not None and obj.get(name) != "": obj[name] = obj[name] - i else: Logger().logger.error("[-]count.txt文件内容没有[%s]" % (name)) else: Logger().logger.error("[-]count.txt文件内容为空") with open(count_path, 'w') as f: f.write(str(obj))
class Form(QDialog): def __init__(self, console, otp_key, parent=None): super(Form, self).__init__(parent) self.console = console self.otp_key = otp_key self.logger = Logger('Rule', Logger.INFO) self.setWindowTitle("PttOTP 驗證視窗") self.setWindowIcon(util.load_icon(config.icon_small)) self.setWindowFlags(Qt.WindowStaysOnTopHint) rule_text = ''' 1. 請開啟 google authenticator 掃描以下圖片 2. 於下方輸入框輸入 google authenticator 顯示的驗證碼 ''' rule_text = rule_text.strip() layout = QVBoxLayout() for rule_line in rule_text.split('\n'): layout.addWidget(QLabel(rule_line)) label = QLabel() label.setPixmap(QPixmap('./temp.png')) layout.addWidget(label) button_layout = QHBoxLayout() self.otp_edit = QLineEdit() button_layout.addWidget(self.otp_edit) ok_button = QPushButton("驗證") ok_button.clicked.connect(self.click_verify) button_layout.addWidget(ok_button) layout.addLayout(button_layout) self.setLayout(layout) self.ok = False def click_verify(self): self.logger.show(Logger.INFO, '驗證') current_otp = self.otp_edit.text() self.logger.show_value(Logger.INFO, 'Current otp', current_otp) otp_obj = pyotp.TOTP(self.otp_key) otp = otp_obj.now() self.logger.show_value(Logger.INFO, 'otp', otp) if current_otp != otp: self.console.system_alert('驗證失敗請再輸入一次') return self.ok = True self.close() self.console.system_alert('驗證成功')
class MessageListenerImpl(object): implements(MessageListener) def __init__(self, web_socket_factory, database): self.ws = web_socket_factory self.db = database self.log = Logger(system=self) def notify(self, plaintext, signature): try: success = self.db.messages.save_message( plaintext.sender_guid.encode("hex"), plaintext.handle, plaintext.pubkey, plaintext.subject, PlaintextMessage.Type.Name(plaintext.type), plaintext.message, plaintext.timestamp, plaintext.avatar_hash, signature, False) if plaintext.subject != "": self.db.purchases.update_unread(plaintext.subject) self.db.sales.update_unread(plaintext.subject) self.db.cases.update_unread(plaintext.subject) if success: message_json = { "message": { "sender": plaintext.sender_guid.encode("hex"), "subject": plaintext.subject, "message_type": PlaintextMessage.Type.Name(plaintext.type), "message": plaintext.message, "timestamp": plaintext.timestamp, "avatar_hash": plaintext.avatar_hash.encode("hex"), "public_key": plaintext.pubkey.encode("hex") } } if plaintext.handle: message_json["message"]["handle"] = plaintext.handle self.ws.push(json.dumps(sanitize_html(message_json), indent=4)) except Exception as e: self.log.error('Market.Listener.notify Exception: %s' % e)
def _risk_assessment_helper(self, outer_k, experiment_class, exp_path, debug=False, other=None): dataset_getter = DatasetGetter(outer_k) best_config = self.model_selector.model_selection( dataset_getter, experiment_class, exp_path, self.model_configs, debug, other) # Retrain with the best configuration and test experiment = experiment_class(best_config['config'], exp_path) # Set up a log file for this experiment (run in a separate process) logger = Logger.Logger(str( os.path.join(experiment.exp_path, 'experiment.log')), mode='a') dataset_getter = DatasetGetter(outer_k) dataset_getter.set_inner_k(None) # needs to stay None training_scores, test_scores = [], [] # Mitigate bad random initializations for i in range(3): training_score, test_score = experiment.run_test( dataset_getter, logger, other) print( f'Final training run {i + 1}: {training_score}, {test_score}') training_scores.append(training_score) test_scores.append(test_score) training_score = sum(training_scores) / 3 test_score = sum(test_scores) / 3 logger.log('End of Outer fold. TR score: ' + str(training_score) + ' TS score: ' + str(test_score)) with open(os.path.join(exp_path, self._OUTER_RESULTS_FILENAME), 'w') as fp: json.dump( { 'best_config': best_config, 'OUTER_TR': training_score, 'OUTER_TS': test_score }, fp)
def comm(ip, port, command): try: Logger.getLog().logger.info('发送指令到投影' + str(command, 'utf-8')) commonData.SENDSIG.sendText('发送指令到投影' + str(command, 'utf-8')) s = socket.socket() s.settimeout(3) port = int(port) s.connect((ip, port)) s.send(command) re = s.recv(1024) Logger.getLog().logger.info('投影返回结果') Logger.getLog().logger.info(str(re, 'utf-8')) commonData.RECSIG.sendText('投影返回结果' + str(re, 'utf-8')) except Exception as e: Logger.getLog().logger.error(e)
def __init__(self, observation_space, action_space, from_dir=None): self.action_space = action_space self.memory = deque(maxlen=FLAGS.memory_size) self.exploration_rate = FLAGS.exploration_max self.reward_logs = Logger() self.reward_update_logs = Logger() if from_dir is None: self.model = tf.keras.models.Sequential([ InputLayer(input_shape=observation_space), Flatten(), Dense(128, input_shape=(observation_space, ), activation="relu"), Dense(128, activation="relu"), Dense(self.action_space, activation="linear") ]) else: with open(os.path.join(from_dir, "architecture.json"), "r") as json_file: model_json = json_file.read() self.model = tf.keras.models.model_from_json(model_json) self.model.load_weights(os.path.join(from_dir, "weights.h5")) self.model.compile(loss="mse", optimizer=tf.keras.optimizers.Adam( FLAGS.learning_rate)) self.target_model = tf.keras.models.clone_model(self.model) self.steps = 0 self.last_transition = None self.model.summary()
def decompression(file_path, target_path): """ 解压rar、zip压缩包到指定文件夹 :param file_path: 压缩包路径 :param target_path: 解压路径 :return: """ if file_path.endswith(".rar"): try: # mode的值只能为'r' rar_file = rarfile.RarFile(file_path, mode='r') # 得到压缩包里所有的文件 rar_list = rar_file.namelist() for f in rar_list: rar_file.extract(f, target_path) except Exception as e: Logger('decompress.log', level='error').logger.error(e) elif file_path.endswith(".zip"): # zip_file = zipfile.ZipFile(file_path, mode='r') with zipfile.ZipFile(file_path, mode='r') as zip_file: # 得到解压包所有文件 zip_list = zip_file.namelist() for f in zip_list: # 循环解压文件到指定目录 zip_file.extract(f, target_path) for file in os.listdir(target_path): if file in zip_list: try: new_file = file.encode('cp437').decode('gbk') print(new_file) try: os.rename(join(target_path, file), join(target_path, new_file)) except Exception as e: os.remove(join(target_path, file)) except Exception as e: Logger('decompress.log', level='error').logger.error(e) else: pass
def __init__(self, caller, confpath=None, **kwargs): self.optional = dict() self.logger = Logger(str(self.__class__)) self._filename = '/etc/argo-egi-connectors/global.conf' if not confpath else confpath self._checkpath = kwargs['checkpath'] if 'checkpath' in kwargs.keys( ) else False self.optional.update(self._lowercase_dict(self.conf_ams)) self.optional.update(self._lowercase_dict(self.conf_auth)) self.shared_secopts = self._merge_dict(self.conf_ams, self.conf_general, self.conf_auth, self.conf_conn, self.conf_state) self.secopts = { 'topology-gocdb-connector.py': self._merge_dict(self.shared_secopts, self.conf_topo_schemas, self.conf_topo_output), 'downtimes-gocdb-connector.py': self._merge_dict(self.shared_secopts, self.conf_downtimes_schemas, self.conf_downtimes_output), 'weights-vapor-connector.py': self._merge_dict(self.shared_secopts, self.conf_weights_schemas, self.conf_weights_output), 'poem-connector.py': self._merge_dict(self.shared_secopts, self.conf_poem_schemas, self.conf_poem_output, self.conf_poem_prefilter), 'prefilter-egi.py': self._merge_dict(self.conf_general, self.conf_prefilter_output, self.conf_prefilter_schemas, self.conf_prefilter_prefilter) } if caller: self.caller_secopts = self.secopts[os.path.basename(caller)] else: self.caller_secopts = self.shared_secopts
class Selenium: vmrunPath = None log = Logger() def __init__(self): """Also this doc should be in shown in library doc.""" def start(self): p = subprocess.Popen( ['java', '-jar', 'java/selenium-server-standalone-2.21.0.jar'], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
def select_task_impala_load_ready(self): try: con = MySQLdb.connect(host=self.mysqlinfo["host"], port=string.atoi(self.mysqlinfo["port"]), user=self.mysqlinfo["user"], passwd=self.mysqlinfo["passwd"], db=self.mysqlinfo["dbname"]) cursor = con.cursor() task_str = self.select_task_impala_taskname_list() sql = "select task_name,node_num,batch_id,h_db_name,h_table_name,h_table_part,i_db_name,i_table_name,i_table_part,insert_type,count(1) as num \ from task_impala_load where status='READY' \ and task_name in {task_str} \ group by task_name,node_num,batch_id,h_db_name,h_table_name,h_table_part,i_db_name,i_table_name,i_table_part,insert_type having num=node_num;" sql = sql.replace("{task_str}", task_str) cursor.execute(sql) results = cursor.fetchall() return results except Error, e: Logger.error("mysql error select_task_impala_load_ready" + e.args[0].__str__() + ":" + e.args[1].__str__()) print "mysql error select_task_impala_load_ready%d: %s" % ( e.args[0], e.args[1])
def _wrapper(func): logger = Logger(logname=os.path.join(os.path.dirname(basedir), 'logs', 'install.log'), loglevel=1, logger=str(loggername)).getlog() def __wrapper(): logger.info("+++++++++++++ begin %s +++++++++++++++++++++++" % loggername) func() logger.info("+++++++++++++ finish %s +++++++++++++++++++++++" % loggername) return __wrapper
class Main(object): def __init__(self): self._logger = Logger().get_logger() self._logger.info("Main class create") def __del__(self): self._logger.info("Main class release") def run(self): self._logger.info("Main thread running") main_launcher = LaunchMainInterface() main_launcher.start() main_launcher.join() self._logger.info("Main thread run done")
def _get_historical_data(self): base_url = 'https://finance.naver.com/item/sise_day.nhn?code=%s&page=%d' for event, code in self.event_code_dict.iteritems(): ratio = 0 page = 1 datas = [] while True: url = base_url % (code, page) page_datas, last_page = self._get_page_datas(url) datas.extend(page_datas) page += 1 if page > last_page: break new_ratio = int((float(page) / last_page) * 100) if new_ratio - ratio > 1: ratio = new_ratio Logger.info('proc: %s %d%%' % (event, ratio)) self._write_event_data(event, datas) self._make_done_file()
def __init__(self, embedding_path, lr=.01, momentum=.9, batch_size=50, epoch=1000, use_cuda=False, verbose=1, tensorboard=False): super(SentimentClassification, self).__init__() self.embedding_path = embedding_path self.lr = lr self.momentum = momentum self.batch_size = batch_size self.epoch = epoch self.use_cuda = use_cuda self.logger = Logger(verbose) self.tensorboard = tensorboard self._build_model() self.loader = Loader(for_embedding=False, logger=self.logger) if self.tensorboard: from tensorboardX import SummaryWriter self.writer = SummaryWriter('logs')
def keyClose(self): '''一键全关只能关闭电脑,然后关闭投影,间隔4分钟后,最后继电器''' self.sendText.append(':'.join( (time.strftime('%Y-%m-%d %H:%M:%S'), '电脑全关'))) for c in self.cpt: checksocket = socket.socket() checksocket.settimeout(2) intstatus = checksocket.connect_ex((c['IP'], 5800)) print(intstatus) if (intstatus == 0 or intstatus == 10061): cs.shutComputfromJd(c['ip2'], c['port2'], c['addr'], c['road']) time.sleep(0.3) self.sendText.append(':'.join( (time.strftime('%Y-%m-%d %H:%M:%S'), '投影全关'))) for ty in self.t: Logger.getLog().logger.info('关闭投影机' + ty['IP']) self.comm(ty['IP'], 4196, bytes.fromhex('02 50 4F 46 03')) Logger.getLog().logger.info('等待50秒') time.sleep(50) self.sendText.append(':'.join( (time.strftime('%Y-%m-%d %H:%M:%S'), '继电器全关'))) for d in range(len(self.devices)): dev = self.devices[d]['device'] for t in dev: ip = t['ip'] port = t['port'] addr = t['addr'] road = t['road'] - 1 if (addr == 2) and (road == 2): print("no close") elif (addr == 1) and (road == 4): print("no close") else: cmod = self.getSingleCommand(hex(addr), hex(road), '0000') self.sendCommand(ip, port, cmod, '继电器全关') time.sleep(0.3)
def __init__(self): """ constructor """ IWatchdog.__init__(self) self._eventloop = GObject.MainLoop() self.logger = Logger("bt.watchdog") self.logger.debug("initializing Bluetooth watchdog") self._events = WatchdogEvent(self.logger) self.bt_powered = False # global objects about DBus self._bus = dbus.SystemBus() self._dbus_obj = self._bus.get_object(Consts.Bt.SVC_NAME, Consts.DBus.OBJ_MNGR_PATH) try: self._dbus_manager = dbus.Interface(self._dbus_obj, Consts.DBus.OBJ_MNGR) except dbus.DBusException as E: self.logger.error("%s" % (E.get_dbus_message())) self._dbus_manager = None except: self.logger.error( "Unknown error while retrieving DBUS object manager") self._dbus_manager = None self._dbus_adapter_obj = None self._adapter = [Adapter(self.logger)] # identify it as the used adapter self._used_adapter = self._adapter[0] self.logger.debug("registering adapter") EXPOSED_OBJECTS["adapter"] = self._used_adapter self.logger.debug(EXPOSED_OBJECTS) # devices is expected to be a @MAC -> Device object mapping self._devices = self._used_adapter.get_devices() # map_devices is expected to be a path -> @MAC mapping self._map_devices = {}
class SynorepUtil(object): ''' 分词后进行同义词替换工具 ''' Log = Logger.getLogger(__name__) @staticmethod def synorepm(resource, customdic, synodic): seq_re = None try: assert isinstance(resource, str) and os.path.exists(customdic) \ and os.path.exists(synodic) seq_pr = SynorepUtil().__partictxt(resource, customdic) seq_re = SynorepUtil().__repsynor(seq_pr, synodic) except BaseException as e: SynorepUtil.Log.error(e) raise ParticException(e) else: return seq_re def __partictxt(self, resource, customdic): # 添加自定义词典 try: jieba.load_userdict(customdic) seg_list = jieba.cut(resource, cut_all=False) except BaseException as e: SynorepUtil.Log.error(e) raise ParticException(e) else: return "/".join(seg_list) def __repsynor(self, resource, synodic): # 同义词替换返回替换后的字符串 combine_dict = {} for w in open(synodic, "r", encoding='utf-8'): w_1 = w.strip().split("\t") num = len(w_1) for i in range(0, num): combine_dict[w_1[i]] = w_1[0] seg_list_2 = "" for word in resource.split("/"): if word in combine_dict: word = combine_dict[word] seg_list_2 += word else: seg_list_2 += word return seg_list_2
def __init__(self, console): super(Form, self).__init__(None) self.logger = Logger('OTP', Logger.INFO) self.console = console console.system_alert = self.system_alert self.icon = util.load_icon(config.icon_small) self.setIcon(self.icon) self.set_menu(False) self.setToolTip('Ptt OTP') self.show() self.activated.connect(self.icon_clicked) self.login_success = False self.in_process = False self.about_window_form = None self.show_login_form()
def GA_CNN2_MAIN(): args = parser() cfg = Config.fromfile(args.config) log = Logger(cfg.PARA.utils_paths.log_path + 'GA_CNN' + '_log_new.txt', level='info') # GA_POP gacnn = GA_CNN2(args, cfg, log) # gacnn.Init_Chrom()#初始化种群 gacnn.Evolution() #开始进化 gacnn.Plot_Save() #绘图并保存数据 # Rand_POP randcnn = Rand_POP_CNN2(args, cfg, log) randcnn.Evolution()
class Server(object): def __init__(self, kserver, signing_key, database): """ A high level class for sending direct, market messages to other nodes. A node will need one of these to participate in buying and selling. Should be initialized after the Kademlia server. """ self.kserver = kserver self.signing_key = signing_key self.router = kserver.protocol.router self.db = database self.log = Logger(system=self) self.protocol = MarketProtocol(kserver.node, self.router, signing_key, database) # TODO: we need a loop here that republishes keywords when they are about to expire # TODO: we also need a loop here to delete expiring contract (if they are set to expire) def querySeed(self, list_seed_pubkey): """ Query an HTTP seed for known vendors and save the vendors to the db. Args: Receives a list of one or more tuples Example [(seed, pubkey)] seed: A `string` consisting of "ip:port" or "hostname:port" pubkey: The hex encoded public key to verify the signature on the response """ for sp in list_seed_pubkey: seed, pubkey = sp try: self.log.debug("querying %s for vendors" % seed) c = httplib.HTTPConnection(seed) c.request("GET", "/?type=vendors") response = c.getresponse() self.log.debug("Http response from %s: %s, %s" % (seed, response.status, response.reason)) data = response.read() reread_data = data.decode("zlib") proto = peers.PeerSeeds() proto.ParseFromString(reread_data) verify_key = nacl.signing.VerifyKey( pubkey, encoder=nacl.encoding.HexEncoder) verify_key.verify("".join(proto.serializedNode), proto.signature) v = self.db.VendorStore() for peer in proto.serializedNode: try: n = objects.Node() n.ParseFromString(peer) v.save_vendor(n.guid.encode("hex"), peer) except Exception: pass except Exception, e: self.log.error("failed to query seed: %s" % str(e))
def classify(self, sentence, lower_bounder=None, upper_bounder=None): """ ML model wrapper. No time regular expression involved! input: sentence - type string return label """ if self.log is None: self.log = Logger(self.__class__.__name__, level=ENV.MODEL_LOG_LEVEL.value).logger sentence = jieba.cut(sentence, cut_all=False) sentence = ' '.join(sentence) matrix = self.tfidf.transform([sentence]) self.log.debug( 'In transfered tfidf, the number of words in vocalbulary is: {}'. format(len(matrix.data))) result = np.vstack((self.svc.predict_proba(matrix), self.logistic.predict_proba(matrix), self.nb.predict_proba(matrix))) av_pred = np.mean(result, axis=0) max_pred = np.max(av_pred, axis=0) max_arg = np.argmax(av_pred) response = None label = max_arg dictionary = { 'label': label, 'pred_prob': result, 'av_pred': av_pred, 'other_response': response } self.log.debug('Final Pred label is: {}'.format(dictionary['label'])) self.log.debug('svc,logistic,nb result:\n {}'.format( dictionary['pred_prob'])) self.log.debug('ave result:\n {}'.format(dictionary['av_pred'])) return dictionary
class Usable_proxy(Public): def __init__(self): self.logger = Logger('filer_log') conn = MongoClient(constants.conn_db) self.db = conn[constants.proxy_db] self.my_set = self.db[constants.filer_colletion] # 获取测试代理ip @property def get_proxy(self): # 从数据库中获取数据 my_colletion = self.db[constants.proxy_db] self.logger.dbuglog('从数据库中读取到数据:%s' % my_colletion.count()) proxy_list = my_colletion.find() for val in proxy_list: yield val # 测试方法 def check(self, proxy): url = 'https://baidu.com' try: proxies = { 'http': 'http://%s' % proxy, 'https': 'http://%s' % proxy } res = requests.get(url, headers=self.headers, proxies=proxies, timeout=0.5) self.logger.dbuglog(proxy + ' -----该代理ip可用,响应速度在0.5s内') return True except Exception as e: return False def save(self): for val in self.get_proxy: try: judge = self.check(val['ip_port']) if judge: # 保存到数据库 self.my_set.save(val) self.logger.dbuglog('存储该优质代理ip') except Exception as e: self.logger.errlog(val['ip_port'] + '---------该优质代理ip保存失败') pass
def __init__(self, proto, router, waitTimeout=5, noisy=True, testnet=False): """ Args: proto: A protobuf `Node` object containing info about this node. router: A `RoutingTable` object from dht.routing. Implies a `network.Server` object must be started first. waitTimeout: Consider it a connetion failure if no response within this time window. noisy: Whether or not to log the output for this class. testnet: The network parameters to use. """ self.proto = proto self.router = router self._waitTimeout = waitTimeout self._outstanding = {} self.noisy = noisy self.testnet = testnet self.log = Logger(system=self)