MouseTools 4.3.0__tar.gz → 4.4.0__tar.gz

{mousetools-4.3.0 → mousetools-4.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mousetools
-Version: 4.3.0
+Version: 4.4.0
 Summary: An unofficial Python wrapper for Disney's API
 Author: Scott Caratozzolo
 License-Expression: MIT

{mousetools-4.3.0 → mousetools-4.4.0}/mousetools/api/menu.py

@@ -1,5 +1,6 @@
-import typing
+import logging
 from datetime import datetime, timedelta
+from typing import Optional
 from zoneinfo import ZoneInfo
 
 from dateutil.parser import isoparse
@@ -8,11 +9,11 @@ from mousetools.auth import auth_obj
 from mousetools.decorators import disney_property, json_property
 from mousetools.mixins.disney import DisneyAPIMixin
 
-# menus -> menu -> menugroups -> menuitems
+logger = logging.getLogger(__name__)
 
 
 class MenuItem:
-    def __init__(self, raw_item_data: dict, parent_resturant_id: typing.Optional[str] = None):
+    def __init__(self, raw_item_data: dict, parent_resturant_id: Optional[str] = None) -> None:
         self._raw_item_data = raw_item_data
         self._parent_restaurant_id = parent_resturant_id
 
@@ -20,118 +21,118 @@ class MenuItem:
         return f"MenuItem(entity_id={self.entity_id}, parent_resturant_id={self._parent_restaurant_id})"
 
     @json_property
-    def entity_id(self) -> typing.Optional[str]:
+    def entity_id(self) -> Optional[str]:
         """
         The entity id of the menu item.
 
         Returns:
-            (typing.Optional[str]): The entity id of the menu item.
+            (Optional[str]): The entity id of the menu item.
         """
         return self._raw_item_data["id"]
 
     @json_property
-    def pc_short_name(self) -> typing.Optional[str]:
+    def pc_short_name(self) -> Optional[str]:
         """
         The short name of the menu item.
 
         Returns:
-            (typing.Optional[str]): The short name of the menu item.
+            (Optional[str]): The short name of the menu item.
         """
         return self._raw_item_data["names"]["PCShort"]
 
     @json_property
-    def pc_long_name(self) -> typing.Optional[str]:
+    def pc_long_name(self) -> Optional[str]:
         """
         The long name of the menu item.
 
         Returns:
-            (typing.Optional[str]): The long name of the menu item.
+            (Optional[str]): The long name of the menu item.
         """
         return self._raw_item_data["names"]["PCLong"]
 
     @json_property
-    def mobile_short_name(self) -> typing.Optional[str]:
+    def mobile_short_name(self) -> Optional[str]:
         """
         The short name of the menu item.
 
         Returns:
-            (typing.Optional[str]): The short name of the menu item.
+            (Optional[str]): The short name of the menu item.
         """
         return self._raw_item_data["names"]["MobileShort"]
 
     @json_property
-    def mobile_long_name(self) -> typing.Optional[str]:
+    def mobile_long_name(self) -> Optional[str]:
         """
         The long name of the menu item.
 
         Returns:
-            (typing.Optional[str]): The long name of the menu item.
+            (Optional[str]): The long name of the menu item.
         """
         return self._raw_item_data["names"]["MobileLong"]
 
     @json_property
-    def mickey_check(self) -> typing.Optional[bool]:
+    def mickey_check(self) -> Optional[bool]:
         """
         Whether the menu item is mickey check.
 
         Returns:
-            (typing.Optional[bool]): Whether the menu item is mickey check.
+            (Optional[bool]): Whether the menu item is mickey check.
         """
         return self._raw_item_data["mickeyCheck"]
 
     @json_property
-    def pc_long_description(self) -> typing.Optional[str]:
+    def pc_long_description(self) -> Optional[str]:
         """
         The long description of the menu item.
 
         Returns:
-            (typing.Optional[str]): The long description of the menu item.
+            (Optional[str]): The long description of the menu item.
         """
         return self._raw_item_data["descriptions"]["PCLong"]["text"]
 
     @json_property
-    def mobile_short_description(self) -> typing.Optional[str]:
+    def mobile_short_description(self) -> Optional[str]:
         """
         The short description of the menu item.
 
         Returns:
-            (typing.Optional[str]): The short description of the menu item.
+            (Optional[str]): The short description of the menu item.
         """
         return self._raw_item_data["descriptions"]["MobileShort"]["text"]
 
     @json_property
-    def default_selection(self) -> typing.Optional[bool]:
+    def default_selection(self) -> Optional[bool]:
         """
         Whether the menu item is the default selection.
 
         Returns:
-            (typing.Optional[bool]): Whether the menu item is the default selection.
+            (Optional[bool]): Whether the menu item is the default selection.
         """
         return self._raw_item_data["defaultSelection"]
 
     @json_property
-    def prices(self) -> typing.Optional[dict]:
+    def prices(self) -> Optional[dict]:
         """
         The prices of the menu item.
 
         Returns:
-            (typing.Optional[dict]): The prices of the menu item.
+            (Optional[dict]): The prices of the menu item.
         """
         return self._raw_item_data["prices"]
 
     @json_property
-    def per_serving_without_tax(self) -> typing.Optional[float]:
+    def per_serving_without_tax(self) -> Optional[float]:
         """
         The per serving without tax of the menu item.
 
         Returns:
-            (typing.Optional[float]): The per serving without tax of the menu item.
+            (Optional[float]): The per serving without tax of the menu item.
         """
         return self._raw_item_data["prices"]["PerServing"]["withoutTax"]
 
 
 class MenuGroup:
-    def __init__(self, raw_menu_group_data: dict, parent_restaurant_id: typing.Optional[str] = None):
+    def __init__(self, raw_menu_group_data: dict, parent_restaurant_id: Optional[str] = None) -> None:
         self._raw_menu_group_data = raw_menu_group_data
         self._parent_restaurant_id = parent_restaurant_id
 
@@ -139,92 +140,92 @@ class MenuGroup:
         return f"MenuGroup(menu_group_type={self.menu_group_type}, parent_restaurant_id={self._parent_restaurant_id})"
 
     @json_property
-    def menu_group_type(self) -> typing.Optional[str]:
+    def menu_group_type(self) -> Optional[str]:
         """
         The type of the menu group.
 
         Returns:
-            (typing.Optional[str]): The type of the menu group.
+            (Optional[str]): The type of the menu group.
         """
         return self._raw_menu_group_data["menuGroupType"]
 
     @json_property
-    def multiple_price_types(self) -> typing.Optional[bool]:
+    def multiple_price_types(self) -> Optional[bool]:
         """
         Whether the menu group has multiple price types.
 
         Returns:
-            (typing.Optional[bool]): Whether the menu group has multiple price types.
+            (Optional[bool]): Whether the menu group has multiple price types.
         """
         return self._raw_menu_group_data["multiplePriceTypes"]
 
     @json_property
-    def mickey_check_items(self) -> typing.Optional[bool]:
+    def mickey_check_items(self) -> Optional[bool]:
         """
         Whether the menu group has mickey check items.
 
         Returns:
-            (typing.Optional[bool]): Whether the menu group has mickey check items.
+            (Optional[bool]): Whether the menu group has mickey check items.
         """
         return self._raw_menu_group_data["mickeyCheckItems"]
 
     @json_property
-    def names(self) -> typing.Optional[dict]:
+    def names(self) -> Optional[dict]:
         """
         The names of the menu group.
 
         Returns:
-            (typing.Optional[dict]): The names of the menu group.
+            (Optional[dict]): The names of the menu group.
         """
         return self._raw_menu_group_data["names"]
 
     @json_property
-    def pc_short_name(self) -> typing.Optional[str]:
+    def pc_short_name(self) -> Optional[str]:
         """
         The short name of the menu group.
 
         Returns:
-            (typing.Optional[str]): The short name of the menu group.
+            (Optional[str]): The short name of the menu group.
         """
         return self._raw_menu_group_data["names"]["PCShort"]
 
     @json_property
-    def pc_long_name(self) -> typing.Optional[str]:
+    def pc_long_name(self) -> Optional[str]:
         """
         The long name of the menu group.
 
         Returns:
-            (typing.Optional[str]): The long name of the menu group.
+            (Optional[str]): The long name of the menu group.
         """
         return self._raw_menu_group_data["names"]["PCLong"]
 
     @json_property
-    def mobile_short_name(self) -> typing.Optional[str]:
+    def mobile_short_name(self) -> Optional[str]:
         """
         The short name of the menu group.
 
         Returns:
-            (typing.Optional[str]): The short name of the menu group.
+            (Optional[str]): The short name of the menu group.
         """
         return self._raw_menu_group_data["names"]["MobileShort"]
 
     @json_property
-    def mobile_long_name(self) -> typing.Optional[str]:
+    def mobile_long_name(self) -> Optional[str]:
         """
         The long name of the menu group.
 
         Returns:
-            (typing.Optional[str]): The long name of the menu group.
+            (Optional[str]): The long name of the menu group.
         """
         return self._raw_menu_group_data["names"]["MobileLong"]
 
     @property
-    def menu_items(self) -> typing.Optional[list[MenuItem]]:
+    def menu_items(self) -> Optional[list[MenuItem]]:
         """
         The menu items of the menu group.
 
         Returns:
-            (typing.Optional[list[MenuItem]]): The menu items of the menu group.
+            (Optional[list[MenuItem]]): The menu items of the menu group.
         """
         try:
             return [MenuItem(i, self._parent_restaurant_id) for i in self._raw_menu_group_data["menuItems"]]
@@ -233,80 +234,80 @@ class MenuGroup:
 
 
 class Menu:
-    def __init__(self, raw_menu_data: dict, parent_restaurant_id: typing.Optional[str] = None):
+    def __init__(self, raw_menu_data: dict, parent_restaurant_id: Optional[str] = None) -> None:
         self._raw_menu_data = raw_menu_data
         self._parent_restaurant_id = parent_restaurant_id
 
-    def __str__(self):
+    def __str__(self) -> str:
         return f"Menu(entity_id={self.entity_id}, menu_type={self.menu_type}, parent_restaurant_id={self._parent_restaurant_id})"
 
     @json_property
-    def entity_id(self) -> typing.Optional[str]:
+    def entity_id(self) -> Optional[str]:
         """
         The entity id of the menu.
 
         Returns:
-            (typing.Optional[str]): The entity id of the menu.
+            (Optional[str]): The entity id of the menu.
         """
         return self._raw_menu_data["id"]
 
     @json_property
-    def menu_type(self) -> typing.Optional[str]:
+    def menu_type(self) -> Optional[str]:
         """
         The type of the menu.
 
         Returns:
-            (typing.Optional[str]): The type of the menu.
+            (Optional[str]): The type of the menu.
         """
         return self._raw_menu_data["menuType"]
 
     @json_property
-    def localized_menu_type(self) -> typing.Optional[str]:
+    def localized_menu_type(self) -> Optional[str]:
         """
         The localized type of the menu.
 
         Returns:
-            (typing.Optional[str]): The localized type of the menu.
+            (Optional[str]): The localized type of the menu.
         """
         return self._raw_menu_data["localizedMenuType"]
 
     @json_property
-    def experience_type(self) -> typing.Optional[str]:
+    def experience_type(self) -> Optional[str]:
         """
         The experience type of the menu.
 
         Returns:
-            (typing.Optional[str]): The experience type of the menu.
+            (Optional[str]): The experience type of the menu.
         """
         return self._raw_menu_data["experienceType"]
 
     @json_property
-    def service_style(self) -> typing.Optional[str]:
+    def service_style(self) -> Optional[str]:
         """
         The service style of the menu.
 
         Returns:
-            (typing.Optional[str]): The service style of the menu.
+            (Optional[str]): The service style of the menu.
         """
         return self._raw_menu_data["serviceStyle"]
 
     @json_property
-    def primary_cuisine_type(self) -> typing.Optional[str]:
+    def primary_cuisine_type(self) -> Optional[str]:
         """
         The primary cuisine type of the menu.
 
         Returns:
-            (typing.Optional[str]): The primary cuisine type of the menu.
+            (Optional[str]): The primary cuisine type of the menu.
         """
         return self._raw_menu_data["primaryCuisineType"]
 
     @json_property
-    def secondary_cuisine_type(self) -> typing.Optional[str]:
+    def secondary_cuisine_type(self) -> Optional[str]:
         """
         The secondary cuisine type of the menu.
 
         Returns:
-            (typing.Optional[str]): The secondary cuisine type of the menu.
+            (Optional[str]): The secondary cuisine type of the menu.
         """
         return self._raw_menu_data["secondaryCuisineType"]
 
@@ -329,7 +330,7 @@ class Menus(DisneyAPIMixin):
 
     _menu_service_base = f"{auth_obj._environments['serviceMenuUrl']}/diningMenuSvc/orchestration/menus"
 
-    def __init__(self, restaurant_channel_id: str, lazy_load: bool = True):
+    def __init__(self, restaurant_channel_id: str, lazy_load: bool = True) -> None:
         self.entity_id = restaurant_channel_id.rsplit(".", 1)[-1]
         self._menu_service_url = f"{self._menu_service_base}/{self.entity_id}"
 
@@ -338,20 +339,30 @@ class Menus(DisneyAPIMixin):
         )  # properties are rarely updated, no need to spam the API
         self._tz = ZoneInfo("UTC")
 
-        self._disney_data: typing.Optional[dict] = None
+        self._disney_data: Optional[dict] = None
         self._disney_data_pull_time: datetime = datetime.now(tz=self._tz)
         if not lazy_load:
             self.refresh()
 
-    def __str__(self):
+    def __str__(self) -> str:
         return f"Menus(entity_id={self.entity_id})"
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f"Menus(restaurant_channel_id={self.entity_id})"
 
     def refresh(self) -> None:
         """Pulls initial data if none exists or if it is older than the refresh interval"""
-        if self._disney_data is None or datetime.now(tz=self._tz) - self.last_refresh > self._refresh_interval:
+        no_data_check = self._disney_data is None
+        time_since_pull = datetime.now(tz=self._tz) - self._disney_data_pull_time
+        old_data_check = time_since_pull > self._refresh_interval
+        logger.debug(
+            "No data check: %s, Time since last update: %s, Old data check: %s",
+            no_data_check,
+            time_since_pull,
+            old_data_check,
+        )
+        if no_data_check or old_data_check:
+            logger.info("Refreshing menu data %s", self.entity_id)
             self._disney_data = self.get_disney_data(self._menu_service_url)
             self._disney_data_pull_time = datetime.now(tz=self._tz)
 
@@ -367,48 +378,43 @@ class Menus(DisneyAPIMixin):
         return [Menu(i, self.entity_id) for i in self._disney_data["menus"]]
 
     @disney_property()
-    def facility_name(self) -> typing.Optional[str]:
+    def facility_name(self) -> Optional[str]:
         """
         The name of the facility.
 
         Returns:
-            (typing.Optional[str]): The name of the facility.
+            (Optional[str]): The name of the facility.
         """
         return self._disney_data["facilityName"]
 
     @disney_property()
-    def ancestor_location_park_resort(self) -> typing.Optional[str]:
+    def ancestor_location_park_resort(self) -> Optional[str]:
         """
         The name of the ancestor location.
 
         Returns:
-            (typing.Optional[str]): The name of the ancestor location.
+            (Optional[str]): The name of the ancestor location.
         """
         return self._disney_data["ancestorLocationParkResort"]
 
     @disney_property()
-    def ancestor_location_land_area(self) -> typing.Optional[str]:
+    def ancestor_location_land_area(self) -> Optional[str]:
         """
         The name of the ancestor location.
 
         Returns:
-            (typing.Optional[str]): The name of the ancestor location.
+            (Optional[str]): The name of the ancestor location.
         """
         return self._disney_data["ancestorLocationLandArea"]
 
-    @property
-    def last_refresh(self) -> datetime:
+    @disney_property()
+    def last_refresh(self) -> Optional[datetime]:
         """
         The last time the menus were refreshed.
 
         Returns:
-            (datetime): The last time the menus were refreshed.
+            (Optional[datetime]): The last time the menus were refreshed.
         """
-        if self._disney_data is None:
-            self._disney_data = self.get_disney_data(self.entity_id)
-        try:
-            refresh_time = isoparse(self._disney_data["lastRefresh"])
-            refresh_time = refresh_time.replace(tzinfo=self._tz)
-            return refresh_time
-        except (KeyError, TypeError, ValueError):
-            return self._disney_data_pull_time
+        refresh_time = isoparse(self._disney_data["lastRefresh"])
+        refresh_time = refresh_time.replace(tzinfo=self._tz)
+        return refresh_time

{mousetools-4.3.0 → mousetools-4.4.0}/mousetools/api/search.py

@@ -9,7 +9,7 @@ from mousetools.mixins.disney import DisneyAPIMixin
 class Search(DisneyAPIMixin):
     _search_service_base = auth_obj._environments["searchServiceUrl"]
 
-    def __init__(self, destination: Union[DestinationShort, str]):
+    def __init__(self, destination: Union[DestinationShort, str]) -> None:
         """
         Args:
             destination (Union[DestinationShort, str]): Search the facilities for this destination
@@ -54,5 +54,5 @@ class Search(DisneyAPIMixin):
         """
         return self.search(*args, **kwargs)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f"Search(destination='{self.destination}')"

{mousetools-4.3.0 → mousetools-4.4.0}/mousetools/auth.py

@@ -1,17 +1,20 @@
 import base64
 import json
-import typing
+import logging
 from datetime import datetime, timedelta
 from importlib.resources import as_file, files
+from typing import Optional
 
 import httpx
 from Crypto.Cipher import AES
 
+logger = logging.getLogger(__name__)
+
 
 class Authentication:
-    def __init__(self):
-        self.time_of_expire: typing.Optional[datetime] = None
-        self.access_token: typing.Optional[str] = None
+    def __init__(self) -> None:
+        self.time_of_expire: Optional[datetime] = None
+        self.access_token: Optional[str] = None
         self._environments = self._decrypt_file("resources/environments.bin").get("production", {})
 
     def authenticate(self) -> tuple[str, int]:
@@ -38,6 +41,7 @@ class Authentication:
             "client_id": self._environments["authzClientId"],
         }
 
+        logger.debug("Sending request for authentication token")
         response = httpx.post(
             f"{self._environments['authzServiceUrl']}/token",
             headers=headers,
@@ -57,6 +61,7 @@ class Authentication:
         """
 
         if self.time_of_expire is None or (datetime.now() > self.time_of_expire):
+            logger.info("Requesting new authentication token")
             access_token, expires_in = self.authenticate()
             self.time_of_expire = datetime.now() + timedelta(seconds=(expires_in - 10))
             self.access_token = access_token
@@ -95,7 +100,7 @@ class Authentication:
             decrypted = cipher.decrypt(file.read())
             return json.loads(decrypted.decode("Windows-1252")[:-16])
 
-    def _e(self):
+    def _e(self) -> bytes:
         s = ""
         for i in range(1, 17):
             if i % 2 != 0 or i >= 16:
@@ -105,7 +110,7 @@ class Authentication:
         bytes_ = s.encode("utf-8")
         return bytes_
 
-    def _b(self):
+    def _b(self) -> bytes:
         return bytes(reversed(self._e()))