MouseTools 3.1.0.dev2__py3-none-any.whl → 4.0.0__py3-none-any.whl

mousetools/__init__.py

@@ -3,5 +3,5 @@ import logging
 logger = logging.getLogger(__name__)
 logger.addHandler(logging.NullHandler())
 
-__version__ = "3.1.0-dev.2"  # will be set at runtime
+__version__ = "0.0.0"  # will be set at runtime
 logger.info(f"MouseTools version: {__version__}")

mousetools/api/menu.py

@@ -0,0 +1,433 @@
+import typing
+
+from mousetools.auth import auth_obj
+from mousetools.mixins.disney import DisneyAPIMixin
+
+# menus -> menu -> menugroups -> menuitems
+
+
+class MenuItem:
+    def __init__(self, raw_item_data: dict, parent_resturant_id: typing.Optional[str] = None):
+        self._raw_item_data = raw_item_data
+        self._parent_restaurant_id = parent_resturant_id
+
+    def __repr__(self) -> str:
+        return f"MenuItem(entity_id={self.entity_id}, parent_resturant_id={self._parent_restaurant_id})"
+
+    @property
+    def entity_id(self) -> typing.Optional[str]:
+        """
+        The entity id of the menu item.
+
+        Returns:
+            (typing.Optional[str]): The entity id of the menu item.
+        """
+        try:
+            return self._raw_item_data["id"]
+        except KeyError:
+            return None
+
+    @property
+    def pc_short_name(self) -> typing.Optional[str]:
+        """
+        The short name of the menu item.
+
+        Returns:
+            (typing.Optional[str]): The short name of the menu item.
+        """
+        try:
+            return self._raw_item_data["names"]["PCShort"]
+        except KeyError:
+            return None
+
+    @property
+    def pc_long_name(self) -> typing.Optional[str]:
+        """
+        The long name of the menu item.
+
+        Returns:
+            (typing.Optional[str]): The long name of the menu item.
+        """
+        try:
+            return self._raw_item_data["names"]["PCLong"]
+        except KeyError:
+            return None
+
+    @property
+    def mobile_short_name(self) -> typing.Optional[str]:
+        """
+        The short name of the menu item.
+
+        Returns:
+            (typing.Optional[str]): The short name of the menu item.
+        """
+        try:
+            return self._raw_item_data["names"]["MobileShort"]
+        except KeyError:
+            return None
+
+    @property
+    def mobile_long_name(self) -> typing.Optional[str]:
+        """
+        The long name of the menu item.
+
+        Returns:
+            (typing.Optional[str]): The long name of the menu item.
+        """
+        try:
+            return self._raw_item_data["names"]["MobileLong"]
+        except KeyError:
+            return None
+
+    @property
+    def mickey_check(self) -> typing.Optional[bool]:
+        """
+        Whether the menu item is mickey check.
+
+        Returns:
+            (typing.Optional[bool]): Whether the menu item is mickey check.
+        """
+        try:
+            return self._raw_item_data["mickeyCheck"]
+        except KeyError:
+            return None
+
+    @property
+    def pc_long_description(self) -> typing.Optional[str]:
+        """
+        The long description of the menu item.
+
+        Returns:
+            (typing.Optional[str]): The long description of the menu item.
+        """
+        try:
+            return self._raw_item_data["descriptions"]["PCLong"]["text"]
+        except KeyError:
+            return None
+
+    @property
+    def mobile_short_description(self) -> typing.Optional[str]:
+        """
+        The short description of the menu item.
+
+        Returns:
+            (typing.Optional[str]): The short description of the menu item.
+        """
+        try:
+            return self._raw_item_data["descriptions"]["MobileShort"]["text"]
+        except KeyError:
+            return None
+
+    @property
+    def default_selection(self) -> typing.Optional[bool]:
+        """
+        Whether the menu item is the default selection.
+
+        Returns:
+            (typing.Optional[bool]): Whether the menu item is the default selection.
+        """
+        try:
+            return self._raw_item_data["defaultSelection"]
+        except KeyError:
+            return None
+
+    @property
+    def prices(self) -> typing.Optional[dict]:
+        """
+        The prices of the menu item.
+
+        Returns:
+            (typing.Optional[dict]): The prices of the menu item.
+        """
+        try:
+            return self._raw_item_data["prices"]
+        except KeyError:
+            return None
+
+    @property
+    def per_serving_without_tax(self) -> typing.Optional[float]:
+        """
+        The per serving without tax of the menu item.
+
+        Returns:
+            (typing.Optional[float]): The per serving without tax of the menu item.
+        """
+        try:
+            return self._raw_item_data["prices"]["PerServing"]["withoutTax"]
+        except KeyError:
+            return None
+
+
+class MenuGroup:
+    def __init__(self, raw_menu_group_data: dict, parent_restaurant_id: typing.Optional[str] = None):
+        self._raw_menu_group_data = raw_menu_group_data
+        self._parent_restaurant_id = parent_restaurant_id
+
+    def __str__(self) -> str:
+        return f"MenuGroup(menu_group_type={self.menu_group_type}, parent_restaurant_id={self._parent_restaurant_id})"
+
+    @property
+    def menu_group_type(self) -> typing.Optional[str]:
+        """
+        The type of the menu group.
+
+        Returns:
+            (typing.Optional[str]): The type of the menu group.
+        """
+        try:
+            return self._raw_menu_group_data["menuGroupType"]
+        except KeyError:
+            return None
+
+    @property
+    def multiple_price_types(self) -> typing.Optional[bool]:
+        """
+        Whether the menu group has multiple price types.
+
+        Returns:
+            (typing.Optional[bool]): Whether the menu group has multiple price types.
+        """
+        try:
+            return self._raw_menu_group_data["multiplePriceTypes"]
+        except KeyError:
+            return None
+
+    @property
+    def mickey_check_items(self) -> typing.Optional[bool]:
+        """
+        Whether the menu group has mickey check items.
+
+        Returns:
+            (typing.Optional[bool]): Whether the menu group has mickey check items.
+        """
+        try:
+            return self._raw_menu_group_data["mickeyCheckItems"]
+        except KeyError:
+            return None
+
+    @property
+    def names(self) -> typing.Optional[dict]:
+        """
+        The names of the menu group.
+
+        Returns:
+            (typing.Optional[dict]): The names of the menu group.
+        """
+        try:
+            return self._raw_menu_group_data["names"]
+        except KeyError:
+            return None
+
+    @property
+    def pc_short_name(self) -> typing.Optional[str]:
+        """
+        The short name of the menu group.
+
+        Returns:
+            (typing.Optional[str]): The short name of the menu group.
+        """
+        try:
+            return self._raw_menu_group_data["names"]["PCShort"]
+        except KeyError:
+            return None
+
+    @property
+    def pc_long_name(self) -> typing.Optional[str]:
+        """
+        The long name of the menu group.
+
+        Returns:
+            (typing.Optional[str]): The long name of the menu group.
+        """
+        try:
+            return self._raw_menu_group_data["names"]["PCLong"]
+        except KeyError:
+            return None
+
+    @property
+    def mobile_short_name(self) -> typing.Optional[str]:
+        """
+        The short name of the menu group.
+
+        Returns:
+            (typing.Optional[str]): The short name of the menu group.
+        """
+        try:
+            return self._raw_menu_group_data["names"]["MobileShort"]
+        except KeyError:
+            return None
+
+    @property
+    def mobile_long_name(self) -> typing.Optional[str]:
+        """
+        The long name of the menu group.
+
+        Returns:
+            (typing.Optional[str]): The long name of the menu group.
+        """
+        try:
+            return self._raw_menu_group_data["names"]["MobileLong"]
+        except KeyError:
+            return None
+
+    @property
+    def menu_items(self) -> typing.Optional[list[MenuItem]]:
+        """
+        The menu items of the menu group.
+
+        Returns:
+            (typing.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"]]
+        except KeyError:
+            return None
+
+
+class Menu:
+    def __init__(self, raw_menu_data: dict, parent_restaurant_id: typing.Optional[str] = None):
+        self._raw_menu_data = raw_menu_data
+        self._parent_restaurant_id = parent_restaurant_id
+
+    def __str__(self):
+        return f"Menu(entity_id={self.entity_id}, menu_type={self.menu_type}, parent_restaurant_id={self._parent_restaurant_id})"
+
+    @property
+    def entity_id(self) -> typing.Optional[str]:
+        """
+        The entity id of the menu.
+
+        Returns:
+            (typing.Optional[str]): The entity id of the menu.
+        """
+        try:
+            return self._raw_menu_data["id"]
+        except KeyError:
+            return None
+
+    @property
+    def menu_type(self) -> typing.Optional[str]:
+        """
+        The type of the menu.
+
+        Returns:
+            (typing.Optional[str]): The type of the menu.
+        """
+        try:
+            return self._raw_menu_data["menuType"]
+        except KeyError:
+            return None
+
+    @property
+    def localized_menu_type(self) -> typing.Optional[str]:
+        """
+        The localized type of the menu.
+
+        Returns:
+            (typing.Optional[str]): The localized type of the menu.
+        """
+        try:
+            return self._raw_menu_data["localizedMenuType"]
+        except KeyError:
+            return None
+
+    @property
+    def experience_type(self) -> typing.Optional[str]:
+        """
+        The experience type of the menu.
+
+        Returns:
+            (typing.Optional[str]): The experience type of the menu.
+        """
+        try:
+            return self._raw_menu_data["experienceType"]
+        except KeyError:
+            return None
+
+    @property
+    def service_style(self) -> typing.Optional[str]:
+        """
+        The service style of the menu.
+
+        Returns:
+            (typing.Optional[str]): The service style of the menu.
+        """
+        try:
+            return self._raw_menu_data["serviceStyle"]
+        except KeyError:
+            return None
+
+    @property
+    def primary_cuisine_type(self) -> typing.Optional[str]:
+        """
+        The primary cuisine type of the menu.
+
+        Returns:
+            (typing.Optional[str]): The primary cuisine type of the menu.
+        """
+        try:
+            return self._raw_menu_data["primaryCuisineType"]
+        except KeyError:
+            return None
+
+    @property
+    def secondary_cuisine_type(self) -> typing.Optional[str]:
+        """
+        The secondary cuisine type of the menu.
+
+        Returns:
+            (typing.Optional[str]): The secondary cuisine type of the menu.
+        """
+        try:
+            return self._raw_menu_data["secondaryCuisineType"]
+        except KeyError:
+            return None
+
+    @property
+    def menu_groups(self) -> list[MenuGroup]:
+        """
+        The menu groups of the menu.
+
+        Returns:
+            (list[MenuGroup]): The menu items of the menu.
+        """
+        try:
+            return [MenuGroup(i, self._parent_restaurant_id) for i in self._raw_menu_data["menuGroups"]]
+        except KeyError:
+            return []
+
+
+class Menus(DisneyAPIMixin):
+    """Class for Menu Entities."""
+
+    _menu_service_base = f"{auth_obj._environments['serviceMenuUrl']}/diningMenuSvc/orchestration/menus"
+
+    def __init__(self, restaurant_channel_id: str, lazy_load: bool = True):
+        self.entity_id = restaurant_channel_id.rsplit(".", 1)[-1]
+        self._menu_service_url = f"{self._menu_service_base}/{self.entity_id}"
+
+        if lazy_load:
+            self.disney_data: typing.Optional[dict] = None
+        else:
+            self.disney_data = self.get_disney_data(self.entity_id)
+
+    def __str__(self):
+        return f"Menus(entity_id={self.entity_id})"
+
+    def __repr__(self):
+        return f"Menus(restaurant_channel_id={self.entity_id})"
+
+    @property
+    def menus(self) -> list[Menu]:
+        """
+        Returns a list of all the menus associated with this entity.
+
+        Returns:
+            (list[Menu]): List of Menu objects that are associated with this entity.
+        """
+        if self.disney_data is None:
+            self.disney_data = self.get_disney_data(self._menu_service_url)
+        try:
+            return [Menu(i, self.entity_id) for i in self.disney_data["menus"]]
+        except KeyError:
+            return []

mousetools/auth.py

@@ -1,20 +1,24 @@
+import base64
+import json
 import typing
 from datetime import datetime, timedelta
+from importlib.resources import as_file, files
 
 import httpx
+from Crypto.Cipher import AES
 
 
 class Authentication:
     def __init__(self):
         self.time_of_expire: typing.Optional[datetime] = None
         self.access_token: typing.Optional[str] = None
+        self._environments = self._decrypt_file("resources/environments.bin").get("production", {})
 
-    @staticmethod
-    def authenticate() -> typing.Tuple[str, int]:
+    def authenticate(self) -> tuple[str, int]:
         """Gets an access token from Disney and the token's expiration time
 
         Returns:
-            (typing.Tuple[str, int]): Access token to the api and how long until it expires
+            (tuple[str, int]): Access token to the api and how long until it expires
         """
 
         headers = {
@@ -31,11 +35,11 @@ class Authentication:
         body = {
             "grant_type": "assertion",
             "assertion_type": "public",
-            "client_id": "TPR-DLR-LBSDK.AND-PROD",
+            "client_id": self._environments["authzClientId"],
         }
 
         response = httpx.post(
-            "https://authorization.go.com/token",
+            f"{self._environments['authzServiceUrl']}/token",
             headers=headers,
             params=body,
             timeout=10,
@@ -45,11 +49,11 @@ class Authentication:
 
         return auth["access_token"], int(auth["expires_in"])
 
-    def get_headers(self) -> typing.Dict[str, str]:
+    def get_headers(self) -> dict[str, str]:
         """Creates the headers to send during the request
 
         Returns:
-            (typing.Dict[str, str]): Headers for the request
+            (dict[str, str]): Headers for the request
         """
 
         if self.time_of_expire is None or (datetime.now() > self.time_of_expire):
@@ -66,5 +70,43 @@ class Authentication:
 
         return headers
 
+    def get_couchbase_headers(self) -> dict[str, str]:
+        """Creates the headers to send during the couchbase request
+
+        Returns:
+            (dict[str, str]): Headers for the couchbase request
+        """
+        username = self._environments["syncGatewayUser"]
+        password = self._environments["syncGatewayPass"]
+        token = base64.b64encode(f"{username}:{password}".encode()).decode()
+
+        header = {
+            "Authorization": f"Basic {token}",
+            "User-Agent": "CouchbaseLite/3.2.1-9 (Java; Android 16; sdk_gphone64_x86_64) EE/release, Commit/2109502be2@02fbcb1b8b44 Core/3.2.1 (19)",
+            "Content-Type": "application/json",
+            "Accept": "multipart/related",
+        }
+
+        return header
+
+    def _decrypt_file(self, filename: str) -> dict:
+        cipher = AES.new(self._e(), AES.MODE_GCM, nonce=self._b())
+        with as_file(files("mousetools") / filename) as f, open(f, "rb") as file:
+            decrypted = cipher.decrypt(file.read())
+            return json.loads(decrypted.decode("Windows-1252")[:-16])
+
+    def _e(self):
+        s = ""
+        for i in range(1, 17):
+            if i % 2 != 0 or i >= 16:
+                s += chr(i + 65)
+            else:
+                s += str(3.141592653589793)[i]
+        bytes_ = s.encode("utf-8")
+        return bytes_
+
+    def _b(self):
+        return bytes(reversed(self._e()))
+
 
 auth_obj = Authentication()

mousetools/channels/__init__.py

@@ -0,0 +1,46 @@
+import typing
+from datetime import datetime, timedelta
+from enum import Enum
+
+from mousetools.channels.enums import DestinationShort, DestinationTimezones, DLRCouchbaseChannels, WDWCouchbaseChannels
+from mousetools.mixins.couchbase import CouchbaseMixin
+
+
+class CouchbaseChannel(CouchbaseMixin):
+    def __init__(self, channel_id: typing.Union[WDWCouchbaseChannels, DLRCouchbaseChannels], lazy_load: bool = True):
+        """
+        Args:
+            channel_id (typing.Union[WDWCouchbaseChannels, DLRCouchbaseChannels]): Channel ID from the enum
+            lazy_load (bool, optional): If True, will not pull data until a method or property is called. Defaults to True.
+        """
+        if isinstance(channel_id, Enum):
+            channel_id = channel_id.value
+        self.channel_id = channel_id
+
+        self._destination_short: DestinationShort = channel_id.split(".")[0]
+        self._tz: DestinationTimezones = (
+            DestinationTimezones.WALT_DISNEY_WORLD
+            if self._destination_short == DestinationShort.WALT_DISNEY_WORLD
+            else DestinationTimezones.DISNEYLAND_RESORT
+        )
+
+        self._cb_data = None
+        self._refresh_interval = timedelta(minutes=10)
+        self.last_update = datetime.now(tz=self._tz.value)
+
+        if not lazy_load:
+            self.refresh()
+
+    def refresh(self) -> None:
+        """Pulls initial data if none exists or if it is older than the refresh interval"""
+        if self._cb_data is None or datetime.now(tz=self._tz.value) - self.last_update > self._refresh_interval:
+            self._cb_data = self.get_channel_changes(self.channel_id)
+
+    def get_children_channel_ids(self) -> list[str]:
+        """Returns a list of child channel ids for the channel."""
+        self.refresh()
+
+        return [i["id"] for i in self._cb_data["results"]]
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}({self.channel_id})"

mousetools/channels/enums.py

@@ -0,0 +1,67 @@
+from enum import Enum
+from zoneinfo import ZoneInfo
+
+
+class DestinationShort(str, Enum):
+    WALT_DISNEY_WORLD = "wdw"
+    DISNEYLAND_RESORT = "dlr"
+
+
+class CouchbaseChannels(str, Enum):
+    FACILITIES = "facilities"
+    FACILITY_STATUS = "facilitystatus"
+    CALENDAR = "calendar"
+    FORECASTED_WAIT_TIME = "forecastedwaittimes"
+    TODAY = "today"
+
+
+def get_complete_channel_id(
+    destination_short: DestinationShort, channel: CouchbaseChannels, version: str, is_multi_language: bool
+) -> str:
+    channel_id = f"{destination_short.value}.{channel.value}.{version}"
+
+    if is_multi_language:
+        channel_id += ".en_us"
+
+    return channel_id
+
+
+class WDWCouchbaseChannels(str, Enum):
+    FACILITIES = get_complete_channel_id(DestinationShort.WALT_DISNEY_WORLD, CouchbaseChannels.FACILITIES, "1_0", True)
+    """Walt Disney World Facilities Channel"""
+    FACILITY_STATUS = get_complete_channel_id(
+        DestinationShort.WALT_DISNEY_WORLD, CouchbaseChannels.FACILITY_STATUS, "1_0", False
+    )
+    """Walt Disney World Facility Status Channel"""
+    CALENDAR = get_complete_channel_id(DestinationShort.WALT_DISNEY_WORLD, CouchbaseChannels.CALENDAR, "1_0", False)
+    """Walt Disney World Calendar Channel"""
+    FORECASTED_WAIT_TIME = get_complete_channel_id(
+        DestinationShort.WALT_DISNEY_WORLD, CouchbaseChannels.FORECASTED_WAIT_TIME, "1_0", True
+    )
+    """Walt Disney World Forecasted Wait Time Channel"""
+    TODAY = get_complete_channel_id(DestinationShort.WALT_DISNEY_WORLD, CouchbaseChannels.TODAY, "1_0", False)
+    """Walt Disney World Today Channel"""
+
+
+class DLRCouchbaseChannels(str, Enum):
+    FACILITIES = get_complete_channel_id(DestinationShort.DISNEYLAND_RESORT, CouchbaseChannels.FACILITIES, "1_0", True)
+    """Disneyland Resort Facilities Channel"""
+    FACILITY_STATUS = get_complete_channel_id(
+        DestinationShort.DISNEYLAND_RESORT, CouchbaseChannels.FACILITY_STATUS, "1_0", False
+    )
+    """Disneyland Resort Facility Status Channel"""
+    CALENDAR = get_complete_channel_id(DestinationShort.DISNEYLAND_RESORT, CouchbaseChannels.CALENDAR, "1_0", False)
+    """Disneyland Resort Calendar Channel"""
+    FORECASTED_WAIT_TIME = get_complete_channel_id(
+        DestinationShort.DISNEYLAND_RESORT, CouchbaseChannels.FORECASTED_WAIT_TIME, "1_0", True
+    )
+    """Disneyland Resort Forecasted Wait Time Channel"""
+    TODAY = get_complete_channel_id(DestinationShort.DISNEYLAND_RESORT, CouchbaseChannels.TODAY, "1_0", False)
+    """Disneyland Resort Today Channel"""
+
+
+class DestinationTimezones(Enum):
+    WALT_DISNEY_WORLD = ZoneInfo("America/New_York")
+    """Walt Disney World Timezone"""
+    DISNEYLAND_RESORT = ZoneInfo("America/Los_Angeles")
+    """Disneyland Resort Timezone"""