def _restartPogoDroid(self): successfulStop = self._stopPogoDroid() time.sleep(1) logger.debug("restartPogoDroid: stop pogodriud resulted in {}", str(successfulStop)) if successfulStop: return self._start_pogodroid() else: return False
def _turn_map(self, delayadd): logger.debug('{_turn_map} called') logger.info('Turning map') x1, x2, y = self._resocalc.get_gym_spin_coords(self)[0], self._resocalc.get_gym_spin_coords(self)[1], \ self._resocalc.get_gym_spin_coords(self)[2] self._communicator.swipe(int(x1), int(y), int(x2), int(y)) time.sleep(int(delayadd)) logger.debug('{_turn_map} called') return
async def _update_position_file(self): logger.debug("Updating .position file") if self.current_location is not None: with open( os.path.join(self._applicationArgs.file_path, self._id + '.position'), 'w') as outfile: outfile.write( str(self.current_location.lat) + ", " + str(self.current_location.lng))
def debug_message(self, message, event_type): logger.debug( '{:8} {:15.15} {:20} {}'.format( event_type, message.author.name, message.author.id, message.content ) )
def _open_gym(self, delayadd): logger.debug('{_open_gym} called') time.sleep(.5) x, y = self._resocalc.get_gym_click_coords( self)[0], self._resocalc.get_gym_click_coords(self)[1] self._communicator.click(int(x), int(y)) time.sleep(.5 + int(delayadd)) logger.debug('{_open_gym} finished') return
def getJsonRoute(self, coords, maxRadius, maxCoordsInRadius, in_memory, num_processes=1, algorithm='optimized', useS2: bool = False, S2level: int=15, route_name: str = 'Unknown'): export_data = [] if useS2: logger.debug("Using S2 method for calculation with S2 level: {}", S2level) if not in_memory and \ (self._data['fields']['routefile'] is not None and len(self._data['fields']['routefile']) > 0): logger.debug('Using routefile from DB') for line in self._data['fields']['routefile']: # skip empty lines if not line.strip(): continue lineSplit = line.split(',') export_data.append({'lat': float(lineSplit[0].strip()), 'lng': float(lineSplit[1].strip())}) return export_data lessCoordinates = coords if len(coords) > 0 and maxRadius and maxCoordsInRadius: logger.info("Calculating route for {}", route_name) newCoords = self.getLessCoords(coords, maxRadius, maxCoordsInRadius, useS2, S2level) lessCoordinates = np.zeros(shape=(len(newCoords), 2)) for i in range(len(lessCoordinates)): lessCoordinates[i][0] = newCoords[i][0] lessCoordinates[i][1] = newCoords[i][1] logger.debug("Coords summed up: {}, that's just {} coords", str(lessCoordinates), str(len(lessCoordinates))) logger.debug("Got {} coordinates", len(lessCoordinates)) if len(lessCoordinates) < 3: logger.debug("less than 3 coordinates... not gonna take a shortest route on that") export_data = [] for i in range(len(lessCoordinates)): export_data.append({'lat': lessCoordinates[i][0].item(), 'lng': lessCoordinates[i][1].item()}) else: logger.info("Calculating a short route through all those coords. Might take a while") from timeit import default_timer as timer start = timer() if algorithm == 'quick': from route.routecalc.calculate_route_quick import route_calc_impl else: from route.routecalc.calculate_route_optimized import route_calc_impl sol_best = route_calc_impl(lessCoordinates, route_name, num_processes) end = timer() logger.info("Calculated route in {} minutes", str((end - start) / 60)) for i in range(len(sol_best)): export_data.append({'lat': lessCoordinates[int(sol_best[i])][0].item(), 'lng': lessCoordinates[int(sol_best[i])][1].item()}) if not in_memory: calc_coords = [] for coord in export_data: calc_coord = '%s,%s' % (coord['lat'], coord['lng']) calc_coords.append(calc_coord) # Only save if we aren't calculating in memory self._data['fields']['routefile'] = calc_coords self.save() return export_data
def get_gym_count(self): logger.debug('Fetching gym count from db') query = ( "SELECT If(team_id=0, 'WHITE', if(team_id=1, 'BLUE', if (team_id=2, 'RED', 'YELLOW'))) " "AS Color, count(team_id) AS Count " "FROM `gym` " "GROUP BY team_id" ) res = self._db_exec.execute(query) return res
def get_shiny_stats_hour(self): logger.debug('Fetching shiny pokemon stats from db') query = ( "SELECT hour(FROM_UNIXTIME(timestamp_scan)) AS hour, type_id " "FROM trs_stats_detect_raw " "WHERE is_shiny = 1 " "GROUP BY type_id, hour ORDER BY hour ASC" ) res = self._db_exec.execute(query) return res
def insert_usage(self, instance, cpu, mem, garbage, timestamp): logger.debug("dbWrapper::insert_usage") query = ( "INSERT into trs_usage (instance, cpu, memory, garbage, timestamp) VALUES " "(%s, %s, %s, %s, %s)") vals = (instance, cpu, mem, garbage, timestamp) self.execute(query, vals, commit=True) return
async def read(self) -> Optional[Any]: try: dataBytes = await self.pipeReader.read(1024) data = json.loads(dataBytes[8:].decode("utf-8")) logger.debug("[READ] %s", data) return data except: logger.exception( "An unexpected error occured during a RPC read operation") self.connected = False
def get_location_info(self): logger.debug('Fetching all empty locations from db') query = ( "SELECT worker, sum(location_count), sum(location_ok), sum(location_nok), " "sum(location_nok) / sum(location_count) * 100 as Loc_fail_rate " "FROM trs_stats_location " "GROUP BY worker" ) res = self._db_exec.execute(query) return res
def get_all_empty_scans(self): logger.debug('Fetching all empty locations from db') query = ("SELECT count(b.id) as Count, b.lat, b.lng, GROUP_CONCAT(DISTINCT b.worker order by worker asc " "SEPARATOR ', '), if(b.type=0,'Normal','PrioQ'), max(b.period), (select count(c.id) " "from trs_stats_location_raw c where c.lat=b.lat and c.lng=b.lng and c.success=1) as successcount from " "trs_stats_location_raw b where success=0 group by lat, lng HAVING Count > 5 and successcount=0 " "ORDER BY count(id) DESC" ) res = self._db_exec.execute(query) return res
def _get_screen_size(self): screen = self._communicator.getscreensize().split(' ') self._screen_x = screen[0] self._screen_y = screen[1] x_offset = self._devicesettings.get("screenshot_x_offset", 0) y_offset = self._devicesettings.get("screenshot_y_offset", 0) logger.debug('Get Screensize of {}: X: {}, Y: {}, X-Offset: {}, Y-Offset: {}', str( self._id), str(self._screen_x), str(self._screen_y), str(x_offset), str(y_offset)) self._resocalc.get_x_y_ratio( self, self._screen_x, self._screen_y, x_offset, y_offset)
def process(filename, args, db_wrapper, hash, raidno, captureTime, captureLat, captureLng, src_path, radius): logger.debug("Cropscanning started") scanner = Scanner(args, db_wrapper, hash) logger.info("Initialized scanned, starting analysis of {}", str(filename)) checkcrop = scanner.start_detect(filename, hash, raidno, captureTime, captureLat, captureLng, src_path, radius) return checkcrop
def _merge_priority_queue(self, new_queue): if new_queue is not None: with self._manager_mutex: merged = list(new_queue) logger.info("New raw priority queue with {} entries", len(merged)) merged = self._filter_priority_queue_internal(merged) heapq.heapify(merged) self._prio_queue = merged logger.info("New clustered priority queue with {} entries", len(merged)) logger.debug("Priority queue entries: {}", str(merged))
def write(self, op: int, payload: Any) -> None: try: logger.debug("[WRITE] %s", payload) payload = json.dumps(payload) self.pipeWriter.write( struct.pack("<ii", op, len(payload)) + payload.encode("utf-8")) except: logger.exception( "An unexpected error occured during a RPC write operation") self.connected = False
def retrieve_next_spawns(self, geofence_helper): """ Retrieve the spawnpoints with their respective unixtimestamp that are due in the next 300 seconds :return: """ logger.debug("DbWrapper::retrieve_next_spawns called") current_time_of_day = datetime.now().replace(microsecond=0) minLat, minLon, maxLat, maxLon = geofence_helper.get_polygon_from_fence( ) query = ( "SELECT latitude, longitude, spawndef, calc_endminsec " "FROM trs_spawn " "WHERE calc_endminsec IS NOT NULL " "AND (latitude >= {} AND longitude >= {} AND latitude <= {} AND longitude <= {}) " "AND DATE_FORMAT(STR_TO_DATE(calc_endminsec,'%i:%s'),'%i:%s') BETWEEN DATE_FORMAT(DATE_ADD(NOW(), " " INTERVAL if(spawndef=15,60,30) MINUTE),'%i:%s') " "AND DATE_FORMAT(DATE_ADD(NOW(), INTERVAL if(spawndef=15,70,40) MINUTE),'%i:%s')" ).format(minLat, minLon, maxLat, maxLon) res = self.execute(query) next_up = [] current_time = time.time() for (latitude, longitude, spawndef, calc_endminsec) in res: if geofence_helper and not geofence_helper.is_coord_inside_include_geofence( [latitude, longitude]): continue endminsec_split = calc_endminsec.split(":") minutes = int(endminsec_split[0]) seconds = int(endminsec_split[1]) temp_date = current_time_of_day.replace(minute=minutes, second=seconds) if minutes < datetime.now().minute: temp_date = temp_date + timedelta(hours=1) if temp_date < current_time_of_day: # spawn has already happened, we should've added it in the past, let's move on # TODO: consider crosschecking against current mons... continue spawn_duration_minutes = 60 if spawndef == 15 else 30 timestamp = time.mktime(temp_date.timetuple()) - \ spawn_duration_minutes * 60 # check if we calculated a time in the past, if so, add an hour to it... timestamp = timestamp + 60 * 60 if timestamp < current_time else timestamp # TODO: consider the following since I am not sure if the prio Q clustering handles stuff properly yet # if timestamp >= current_time + 600: # # let's skip monspawns that are more than 10minutes in the future # continue next_up.append((timestamp, Location(latitude, longitude))) return next_up
def kill_old_jobs(self): logger.info("Checking for outdated jobs") for job in self._log.copy(): if self._log[job]['status'] in ('pending', 'starting', 'processing', 'not connected', 'future') \ and not self._log[job].get('auto', False): logger.debug("Cancel job {} - it is outdated".format(str(job))) self.write_status_log(str(job), field='status', value='cancelled') elif self._log[job].get('auto', False): self.write_status_log(str(job), delete=True)
def _wait_data_worker(self, latest, proto_to_wait_for, timestamp): data_requested = LatestReceivedType.UNDEFINED if latest is None: logger.debug( "Nothing received from {} since MAD started", str(self._id)) time.sleep(0.5) elif proto_to_wait_for not in latest: logger.debug( "No data linked to the requested proto since MAD started.") time.sleep(0.5) else: # proto has previously been received, let's check the timestamp... # TODO: int vs str-key? latest_proto = latest.get(proto_to_wait_for, None) mode = self._mapping_manager.routemanager_get_mode(self._routemanager_name) latest_timestamp = latest_proto.get("timestamp", 0) if latest_timestamp >= timestamp: # TODO: consider reseting timestamp here since we clearly received SOMETHING latest_data = latest_proto.get("values", None) if latest_data is None: time.sleep(0.5) return LatestReceivedType.UNDEFINED elif mode in ["mon_mitm", "iv_mitm"]: # check if the GMO contains mons for data_extract in latest_data['payload']['cells']: for WP in data_extract['wild_pokemon']: # TODO: teach Prio Q / Clusterer to hold additional data such as mon/encounter IDs if WP['spawnpoint_id']: data_requested = latest_data break if data_requested is None: logger.debug("No spawnpoints in data requested") time.sleep(1) elif mode in ["raids_mitm"]: for data_extract in latest_data['payload']['cells']: for forts in data_extract['forts']: if forts['id']: data_requested = latest_data break if data_requested is None: logger.debug("No forts in data received") time.sleep(0.5) else: logger.warning( "No mode specified to wait for - this should not even happen...") time.sleep(0.5) else: logger.debug("latest timestamp of proto {} ({}) is older than {}", str(proto_to_wait_for), str(latest_timestamp), str(timestamp)) # TODO: timeout error instead of data_error_counter? Differentiate timeout vs missing data (the # TODO: latter indicates too high speeds for example time.sleep(0.5) return data_requested
def del_from_route(self): logger.debug( "{}: Location available, acquiring lock and trying to return location", str(self.name)) self._manager_mutex.acquire() logger.info('Removing coords from Route') self._route.pop(int(self._current_index_of_route) - 1) self._current_index_of_route -= 1 if len(self._route) == 0: logger.info('No more coords are available... Sleeping.') self._manager_mutex.release()
def _init_route_queue(self): self._manager_mutex.acquire() try: if len(self._route) > 0: self._route_queue.queue.clear() logger.debug("Creating queue for coords") for latlng in self._route: self._route_queue.put((latlng.lat, latlng.lng)) logger.debug("Finished creating queue") finally: self._manager_mutex.release()
async def __retrieve_next_send(self, websocket_client_connection): found = None while found is None and websocket_client_connection.open: try: found = self.__send_queue.get_nowait() except Exception as e: await asyncio.sleep(0.02) if not websocket_client_connection.open: logger.debug( "retrieve_next_send: connection closed, returning None") return found
def _check_coords_before_returning(self, lat, lng): if self.init: logger.debug('Init Mode - coord is valid') return True stop = Location(lat, lng) logger.info('Checking Stop with ID {}', str(stop)) if stop not in self._stoplist and not self._level: logger.info('Already got this Stop') return False logger.info('Getting new Stop') return True
def generate_stop_list(self): time.sleep(5) stops, stops_with_visits = self.db_wrapper.stop_from_db_without_quests( self.geofence_helper, True) logger.info('Detected stops without quests: {}', str(len(stops_with_visits))) logger.debug('Detected stops without quests: {}', str(stops_with_visits)) self._stoplist: List[Location] = stops self._stops_with_visits: List[LocationWithVisits] = stops_with_visits
def get_all_hash(self, type): logger.debug("DbWrapperBase::get_all_hash called") query = ("SELECT id, hash, type, count, modify " "FROM trshash " "HAVING type = %s") vals = (str(type), ) logger.debug(query) res = self.execute(query, vals) return res
def _check_coords_before_returning(self, lat, lng, origin): if self.init: logger.debug('Init Mode - coord is valid') return True stop = Location(lat, lng) logger.info('Checking Stop with ID {}', str(stop)) if stop in self._coords_to_be_ignored: logger.info('Already tried this Stop and failed it') return False logger.info('DB knows nothing of this stop for {} lets try and go there', origin) return True
def get_best_pokemon_spawns(self): logger.debug('Fetching best pokemon spawns from db') query = ( "SELECT encounter_id, pokemon_id, unix_timestamp(last_modified), " "individual_attack, individual_defense, individual_stamina, cp_multiplier, cp " "FROM pokemon " "WHERE individual_attack = 15 and individual_defense = 15 and individual_stamina = 15 " "ORDER BY last_modified DESC LIMIT 300" ) res = self._db_exec.execute(query) return res
async def __producer_handler(self, websocket_client_connection): while websocket_client_connection.open: # logger.debug("Connection still open, trying to send next message") # retrieve next message from queue to be sent, block if empty next = None while next is None and websocket_client_connection.open: logger.debug("Fetching next message to send") next = await self.__retrieve_next_send(websocket_client_connection) if next is None: # logger.debug("next is None, stopping connection...") return await self.__send_specific(websocket_client_connection, next.id, next.message)
def get_stop_quest(self): logger.debug('Fetching gym count from db') query = ( "SELECT " "If(FROM_UNIXTIME(trs_quest.quest_timestamp, '%y-%m-%d') IS NULL, 'NO QUEST', " "FROM_UNIXTIME(trs_quest.quest_timestamp, '%y-%m-%d')) AS Quest, " "count(pokestop.pokestop_id) AS Count " "FROM pokestop LEFT JOIN trs_quest ON pokestop.pokestop_id = trs_quest.GUID " "GROUP BY FROM_UNIXTIME(trs_quest.quest_timestamp, '%y-%m-%d')" ) res = self._db_exec.execute(query) return res
def stats_location_raw_parser(client_id: int, data, period): data_location_raw = [] if 'location' in data: for loc_raw in data['location']: data_location_raw.append(loc_raw) logger.debug('Submit raw location stats for {} - Period: {} - Count: {}', str(client_id), str(period), str(len(data_location_raw))) return data_location_raw
def get_shiny_stats(self): logger.debug('Fetching shiny pokemon stats from db') query = ( "SELECT (select count(DISTINCT encounter_id) from pokemon inner join trs_stats_detect_raw on " "CAST(trs_stats_detect_raw.type_id as unsigned int)=pokemon.encounter_id where pokemon.pokemon_id=a.pokemon_id and " "trs_stats_detect_raw.worker=b.worker and pokemon.form=a.form), count(DISTINCT encounter_id), a.pokemon_id," "b.worker, GROUP_CONCAT(DISTINCT encounter_id ORDER BY encounter_id DESC SEPARATOR '<br>'), a.form, b.timestamp_scan " "FROM pokemon a left join trs_stats_detect_raw b on a.encounter_id=CAST(b.type_id as unsigned int) where b.is_shiny=1 group by " "b.is_shiny, a.pokemon_id, a.form, b.worker order by b.timestamp_scan DESC " ) res = self._db_exec.execute(query) return res
async def on_channel_delete(self, channel): logger.debug( 'The "{}" channel has been removed on the server "{}"' .format(channel.name, channel.server.name) )
async def on_channel_update(self, before, after): logger.debug( 'The "{}" channel has been modified on the server "{}"' .format(before.name, before.server.name) )
async def on_member_join(self, member): logger.debug( '{} ({}) has joined the server "{}"' .format(member.name, member.id, member.server.name) )
async def on_member_remove(self, member): logger.debug( '{} ({}) has left the server "{}"' .format(member.name, member.id, member.server.name) )