def onPlayBackStopped(self): utils.log('Service: Playback Stopped') # Is the item from our addon? if self.tracking: download_id = self.win.getProperty('download_id') if download_id: utils.log('Service: Stopping Axel Download: %s' % (download_id), xbmc.LOGDEBUG) import axelproxy as proxy axelhelper = proxy.ProxyHelper() axelhelper.stop_download(download_id) playedTime = int(self._lastPos) min_watched_percent = int(ADDON.getSetting('watched-percent')) try: percent_played = int((playedTime / self._totalTime) * 100) except: percent_played = 0 # guard div by zero pTime = utils.format_time(playedTime) tTime = utils.format_time(self._totalTime) utils.log('Service: Played %s of %s total = %s%%/%s%%' % (pTime, tTime, percent_played, min_watched_percent)) videotype = 'movie' if self.video_type == 'movie' else 'episode' if playedTime == 0 and self._totalTime == 999999: raise RuntimeError('XBMC silently failed to start playback') elif (percent_played >= min_watched_percent): if (self.video_type == 'movie' or (self.meta['season'] and self.meta['episode'])): utils.log('Service: Threshold met. Marking item as watched', xbmc.LOGDEBUG) video_title = self.meta['title'] if self.video_type == 'movie' else self.meta['TVShowTitle'] dbid = self.meta['DBID'] if 'DBID' in self.meta else '' builtin = 'RunPlugin(plugin://plugin.video.1channel/?mode=%s&imdbnum=%s&video_type=%s&title=%s&season=%s&episode=%s&year=%s&primewire_url=%s&dbid=%s&watched=%s)' xbmc.executebuiltin(builtin % (MODES.CH_WATCH, self.imdb_id, videotype, video_title.strip(), self.meta['season'], self.meta['episode'], self.meta['year'], self.primewire_url, dbid, True)) db_connection.clear_bookmark(self.primewire_url) elif playedTime > 0: utils.log('Service: Threshold not met. Setting bookmark on %s to %s seconds' % (self.primewire_url, playedTime), xbmc.LOGDEBUG) db_connection.set_bookmark(self.primewire_url, playedTime) self.reset()
def onPlayBackStopped(self): logger.log('Service: Playback Stopped', log_utils.LOGNOTICE) if self.tracked: # clear the playlist if SALTS was playing and only one item in playlist to # use playlist to determine playback method in get_sources pl = xbmc.PlayList(xbmc.PLAYLIST_VIDEO) plugin_url = 'plugin://%s/' % (kodi.get_id()) if pl.size() == 1 and pl[0].getfilename().lower().startswith(plugin_url): logger.log('Service: Clearing Single Item SALTS Playlist', log_utils.LOGDEBUG) pl.clear() playedTime = float(self._lastPos) try: percent_played = int((playedTime / self._totalTime) * 100) except: percent_played = 0 # guard div by zero pTime = utils.format_time(playedTime) tTime = utils.format_time(self._totalTime) logger.log('Service: Played %s of %s total = %s%%' % (pTime, tTime, percent_played), log_utils.LOGDEBUG) if playedTime == 0 and self._totalTime == 999999: logger.log('Kodi silently failed to start playback', log_utils.LOGWARNING) elif playedTime >= 5: if percent_played <= 98: logger.log('Service: Setting bookmark on |%s|%s|%s| to %s seconds' % (self.trakt_id, self.season, self.episode, playedTime), log_utils.LOGDEBUG) self.db_connection.set_bookmark(self.trakt_id, playedTime, self.season, self.episode) if percent_played >= 75 and self._from_library: if kodi.has_addon('script.trakt'): run = 'RunScript(script.trakt, action=sync, silent=True)' xbmc.executebuiltin(run) self.reset()
def __render_eta (self, column, cell, model, iter, data): # get the item we are dealing with item = model[iter][0] # link is active if item.links_downloading: eta = 0 downloads = self.client.downloads.value for link in item.links.itervalues(): if downloads.has_key (link.id): eta += downloads[link.id].eta eta = utils.format_time (eta) cell.set_property ("markup", eta) # link is waiting elif not item.links_downloading and item.links_waiting: eta = None downloads = self.client.downloads.value for link in item.links.itervalues(): if downloads.has_key (link.id): time_left = downloads[link.id].time_left if not eta: eta = time_left elif time_left < eta: eta = time_left eta = eta if eta > 0 else 0 eta = utils.format_time (eta) cell.set_property ("markup", "<small>Waiting - {0}</small>".format (eta)) # inactive link else: cell.set_property ("markup", "")
def __render_details (self, column, cell, model, iter, data): # get the item we are dealing with item = model[iter][0] downloads = self.client.downloads.value text = "" # link is active if downloads.has_key (item.id): download = downloads[item.id] # link is downloading if item.status == Link.Status.DOWNLOADING: speed = utils.format_size (download.speed) eta = utils.format_time (download.eta) size = utils.format_size (download.size) downloaded = utils.format_size (download.bytes_transferred) cell.set_property ("markup", "<small><b>{0}</b> of <b>{1}</b> downloaded @ <b>{2}/s</b> with {3} remaining</small>".format (downloaded, size, speed, eta)) # link is pending some action elif item.status == Link.Status.WAITING: # get the current wait time remaining = download.time_left if download.time_left > 0 else 0 wait_time = utils.format_time (remaining) cell.set_property ("markup", "<small>{0} left</small>".format (wait_time)) elif item.status == Link.Status.FINISHED: size = utils.format_size (item.size) cell.set_property ("markup", "<small>{0} downloaded</small>".format (size)) else: text = "<b>{0}</b>".format (item.error) if item.error else "" cell.set_property ("markup", "<small>{0}</small>".format (text))
async def profile(self, ctx, user: Member = None): if user is None: user = ctx.author em = utils.embed(title="{} #{}".format(user.display_name, user.discriminator), thumbnail=user.avatar_url, colour=user.colour) em.add_field(name="Name", value=user.name) em.add_field(name="Id", value=user.id) em.add_field(name="Created", value=utils.format_time(user.created_at, self.bot.config.TIMEZONE)) em.add_field(name="Joined", value=utils.format_time(user.joined_at, self.bot.config.TIMEZONE)) em.add_field(name="Status", value=user.status) em.add_field(name="Top role", value=user.top_role) if user.activity is not None: activity = user.activity.type.name.title() activity = activity + ' to' if activity == 'Listening' else activity activity_name = user.activity.name if activity_name == 'Spotify': activity_name += f': {user.activity.title} by {user.activity.artist}' em.add_field(name=activity, value=activity_name) utils.log( f"{ctx.message.author.display_name} requested {user.display_name}'s profile" ) await ctx.send(embed=em)
def onPlayBackStopped(self): logger.log('Service: Playback Stopped', log_utils.LOGNOTICE) if self.tracked: # clear the playlist if transistortv was playing and only one item in playlist to # use playlist to determine playback method in get_sources pl = xbmc.PlayList(xbmc.PLAYLIST_VIDEO) plugin_url = 'plugin://%s/' % (kodi.get_id()) if pl.size() == 1 and pl[0].getfilename().lower().startswith(plugin_url): logger.log('Service: Clearing Single Item Stream All The Sources Playlist', log_utils.LOGDEBUG) pl.clear() playedTime = float(self._lastPos) try: percent_played = int((playedTime / self._totalTime) * 100) except: percent_played = 0 # guard div by zero pTime = utils.format_time(playedTime) tTime = utils.format_time(self._totalTime) logger.log('Service: Played %s of %s total = %s%%' % (pTime, tTime, percent_played), log_utils.LOGDEBUG) if playedTime == 0 and self._totalTime == 999999: logger.log('Kodi silently failed to start playback', log_utils.LOGWARNING) elif playedTime >= 5: if percent_played <= 98: logger.log('Service: Setting bookmark on |%s|%s|%s| to %s seconds' % (self.trakt_id, self.season, self.episode, playedTime), log_utils.LOGDEBUG) self.db_connection.set_bookmark(self.trakt_id, playedTime, self.season, self.episode) if percent_played >= 75 and self._from_library: if kodi.has_addon('script.trakt'): run = 'RunScript(script.trakt, action=sync, silent=True)' xbmc.executebuiltin(run) self.reset()
def onPlayBackStopped(self): utils.log('Service: Playback Stopped') # Is the item from our addon? if self.tracking: download_id = self.win.getProperty('download_id') if download_id: utils.log('Service: Stopping Axel Download: %s' % (download_id), xbmc.LOGDEBUG) import axelproxy as proxy axelhelper = proxy.ProxyHelper() axelhelper.stop_download(download_id) playedTime = int(self._lastPos) min_watched_percent = int(ADDON.getSetting('watched-percent')) try: percent_played = int((playedTime / self._totalTime) * 100) except: percent_played = 0 # guard div by zero pTime = utils.format_time(playedTime) tTime = utils.format_time(self._totalTime) utils.log('Service: Played %s of %s total = %s%%/%s%%' % (pTime, tTime, percent_played, min_watched_percent)) videotype = 'movie' if self.video_type == 'movie' else 'episode' if playedTime == 0 and self._totalTime == 999999: raise RuntimeError('XBMC silently failed to start playback') elif (percent_played >= min_watched_percent): if (self.video_type == 'movie' or (self.meta['season'] and self.meta['episode'])): utils.log('Service: Threshold met. Marking item as watched', xbmc.LOGDEBUG) video_title = self.meta['title'] if self.video_type == 'movie' else self.meta['TVShowTitle'] dbid = self.meta['DBID'] if 'DBID' in self.meta else '' builtin = 'RunPlugin(plugin://plugin.video.1channel_bp/?mode=%s&imdbnum=%s&video_type=%s&title=%s&season=%s&episode=%s&year=%s&primewire_url=%s&dbid=%s&watched=%s)' xbmc.executebuiltin(builtin % (MODES.CH_WATCH, self.imdb_id, videotype, video_title.strip(), self.meta['season'], self.meta['episode'], self.meta['year'], self.primewire_url, dbid, True)) db_connection.clear_bookmark(self.primewire_url) elif playedTime > 0: utils.log('Service: Threshold not met. Setting bookmark on %s to %s seconds' % (self.primewire_url, playedTime), xbmc.LOGDEBUG) db_connection.set_bookmark(self.primewire_url, playedTime) self.reset()
def __init__(self, widget_id, widget_type, widget_name, widget_ttfb, widget_duration, widget_timestamp, widget_finish_timestamp, user_action, user_action_timestamp): super().__init__(widget_id) if widget_type is not None: self.widget_type = utils.check_widget_type(widget_type) else: self.widget_type = widget_type self.widget_name = widget_name or 'N/A' if widget_ttfb is not None: # self.widget_ttfb = '{:,.2f}'.format(float(widget_ttfb) / 1000) self.widget_ttfb = '{:,.2f}'.format(float(widget_ttfb)) else: self.widget_ttfb = widget_ttfb or 'N/A' self.widget_duration = widget_duration if widget_timestamp is not None: self.widget_timestamp = utils.format_time(widget_timestamp) else: self.widget_timestamp = widget_timestamp or 'N/A' if widget_finish_timestamp is not None: self.widget_finish_timestamp = utils.format_time( widget_finish_timestamp) else: self.widget_finish_timestamp = widget_finish_timestamp or 'N/A' self.user_action = user_action or '' if user_action_timestamp is not None: self.user_action_timestamp = utils.format_time( user_action_timestamp) else: self.user_action_timestamp = user_action_timestamp or 'N/A'
def init_files(path): new_path = format_path(path) headers_with_token = {'Authorization': 'Bearer ' + cache['access_token']} url = f'https://graph.microsoft.com/v1.0/me/drive/root{new_path}children' r = requests.get(url, headers=headers_with_token) file_data = eval(r.text) if "error" in file_data: print(file_data['error']['message']) else: values = {} for value in file_data['value']: if value['name'].lower().strip() == 'readme.md': readme = requests.get(value['@microsoft.graph.downloadUrl']).text values['readme.md'] = render_markdown(readme) elif value['name'].lower().strip() == 'head.md': readme = requests.get(value['@microsoft.graph.downloadUrl']).text values['head.md'] = render_markdown(readme) else: if 'folder' in value: folder = { 'time': format_time(value['lastModifiedDateTime']), 'size': format_size(value['size']) } values[value['name']] = folder init_files(path.rstrip('/') + '/' + value['name']) elif 'file' in value: file = { 'time': format_time(value['lastModifiedDateTime']), 'size': format_size(value['size']), 'url': value['@microsoft.graph.downloadUrl'] } values[value['name']] = file cache_tmp['files'][path] = values
def filter_fastq(logfp, infile, outfile, length, quality): try: fin = ps.FastxFile(infile) except: logfp.write('Error in parsing read file %s\n' % (infile)) sys.exit(IOError) try: fout = open(outfile, 'w') except: logfp.write('Error in opening output read file %s\n' % (outfile)) sys.exit(IOError) utils.format_time(logfp, __name__, 'Filtering reads\n') cnt = 0 for entry in fin: if len(entry.sequence) >= length: if entry.quality is not None: nq = [] for q in entry.quality: nq.append(ord(q) - 33) if np.average(nq) >= quality: fout.write(str(entry) + '\n') cnt += 1 else: fout.write(str(entry) + '\n') cnt += 1 utils.format_time(logfp, __name__, 'Filtered reads: %s\n' % cnt) fin.close() fout.close()
def update(request): """ 更新 todo 并返回更新后的 todo """ form = request.dejson() log('api todo update form', form) t = Todo.update(form) format_time(t) log('update todo:({})'.format(t)) return json_response(t.to_dict())
def train_pass(self): start_time = t() for step, batch in enumerate(self.trn_set): elapsed_time = t() - start_time time_per_step = elapsed_time / (step + 1) exp_rem_time = (len(self.trn_set) - (step + 1)) * time_per_step print("\r" + str(step + 1) + "/" + str(len(self.trn_set)) + " processed batches (elapsed time: " + utils.format_time(elapsed_time) + " exp. rem. time: " + utils.format_time(exp_rem_time) + ")", end="") # Get next input input_enc = batch["encoded_image"] if P.GPU: input_enc = input_enc.cuda() # Run the network on the input self.network.train(True) self.network.run(inputs={"X": input_enc}, time=self.config.TIME) self.network.train(False) # Reset network state self.network.reset_state_variables() # Evaluate performance at fixed intervals if (((step + 1) * self.config.BATCH_SIZE) % self.config.EVAL_INTERVAL == 0) or (step == len(self.trn_set) - 1): print("\nEvaluating...") print("Computing train accuracy...") self.eval_pass(self.trn_set4eval, train=True) print("Computing validation accuracy...") self.eval_pass(self.val_set, train=False) # Print results print("Current evaluation step: " + str(len(self.stats_manager.eval_accuracy))) print("Current trn. accuracy: " + str(100 * self.stats_manager.trn_accuracy[-1]) + "%") print("Current val. accuracy: " + str(100 * self.stats_manager.eval_accuracy[-1]) + "%") print("Top accuracy so far: " + str(100 * self.stats_manager.best_acc) + "%" + " at evaluation step: " + str(self.stats_manager.best_step)) # Plot results utils.plot_performance( self.stats_manager.trn_accuracy, self.stats_manager.eval_accuracy, self.config.RESULT_FOLDER + "/accuracy.png") # Check if accuracy improved if self.stats_manager.check_improvement(): # Save model print("Top accuracy improved! Saving new best model...") self.network.save(self.config.RESULT_FOLDER + "/model.pt") print("Model saved!") print("Evaluation complete!") print("Continuing training...")
def all(request): """ 返回 json 格式的所有 todo 数据 """ u = current_user(request) todos = Todo.all(user_id=u.id) #处理时间格式 format_time(todos) todos = [todo.to_dict() for todo in todos] return json_response(todos)
def add_event(): if request.method == 'GET': return render_template('forms/add_event.html', event=None) form = request.form.copy() utils.prune(form) utils.format_time(form, 'start') utils.format_time(form, 'end') events.add(form) return redirect(url_for('hub'))
def train_bootstrap(model, train_loader, epochs, optimizer, scheduler, device): model.train() for i in range(epochs): t0 = time.time() total_train_loss = 0 print(f"\nEpoch {i+1}:") for step, batch in enumerate(train_loader): if step % 40 == 0 and not step == 0: elapsed = format_time(time.time() - t0) print( f"lr: {optimizer.param_groups[0]['lr']:.4g}\tBatch {step:>5,} of {len(train_loader):>5,}.\tElapsed: {elapsed}." ) input_ids = batch[0].to(device) input_mask = batch[1].to(device) labels = batch[2].to(device) model.zero_grad() outputs = model(input_ids, pred_mode="topic", token_type_ids=None, attention_mask=input_mask) logits = outputs[0][:, 0, :] # topic_loss = nn.CrossEntropyLoss()(logits.view(-1, model.module.config.num_labels), labels.view(-1)) masked_topic_loss = nn.CrossEntropyLoss()(logits.view( -1, model.module.config.num_labels), labels.view(-1)) loss = masked_topic_loss # loss = topic_loss if torch.cuda.device_count() > 1: loss = loss.mean() total_train_loss += loss.item() loss.backward() # Clip the norm of the gradients to 1.0. nn.utils.clip_grad_norm_(model.parameters(), 1.0) optimizer.step() scheduler.step() avg_train_loss = total_train_loss / len(train_loader) training_time = format_time(time.time() - t0) print(f"\n Average training loss: {avg_train_loss:.2g}") print(f" Training took: {training_time}") return
def report_speeds(sample, secs_remaining): status_dot[0] = (status_dot[0] + 1) % 3 status_line = ''.join(['.' if i == status_dot[0] else ' ' for i in range(3)]) if secs_remaining < 0: print (' %s %s %s (warming up, %s)\r' % (algorithm.name, status_line, utils.format_speeds(sample), utils.format_time(-secs_remaining))), else: print (' %s %s %s (sampling, %s) \r' % (algorithm.name, status_line, utils.format_speeds(sample), utils.format_time(secs_remaining))), sys.stdout.flush()
def add(request): ''' 拿到浏览器发送的数据 用数据创建一个新的 todo 返回给浏览器 ''' # 得到浏览器发送的表单, 浏览器用 ajax 发送 json 格式的数据过来 # 所以用新增加的 dejson 函数来获取解析后的 json 数据 form = request.dejson() u = current_user(request) form['user_id'] = u.id t = Todo.add(form) format_time(t) return json_response(t.to_dict())
def get_error_from_Cigar(cigartuples=[], full_query_seq='', align_ref_seq='', ref_start=0): mis, ins, dele = [], [], [] last_error = '' ref_pos, query_pos = ref_start, 0 for tuples in cigartuples: if tuples[0] == BAM_CMATCH: for q, r in zip( full_query_seq[query_pos:query_pos + tuples[1]], align_ref_seq[ref_pos - ref_start:ref_pos - ref_start + tuples[1]]): if q != r: # MISMATCH if last_error != 'MIS' or mis[-1][0] != query_pos - 1: mis_error = [query_pos, ref_pos, 1, q, r] mis.append(mis_error) else: # last_error == 'MIS' and mis[-1][1] == ap[0] - 1: mis[-1][-3] += 1 mis[-1][-2] += q mis[-1][-1] += r last_error = 'MIS' ref_pos += 1 query_pos += 1 elif tuples[0] == BAM_CDEL: del_error = [ query_pos - 1, ref_pos, tuples[1], align_ref_seq[ref_pos - ref_start:ref_pos - ref_start + tuples[1]] ] dele.append(del_error) last_error = 'DEL' ref_pos += tuples[1] elif tuples[0] == BAM_CINS: ins_error = [ query_pos, ref_pos - 1, tuples[1], full_query_seq[query_pos:query_pos + tuples[1]] ] ins.append(ins_error) last_error = 'INS' query_pos += tuples[1] elif tuples[0] == BAM_CHARD_CLIP or tuples[0] == BAM_CSOFT_CLIP: query_pos += tuples[1] elif tuples[0] == BAM_CREF_SKIP: ref_pos += tuples[1] else: ut.format_time(sys.stderr, 'get_error_from_Cigar', 'Unexpected cigar: {}\n'.format(cigartuples)) sys.exit(1) return mis, ins, dele
def edit_event(): if request.method == 'GET': ID = request.args.get('ID') event = events.get(ID) utils.reverse_format_time(event, 'start') utils.reverse_format_time(event, 'end') return render_template('forms/add_event.html', event=event) form = request.form.copy() utils.prune(form) utils.format_time(form, 'start') utils.format_time(form, 'end') events.update(form['ID'], form) return redirect(url_for('admin'))
async def default(self, message, args): group = get_group(args, message.author.id) ics = await get_group_ics(message, group) if not ics: return # This is only to test (on weekends bruh) # now = datetime.datetime.now().replace(tzinfo=pytz.UTC) # events = ics.timeline.start_after(now) events = list(ics.timeline.today()) now = datetime.datetime.utcnow().replace(tzinfo=pytz.UTC) exists = any(events) embed = discord.Embed(title="It seems you are free today!" if not exists else f"Today's {group} lessons' are", colour=BOT_COLOR, timestamp=now) if exists: embed.set_thumbnail(url=ICON) embed.set_footer(text="Momento", icon_url=ICON) for event in events: start = datetime.datetime.fromisoformat(str(event.begin)) end = datetime.datetime.fromisoformat(str(event.end)) lesson_link = BASE_LESSON + get_group_id(event) desc = "" delim = "__" if now >= start: if now < end: fmt = format_time(get_time_diff(now - start)) desc += f":teacher: [Started since]({lesson_link}) {fmt}\n" else: # if the lesson is over delim = "~~" else: fmt = format_time(get_time_diff(start - now)) desc += f"⏲ [Starts]({lesson_link}) in {fmt}\n" desc += f"From **{start:%H:%M}** to **{end:%H:%M}** " desc += f"with **{get_teacher(event)}**\n" embed.add_field(name=f"{delim}{str(event.name)}{delim}", value=desc, inline=False) msg = await message.channel.send(embed=embed) await msg.add_reaction(emoji='❌')
def trip_duration_stats(df): """Displays statistics on the total and average trip duration.""" print('\nCalculating Trip Duration...\n') start_time = time.time() tot = u.format_time(dt.timedelta(seconds=float(df['Trip Duration'].sum()))) print('Total travel time is ', tot) mn = u.format_time(dt.timedelta(seconds=float(df['Trip Duration'].mean()))) print('Mean travel time is ', mn) print("\nThis took %s seconds." % (time.time() - start_time)) input('Press ENTER to continue.') print('-' * 40)
def main(): input_df = pd.read_csv(sys.stdin) old_contexts = list() new_contexts = list() start = time.time() for idx, word, year in input_df[['WORD', 'BASE_YEAR']].itertuples(): if idx > 0: duration = time.time() - start ETA = format_time((duration / idx) * (len(input_df) - idx)) else: ETA = "UNK" if '_' in word: word = word[:word.find('_')] log("{idx}/{total},{year},ETA {ETA},{word}".format(idx=idx, year=year, total=len(input_df), word=word.ljust(40), ETA=ETA), end='\r') try: if len(get_instances(word, year)) > 5: five_old_samples = random.sample(get_instances(word, year), 5) else: five_old_samples = get_instances(word, year) if len(get_instances(word, year + 1)) > 5: five_new_samples = random.sample(get_instances(word, year + 1), 5) else: five_new_samples = get_instances(word, year + 1) old_contexts.append(five_old_samples) new_contexts.append(five_new_samples) except ValueError: raise ValueError("Problem with", idx, word, year, "because not enough samples found") log("") log("This took", format_time(time.time() - start)) output_df = pd.DataFrame({ "ID": input_df["ID"], "WORD": input_df["WORD"], "BASE_YEAR": input_df["BASE_YEAR"], "OLD_CONTEXTS": old_contexts, "NEW_CONTEXTS": new_contexts }) output_df = output_df.set_index('ID') print(output_df.to_csv())
def add(): form = request.form t = Todo.new(form) t.username = session.get('user_name',None) t.ut = format_time(t.ut) t.save() return redirect(url_for('todo.index'))
def getFinishTime(rr): if rr.status != Finisher: return u'' try: return utils.format_time(rr.finish_time, forceHours=True) except: return u''
def resolve_link(self, link): playlist = super(self.__class__, self)._http_get(link, cache_limit=.5) try: ns = '{http://xspf.org/ns/0/}' root = ET.fromstring(playlist) tracks = root.findall('.//%strack' % (ns)) locations = [] for track in tracks: duration = track.find('%sduration' % (ns)).text try: duration = int(duration) except: duration = 0 if duration >= MIN_DURATION: location = track.find('%slocation' % (ns)).text locations.append({ 'duration': duration / 1000, 'url': location }) if len(locations) > 1: result = xbmcgui.Dialog().select(i18n('choose_stream'), [ utils.format_time(location['duration']) for location in locations ]) if result > -1: return locations[result]['url'] elif locations: return locations[0]['url'] except Exception as e: logger.log('Failure during furk playlist parse: %s' % (e), log_utils.LOGWARNING)
def updateSelectedTimestamp(self, ts): tstext = format_time(ts) item = self.tableWidget.currentItem() if item != None: c = item.column() if c in [1, 2]: if c == 2: i = str_to_ms(item.text()) if i <= ts: item.setText(tstext) else: n = str_to_ms( self.tableWidget.item(item.row(), 1).text()) if n <= ts: item.setText(tstext) else: i = str_to_ms(item.text()) if i >= ts: item.setText(tstext) else: n = str_to_ms( self.tableWidget.item(item.row(), 2).text()) if n < 0 or n >= ts: item.setText(tstext) self.update_incompatibilities()
async def fire_entries(self, schedule_list, message, hour_interval=0): for entry_id in schedule_list: entry_info = schedule_list[entry_id] utc_offset = entry_info.get(Constants.UTC_OFFSET) if utc_offset is None: utc_offset = 0 now = datetime.utcnow() + timedelta(hours=utc_offset) secs_now = now.timestamp() # Don't even try to fire on Sunday. Everyone deserves some *me time* if now.weekday() == 6: return if Constants.ENTRIES not in entry_info: break for entry in entry_info[Constants.ENTRIES]: should_fire = secs_now - entry.fired > 3600 * 6 if should_fire and \ entry.hour + hour_interval >= now.hour >= entry.hour - hour_interval \ and now.minute == entry.minute: # Event fired entry.fired = secs_now channel = self.get_entry_channel(entry) if not channel: log.error(f"Channel not found {entry.channel_id}") return time_str = utils.format_time(entry.hour, entry.minute) await channel.send(message.format(time_str))
def _update(self): if self._active: remaining = self.end_time - datetime.datetime.now() remaining_seconds = max(remaining.total_seconds(), 0) self.progress.setValue( remaining.seconds if self._direction == NDirection.DOWN else self.progress.maximum() - remaining_seconds) if remaining_seconds <= 30: self.setStyleSheet(self.styleSheet() + styles.spell_warning()) if not self._alert: self._alert = True if self._sound: sound.play(self._sound) else: self._alert = False if remaining_seconds <= 0: if self.persistent: self._time_label.setText("") else: self._remove() else: self._time_label.setText(format_time(remaining)) self.progress.update() QTimer.singleShot(1000, self._update)
async def purgesince(self, ctx, msg: discord.Message, from_user: Member = None): self.bot.admins.verify_admin(ctx) self.deleted_message_count = 0 await ctx.message.channel.purge( limit=100, after=msg.created_at, check=lambda m: self.sent_by_user(m.author, from_user)) sent_by_message = f" sent by {from_user.mention}" if from_user is not None else "" time = utils.format_time(msg.created_at, self.bot.config.TIMEZONE) await ctx.send(embed=utils.embed( title="Purge since", description= f"{ctx.message.author.mention} purged messages sent since {time}" f"{sent_by_message} from {ctx.message.channel.mention}.", footer_text=f"Total messages removed: {self.deleted_message_count}" )) sent_by_message = f" sent by {from_user.display_name}" if from_user is not None else "" self.logger.info( f"{ctx.message.author.display_name} purged messages sent since {time}" f"{sent_by_message} from {ctx.message.channel.name}.")
def __init__(self, loc='../../'): if self.DIR_NAME not in loc: loc = os.path.join(loc, self.DIR_NAME) if not os.path.exists(loc): os.makedirs(loc) self.path = loc self.logger = logging.getLogger() self.logger.setLevel(logging.INFO) file_handler = logging.handlers.TimedRotatingFileHandler( os.path.join(self.path, format_time(self.FILE_FORMAT) + self.LOG_SUF), when='D', interval=1, backupCount=40) file_handler.setLevel(logging.DEBUG) conslog = logging.StreamHandler() conslog.setLevel(logging.WARNING) fmt = logging.Formatter(self.FORMAT) file_handler.setFormatter(fmt) conslog.setFormatter(fmt) self.logger.addHandler(file_handler) self.logger.addHandler(conslog)
def __update_screen(self, sender, **kw): self.trip_type = "Business" if sender.trip_type == BUSINESS else "Non business" self.odometer = '{:.0f} km'.format(sender.odometer_start / 1000) self.started_on = format_time(sender.started_on) self.duration = '{0}'.format(sender.duration) self.dist = '{:.1f} km'.format(sender.distance_covered / 1000) self.avg_speed = format_speed(sender.average_speed)
def validate(val_loader, model, criterion, tencrop=False): batch_time = AverageMeter() data_time = AverageMeter() losses = AverageMeter() top1 = AverageMeter() top5 = AverageMeter() # switch to evaluate mode model.eval() end = time.time() with torch.no_grad(): for i, (input, target) in enumerate(val_loader): # measure data loading time data_time.update(time.time() - end) target = target.cuda(async=True) input_var = torch.autograd.Variable(input, volatile=True) target_var = torch.autograd.Variable(target, volatile=True) if tencrop: bs, ncrops, c, h, w = input_var.size() # compute output temp_output = model(input_var.view(-1, c, h, w)) output = temp_output.view(bs, ncrops, -1).mean(1) else: # compute output output = model(input_var) loss = criterion(output, target_var) # measure accuracy and record loss prec1, prec5 = accuracy(output.data, target, topk=(1, 5)) losses.update(loss.data.item(), input.size(0)) top1.update(prec1.item(), input.size(0)) top5.update(prec5.item(), input.size(0)) # measure elapsed time batch_time.update(time.time() - end) end = time.time() # if i % args.print_freq == 0: # print('Test: [{0}/{1}]\t' # 'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t' # 'Loss {loss.val:.4f} ({loss.avg:.4f})\t' # 'Prec@1 {top1.val:.3f} ({top1.avg:.3f})\t' # 'Prec@5 {top5.val:.3f} ({top5.avg:.3f})'.format( # i, len(val_loader), batch_time=batch_time, loss=losses, # top1=top1, top5=top5)) progress_bar( i, len(val_loader), 'Data: {data_time} | ' 'Target Loss: {loss.val:.4f} ({loss.avg:.4f}) | ' 'Prec@1: {top1.val:.3f} ({top1.avg:.3f}) | ' 'Prec@5: {top5.val:.3f} ({top5.avg:.3f})'.format( data_time=format_time(data_time.sum), loss=losses, top1=top1, top5=top5)) return top1.avg, top5.avg
def _update(self): if self.timer: remaining = self._end_time - datetime.datetime.now() remaining_seconds = remaining.total_seconds() if remaining_seconds < 0: self.stop() elif remaining_seconds <= 30: self.text.setHtml( "<font color='red' size='5'>{}</font>".format( format_time(remaining))) else: self.text.setHtml("<font color='white'>{}</font>".format( format_time(remaining))) self.realign() if remaining_seconds > 0 and self.timer: self.timer.singleShot(1000, self._update)
def update(self): self.name.set_markup("<small>{0}</small>".format(self.link.name)) self.progress.set_fraction(self.status.percent / 100.0) self.speed.set_markup( "<small>{0}/s - {1}</small>".format( utils.format_size(self.status.speed), utils.format_time(self.status.eta) ) )
def print_log(self, loss, step_duration, data_fetch_time, model_update_time): """Print a log statement to the terminal.""" samples_per_sec = self.config.batch_size / step_duration time_so_far = time() - self.start_time training_time_left = (self.config.n_iterations / self.global_step - 1.0) * time_so_far print_string = 'Iteration {:>6}/{} | examples/s: {:5.1f}' + \ ' | loss: {:.4f} | time elapsed: {} | time left: {}' print( print_string.format(self.global_step, self.config.n_iterations, samples_per_sec, loss, format_time(time_so_far), format_time(training_time_left))) print( 'Fetch data time: {:.0f}ms, model update time: {:.0f}ms\n'.format( 1000 * data_fetch_time, 1000 * model_update_time))
def _have_applied_incense(self): for applied_item in inventory.applied_items().all(): if applied_item.expire_ms > 0: mins = format_time(applied_item.expire_ms * 1000) self.logger.info("Not applying incense, currently active: %s, %s minutes remaining", applied_item.item.name, mins) return False else: return True
def all_done(self): if self._done_called: return print "Done with file " + self._org_filename, " - Uploaded ", utils.sizeof_fmt(self.len), "in", \ utils.format_time(time.time() - self._start_time), "\r", print self._done_called = True
def __init__(self, **kwargs): self.time = utils.format_time(kwargs["hour"], kwargs["minute"]) self.hour = kwargs.get("hour") self.minute = kwargs.get("minute") self.fired = 0 self.guild_id = kwargs.get("guild_id") self.channel_id = kwargs.get("channel_id") self.author_id = kwargs.get("author_id")
def onPlayBackStopped(self): xbmc.log('PrimeWire: Playback Stopped') #Is the item from our addon? if self.tracking: DBID = self.meta['DBID'] if 'DBID' in self.meta else None playedTime = int(self._lastPos) min_watched_percent = int(ADDON.getSetting('watched-percent')) percent_played = int((playedTime / self._totalTime) * 100) pTime = utils.format_time(playedTime) tTime = utils.format_time(self._totalTime) xbmc.log('PrimeWire: Service: Played %s of %s total = %s%%/%s%%' % (pTime, tTime, percent_played, min_watched_percent)) videotype = 'movie' if self.video_type == 'movie' else 'episode' if playedTime == 0 and self._totalTime == 999999: raise RuntimeError('XBMC silently failed to start playback') elif (percent_played >= min_watched_percent) and ( self.video_type == 'movie' or (self.meta['season'] and self.meta['episode'])): xbmc.log('PrimeWire: Service: Threshold met. Marking item as watched') # meta['DBID'] only gets set for strms in default.py if DBID: if videotype == 'episode': cmd = '{"jsonrpc": "2.0", "method": "VideoLibrary.GetEpisodeDetails", "params": {"episodeid": %s, "properties": ["playcount"]}, "id": 1}' cmd = cmd %(DBID) result = json.loads(xbmc.executeJSONRPC(cmd)) cmd = '{"jsonrpc": "2.0", "method": "VideoLibrary.SetEpisodeDetails", "params": {"episodeid": %s, "playcount": %s}, "id": 1}' playcount = int(result['result']['episodedetails']['playcount']) + 1 cmd = cmd %(DBID, playcount) result = xbmc.executeJSONRPC(cmd) xbmc.log('PrimeWire: Marking episode .strm as watched: %s' %result) if videotype == 'movie': cmd = '{"jsonrpc": "2.0", "method": "VideoLibrary.GetMovieDetails", "params": {"movieid": %s, "properties": ["playcount"]}, "id": 1}' cmd = cmd %(DBID) result = json.loads(xbmc.executeJSONRPC(cmd)) cmd = '{"jsonrpc": "2.0", "method": "VideoLibrary.SetMovieDetails", "params": {"movieid": %s, "playcount": %s}, "id": 1}' playcount = int(result['result']['moviedetails']['playcount']) + 1 cmd = cmd %(DBID, playcount) result = xbmc.executeJSONRPC(cmd) xbmc.log('PrimeWire: Marking movie .strm as watched: %s' %result) video_title = self.meta['title'] if self.video_type == 'movie' else self.meta['TVShowTitle'] ChangeWatched(self.meta['imdb'], videotype,video_title.strip(), self.meta['season'], self.meta['episode'], self.meta['year'], watched=7) db_connection.clear_bookmark(self.primewire_url) elif playedTime>0: xbmc.log('PrimeWire: Service: Threshold not met. Setting bookmark on %s to %s seconds' % (self.primewire_url,playedTime)) db_connection.set_bookmark(self.primewire_url,playedTime) self.reset()
def get_resume_choice(trakt_id, season, episode): if kodi.get_setting('trakt_bookmark') == 'true': resume_point = '%s%%' % (trakt_api.get_bookmark(trakt_id, season, episode)) header = utils2.i18n('trakt_bookmark_exists') else: resume_point = utils.format_time(db_connection.get_bookmark(trakt_id, season, episode)) header = utils2.i18n('local_bookmark_exists') question = utils2.i18n('resume_from') % (resume_point) dialog = xbmcgui.Dialog() try: return dialog.contextmenu([question, utils2.i18n('start_from_beginning')]) == 0 except: return dialog.yesno(header, question, '', '', utils2.i18n('start_from_beginning'), utils2.i18n('resume')) == 1
def resolve_link(self, link): playlist = super(self.__class__, self)._http_get(link, cache_limit=.5) try: ns = '{http://xspf.org/ns/0/}' root = ET.fromstring(playlist) tracks = root.findall('.//%strack' % (ns)) locations = [] for track in tracks: duration = track.find('%sduration' % (ns)).text try: duration = int(duration) except: duration = 0 if duration >= MIN_DURATION: location = track.find('%slocation' % (ns)).text locations.append({'duration': duration / 1000, 'url': location}) if len(locations) > 1: result = xbmcgui.Dialog().select(i18n('choose_stream'), [utils.format_time(location['duration']) for location in locations]) if result > -1: return locations[result]['url'] elif locations: return locations[0]['url'] except Exception as e: logger.log('Failure during furk playlist parse: %s' % (e), log_utils.LOGWARNING)
def work(self): forts = self.get_forts_in_range() if not self.should_run() or len(forts) == 0: return WorkerResult.SUCCESS fort = forts[0] lat = fort['latitude'] lng = fort['longitude'] details = fort_details(self.bot, fort['id'], lat, lng) fort_name = details.get('name', 'Unknown') response_dict = self.bot.api.fort_search( fort_id=fort['id'], fort_latitude=lat, fort_longitude=lng, player_latitude=f2i(self.bot.position[0]), player_longitude=f2i(self.bot.position[1]) ) if ('responses' in response_dict) and ('FORT_SEARCH' in response_dict['responses']): spin_details = response_dict['responses']['FORT_SEARCH'] spin_result = spin_details.get('result', -1) if (spin_result == SPIN_REQUEST_RESULT_SUCCESS) or (spin_result == SPIN_REQUEST_RESULT_INVENTORY_FULL): self.bot.softban = False experience_awarded = spin_details.get('experience_awarded', 0) items_awarded = self.get_items_awarded_from_fort_spinned(response_dict) egg_awarded = spin_details.get('pokemon_data_egg', None) if egg_awarded is not None: items_awarded[u'Egg'] = egg_awarded['egg_km_walked_target'] if experience_awarded or items_awarded: awards = ', '.join(["{}x {}".format(items_awarded[x], x) for x in items_awarded if x != u'Egg']) if egg_awarded is not None: awards += u', {} Egg'.format(egg_awarded['egg_km_walked_target']) self.emit_event( 'spun_pokestop', formatted="Spun pokestop {pokestop}. Experience awarded: {exp}. Items awarded: {items}", data={ 'pokestop': fort_name, 'exp': experience_awarded, 'items': awards } ) else: self.emit_event( 'pokestop_empty', formatted='Found nothing in pokestop {pokestop}.', data={'pokestop': fort_name} ) with self.bot.database as conn: c = conn.cursor() c.execute("SELECT COUNT(name) FROM sqlite_master WHERE type='table' AND name='pokestop_log'") result = c.fetchone() c.execute("SELECT DISTINCT COUNT(pokestop) FROM pokestop_log WHERE dated >= datetime('now','-1 day')") if c.fetchone()[0] >= self.config.get('daily_spin_limit', 2000): self.emit_event('spin_limit', formatted='WARNING! You have reached your daily spin limit') sys.exit(2) while True: if result[0] == 1: conn.execute('''INSERT INTO pokestop_log (pokestop, exp, items) VALUES (?, ?, ?)''', (fort_name, str(experience_awarded), str(items_awarded))) break else: self.emit_event('pokestop_log', sender=self, level='info', formatted="pokestop_log table not found, skipping log") break pokestop_cooldown = spin_details.get( 'cooldown_complete_timestamp_ms') self.bot.fort_timeouts.update({fort["id"]: pokestop_cooldown}) self.bot.recent_forts = self.bot.recent_forts[1:] + [fort['id']] elif spin_result == SPIN_REQUEST_RESULT_OUT_OF_RANGE: self.emit_event( 'pokestop_out_of_range', formatted="Pokestop {pokestop} out of range.", data={'pokestop': fort_name} ) elif spin_result == SPIN_REQUEST_RESULT_IN_COOLDOWN_PERIOD: pokestop_cooldown = spin_details.get( 'cooldown_complete_timestamp_ms') if pokestop_cooldown: self.bot.fort_timeouts.update({fort["id"]: pokestop_cooldown}) seconds_since_epoch = time.time() minutes_left = format_time( (pokestop_cooldown / 1000) - seconds_since_epoch ) self.emit_event( 'pokestop_on_cooldown', formatted="Pokestop {pokestop} on cooldown. Time left: {minutes_left}.", data={'pokestop': fort_name, 'minutes_left': minutes_left} ) else: self.emit_event( 'unknown_spin_result', formatted="Unknown spint result {status_code}", data={'status_code': str(spin_result)} ) if 'chain_hack_sequence_number' in response_dict['responses'][ 'FORT_SEARCH']: action_delay(self.spin_wait_min, self.spin_wait_max) return response_dict['responses']['FORT_SEARCH'][ 'chain_hack_sequence_number'] else: self.emit_event( 'pokestop_searching_too_often', formatted="Possibly searching too often, take a rest." ) if spin_result == 1 and not items_awarded and not experience_awarded and not pokestop_cooldown: self.bot.softban = True self.emit_event( 'softban', formatted='Probably got softban.' ) with self.bot.database as conn: c = conn.cursor() c.execute("SELECT COUNT(name) FROM sqlite_master WHERE type='table' AND name='softban_log'") result = c.fetchone() if result[0] == 1: source = str("PokemonCatchWorker") status = str("Possible Softban") conn.execute('''INSERT INTO softban_log (status, source) VALUES (?, ?)''', (status, source)) else: self.emit_event('softban_log', sender=self, level='info', formatted="softban_log table not found, skipping log") self.bot.fort_timeouts[fort["id"]] = (time.time() + 300) * 1000 # Don't spin for 5m return WorkerResult.ERROR action_delay(self.spin_wait_min, self.spin_wait_max) if len(forts) > 1: return WorkerResult.RUNNING return WorkerResult.SUCCESS
def work(self): lat = self.fort['latitude'] lng = self.fort['longitude'] self.api.fort_details(fort_id=self.fort['id'], latitude=lat, longitude=lng) response_dict = self.api.call() if 'responses' in response_dict \ and'FORT_DETAILS' in response_dict['responses'] \ and 'name' in response_dict['responses']['FORT_DETAILS']: fort_details = response_dict['responses']['FORT_DETAILS'] fort_name = fort_details['name'].encode('utf8', 'replace') else: fort_name = 'Unknown' logger.log('[#] Now at Pokestop: ' + fort_name + ' - Spinning...', 'yellow') sleep(2) self.api.fort_search(fort_id=self.fort['id'], fort_latitude=lat, fort_longitude=lng, player_latitude=f2i(self.position[0]), player_longitude=f2i(self.position[1])) response_dict = self.api.call() if 'responses' in response_dict and \ 'FORT_SEARCH' in response_dict['responses']: spin_details = response_dict['responses']['FORT_SEARCH'] if spin_details['result'] == 1: logger.log("[+] Loot: ", 'green') experience_awarded = spin_details.get('experience_awarded', False) if experience_awarded: logger.log("[+] " + str(experience_awarded) + " xp", 'green') items_awarded = spin_details.get('items_awarded', False) if items_awarded: tmp_count_items = {} for item in items_awarded: item_id = item['item_id'] if not item_id in tmp_count_items: tmp_count_items[item_id] = item['item_count'] else: tmp_count_items[item_id] += item['item_count'] for item_id, item_count in tmp_count_items.iteritems(): item_name = self.item_list[str(item_id)] logger.log("[+] " + str(item_count) + "x " + item_name + " (Total: " + str(self.bot.item_inventory_count(item_id)) + ")", 'green') # RECYCLING UNWANTED ITEMS if str(item_id) in self.config.item_filter: logger.log("[+] Recycling " + str(item_count) + "x " + item_name + "...", 'green') #RECYCLE_INVENTORY_ITEM response_dict_recycle = self.bot.drop_item(item_id=item_id, count=item_count) if response_dict_recycle and \ 'responses' in response_dict_recycle and \ 'RECYCLE_INVENTORY_ITEM' in response_dict_recycle['responses'] and \ 'result' in response_dict_recycle['responses']['RECYCLE_INVENTORY_ITEM']: result = response_dict_recycle['responses']['RECYCLE_INVENTORY_ITEM']['result'] if result is 1: # Request success logger.log("[+] Recycling success", 'green') else: logger.log("[+] Recycling failed!", 'red') else: logger.log("[#] Nothing found.", 'yellow') pokestop_cooldown = spin_details.get( 'cooldown_complete_timestamp_ms') if pokestop_cooldown: seconds_since_epoch = time.time() logger.log('[#] PokeStop on cooldown. Time left: ' + str( format_time((pokestop_cooldown / 1000) - seconds_since_epoch))) if not items_awarded and not experience_awarded and not pokestop_cooldown: message = ( 'Stopped at Pokestop and did not find experience, items ' 'or information about the stop cooldown. You are ' 'probably softbanned. Try to play on your phone, ' 'if pokemons always ran away and you find nothing in ' 'PokeStops you are indeed softbanned. Please try again ' 'in a few hours.') raise RuntimeError(message) elif spin_details['result'] == 2: logger.log("[#] Pokestop out of range") elif spin_details['result'] == 3: pokestop_cooldown = spin_details.get( 'cooldown_complete_timestamp_ms') if pokestop_cooldown: seconds_since_epoch = time.time() logger.log('[#] PokeStop on cooldown. Time left: ' + str( format_time((pokestop_cooldown / 1000) - seconds_since_epoch))) elif spin_details['result'] == 4: print_red("[#] Inventory is full, switching to catch mode...") self.config.mode = 'poke' if 'chain_hack_sequence_number' in response_dict['responses'][ 'FORT_SEARCH']: time.sleep(2) return response_dict['responses']['FORT_SEARCH'][ 'chain_hack_sequence_number'] else: print_yellow('[#] may search too often, lets have a rest') return 11 sleep(8) return 0
if args.timeout is not None: with time_limit(args.timeout): patch = repair() else: patch = repair() except TimeoutException: logger.info("failed to generate patch (timeout)") print('TIMEOUT') exit(0) except (CompilationError, InferenceError, TransformationError): logger.info("failed to generate patch") print('FAIL') exit(1) end = time.time() elapsed = format_time(end - start) if patch is None: logger.info("no patch generated in {}".format(elapsed)) print('FAIL') exit(0) else: if not config['synthesis_only']: patch_file = basename(abspath(args.src)) + '-' + time.strftime("%Y-%b%d-%H%M%S") + '.patch' logger.info("patch successfully generated in {} (see {})".format(elapsed, patch_file)) print('SUCCESS') with open(patch_file, 'w+') as file: for line in patch: file.write(line) else: logger.info("patch successfully generated in {}".format(elapsed))
KerasPredictor(InceptionRestNetV2Classifier(), MODE), ], policies=INTEGRATED_POLICY, all_combine=PATH_TARGET != PATH_TEST_B) path_json_dumps = dump_json(predictor, batch_size=128, target_dir=PATH_TARGET) if not isinstance(path_json_dumps, list): path_json_dumps = [path_json_dumps] finally: im_utils.recycle_pool() else: root_path = os.path.dirname(os.path.dirname(CONTEXT('mock')['path_json_dump'])) path_json_dumps = utils.get_files(root_path) if EVAL: scores = [] model_names = [] for json_path in path_json_dumps: filename = os.path.basename(json_path) policy = filename.replace('result_', '').replace('.json', '') if filename.__contains__('result_') else '' combine_name = os.path.basename(os.path.dirname(json_path)) model_name = '%s%s' % (combine_name, ('_%s' % policy) if policy else '') print('\n%s' % model_name) scores.append(evaluate(json_path, PATH_VAL_JSON)) model_names.append(model_name) sort_index = np.argsort(scores)[::-1] print('\n[Sorted by scores:]') for index in sort_index: print('%.16f, %s' % (scores[index], model_names[index])) time_str = utils.format_time(time.time() - START_TIME) print('\nEvaluation time of your result: %s.' % time_str)
def work(self): fort = self.get_fort_in_range() if not self.should_run() or fort is None: return WorkerResult.SUCCESS lat = fort['latitude'] lng = fort['longitude'] details = fort_details(self.bot, fort['id'], lat, lng) fort_name = details.get('name', 'Unknown').encode('utf8', 'replace') logger.log('Now at Pokestop: {0}'.format(fort_name), 'cyan') logger.log('Spinning ...', 'cyan') self.bot.api.fort_search(fort_id=fort['id'], fort_latitude=lat, fort_longitude=lng, player_latitude=f2i(self.bot.position[0]), player_longitude=f2i(self.bot.position[1])) response_dict = self.bot.api.call() if 'responses' in response_dict and \ 'FORT_SEARCH' in response_dict['responses']: spin_details = response_dict['responses']['FORT_SEARCH'] spin_result = spin_details.get('result', -1) if spin_result == 1: self.bot.softban = False logger.log("Loot: ", 'green') experience_awarded = spin_details.get('experience_awarded', False) if experience_awarded: logger.log(str(experience_awarded) + " xp", 'green') items_awarded = spin_details.get('items_awarded', False) if items_awarded: self.bot.latest_inventory = None tmp_count_items = {} for item in items_awarded: item_id = item['item_id'] if not item_id in tmp_count_items: tmp_count_items[item_id] = item['item_count'] else: tmp_count_items[item_id] += item['item_count'] for item_id, item_count in tmp_count_items.iteritems(): item_name = self.bot.item_list[str(item_id)] logger.log( '- ' + str(item_count) + "x " + item_name + " (Total: " + str(self.bot.item_inventory_count(item_id)) + ")", 'yellow' ) else: logger.log("[#] Nothing found.", 'yellow') pokestop_cooldown = spin_details.get( 'cooldown_complete_timestamp_ms') self.bot.fort_timeouts.update({fort["id"]: pokestop_cooldown}) if pokestop_cooldown: seconds_since_epoch = time.time() logger.log('PokeStop on cooldown. Time left: ' + str( format_time((pokestop_cooldown / 1000) - seconds_since_epoch))) self.bot.recent_forts = self.bot.recent_forts[1:] + [fort['id']] elif spin_result == 2: logger.log("[#] Pokestop out of range") elif spin_result == 3: pokestop_cooldown = spin_details.get( 'cooldown_complete_timestamp_ms') if pokestop_cooldown: self.bot.fort_timeouts.update({fort["id"]: pokestop_cooldown}) seconds_since_epoch = time.time() logger.log('PokeStop on cooldown. Time left: ' + str( format_time((pokestop_cooldown / 1000) - seconds_since_epoch))) elif spin_result == 4: logger.log("Inventory is full", 'red') else: logger.log("Unknown spin result: " + str(spin_result), 'red') if 'chain_hack_sequence_number' in response_dict['responses'][ 'FORT_SEARCH']: time.sleep(2) return response_dict['responses']['FORT_SEARCH'][ 'chain_hack_sequence_number'] else: logger.log('Possibly searching too often - taking a short rest :)', 'yellow') if spin_result == 1 and not items_awarded and not experience_awarded and not pokestop_cooldown: self.bot.softban = True logger.log('[!] Possibly got softban too...', 'red') else: self.bot.fort_timeouts[fort["id"]] = (time.time() + 300) * 1000 # Don't spin for 5m return 11 sleep(2) return 0
def work(self): lat = self.fort['latitude'] lng = self.fort['longitude'] unit = self.config.distance_unit # Unit to use when printing formatted distance fortID = self.fort['id'] dist = distance(self.position[0], self.position[1], lat, lng) # print('[#] Found fort {} at distance {}m'.format(fortID, dist)) logger.log('[#] Found fort {} at distance {}'.format( fortID, format_dist(dist, unit))) if dist > 10: logger.log('[#] Need to move closer to Pokestop') position = (lat, lng, 0.0) if self.config.walk > 0: self.stepper._walk_to(self.config.walk, *position) else: self.api.set_position(*position) self.api.player_update(latitude=lat, longitude=lng) response_dict = self.api.call() logger.log('[#] Arrived at Pokestop') sleep(2) self.api.fort_details(fort_id=self.fort['id'], latitude=lat, longitude=lng) response_dict = self.api.call() if 'responses' in response_dict \ and'FORT_DETAILS' in response_dict['responses'] \ and 'name' in response_dict['responses']['FORT_DETAILS']: fort_details = response_dict['responses']['FORT_DETAILS'] fort_name = fort_details['name'].encode('utf8', 'replace') else: fort_name = 'Unknown' logger.log('[#] Now at Pokestop: ' + fort_name + ' - Spinning...', 'yellow') sleep(2) self.api.fort_search(fort_id=self.fort['id'], fort_latitude=lat, fort_longitude=lng, player_latitude=f2i(self.position[0]), player_longitude=f2i(self.position[1])) response_dict = self.api.call() if 'responses' in response_dict and \ 'FORT_SEARCH' in response_dict['responses']: spin_details = response_dict['responses']['FORT_SEARCH'] if spin_details['result'] == 1: logger.log("[+] Loot: ", 'green') experience_awarded = spin_details.get('experience_awarded', False) if experience_awarded: logger.log("[+] " + str(experience_awarded) + " xp", 'green') items_awarded = spin_details.get('items_awarded', False) if items_awarded: tmp_count_items = {} for item in items_awarded: item_id = item['item_id'] if not item_id in tmp_count_items: tmp_count_items[item_id] = item['item_count'] else: tmp_count_items[item_id] += item['item_count'] for item_id, item_count in tmp_count_items.iteritems(): item_id = str(item_id) item_name = self.item_list[item_id] logger.log("[+] " + str(item_count) + "x " + item_name, 'green') else: logger.log("[#] Nothing found.", 'yellow') pokestop_cooldown = spin_details.get( 'cooldown_complete_timestamp_ms') if pokestop_cooldown: seconds_since_epoch = time.time() logger.log('[#] PokeStop on cooldown. Time left: ' + str( format_time((pokestop_cooldown / 1000) - seconds_since_epoch))) if not items_awarded and not experience_awarded and not pokestop_cooldown: message = ( 'Stopped at Pokestop and did not find experience, items ' 'or information about the stop cooldown. You are ' 'probably softbanned. Try to play on your phone, ' 'if pokemons always ran away and you find nothing in ' 'PokeStops you are indeed softbanned. Please try again ' 'in a few hours.') raise RuntimeError(message) elif spin_details['result'] == 2: logger.log("[#] Pokestop out of range") elif spin_details['result'] == 3: pokestop_cooldown = spin_details.get( 'cooldown_complete_timestamp_ms') if pokestop_cooldown: seconds_since_epoch = time.time() logger.log('[#] PokeStop on cooldown. Time left: ' + str( format_time((pokestop_cooldown / 1000) - seconds_since_epoch))) elif spin_details['result'] == 4: print_red("[#] Inventory is full, switching to catch mode...") self.config.mode = 'poke' if 'chain_hack_sequence_number' in response_dict['responses'][ 'FORT_SEARCH']: time.sleep(2) return response_dict['responses']['FORT_SEARCH'][ 'chain_hack_sequence_number'] else: print_yellow('[#] may search too often, lets have a rest') return 11 sleep(8) return 0
def work(self): forts = self.get_forts_in_range() if not self.should_run() or len(forts) == 0: return WorkerResult.SUCCESS fort = forts[0] lat = fort['latitude'] lng = fort['longitude'] details = fort_details(self.bot, fort['id'], lat, lng) fort_name = details.get('name', 'Unknown') response_dict = self.bot.api.fort_search( fort_id=fort['id'], fort_latitude=lat, fort_longitude=lng, player_latitude=f2i(self.bot.position[0]), player_longitude=f2i(self.bot.position[1]) ) if ('responses' in response_dict) and ('FORT_SEARCH' in response_dict['responses']): spin_details = response_dict['responses']['FORT_SEARCH'] spin_result = spin_details.get('result', -1) if (spin_result == SPIN_REQUEST_RESULT_SUCCESS) or (spin_result == SPIN_REQUEST_RESULT_INVENTORY_FULL): self.bot.softban = False experience_awarded = spin_details.get('experience_awarded', 0) items_awarded = self.get_items_awarded_from_fort_spinned(response_dict) if experience_awarded or items_awarded: self.emit_event( 'spun_pokestop', formatted="Spun pokestop {pokestop}. Experience awarded: {exp}. Items awarded: {items}", data={ 'pokestop': fort_name, 'exp': experience_awarded, 'items': items_awarded } ) else: self.emit_event( 'pokestop_empty', formatted='Found nothing in pokestop {pokestop}.', data={'pokestop': fort_name} ) pokestop_cooldown = spin_details.get( 'cooldown_complete_timestamp_ms') self.bot.fort_timeouts.update({fort["id"]: pokestop_cooldown}) self.bot.recent_forts = self.bot.recent_forts[1:] + [fort['id']] elif spin_result == SPIN_REQUEST_RESULT_OUT_OF_RANGE: self.emit_event( 'pokestop_out_of_range', formatted="Pokestop {pokestop} out of range.", data={'pokestop': fort_name} ) elif spin_result == SPIN_REQUEST_RESULT_IN_COOLDOWN_PERIOD: pokestop_cooldown = spin_details.get( 'cooldown_complete_timestamp_ms') if pokestop_cooldown: self.bot.fort_timeouts.update({fort["id"]: pokestop_cooldown}) seconds_since_epoch = time.time() minutes_left = format_time( (pokestop_cooldown / 1000) - seconds_since_epoch ) self.emit_event( 'pokestop_on_cooldown', formatted="Pokestop {pokestop} on cooldown. Time left: {minutes_left}.", data={'pokestop': fort_name, 'minutes_left': minutes_left} ) else: self.emit_event( 'unknown_spin_result', formatted="Unknown spint result {status_code}", data={'status_code': str(spin_result)} ) if 'chain_hack_sequence_number' in response_dict['responses'][ 'FORT_SEARCH']: action_delay(self.spin_wait_min, self.spin_wait_max) return response_dict['responses']['FORT_SEARCH'][ 'chain_hack_sequence_number'] else: self.emit_event( 'pokestop_searching_too_often', formatted="Possibly searching too often, take a rest." ) if spin_result == 1 and not items_awarded and not experience_awarded and not pokestop_cooldown: self.bot.softban = True self.emit_event( 'softban', formatted='Probably got softban.' ) else: self.bot.fort_timeouts[fort["id"]] = (time.time() + 300) * 1000 # Don't spin for 5m return WorkerResult.ERROR action_delay(self.spin_wait_min, self.spin_wait_max) if len(forts) > 1: return WorkerResult.RUNNING return WorkerResult.SUCCESS
def work(self): lat = self.fort["latitude"] lng = self.fort["longitude"] unit = self.config.distance_unit # Unit to use when printing formatted distance fortID = self.fort["id"] dist = distance(self.position[0], self.position[1], lat, lng) logger.log("[#] Found fort {} at distance {}".format(fortID, format_dist(dist, unit))) if dist > 0: logger.log("[#] Need to move closer to Pokestop") position = (lat, lng, 0.0) if self.config.walk > 0: self.stepper.walk_to(self.config.walk, *position) else: self.api.set_position(*position) self.api.player_update(latitude=lat, longitude=lng) logger.log("[#] Arrived at Pokestop") sleep(2) self.api.fort_details(fort_id=self.fort["id"], latitude=lat, longitude=lng) response_dict = self.api.call() fort_details = response_dict.get("responses", {}).get("FORT_DETAILS", {}) fort_name = fort_details.get("name").encode("utf8", "replace") fort_name = fort_name if fort_name is not None else "Unknown" logger.log("[#] Now at Pokestop: " + fort_name + " - Spinning...", "yellow") sleep(3) self.api.fort_search(fort_id=self.fort["id"], fort_latitude=lat, fort_longitude=lng, player_latitude=f2i(self.position[0]), player_longitude=f2i(self.position[1])) response_dict = self.api.call() spin_details = response_dict.get("responses", {}).get("FORT_SEARCH", {}) spin_result = spin_details.get("result") if spin_result == 1: logger.log("[+] Loot: ", "green") experience_awarded = spin_details.get("experience_awarded", False) if experience_awarded: logger.log("[+] " + str(experience_awarded) + " xp", "green") items_awarded = spin_details.get("items_awarded", False) if items_awarded: tmp_count_items = {} for item in items_awarded: item_id = item["item_id"] if item_id not in tmp_count_items: tmp_count_items[item_id] = item["item_count"] else: tmp_count_items[item_id] += item["item_count"] for item_id, item_count in tmp_count_items.iteritems(): item_id = str(item_id) item_name = self.item_list[item_id] logger.log("[+] " + str(item_count) + "x " + item_name, "green") else: logger.log("[#] Nothing found.", "yellow") pokestop_cooldown = spin_details.get( "cooldown_complete_timestamp_ms") if pokestop_cooldown: seconds_since_epoch = time.time() logger.log("[#] PokeStop on cooldown. Time left: " + str( format_time((pokestop_cooldown / 1000) - seconds_since_epoch))) if not items_awarded and not experience_awarded and not pokestop_cooldown: message = ( "Stopped at Pokestop and did not find experience, items " "or information about the stop cooldown. You are " "probably softbanned. Try to play on your phone, " "if pokemons always ran away and you find nothing in " "PokeStops you are indeed softbanned. Please try again " "in a few hours.") raise RuntimeError(message) elif spin_result == 2: logger.log("[#] Pokestop out of range") elif spin_result == 3: pokestop_cooldown = spin_details.get( "cooldown_complete_timestamp_ms") if pokestop_cooldown: seconds_since_epoch = time.time() logger.log("[#] PokeStop on cooldown. Time left: " + str( format_time((pokestop_cooldown / 1000) - seconds_since_epoch))) elif spin_result == 4: print_red("[#] Inventory is full, switching to catch mode...") self.config.mode = "poke" if "chain_hack_sequence_number" in fort_details: time.sleep(2) return fort_details[ "chain_hack_sequence_number"] else: print_yellow("[#] may search too often, lets have a rest") return 11 sleep(10) return 0
def RunCFind(self): tags = [(0x0010, 0x0010), (0x0010, 0x1010), (0x0010,0x0040), (0x0008,0x1030),\ (0x0008,0x0060), (0x0008,0x0022), (0x0008,0x0080), (0x0010,0x0030),\ (0x0008,0x0050), (0x0008,0x0090), (0x0008,0x103E), (0x0008,0x0033),\ (0x0008,0x0032), (0x0020,0x000d)] ds = gdcm.DataSet() for tag in tags: tg = gdcm.Tag(tag[0], tag[1]) de = gdcm.DataElement(tg) if self.search_type == 'patient' and tag == (0x0010, 0x0010): bit_size = len(self.search_word) + 1 de.SetByteValue(str(self.search_word + '*'), gdcm.VL(bit_size)) else: de.SetByteValue('*', gdcm.VL(1)) ds.Insert(de) cnf = gdcm.CompositeNetworkFunctions() theQuery = cnf.ConstructQuery(gdcm.ePatientRootType, gdcm.eImageOrFrame, ds) ret = gdcm.DataSetArrayType() cnf.CFind(self.address, int(self.port), theQuery, ret, self.aetitle,\ self.aetitle_call) patients = {} exist_images = False c = 0 for i in range(0,ret.size()): patient_id = str(ret[i].GetDataElement(gdcm.Tag(0x0010, 0x0020)).GetValue) serie_id = str(ret[i].GetDataElement(gdcm.Tag(0x0020, 0x000e)).GetValue) if not(patient_id in patients.keys()): patients[patient_id] = {} if not(serie_id in patients[patient_id]): rt = ret[i] name = self.GetValueFromDICOM(rt, (0x0010, 0x0010)) age = self.GetValueFromDICOM(rt, (0x0010, 0x1010)) gender = self.GetValueFromDICOM(rt, (0x0010,0x0040)) study_description = self.GetValueFromDICOM(rt, (0x0008,0x1030)) modality = self.GetValueFromDICOM(rt, (0x0008,0x0060)) institution = self.GetValueFromDICOM(rt, (0x0008,0x0080)) date_of_birth = utils.format_date(self.GetValueFromDICOM(rt, (0x0010,0x0030))) acession_number = self.GetValueFromDICOM(rt, (0x0008,0x0050)) ref_physician = self.GetValueFromDICOM(rt, (0x0008,0x0090)) serie_description = self.GetValueFromDICOM(rt, (0x0008,0x103E)) acquisition_time = utils.format_time(self.GetValueFromDICOM(rt, (0x0008,0x0032))) acquisition_date = utils.format_date(self.GetValueFromDICOM(rt, (0x0008,0x0022))) teste = self.GetValueFromDICOM(rt, (0x0020,0x000d)) print ">>>>>>>>>>>>>>>>>>>>", teste patients[patient_id][serie_id] = {'name':name, 'age':age, 'gender':gender,\ 'study_description':study_description,\ 'modality':modality, \ 'acquisition_time':acquisition_time,\ 'acquisition_date':acquisition_date,\ 'institution':institution,\ 'date_of_birth':date_of_birth,\ 'acession_number':acession_number,\ 'ref_physician':ref_physician,\ 'serie_description':serie_description} patients[patient_id][serie_id]['n_images'] = 1 else: patients[patient_id][serie_id]['n_images'] += 1 return patients
def main(args): if len(args) != 5: print 'Usage: <trace> <segment> <user_ids> <output>' return f = open(args[1], 'r') requests = [] for line in f: request = json.loads(line) requests.append(request) f.close() f = open(args[2], 'r') segments = [] for line in f: request = json.loads(line) segments.append(request) f.close() user_requests = {} f = open(args[3], 'r') for line in f: line = line[:-1] user_requests[line] = [] f.close() start_date = segments[0]['start_time'].split()[0] is_full = set() cnt = 0 for request in requests: uid = request['uid'] if uid in user_requests and uid not in is_full: cnt += 1 # each request has an unique id request['idx'] = str(int(segments[-1]['idx']) + cnt) # avoid using same expt_idx in segment request['expt_idx'] = 'zfeng' + request['expt_idx'] request['uid'] = 'zfeng' + uid req_list = user_requests[uid] if len(req_list) == 0: splits = request['start_time'].split() # new_time = replace date request['new_time'] = start_date + ' ' + splits[1] else: start_time = utils.parse_time(req_list[0]['start_time']) cur_time = utils.parse_time(request['start_time']) diff = cur_time - start_time if diff.days >= 31: is_full.add(uid) continue start_new_time = utils.parse_time(req_list[0]['new_time']) cur_new_time = start_new_time + diff # new_time = new_time of first request + difference request['new_time'] = utils.format_time(cur_new_time) req_list.append(request) f = open(args[4], 'w') # output requests in segment for request in segments: f.write(json.dumps(request) + '\n') # output requests in users for uid in user_requests.keys(): req_list = user_requests[uid] print uid, len(req_list) for request in req_list: f.write(json.dumps(request) + '\n') f.close()
def work(self): lat = self.fort['latitude'] lng = self.fort['longitude'] self.api.fort_details(fort_id=self.fort['id'], latitude=lat, longitude=lng) response_dict = self.api.call() if 'responses' in response_dict \ and'FORT_DETAILS' in response_dict['responses'] \ and 'name' in response_dict['responses']['FORT_DETAILS']: fort_details = response_dict['responses']['FORT_DETAILS'] fort_name = fort_details['name'].encode('utf8', 'replace') else: fort_name = 'Unknown' logger.log('[#] Sekarang berada di Pokestop: ' + fort_name + ' - Memutar...', 'yellow') sleep(2) self.api.fort_search(fort_id=self.fort['id'], fort_latitude=lat, fort_longitude=lng, player_latitude=f2i(self.position[0]), player_longitude=f2i(self.position[1])) response_dict = self.api.call() if 'responses' in response_dict and \ 'FORT_SEARCH' in response_dict['responses']: spin_details = response_dict['responses']['FORT_SEARCH'] if spin_details['result'] == 1: logger.log("[+] Loot: ", 'green') experience_awarded = spin_details.get('experience_awarded', False) if experience_awarded: logger.log("[+] " + str(experience_awarded) + " xp", 'green') items_awarded = spin_details.get('items_awarded', False) if items_awarded: self.config.mode = 'all' tmp_count_items = {} for item in items_awarded: item_id = item['item_id'] if not item_id in tmp_count_items: tmp_count_items[item_id] = item['item_count'] else: tmp_count_items[item_id] += item['item_count'] for item_id, item_count in tmp_count_items.iteritems(): item_name = self.item_list[str(item_id)] logger.log("[+] " + str(item_count) + "x " + item_name + " (Total: " + str(self.bot.item_inventory_count(item_id)) + ")", 'green') # RECYCLING UNWANTED ITEMS if str(item_id) in self.config.item_filter: logger.log("[+] Recycling " + str(item_count) + "x " + item_name + "...", 'green') #RECYCLE_INVENTORY_ITEM response_dict_recycle = self.bot.drop_item(item_id=item_id, count=item_count) if response_dict_recycle and \ 'responses' in response_dict_recycle and \ 'RECYCLE_INVENTORY_ITEM' in response_dict_recycle['responses'] and \ 'result' in response_dict_recycle['responses']['RECYCLE_INVENTORY_ITEM']: result = response_dict_recycle['responses']['RECYCLE_INVENTORY_ITEM']['result'] if result is 1: # Request success logger.log("[+] Recycling success", 'green') else: logger.log("[+] Recycling gagal!", 'red') else: logger.log("[#] Nothing found.", 'yellow') pokestop_cooldown = spin_details.get( 'cooldown_complete_timestamp_ms') if pokestop_cooldown: seconds_since_epoch = time.time() logger.log('[#] PokeStop on cooldown. Time left: ' + str( format_time((pokestop_cooldown / 1000) - seconds_since_epoch))) if not items_awarded and not experience_awarded and not pokestop_cooldown: print_red('Masih kena softbanned') self.config.mode = 'farm' elif spin_details['result'] == 2: logger.log("[#] Pokestop out of range") elif spin_details['result'] == 3: pokestop_cooldown = spin_details.get( 'cooldown_complete_timestamp_ms') if pokestop_cooldown: seconds_since_epoch = time.time() logger.log('[#] PokeStop cooldown. Time left: ' + str( format_time((pokestop_cooldown / 1000) - seconds_since_epoch))) elif spin_details['result'] == 4: print_red("[#] Inventory penuh, ke mode berburu...") self.config.mode = 'poke' if 'chain_hack_sequence_number' in response_dict['responses'][ 'FORT_SEARCH']: time.sleep(2) return response_dict['responses']['FORT_SEARCH'][ 'chain_hack_sequence_number'] else: print_yellow('[#] Leren seek...') return 11 sleep(8) return 0
def work(self): fort = self.get_fort_in_range() if (not self.should_run() or fort == None): return WorkerResult.SUCCESS lat = fort['latitude'] lng = fort['longitude'] logger.log('Spinning ...', 'cyan') self.api.fort_search(fort_id=fort['id'], fort_latitude=lat, fort_longitude=lng, player_latitude=f2i(self.position[0]), player_longitude=f2i(self.position[1])) response_dict = self.api.call() if 'responses' in response_dict and \ 'FORT_SEARCH' in response_dict['responses']: spin_details = response_dict['responses']['FORT_SEARCH'] spin_result = spin_details.get('result', -1) if spin_result == 1: logger.log("Loot: ", 'green') experience_awarded = spin_details.get('experience_awarded', False) if experience_awarded: logger.log(str(experience_awarded) + " xp", 'green') items_awarded = spin_details.get('items_awarded', False) if items_awarded: self.bot.latest_inventory = None tmp_count_items = {} for item in items_awarded: item_id = item['item_id'] if not item_id in tmp_count_items: tmp_count_items[item_id] = item['item_count'] else: tmp_count_items[item_id] += item['item_count'] for item_id, item_count in tmp_count_items.iteritems(): item_name = self.item_list[str(item_id)] logger.log('- ' + str(item_count) + "x " + item_name + " (Total: " + str(self.bot.item_inventory_count(item_id)) + ")", 'yellow') else: logger.log("[#] Nothing found.", 'yellow') pokestop_cooldown = spin_details.get( 'cooldown_complete_timestamp_ms') self.bot.fort_timeouts.update({fort["id"]: pokestop_cooldown}) if pokestop_cooldown: seconds_since_epoch = time.time() logger.log('PokeStop on cooldown. Time left: ' + str( format_time((pokestop_cooldown / 1000) - seconds_since_epoch))) if not items_awarded and not experience_awarded and not pokestop_cooldown: message = ( 'Stopped at Pokestop and did not find experience, items ' 'or information about the stop cooldown. You are ' 'probably softbanned. Try to play on your phone, ' 'if pokemons always ran away and you find nothing in ' 'PokeStops you are indeed softbanned. Please try again ' 'in a few hours.') raise RuntimeError(message) self.bot.recent_forts = self.bot.recent_forts[1:] + [fort['id']] elif spin_result == 2: logger.log("[#] Pokestop out of range") elif spin_result == 3: pokestop_cooldown = spin_details.get( 'cooldown_complete_timestamp_ms') if pokestop_cooldown: self.bot.fort_timeouts.update({fort["id"]: pokestop_cooldown}) seconds_since_epoch = time.time() logger.log('PokeStop on cooldown. Time left: ' + str( format_time((pokestop_cooldown / 1000) - seconds_since_epoch))) elif spin_result == 4: logger.log("Inventory is full", 'red') else: logger.log("Unknown spin result: " + str(spin_result), 'red') if 'chain_hack_sequence_number' in response_dict['responses'][ 'FORT_SEARCH']: time.sleep(2) return response_dict['responses']['FORT_SEARCH'][ 'chain_hack_sequence_number'] else: logger.log('Possibly searching too often - taking a short rest :)', 'yellow') self.bot.fort_timeouts[fort["id"]] = (time.time() + 300) * 1000 # Don't spin for 5m return 11 sleep(2) return 0
def work(self): fort = self.get_fort_in_range() if not self.should_run() or fort is None: return WorkerResult.SUCCESS lat = fort['latitude'] lng = fort['longitude'] details = fort_details(self.bot, fort['id'], lat, lng) fort_name = details.get('name', 'Unknown') response_dict = self.bot.api.fort_search( fort_id=fort['id'], fort_latitude=lat, fort_longitude=lng, player_latitude=f2i(self.bot.position[0]), player_longitude=f2i(self.bot.position[1]) ) if 'responses' in response_dict and \ 'FORT_SEARCH' in response_dict['responses']: spin_details = response_dict['responses']['FORT_SEARCH'] spin_result = spin_details.get('result', -1) if spin_result == 1: self.bot.softban = False experience_awarded = spin_details.get('experience_awarded', 0) items_awarded = spin_details.get('items_awarded', {}) if items_awarded: self.bot.latest_inventory = None tmp_count_items = {} for item in items_awarded: item_id = item['item_id'] item_name = self.bot.item_list[str(item_id)] if not item_name in tmp_count_items: tmp_count_items[item_name] = item['item_count'] else: tmp_count_items[item_name] += item['item_count'] if experience_awarded or items_awarded: self.emit_event( 'spun_pokestop', formatted="Spun pokestop {pokestop}. Experience awarded: {exp}. Items awarded: {items}", data={ 'pokestop': fort_name, 'exp': experience_awarded, 'items': tmp_count_items } ) else: self.emit_event( 'pokestop_empty', formatted='Found nothing in pokestop {pokestop}.', data={'pokestop': fort_name} ) pokestop_cooldown = spin_details.get( 'cooldown_complete_timestamp_ms') self.bot.fort_timeouts.update({fort["id"]: pokestop_cooldown}) self.bot.recent_forts = self.bot.recent_forts[1:] + [fort['id']] elif spin_result == 2: self.emit_event( 'pokestop_out_of_range', formatted="Pokestop {pokestop} out of range.", data={'pokestop': fort_name} ) elif spin_result == 3: pokestop_cooldown = spin_details.get( 'cooldown_complete_timestamp_ms') if pokestop_cooldown: self.bot.fort_timeouts.update({fort["id"]: pokestop_cooldown}) seconds_since_epoch = time.time() minutes_left = format_time( (pokestop_cooldown / 1000) - seconds_since_epoch ) self.emit_event( 'pokestop_on_cooldown', formatted="Pokestop {pokestop} on cooldown. Time left: {minutes_left}.", data={'pokestop': fort_name, 'minutes_left': minutes_left} ) elif spin_result == 4: if not self.ignore_item_count: self.emit_event( 'inventory_full', formatted="Inventory is full!" ) else: self.emit_event( 'unknown_spin_result', formatted="Unknown spint result {status_code}", data={'status_code': str(spin_result)} ) if 'chain_hack_sequence_number' in response_dict['responses'][ 'FORT_SEARCH']: time.sleep(2) return response_dict['responses']['FORT_SEARCH'][ 'chain_hack_sequence_number'] else: self.emit_event( 'pokestop_searching_too_often', formatted="Possibly searching too often, take a rest." ) if spin_result == 1 and not items_awarded and not experience_awarded and not pokestop_cooldown: self.bot.softban = True self.emit_event( 'softban', formatted='Probably got softban.' ) else: self.bot.fort_timeouts[fort["id"]] = (time.time() + 300) * 1000 # Don't spin for 5m return 11 sleep(2) return 0