def load_gym_section(settings):
log.info("Setting Gym filters...")
# Set the defaults for "True"
# Override defaults using a new Filter to verify inputs
default_filt = GymFilter(settings.pop('default', {}), {
"to_team": {0, 1, 2, 3}, "from_team": {0, 1, 2, 3},
"min_dist": 0.0, "max_dist": float('inf')
}, 'default')
default = default_filt.to_dict()
# Create the settings for gyms
gym = {
"enabled": bool(parse_boolean(settings.pop('enabled', None)) or False),
"ignore_neutral": bool(parse_boolean(settings.pop('ignore_neutral', None)) or False),
"filters": create_multi_filter('Gym --> filters', GymFilter,
settings.pop('filters', "False"), default)
}
reject_leftover_parameters(settings, 'Gym section of Filters file.') # Check for leftovers
for filt in gym['filters']:
log.debug("Team(s) {} changes to Team(s) {} between {} and {}.".format(
filt.from_team, filt.to_team, get_dist_as_str(filt.min_dist), get_dist_as_str(filt.max_dist)
))
if gym['enabled'] is False:
log.info("Gym notifications will NOT be sent. - Enabled is False ")
return gym
def parse_alarms_file(manager, filename):
try:
filepath = utils.get_path(filename)
log.info("Loading Alarms from file at {}".format(filepath))
with open(filepath, 'r') as f:
alarm_settings = json.load(f, object_pairs_hook=OrderedDict)
if type(alarm_settings) is not OrderedDict:
log.critical("Alarms file must be an object of Alarms objects "
+ "- { 'alarm1': {...}, ... 'alarm5': {...} }")
sys.exit(1)
except ValueError as e:
log.error("Encountered error while loading Alarms:"
" {}: {}".format(type(e).__name__, e))
log.error(
"PokeAlarm has encountered a 'ValueError' while loading the "
"Alarms file. This typically means the file isn't in the "
"correct json format. Try loading the file contents into a "
"json validator.")
log.debug("Stack trace: \n {}".format(traceback.format_exc()))
sys.exit(1)
try:
for name, alarm in alarm_settings.iteritems():
active = parse_boolean(require_and_remove_key(
'active', alarm, "Alarm objects in file."))
if active:
manager.add_alarm(name, alarm)
else:
log.debug("%s alarm ignored: active is set to 'false'", name)
except Exception as e:
log.error("Encountered error while loading Alarms: "
+ "{}: {}".format(type(e).__name__, e))
log.debug("Stack trace: \n {}".format(traceback.format_exc()))
sys.exit(1)
def __init__(self, settings, default, location):
self.min_dist = float(settings.pop('min_dist', None) or default['min_dist'])
self.max_dist = float(settings.pop('max_dist', None) or default['max_dist'])
# Do we ignore pokemon with missing info?
self.ignore_missing = bool(parse_boolean(settings.pop('ignore_missing', default['ignore_missing'])))
# CP
self.min_cp = int(settings.pop('min_cp', None) or default['min_cp'])
self.max_cp = int(settings.pop('max_cp', None) or default['max_cp'])
# Level
self.min_level = int(settings.pop('min_level', None) or default['min_level'])
self.max_level = int(settings.pop('max_level', None) or default['max_level'])
# IVs
self.min_iv = float(settings.pop('min_iv', None) or default['min_iv'])
self.max_iv = float(settings.pop('max_iv', None) or default['max_iv'])
self.min_atk = int(settings.pop('min_atk', None) or default['min_atk'])
self.max_atk = int(settings.pop('max_atk', None) or default['max_atk'])
self.min_def = int(settings.pop('min_def', None) or default['min_def'])
self.max_def = int(settings.pop('max_def', None) or default['max_def'])
self.min_sta = int(settings.pop('min_sta', None) or default['min_sta'])
self.max_sta = int(settings.pop('max_sta', None) or default['max_sta'])
# Size
self.sizes = PokemonFilter.check_sizes(settings.pop("size", default['size']))
self.genders = PokemonFilter.check_genders(settings.pop("gender", default['gender']))
self.forms = PokemonFilter.check_forms(settings.pop("form", default['form']))
# Moves - These can't be set in the default filter
self.req_quick_move = PokemonFilter.create_moves_list(settings.pop("quick_move", default['quick_move']))
self.req_charge_move = PokemonFilter.create_moves_list(settings.pop("charge_move", default['charge_move']))
self.req_moveset = PokemonFilter.create_moveset_list(settings.pop("moveset", default['moveset']))
reject_leftover_parameters(settings, "pokemon filter under '{}'".format(location))
def load_raid_section(settings):
log.info("Setting up Raid Filters...")
raid = {
"enabled": bool(parse_boolean(settings.pop('enabled', None)) or False)
}
# load any raid pokemon filters
filters = load_pokemon_filters(settings)
raid['filters'] = filters
return raid
def load_egg_section(settings):
log.info("Setting up Egg Filters...")
egg = {
"enabled": bool(parse_boolean(settings.pop('enabled', None)) or False),
"min_level": int(settings.pop('min_level', 0) or 0),
"max_level": int(settings.pop('max_level', 10) or 10)
}
log.debug("Report eggs between level {} and {}".format(egg['min_level'], egg['max_level']))
return egg
def load_pokemon_section(settings):
log.info("Setting Pokemon filters...")
pokemon = { "enabled": bool(parse_boolean(settings.pop('enabled', None)) or False)}
filters = load_pokemon_filters(settings)
pokemon['filters'] = filters
# Output filters
log.debug(filters)
for pkmn_id in sorted(filters):
log.debug("The following filters are set for #{}:".format(pkmn_id))
for i in range(len(filters[pkmn_id])):
log.debug("F#{}: ".format(i) + filters[pkmn_id][i].to_string())
if pokemon['enabled'] is False:
log.info("Pokemon notifications will NOT be sent - Enabled is False.")
return pokemon
def load_pokestop_section(settings):
log.info("Setting Pokestop filters...")
# Set the defaults settings for "True"
default_true = {"min_dist": 0.0, "max_dist": float('inf')}
stop = {
"enabled": bool(parse_boolean(require_and_remove_key('enabled', settings, 'Pokestops')) or False),
"filters": create_multi_filter('Pokestops --> filters', PokestopFilter,
settings.pop('filters', "False"), default_true)
}
reject_leftover_parameters(settings, "Pokestops section of Filters file.")
for filt in stop['filters']:
log.debug("Between {} and {} away.".format(
get_dist_as_str(filt.min_dist), get_dist_as_str(filt.max_dist)))
if stop['enabled'] is False:
log.info("Pokestop notifications will NOT be sent - Enabled is False.")
return stop
def create_multi_filter(location, FilterType, settings, default):
bool = parse_boolean(settings)
if bool is not None: # Make a new filter off of one of the defaults
if bool is True:
return [FilterType({}, default, location)]
else:
return None
elif type(settings) == dict: # Single filter
return [FilterType(settings, default, location)]
elif type(settings) == list: # Multiple Filters
rtn = []
for filt in settings:
rtn.append(FilterType(filt, default, location))
return rtn
else:
log.error("{} contains filter that is not in the proper format. Accepted formats are: ".format(location))
log.error("'True' for default filter, 'False' for disabled,")
log.error("{ ... filter info ...} for a single filter,")
log.error("[ {filter1}, {filter2}, {filter3} ] for multiple filters. ")
log.error("Please check the PokeAlarm documentation for more information.")
sys.exit(1)
def create_multi_filter(location, FilterType, settings, default):
bool = parse_boolean(settings)
if bool is not None: # Make a new filter off of one of the defaults
if bool is True:
return [FilterType({}, default, location)]
else:
return None
elif type(settings) == dict: # Single filter
return [FilterType(settings, default, location)]
elif type(settings) == list: # Multiple Filters
rtn = []
for filt in settings:
rtn.append(FilterType(filt, default, location))
return rtn
else:
log.error(
"{} contains filter that is not in the proper format. Accepted formats are: "
.format(location))
log.error("'True' for default filter, 'False' for disabled,")
log.error("{ ... filter info ...} for a single filter,")
log.error("[ {filter1}, {filter2}, {filter3} ] for multiple filters. ")
log.error(
"Please check the PokeAlarm documentation for more information.")
sys.exit(1)
def load_alarms_file(self, file_path, max_attempts):
log.info("Loading Alarms from the file at {}".format(file_path))
try:
with open(file_path, 'r') as f:
alarm_settings = json.load(f)
if type(alarm_settings) is not list:
log.critical(
"Alarms file must be a list of Alarms objects - [ {...}, {...}, ... {...} ]"
)
sys.exit(1)
self.__alarms = []
for alarm in alarm_settings:
if parse_boolean(
require_and_remove_key(
'active', alarm,
"Alarm objects in Alarms file.")) is True:
_type = require_and_remove_key(
'type', alarm, "Alarm objects in Alarms file.")
self.set_optional_args(str(alarm))
if _type == 'discord':
from Discord import DiscordAlarm
self.__alarms.append(
DiscordAlarm(alarm, max_attempts,
self.__google_key))
elif _type == 'facebook_page':
from FacebookPage import FacebookPageAlarm
self.__alarms.append(FacebookPageAlarm(alarm))
elif _type == 'pushbullet':
from Pushbullet import PushbulletAlarm
self.__alarms.append(PushbulletAlarm(alarm))
elif _type == 'slack':
from Slack import SlackAlarm
self.__alarms.append(
SlackAlarm(alarm, self.__google_key))
elif _type == 'telegram':
from Telegram import TelegramAlarm
self.__alarms.append(TelegramAlarm(alarm))
elif _type == 'twilio':
from Twilio import TwilioAlarm
self.__alarms.append(TwilioAlarm(alarm))
elif _type == 'twitter':
from Twitter import TwitterAlarm
self.__alarms.append(TwitterAlarm(alarm))
else:
log.error("Alarm type not found: " + alarm['type'])
log.error(
"Please consult the PokeAlarm documentation accepted Alarm Types"
)
sys.exit(1)
else:
log.debug("Alarm not activated: " + alarm['type'] +
" because value not set to \"True\"")
log.info("{} active alarms found.".format(len(self.__alarms)))
return # all done
except ValueError as e:
log.error(
"Encountered error while loading Alarms file: {}: {}".format(
type(e).__name__, e))
log.error(
"PokeAlarm has encountered a 'ValueError' while loading the Alarms file. This typically means your "
+
"file isn't in the correct json format. Try loading your file contents into a json validator."
)
except IOError as e:
log.error("Encountered error while loading Alarms: {}: {}".format(
type(e).__name__, e))
log.error(
"PokeAlarm was unable to find a filters file at {}." +
"Please check that this file exists and PA has read permissions."
).format(file_path)
except Exception as e:
log.error("Encountered error while loading Alarms: {}: {}".format(
type(e).__name__, e))
log.debug("Stack trace: \n {}".format(traceback.format_exc()))
sys.exit(1)
def set_pokemon(self, settings):
# Start a new dict to track filters
pokemon = {
'enabled': bool(parse_boolean(settings.pop('enabled', False)))
}
min_dist = float(settings.pop('min_dist', None) or 0)
max_dist = float(settings.pop('max_dist', None) or 'inf')
min_iv = float(settings.pop('min_iv', None) or 0)
max_iv = float(settings.pop('max_iv', None) or 100)
ignore_missing = bool(
parse_boolean(settings.pop('ignore_missing', False)))
if pokemon['enabled']:
log.info(
"Pokemon defaults: distance {:.2f} to {:.2f} / IV's {:.2f} to {:.2f}"
.format(min_dist, max_dist, min_iv, max_iv))
for name in settings:
pkmn_id = get_pkmn_id(name)
if pkmn_id is None:
log.error("Unable to find pokemon named {}...".format(name))
continue
if parse_boolean(settings[name]
) is False: # If set to false, set it as false
log.debug("{} name set to 'false'. Skipping... ".format(name))
continue
else:
try:
info = settings[name]
if parse_boolean(info): # Allow all defaults
info = {}
pokemon[pkmn_id] = {
"min_dist":
float(info.get('min_dist', None) or min_dist),
"max_dist":
float(info.get('max_dist', None) or max_dist),
"min_iv":
float(info.get('min_iv', None) or min_iv),
"max_iv":
float(info.get('max_iv', None) or max_iv),
"move_1":
self.required_moves(info.get("move_1", None)),
"move_2":
self.required_moves(info.get("move_2", None)),
"moveset":
self.required_moveset(info.get("moveset", None)),
"size":
self.check_sizes(info.get("size", None)),
"ignore_missing":
bool(
parse_boolean(
info.get('ignore_missing', ignore_missing)))
}
except Exception as e:
log.error(
"Trying to set pokemon {} gave error: \n {}".format(
pkmn_id, e))
log.debug("Stack trace: \n {}".format(
traceback.format_exc()))
sys.exit(1)
for key in sorted(pokemon.iterkeys()): # Output the pokemon in order
log.debug("#{} was set to the following: \n{}".format(
key, json.dumps(pokemon[key], sort_keys=True, indent=4)))
self.__pokemon_filter = pokemon
