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
