Adding deep linking for PokeGo++2.0

.gitignore

@@ -16,7 +16,7 @@ _build
 
 # pa runtime files
 *.pyc
-cache/*.cache
+cache/*
 
 # OS files
 .DS_Store

PokeAlarm/Alarms/Discord/DiscordAlarm.py

@@ -28,9 +28,9 @@ class DiscordAlarm(Alarm):
             'username': "<mon_name>",
             'content': "",
             'icon_url': get_image_url(
-                "regular/monsters/<mon_id_3>_<form_id_3>.png"),
+                "regular/monsters/<image_suffix>.png"),
             'avatar_url': get_image_url(
-                "regular/monsters/<mon_id_3>_<form_id_3>.png"),
+                "regular/monsters/<image_suffix>.png"),
             'title': "A wild <mon_name> has appeared!",
             'url': "<gmaps>",
             'body': "Available until <24h_time> (<time_left>)."
@@ -107,7 +107,8 @@ def __init__(self, settings, max_attempts, static_map_key):
 
         # Set Alert Parameters
         self.__monsters = self.create_alert_settings(
-            settings.pop('monsters', {}), self._defaults['monsters'], 'monsters')
+            settings.pop('monsters', {}),
+            self._defaults['monsters'], 'monsters')
         self.__stops = self.create_alert_settings(
             settings.pop('stops', {}), self._defaults['stops'], 'stops')
         self.__gyms = self.create_alert_settings(

PokeAlarm/Alarms/FacebookPage/FacebookPageAlarm.py

@@ -28,7 +28,7 @@ class FacebookPageAlarm(Alarm):
         'monsters': {
             'message': "A wild <mon_name> has appeared!",
             'image': get_image_url(
-                "regular/monsters/<mon_id_3>_<form_id_3>.png"),
+                "regular/monsters/<image_suffix>.png"),
             'link': "<gmaps>",
             'name': "<mon_name>",
             'description': "Available until <24h_time> (<time_left>).",

PokeAlarm/Alarms/Slack/SlackAlarm.py

@@ -28,7 +28,7 @@ class SlackAlarm(Alarm):
         'monsters': {
             'username': "<mon_name>",
             'icon_url': get_image_url(
-                "regular/monsters/<mon_id_3>_<form_id_3>.png"),
+                "regular/monsters/<image_suffix>.png"),
             'title': "A wild <mon_name> has appeared!",
             'url': "<gmaps>",
             'body': "Available until <24h_time> (<time_left>)."

PokeAlarm/Alarms/Telegram/TelegramAlarm.py

@@ -28,14 +28,15 @@ class TelegramAlarm(Alarm):
     Alert = namedtuple(
         "Alert", ['bot_token', 'chat_id', 'sticker', 'sticker_url',
                   'sticker_notify', 'message', 'message_notify', 'venue',
-                  'venue_notify', 'map', 'map_notify', 'max_attempts'])
+                  'venue_notify', 'map', 'map_notify', 'max_attempts',
+                  'web_preview'])
 
     _defaults = {  # No touchy!!! Edit alarms.json!
         'monsters': {
             'message': "*A wild <mon_name> has appeared!*\n"
                        "Available until <24h_time> (<time_left>).",
             'sticker_url': get_image_url(
-                "telegram/monsters/<mon_id_3>_<form_id_3>.webp")
+                "telegram/monsters/<image_suffix>.webp")
         },
         'stops': {
             'message': "*Someone has placed a lure on a Pokestop!*\n"
@@ -93,6 +94,8 @@ def __init__(self, settings):
                 settings, 'map_notify', utils.parse_bool, False),
             'max_attempts': self.pop_type(
                 settings, 'max_attempts', int, 3),
+            'web_preview': self.pop_type(
+                settings, 'web_preview', utils.parse_bool, False)
         }
 
         # Alert Settings
@@ -152,7 +155,10 @@ def create_alert_settings(self, kind, settings, alert_defaults):
                 settings, 'map_notify', utils.parse_bool,
                 default['map_notify']),
             max_attempts=Alarm.pop_type(
-                settings, 'max_attempts', int, default['max_attempts'])
+                settings, 'max_attempts', int, default['max_attempts']),
+            web_preview=Alarm.pop_type(
+                settings, 'web_preview', utils.parse_bool,
+                default['web_preview'])
         )
 
         # Reject leftover parameters
@@ -190,7 +196,8 @@ def generic_alert(self, alert, dts):
             return  # Don't send message or map
 
         # Send Message
-        self.send_message(bot_token, chat_id, replace(message, dts))
+        self.send_message(bot_token, chat_id, replace(message, dts),
+                          web_preview=alert.web_preview)
 
         # Send Map
         if alert.map:
@@ -231,14 +238,14 @@ def send_sticker(self, token, chat_id, sticker_url,
             max_attempts)
 
     def send_message(self, token, chat_id, message,
-                     max_attempts=3, notify=True):
+                     max_attempts=3, notify=True, web_preview=False):
         args = {
             'url': "https://api.telegram.org/bot{}/sendMessage".format(token),
             'payload': {
                 'chat_id': chat_id,
                 'text': message,
                 'parse_mode': 'Markdown',
-                'disable_web_page_preview': True,
+                'disable_web_page_preview': not web_preview,
                 'disable_notification': not notify
             }
         }

PokeAlarm/Alarms/Twitter/__init__.py

@@ -1,8 +1,8 @@
-from TwitterAlarm import TwitterAlarm  # noqa F401
-
 try:
     import twitter  # noqa F401
 except ImportError:
     from PokeAlarm.Utils import pip_install
 
     pip_install('twitter', '1.17.1')
+
+from TwitterAlarm import TwitterAlarm  # noqa F401

PokeAlarm/Cache/Cache.py

@@ -3,7 +3,8 @@
 from datetime import datetime
 # 3rd Party Imports
 # Local Imports
-from ..Utils import get_image_url
+from PokeAlarm import Unknown
+from PokeAlarm.Utils import get_image_url
 
 log = logging.getLogger('Cache')
 
@@ -15,71 +16,67 @@ class Cache(object):
     be lost between run times if save has not been implemented correctly.
     """
 
-    _default_gym_info = {
-        "name": "unknown",
-        "description": "unknown",
-        "url": get_image_url('icons/gym_0.png')
-    }
+    default_image_url = get_image_url("regular/gyms/0.png"),
 
     def __init__(self):
         """ Initializes a new cache object for storing data between events. """
-        self._pokemon_hist = {}
-        self._pokestop_hist = {}
-        self._gym_team = {}
-        self._gym_info = {}
+        self._mon_hist = {}
+        self._stop_hist = {}
         self._egg_hist = {}
         self._raid_hist = {}
         self._weather_hist = {}
-
-    def get_pokemon_expiration(self, pkmn_id):
-        """ Get the datetime that the pokemon expires."""
-        return self._pokemon_hist.get(pkmn_id)
-
-    def update_pokemon_expiration(self, pkmn_id, expiration):
-        """ Updates the datetime that the pokemon expires. """
-        self._pokemon_hist[pkmn_id] = expiration
-
-    def get_pokestop_expiration(self, stop_id):
-        """ Returns the datetime that the pokemon expires. """
-        return self._pokestop_hist.get(stop_id)
-
-    def update_pokestop_expiration(self, stop_id, expiration):
-        """ Updates the datetime that the pokestop expires. """
-        self._pokestop_hist[stop_id] = expiration
-
-    def get_gym_team(self, gym_id):
-        """ Get the current team that owns the gym. """
-        return self._gym_team.get(gym_id, '?')
-
-    def update_gym_team(self, gym_id, team):
-        """ Update the current team of the gym. """
-        self._gym_team[gym_id] = team
-
-    def get_gym_info(self, gym_id):
-        """ Gets the information about the gym. """
-        return self._gym_info.get(gym_id, self._default_gym_info)
-
-    def update_gym_info(self, gym_id, name, desc, url):
-        """ Updates the information about the gym. """
-        if name != 'unknown':  # Don't update if the gym info is missing
-            self._gym_info[gym_id] = {
-                "name": name, "description": desc, "url": url}
-
-    def get_egg_expiration(self, gym_id):
-        """ Returns the datetime that the egg expires. """
-        return self._egg_hist.get(gym_id)
-
-    def update_egg_expiration(self, gym_id, expiration):
-        """ Updates the datetime that the egg expires. """
-        self._egg_hist[gym_id] = expiration
-
-    def get_raid_expiration(self, gym_id):
-        """ Returns the datetime that the raid expires. """
-        return self._raid_hist.get(gym_id)
-
-    def update_raid_expiration(self, gym_id, expiration):
-        """ Updates the datetime that the raid expires. """
-        self._raid_hist[gym_id] = expiration
+        self._gym_team = {}
+        self._gym_name = {}
+        self._gym_desc = {}
+        self._gym_image = {}
+
+    def monster_expiration(self, mon_id, expiration=None):
+        """ Update and return the datetime that a monster expires."""
+        if expiration is not None:
+            self._mon_hist[mon_id] = expiration
+        return self._mon_hist.get(mon_id)
+
+    def stop_expiration(self, stop_id, expiration=None):
+        """ Update and return the datetime that a stop expires."""
+        if expiration is not None:
+            self._stop_hist[stop_id] = expiration
+        return self._stop_hist.get(stop_id)
+
+    def egg_expiration(self, egg_id, expiration=None):
+        """ Update and return the datetime that an egg expires."""
+        if expiration is not None:
+            self._egg_hist[egg_id] = expiration
+        return self._egg_hist.get(egg_id)
+
+    def raid_expiration(self, raid_id, expiration=None):
+        """ Update and return the datetime that a raid expires."""
+        if expiration is not None:
+            self._raid_hist[raid_id] = expiration
+        return self._raid_hist.get(raid_id)
+
+    def gym_team(self, gym_id, team_id=Unknown.TINY):
+        """ Update and return the team_id of a gym. """
+        if Unknown.is_not(team_id):
+            self._gym_team[gym_id] = team_id
+        return self._gym_team.get(gym_id, Unknown.TINY)
+
+    def gym_name(self, gym_id, gym_name=Unknown.REGULAR):
+        """ Update and return the gym_name for a gym. """
+        if Unknown.is_not(gym_name):
+            self._gym_name[gym_id] = gym_name
+        return self._gym_name.get(gym_id, Unknown.REGULAR)
+
+    def gym_desc(self, gym_id, gym_desc=Unknown.REGULAR):
+        """ Update and return the gym_desc for a gym. """
+        if Unknown.is_not(gym_desc):
+            self._gym_desc[gym_id] = gym_desc
+        return self._gym_desc.get(gym_id, Unknown.REGULAR)
+
+    def gym_image(self, gym_id, gym_image=Unknown.REGULAR):
+        """ Update and return the gym_image for a gym. """
+        if Unknown.is_not(gym_image):
+            self._gym_image[gym_id] = gym_image
+        return self._gym_image.get(gym_id, get_image_url('icons/gym_0.png'))
 
     def get_cell_weather(self, weather_cell_id):
         """ Returns the weather for the S2 cell. """
@@ -101,7 +98,7 @@ def _save(self):
     def _clean_hist(self):
         """ Clean expired objects to free up memory. """
         for hist in (
-                self._pokemon_hist, self._pokestop_hist, self._egg_hist,
+                self._mon_hist, self._stop_hist, self._egg_hist,
                 self._raid_hist):
             old = []
             now = datetime.utcnow()

PokeAlarm/Cache/FileCache.py

@@ -21,42 +21,59 @@ def __init__(self, name):
         self._file = get_path(os.path.join("cache", "{}.cache".format(name)))
 
         log.debug("Checking for previous cache at {}".format(self._file))
+        cache_folder = get_path("cache")
+        if not os.path.exists(cache_folder):
+            os.makedirs(cache_folder)
         if os.path.isfile(self._file):
             self._load()
         else:
-            with portalocker.Lock(self._file, mode="wb+") as f:
-                pickle.dump({}, f, protocol=pickle.HIGHEST_PROTOCOL)
+            self._save()
 
     def _load(self):
-        with portalocker.Lock(self._file, mode="rb") as f:
-            data = pickle.load(f)
-            self._pokemon_hist = data.get('pokemon_hist', {})
-            self._pokestop_hist = data.get('pokestop_hist', {})
-            self._gym_team = data.get('gym_team', {})
-            self._gym_info = data.get('gym_info', {})
-            self._egg_hist = data.get('egg_hist', {})
-            self._raid_hist = data.get('raid_hist', {})
-            self._weather_hist = data.get('weather_hist', {})
-            log.debug("LOADED: \n {}".format(data))
+        try:
+            with portalocker.Lock(self._file, mode="rb") as f:
+                data = pickle.load(f)
+                self._mon_hist = data.get('mon_hist', {})
+                self._stop_hist = data.get('stop_hist', {})
+                self._egg_hist = data.get('egg_hist', {})
+                self._raid_hist = data.get('raid_hist', {})
+                self._weather_hist = data.get('weather_hist', {})
+                self._gym_team = data.get('gym_team', {})
+                self._gym_name = data.get('gym_name', {})
+                self._gym_desc = data.get('gym_desc', {})
+                self._gym_image = data.get('gym_image', {})
+
+                log.debug("Cache loaded successfully.")
+        except Exception as e:
+            log.error("There was an error attempting to load the cache. The "
+                      "old cache will be overwritten.")
+            log.error("{}: {}".format(type(e).__name__, e))
 
     def _save(self):
         """ Export the data to a more permanent location. """
         log.debug("Writing cache to file...")
         data = {
-            'pokemon_hist': self._pokemon_hist,
-            'pokestop_hist': self._pokestop_hist,
-            'gym_team': self._gym_team,
-            'gym_info': self._gym_info,
+            'mon_hist': self._mon_hist,
+            'stop_hist': self._stop_hist,
             'egg_hist': self._egg_hist,
             'raid_hist': self._raid_hist,
-            'weather_hist': self._weather_hist
+            'weather_hist': self._weather_hist,
+            'gym_team': self._gym_team,
+            'gym_name': self._gym_name,
+            'gym_desc': self._gym_desc,
+            'gym_image': self._gym_image
         }
-        log.debug(self._pokestop_hist)
-        log.debug("SAVED: {}".format(data))
         try:
-            with portalocker.Lock(self._file, timeout=5, mode="wb+") as f:
-                pickle.dump(data, f, protocol=pickle.HIGHEST_PROTOCOL)
+            # Write to temporary file and then rename
+            temp = self._file + ".new"
+            with portalocker.Lock(self._file + ".lock", timeout=5, mode="wb+"):
+                with portalocker.Lock(temp, timeout=5, mode="wb+") as f:
+                    pickle.dump(data, f, protocol=pickle.HIGHEST_PROTOCOL)
+                if os.path.exists(self._file):
+                    os.remove(self._file)  # Required for Windows
+                os.rename(temp, self._file)
+            log.debug("Cache saved successfully.")
         except Exception as e:
             log.error("Encountered error while saving cache: "
                       + "{}: {}".format(type(e).__name__, e))
-            log.debug("Stack trace: \n {}".format(traceback.format_exc()))
+            log.error("Stack trace: \n {}".format(traceback.format_exc()))

PokeAlarm/Events/EggEvent.py

@@ -3,7 +3,8 @@
 # 3rd Party Imports
 # Local Imports
 from PokeAlarm.Utils import get_time_as_str, get_seconds_remaining, \
-    get_gmaps_link, get_applemaps_link, get_dist_as_str, get_weather_emoji
+    get_gmaps_link, get_applemaps_link, get_pokego2_link, get_dist_as_str, \
+    get_weather_emoji
 from . import BaseEvent
 from PokeAlarm import Unknown
 
@@ -44,14 +45,14 @@ def __init__(self, data):
             str, data.get('description'), Unknown.REGULAR).strip()
         self.gym_image = check_for_none(
             str, data.get('url'), Unknown.REGULAR)
-        self.gym_sponsor = check_for_none(
-            int, data.get('sponsor'), Unknown.SMALL)
-        self.gym_park = check_for_none(
+        self.sponsor_id = check_for_none(
+            int, data.get('sponsor'), Unknown.TINY)
+        self.park = check_for_none(
             str, data.get('park'), Unknown.REGULAR)
 
         # Gym Team (this is only available from cache)
         self.current_team_id = check_for_none(
-            int, data.get('team'), Unknown.TINY)
+            int, data.get('team_id', data.get('team')), Unknown.TINY)
 
         self.name = self.gym_id
         self.geofence = Unknown.REGULAR
@@ -99,8 +100,11 @@ def generate_dts(self, locale, timezone, units):
             'gym_name': self.gym_name,
             'gym_description': self.gym_description,
             'gym_image': self.gym_image,
-            'gym_sponsor': self.gym_sponsor,
-            'gym_park': self.gym_park,
+            'sponsor_id': self.sponsor_id,
+            'sponsored':
+                self.sponsor_id > 0
+                if Unknown.is_not(self.sponsor_id) else Unknown.REGULAR,
+            'park': self.park,
             'team_id': self.current_team_id,
             'team_name': locale.get_team_name(self.current_team_id),
             'team_leader': locale.get_leader_name(self.current_team_id)