def report_single(pokemon_id):
session = db.Session(autoflush=False)
session_stats = db.get_session_stats(session)
js_data = {
'charts_data': {
'hours': db.get_spawns_per_hour(session, pokemon_id),
},
'map_center': utils.MAP_CENTER,
'zoom': 13,
}
template = render_template(
'report_single.html',
current_date=datetime.now(),
area_name=config.AREA_NAME,
area_size=utils.get_scan_area(),
pokemon_id=pokemon_id,
pokemon_name=POKEMON_NAMES[pokemon_id],
total_spawn_count=db.get_total_spawns_count(session, pokemon_id),
session_start=session_stats['start'],
session_end=session_stats['end'],
session_length_hours=int(session_stats['length_hours']),
google_maps_key=config.GOOGLE_MAPS_KEY,
js_data=js_data,
)
session.close()
return template
def report_main():
session = db.Session(autoflush=False)
counts = db.get_sightings_per_pokemon(session)
session_stats = db.get_session_stats(session)
session.close()
count = sum(counts.values())
counts_tuple = tuple(counts.items())
top_pokemon = list(counts_tuple[-30:])
top_pokemon.reverse()
bottom_pokemon = counts_tuple[:30]
nonexistent = [(x, POKEMON_NAMES[x]) for x in range(1, 152)
if x not in counts]
rare_pokemon = [r for r in counts_tuple if r[0] in config.RARE_IDS]
if rare_pokemon:
rare_sightings = db.get_all_sightings(session,
[r[0] for r in rare_pokemon])
else:
rare_sightings = []
js_data = {
'charts_data': {
'punchcard': db.get_punch_card(session),
'top30': [(POKEMON_NAMES[r[0]], r[1]) for r in top_pokemon],
'bottom30': [(POKEMON_NAMES[r[0]], r[1]) for r in bottom_pokemon],
'rare': [(POKEMON_NAMES[r[0]], r[1]) for r in rare_pokemon],
},
'maps_data': {
'rare': [sighting_to_marker(s) for s in rare_sightings],
},
'map_center': utils.MAP_CENTER,
'zoom': 13,
}
icons = {
'top30': [(r[0], POKEMON_NAMES[r[0]]) for r in top_pokemon],
'bottom30': [(r[0], POKEMON_NAMES[r[0]]) for r in bottom_pokemon],
'rare': [(r[0], POKEMON_NAMES[r[0]]) for r in rare_pokemon],
'nonexistent': nonexistent
}
area = utils.get_scan_area()
return render_template(
'report.html',
current_date=datetime.now(),
area_name=config.AREA_NAME,
area_size=area,
total_spawn_count=count,
spawns_per_hour=count // session_stats['length_hours'],
session_start=session_stats['start'],
session_end=session_stats['end'],
session_length_hours=session_stats['length_hours'],
js_data=js_data,
icons=icons,
google_maps_key=config.GOOGLE_MAPS_KEY,
)
def get_pokestopsmarkers():
markers = []
session = db.Session()
pokestops = db.get_pokestops(session)
session.close()
for pokestop in pokestops:
markers.append({
'id': 'pokestop-{}'.format(pokestop.id),
'type': 'pokestop',
'external_id': pokestop.external_id,
'lat': pokestop.lat,
'lon': pokestop.lon
})
return markers
def get_spawnpointsmarkers():
markers = []
session = db.Session()
spawns = db.get_spawn_points(session)
session.close()
for spawn in spawns:
markers.append({
'id': 'spawn-{}'.format(spawn.id),
'type': 'spawn',
'spawn_id': spawn.spawn_id,
'despawn_time': spawn.despawn_time,
'lat': spawn.lat,
'lon': spawn.lon,
'alt': spawn.alt,
'duration': spawn.duration
})
return markers
def get_pokemarkers():
markers = []
session = db.Session(autoflush=False)
pokemons = db.get_sightings(session)
forts = db.get_forts(session)
session.close()
for pokemon in pokemons:
markers.append({
'id': 'pokemon-{}'.format(pokemon.id),
'type': 'pokemon',
'trash': pokemon.pokemon_id in config.TRASH_IDS,
'name': POKEMON_NAMES[pokemon.pokemon_id],
'pokemon_id': pokemon.pokemon_id,
'lat': pokemon.lat,
'lon': pokemon.lon,
'expires_at': pokemon.expire_timestamp,
})
for fort in forts:
if fort['guard_pokemon_id']:
pokemon_name = POKEMON_NAMES[fort['guard_pokemon_id']]
else:
pokemon_name = 'Empty'
markers.append({
'id': 'fort-{}'.format(fort['fort_id']),
'sighting_id': fort['id'],
'type': 'fort',
'prestige': fort['prestige'],
'pokemon_id': fort['guard_pokemon_id'],
'pokemon_name': pokemon_name,
'team': fort['team'],
'lat': fort['lat'],
'lon': fort['lon'],
})
if config.MAP_WORKERS:
# Worker stats
try:
markers.extend(get_worker_markers())
except RemoteError:
print('Unable to connect to manager for worker data.')
return markers
def report_heatmap():
session = db.Session(autoflush=False)
pokemon_id = request.args.get('id')
points = db.get_all_spawn_coords(session, pokemon_id=pokemon_id)
session.close()
return json.dumps(points)
def get_stats():
cache_valid = (
CACHE['data']
and CACHE['generated_at'] > datetime.now() - timedelta(minutes=15))
if cache_valid:
return CACHE['data']
session = db.Session()
forts = db.get_forts(session)
session.close()
count = {t.value: 0 for t in db.Team}
strongest = {t.value: None for t in db.Team}
guardians = {t.value: {} for t in db.Team}
top_guardians = {t.value: None for t in db.Team}
prestige = {t.value: 0 for t in db.Team}
percentages = {}
prestige_percent = {}
total_prestige = 0
last_date = 0
for fort in forts:
if fort['last_modified'] > last_date:
last_date = fort['last_modified']
team = fort['team']
count[team] = count[team] + 1
if team != 0:
# Strongest gym
existing = strongest[team]
should_replace = (existing is not None
and fort['prestige'] > existing[0]
or existing is None)
pokemon_id = fort['guard_pokemon_id']
if should_replace:
strongest[team] = (
fort['prestige'],
pokemon_id,
POKEMON_NAMES[pokemon_id],
)
# Guardians
guardian_value = guardians[team].get(pokemon_id, 0)
guardians[team][pokemon_id] = guardian_value + 1
# Prestige
prestige[team] += fort['prestige']
total_prestige = sum(prestige.values())
for team in db.Team:
# TODO: remove float(...) as soon as we move to Python 3
percentages[team.value] = (count.get(team.value) / float(len(forts)) *
100)
prestige_percent[team.value] = (prestige.get(team.value) /
float(total_prestige) * 100)
if guardians[team.value]:
pokemon_id = sorted(guardians[team.value],
key=guardians[team.value].__getitem__,
reverse=True)[0]
top_guardians[team.value] = POKEMON_NAMES[pokemon_id]
CACHE['generated_at'] = datetime.now()
CACHE['data'] = {
'order': sorted(count, key=count.__getitem__, reverse=True),
'count': count,
'total_count': len(forts),
'strongest': strongest,
'prestige': prestige,
'prestige_percent': prestige_percent,
'percentages': percentages,
'last_date': last_date,
'top_guardians': top_guardians,
'generated_at': CACHE['generated_at'],
}
return CACHE['data']