MouseTools 4.1.1__tar.gz → 4.3.0__tar.gz

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

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

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

@@ -339,7 +339,7 @@ class Menus(DisneyAPIMixin):
         self._tz = ZoneInfo("UTC")
 
         self._disney_data: typing.Optional[dict] = None
-        self._disney_data_pull_time: typing.Optional[datetime] = datetime.now(tz=self._tz)
+        self._disney_data_pull_time: datetime = datetime.now(tz=self._tz)
         if not lazy_load:
             self.refresh()
 
@@ -397,12 +397,12 @@ class Menus(DisneyAPIMixin):
         return self._disney_data["ancestorLocationLandArea"]
 
     @property
-    def last_refresh(self) -> typing.Optional[datetime]:
+    def last_refresh(self) -> datetime:
         """
         The last time the menus were refreshed.
 
         Returns:
-            (typing.Optional[datetime]): The last time the menus were refreshed.
+            (datetime): The last time the menus were refreshed.
         """
         if self._disney_data is None:
             self._disney_data = self.get_disney_data(self.entity_id)

{mousetools-4.1.1 → mousetools-4.3.0}/mousetools/channels/__init__.py

@@ -1,11 +1,62 @@
+import logging
 import typing
 from datetime import datetime, timedelta
 from enum import Enum
 
+from dateutil.parser import isoparse
+
 from mousetools.channels.enums import DestinationTimezones, DLRCouchbaseChannels, WDWCouchbaseChannels
 from mousetools.enums import DestinationShort, EntityType
 from mousetools.mixins.couchbase import CouchbaseMixin
 
+logger = logging.getLogger(__name__)
+
+
+class CouchbaseChildChannel(CouchbaseMixin):
+    def __init__(self, channel_id: str, lazy_load: bool = True):
+        if isinstance(channel_id, Enum):
+            channel_id = channel_id.value
+
+        self.channel_id: str = channel_id
+        self.entity_id: str = channel_id.rsplit(".", 1)[-1]
+
+        self._destination_short: DestinationShort = self.channel_id.split(".")[0]
+        self._tz: DestinationTimezones = (
+            DestinationTimezones.WALT_DISNEY_WORLD
+            if self._destination_short == DestinationShort.WALT_DISNEY_WORLD
+            else DestinationTimezones.DISNEYLAND_RESORT
+        )
+        self._refresh_interval: timedelta = timedelta(minutes=30)
+        self._cb_data: typing.Optional[dict] = None
+        self._cb_data_pull_time: datetime = 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_data(self.channel_id)
+            self._cb_data_pull_time = datetime.now(tz=self._tz.value)
+
+    @property
+    def last_update(self) -> datetime:
+        """
+        The last time the data was updated.
+
+        Returns:
+            (datetime): The last time the entity's data was updated, or None if no such data exists.
+        """
+        if self._cb_data is None:
+            self._cb_data = self.get_channel_data(self.channel_id)
+
+        try:
+            dt = isoparse(self._cb_data["lastUpdate"])
+            dt = dt.replace(tzinfo=self._tz.value)
+            return dt
+        except (KeyError, TypeError, ValueError):
+            logger.debug("No last updated found for %s", self.channel_id)
+            return self._cb_data_pull_time
+
 
 class CouchbaseChannel(CouchbaseMixin):
     def __init__(self, channel_id: typing.Union[WDWCouchbaseChannels, DLRCouchbaseChannels], lazy_load: bool = True):

{mousetools-4.1.1 → mousetools-4.3.0}/mousetools/channels/calendar/__init__.py

@@ -1,21 +1,17 @@
 import logging
 import typing
-from datetime import datetime, timedelta
-from enum import Enum
 from zoneinfo import ZoneInfo
 
 from dateutil.parser import isoparse
 
-from mousetools.channels import CouchbaseChannel
-from mousetools.channels.enums import CouchbaseChannels, DestinationTimezones
+from mousetools.channels import CouchbaseChannel, CouchbaseChildChannel
+from mousetools.channels.enums import CouchbaseChannels
 from mousetools.decorators import disney_property
-from mousetools.enums import DestinationShort
-from mousetools.mixins.couchbase import CouchbaseMixin
 
 logger = logging.getLogger(__name__)
 
 
-class CalendarChildChannel(CouchbaseMixin):
+class CalendarChildChannel(CouchbaseChildChannel):
     def __init__(
         self,
         channel_id: str,
@@ -26,34 +22,11 @@ class CalendarChildChannel(CouchbaseMixin):
             channel_id (str): Calendar Channel ID
             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: str = channel_id
-        self.entity_id: str = channel_id.rsplit(".", 1)[-1]
-
-        self._destination_short: DestinationShort = self.channel_id.split(".")[0]
-        self._tz: DestinationTimezones = (
-            DestinationTimezones.WALT_DISNEY_WORLD
-            if self._destination_short == DestinationShort.WALT_DISNEY_WORLD
-            else DestinationTimezones.DISNEYLAND_RESORT
-        )
-        self._refresh_interval: timedelta = timedelta(minutes=30)
-
-        self._cb_data: typing.Optional[dict] = None
-        self._cb_data_pull_time: typing.Optional[datetime] = datetime.now(tz=self._tz.value)
-        if not lazy_load:
-            self.refresh()
+        super().__init__(channel_id, lazy_load=lazy_load)
 
     def __repr__(self):
         return f"{self.__class__.__name__}(channel_id='{self.channel_id}')"
 
-    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_data(self.channel_id)
-            self._cb_data_pull_time = datetime.now(tz=self._tz.value)
-
     @disney_property()
     def calendar_id(self) -> typing.Optional[str]:
         """The ID of the calendar
@@ -63,24 +36,6 @@ class CalendarChildChannel(CouchbaseMixin):
         """
         return self._cb_data["id"]
 
-    @property
-    def last_update(self) -> typing.Optional[datetime]:
-        """The last time the data was updated.
-
-        Returns:
-            (typing.Optional[datetime]): The last time the entity's data was updated, or None if no such data exists.
-        """
-        if self._cb_data is None:
-            self._cb_data = self.get_channel_data(self.channel_id)
-
-        try:
-            dt = isoparse(self._cb_data["lastUpdate"])
-            dt = dt.replace(tzinfo=self._tz.value)
-            return dt
-        except (KeyError, ValueError, TypeError):
-            logger.debug("No last updated found for %s", self.channel_id)
-            return self._cb_data_pull_time
-
     @disney_property()
     def all_closed(self) -> typing.Optional[list[dict]]:
         """The list of closed facilities.

mousetools-4.3.0/mousetools/channels/characters/__init__.py

@@ -0,0 +1,122 @@
+import logging
+from typing import Optional
+
+from dateutil.parser import isoparse
+
+from mousetools.channels import CouchbaseChannel, CouchbaseChildChannel
+from mousetools.channels.enums import CouchbaseChannels
+from mousetools.decorators import disney_property
+
+logger = logging.getLogger(__name__)
+
+
+class CharactersChildChannel(CouchbaseChildChannel):
+    def __init__(
+        self,
+        channel_id: str,
+        lazy_load: bool = True,
+    ):
+        """
+        Args:
+            channel_id (str): Forecasted Wait Times Channel ID
+            lazy_load (bool, optional): If True, will not pull data until a method or property is called. Defaults to True.
+        """
+        super().__init__(channel_id, lazy_load=lazy_load)
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}(channel_id='{self.channel_id}')"
+
+    @disney_property()
+    def name(self) -> Optional[str]:
+        """The name of the entity.
+
+        Returns:
+            (Optional[str]): The name of the entity, or None if it was not found.
+        """
+        return self._cb_data["name"]
+
+    @disney_property()
+    def character_id(self) -> Optional[str]:
+        """The character ID of the entity. Strips the region from the channel ID.
+
+        Returns:
+            (Optional[str]): The character ID of the entity, or None if it was not found.
+        """
+        return self._cb_data["characterId"]
+
+    @disney_property()
+    def description(self) -> Optional[str]:
+        """The description of the entity.
+
+        Returns:
+            (Optional[str]): The description of the entity, or None if it was not found.
+        """
+        return self._cb_data["description"]
+
+    @disney_property()
+    def thumbnail_url(self) -> Optional[str]:
+        """The thumbnail URL of the entity.
+
+        Returns:
+            (Optional[str]): The thumbnail URL of the entity, or None if it was not found.
+        """
+        return self._cb_data["thumbnailUrl"]
+
+    @disney_property()
+    def banner_url(self) -> Optional[str]:
+        """The banner URL of the entity.
+
+        Returns:
+            (Optional[str]): The banner URL of the entity, or None if it was not found.
+        """
+        return self._cb_data["bannerUrl"]
+
+    def get_appearances(self) -> list[dict]:
+        """The current list of appearances of the character is scheduled for.
+
+        Returns:
+            (list[dict]): The list of appearances of the entity.
+        """
+        self.refresh()
+        try:
+            if "appearances" not in self._cb_data:
+                return []
+
+            _appearances = []
+            for i in self._cb_data["appearances"]:
+                tmp = {}
+                tmp["start_datetime"] = isoparse(i["startDateTime"]).astimezone(self._tz.value)
+                tmp["end_datetime"] = isoparse(i["endDateTime"]).astimezone(self._tz.value)
+                tmp["start_time_str"] = i["startTime"]
+                tmp["end_time_str"] = i["endTime"]
+                tmp["coordinates"] = {"latitude": i["latitude"], "longitude": i["longitude"]}
+                tmp["facility_id"] = i["facilityId"]
+                tmp["location_name"] = i["locationName"]
+                tmp["location_id"] = i["locationId"]
+                tmp["ancestor_land_id"] = i["ancestorLandId"]
+                tmp["ancestor_land_name"] = i["ancestorLandName"]
+                _appearances.append(tmp)
+
+            return sorted(_appearances, key=lambda i: i["start_datetime"])
+
+        except (KeyError, TypeError, ValueError):
+            logger.debug("No forecast found for %s", self.channel_id)
+            return []
+
+
+class CharactersChannel(CouchbaseChannel):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def get_children_channels(self) -> list[CharactersChildChannel]:
+        """Gets a list of children channels for the channel.
+
+        Returns:
+            (list[CharactersChildChannel]): A list of CharactersChildChannel
+        """
+        self.refresh()
+        channels = []
+        for i in self._cb_data["results"]:
+            if CouchbaseChannels.CHARACTERS in i["id"]:
+                channels.append(CharactersChildChannel(i["id"]))
+        return channels

{mousetools-4.1.1 → mousetools-4.3.0}/mousetools/channels/enums.py

@@ -8,7 +8,7 @@ class CouchbaseChannels(str, Enum):
     FACILITIES = "facilities"
     FACILITY_STATUS = "facilitystatus"
     CALENDAR = "calendar"
-    FORECASTED_WAIT_TIME = "forecastedwaittimes"
+    FORECASTED_WAIT_TIMES = "forecastedwaittimes"
     TODAY = "today"
     CHARACTERS = "characters"
 
@@ -33,8 +33,8 @@ class WDWCouchbaseChannels(str, Enum):
     """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
+    FORECASTED_WAIT_TIMES = get_complete_channel_id(
+        DestinationShort.WALT_DISNEY_WORLD, CouchbaseChannels.FORECASTED_WAIT_TIMES, "1_0", True
     )
     """Walt Disney World Forecasted Wait Time Channel"""
     TODAY = get_complete_channel_id(DestinationShort.WALT_DISNEY_WORLD, CouchbaseChannels.TODAY, "1_0", False)
@@ -52,8 +52,8 @@ class DLRCouchbaseChannels(str, Enum):
     """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
+    FORECASTED_WAIT_TIMES = get_complete_channel_id(
+        DestinationShort.DISNEYLAND_RESORT, CouchbaseChannels.FORECASTED_WAIT_TIMES, "1_0", True
     )
     """Disneyland Resort Forecasted Wait Time Channel"""
     TODAY = get_complete_channel_id(DestinationShort.DISNEYLAND_RESORT, CouchbaseChannels.TODAY, "1_0", False)

{mousetools-4.1.1 → mousetools-4.3.0}/mousetools/channels/facilities/__init__.py

@@ -1,29 +1,28 @@
 import logging
+import os
 import typing
 from datetime import datetime, time, timedelta
-from enum import Enum
 from zoneinfo import ZoneInfo
 
-from dateutil.parser import isoparse
+import httpx
 
 from mousetools.api.menu import Menus
-from mousetools.channels import CouchbaseChannel
+from mousetools.channels import CouchbaseChannel, CouchbaseChildChannel
 from mousetools.channels.calendar import CalendarChildChannel
 from mousetools.channels.enums import (
     CouchbaseChannels,
-    DestinationTimezones,
     DLRCouchbaseChannels,
     WDWCouchbaseChannels,
 )
 from mousetools.channels.facilitystatus import FacilityStatusChildChannel
+from mousetools.channels.forecastedwaittimes import ForecastedWaitTimesChildChannel
 from mousetools.decorators import disney_property
 from mousetools.enums import DestinationShort, EntityType
-from mousetools.mixins.couchbase import CouchbaseMixin
 
 logger = logging.getLogger(__name__)
 
 
-class FacilityChildChannel(CouchbaseMixin):
+class FacilityChildChannel(CouchbaseChildChannel):
     """Base class for all Facility Child Channels. Subclasses like Attraction, Restaurant, Entertainment, etc. extend this class.
 
     Example:
@@ -38,8 +37,6 @@ class FacilityChildChannel(CouchbaseMixin):
         {'latitude': 28.4160036778, 'longitude': -81.5811902834}
     """
 
-    _subclasses: typing.ClassVar[dict[str, type["FacilityChildChannel"]]] = {}
-
     def __init__(
         self,
         channel_id: str,
@@ -50,27 +47,12 @@ class FacilityChildChannel(CouchbaseMixin):
             channel_id (str): Facility Channel ID
             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: str = channel_id
-        self.entity_id: str = channel_id.rsplit(".", 1)[-1]
+        super().__init__(channel_id, lazy_load=lazy_load)
 
-        self._destination_short: DestinationShort = self.channel_id.split(".")[0]
-        self._tz: DestinationTimezones = (
-            DestinationTimezones.WALT_DISNEY_WORLD
-            if self._destination_short == DestinationShort.WALT_DISNEY_WORLD
-            else DestinationTimezones.DISNEYLAND_RESORT
-        )
         self._refresh_interval: timedelta = timedelta(
             hours=12
         )  # properties are rarely updated, no need to spam the API
 
-        self._cb_data: typing.Optional[dict] = None
-        self._cb_data_pull_time: typing.Optional[datetime] = datetime.now(tz=self._tz.value)
-        if not lazy_load:
-            self.refresh()
-
         self._today_calendar: typing.Optional[CalendarChildChannel] = None
 
     def refresh(self) -> None:
@@ -391,30 +373,6 @@ class FacilityChildChannel(CouchbaseMixin):
 
         return FacilityStatusChildChannel(facility_status_channel_id)
 
-    @property
-    def last_update(self) -> typing.Optional[datetime]:
-        """
-        The last time the data was updated.
-
-        Returns:
-            (typing.Optional[datetime]): The last time the entity's data was updated, or None if no such data exists.
-        """
-        if self._cb_data is None:
-            self._cb_data = self.get_channel_data(self.channel_id)
-
-        try:
-            tz = (
-                DestinationTimezones.WALT_DISNEY_WORLD
-                if "wdw" in self.channel_id
-                else DestinationTimezones.DISNEYLAND_RESORT
-            )
-            dt = isoparse(self._cb_data["lastUpdate"])
-            dt = dt.replace(tzinfo=tz.value)
-            return dt
-        except (KeyError, TypeError, ValueError):
-            logger.debug("No last updated found for %s", self.channel_id)
-            return self._cb_data_pull_time
-
     @disney_property()
     def sponsor_name(self) -> typing.Optional[str]:
         """The sponsor name of the entity.
@@ -434,16 +392,32 @@ class FacilityChildChannel(CouchbaseMixin):
         """
         return self._cb_data["mealPeriods"]
 
-    @property
-    def menu(self) -> Menus:
+    def get_menu(self) -> Menus:
         """
         The menu of the restaurant.
 
         Returns:
-            (typing.Optional[Menus]): The menu of the restaurant.
+            (Menus): The menu of the restaurant.
         """
         return Menus(self.channel_id)
 
+    def get_forecasted_wait_times_channel(self) -> ForecastedWaitTimesChildChannel:
+        """Get the forecasted wait times channel for this entity.
+
+        Returns:
+            (ForecastedWaitTimesChildChannel): The forecasted wait times channel
+
+        Example:
+            ```python
+            >>> f = FacilityChildChannel("wdw.facilities.1_0.en_us.attraction.80010177;entityType=Attraction", lazy_load=False)
+            >>> fwt = f.get_forecasted_wait_times_channel()
+            >>> fwt.get_forecast()
+            [{'forecasted_wait_minutes': 85, 'bar_graph_percentage': 70, 'accessibility_label': 'High', 'timestamp': datetime.datetime(2025, 5, 27, 9, 0, tzinfo=zoneinfo.ZoneInfo(key='America/New_York'))}, ...]
+            ```
+        """
+        channel_id = f"{WDWCouchbaseChannels.FORECASTED_WAIT_TIMES.value if self._destination_short == DestinationShort.WALT_DISNEY_WORLD else DLRCouchbaseChannels.FORECASTED_WAIT_TIMES.value}.{self.entity_id}"
+        return ForecastedWaitTimesChildChannel(channel_id)
+
     @disney_property()
     def detail_image_url(self) -> typing.Optional[str]:
         """The detail image url of the entity.
@@ -503,6 +477,41 @@ class FacilityChildChannel(CouchbaseMixin):
         closed = self._today_calendar.get_closed(self.entity_id)
         return bool(refurb or closed)
 
+    def get_current_weather(self, api_key: typing.Optional[str] = None) -> dict:
+        """Get the current weather for the facility using the OpenWeatherMap API. https://openweathermap.org
+
+        Args:
+            api_key (typing.Optional[str], optional): The API key to use. Defaults to None. If None, will use the MT_OPEN_WEATHER_API_KEY environment variable.
+
+        Returns:
+            (dict): The current weather for the facility.
+        """
+
+        weather_key = api_key or os.environ.get("MT_OPEN_WEATHER_API_KEY")
+
+        if weather_key is None:
+            logger.warning("No weather API key found")
+            return {}
+
+        coordinates = self.coordinates
+        if coordinates is None:
+            return {}
+
+        weather_url = "https://api.openweathermap.org/data/2.5/weather"
+        params = {
+            "lat": coordinates["latitude"],
+            "lon": coordinates["longitude"],
+            "appid": weather_key,
+        }
+        try:
+            response = httpx.get(weather_url, params=params)
+            response.raise_for_status()
+            data = response.json()
+            return data
+        except httpx.HTTPError as err:
+            logger.error("Request failed: %s", err)
+            return {}
+
     def __str__(self) -> str:
         return f"{self.entity_type}: {self.name} ({self.channel_id})"
 
@@ -514,38 +523,32 @@ class FacilityChildChannel(CouchbaseMixin):
             return self.channel_id == other.channel_id
         return False
 
-    @classmethod
-    def get_subclass(cls, type_name: str) -> type["FacilityChildChannel"]:
-        if type_name not in cls._subclasses:
-            cls._subclasses[type_name] = type(type_name, (cls,), {"__doc__": f"Class for {type_name} Entities."})
-        return cls._subclasses[type_name]
-
-
-AttractionFacilityChild = FacilityChildChannel.get_subclass("AttractionFacilityChild")
-AudioTourFacilityChild = FacilityChildChannel.get_subclass("AudioTourFacilityChild")
-BuildingFacilityChild = FacilityChildChannel.get_subclass("BuildingFacilityChild")
-BusStopFacilityChild = FacilityChildChannel.get_subclass("BusStopFacilityChild")
-DestinationFacilityChild = FacilityChildChannel.get_subclass("DestinationFacilityChild")
-DiningEventFacilityChild = FacilityChildChannel.get_subclass("DiningEventFacilityChild")
-DinnerShowFacilityChild = FacilityChildChannel.get_subclass("DinnerShowFacilityChild")
-EntertainmentFacilityChild = FacilityChildChannel.get_subclass("EntertainmentFacilityChild")
-EntertainmentVenueFacilityChild = FacilityChildChannel.get_subclass("EntertainmentVenueFacilityChild")
-WaterParkFacilityChild = FacilityChildChannel.get_subclass("WaterParkFacilityChild")
-GuestServiceFacilityChild = FacilityChildChannel.get_subclass("GuestServiceFacilityChild")
-LandFacilityChild = FacilityChildChannel.get_subclass("LandFacilityChild")
-MerchandiseFacilityChild = FacilityChildChannel.get_subclass("MerchandiseFacilityChild")
-PhotopassFacilityChild = FacilityChildChannel.get_subclass("PhotopassFacilityChild")
-PointOfInterestFacilityChild = FacilityChildChannel.get_subclass("PointOfInterestFacilityChild")
-RecreationFacilityChild = FacilityChildChannel.get_subclass("RecreationFacilityChild")
-RecreationActivityFacilityChild = FacilityChildChannel.get_subclass("RecreationActivityFacilityChild")
-ResortFacilityChild = FacilityChildChannel.get_subclass("ResortFacilityChild")
-ResortAreaFacilityChild = FacilityChildChannel.get_subclass("ResortAreaFacilityChild")
-SpaFacilityChild = FacilityChildChannel.get_subclass("SpaFacilityChild")
-ThemeParkFacilityChild = FacilityChildChannel.get_subclass("ThemeParkFacilityChild")
-TourFacilityChild = FacilityChildChannel.get_subclass("TourFacilityChild")
-TransportationFacilityChild = FacilityChildChannel.get_subclass("TransportationFacilityChild")
-WaterParkFacilityChild = FacilityChildChannel.get_subclass("WaterParkFacilityChild")
-RestaurantFacilityChild = FacilityChildChannel.get_subclass("RestaurantFacilityChild")
+
+AttractionFacilityChild = type("AttractionFacilityChild", (FacilityChildChannel,), {})
+AudioTourFacilityChild = type("AudioTourFacilityChild", (FacilityChildChannel,), {})
+BuildingFacilityChild = type("BuildingFacilityChild", (FacilityChildChannel,), {})
+BusStopFacilityChild = type("BusStopFacilityChild", (FacilityChildChannel,), {})
+DestinationFacilityChild = type("DestinationFacilityChild", (FacilityChildChannel,), {})
+DiningEventFacilityChild = type("DiningEventFacilityChild", (FacilityChildChannel,), {})
+DinnerShowFacilityChild = type("DinnerShowFacilityChild", (FacilityChildChannel,), {})
+EntertainmentFacilityChild = type("EntertainmentFacilityChild", (FacilityChildChannel,), {})
+EntertainmentVenueFacilityChild = type("EntertainmentVenueFacilityChild", (FacilityChildChannel,), {})
+WaterParkFacilityChild = type("WaterParkFacilityChild", (FacilityChildChannel,), {})
+GuestServiceFacilityChild = type("GuestServiceFacilityChild", (FacilityChildChannel,), {})
+LandFacilityChild = type("LandFacilityChild", (FacilityChildChannel,), {})
+MerchandiseFacilityChild = type("MerchandiseFacilityChild", (FacilityChildChannel,), {})
+PhotopassFacilityChild = type("PhotopassFacilityChild", (FacilityChildChannel,), {})
+PointOfInterestFacilityChild = type("PointOfInterestFacilityChild", (FacilityChildChannel,), {})
+RecreationFacilityChild = type("RecreationFacilityChild", (FacilityChildChannel,), {})
+RecreationActivityFacilityChild = type("RecreationActivityFacilityChild", (FacilityChildChannel,), {})
+ResortFacilityChild = type("ResortFacilityChild", (FacilityChildChannel,), {})
+ResortAreaFacilityChild = type("ResortAreaFacilityChild", (FacilityChildChannel,), {})
+SpaFacilityChild = type("SpaFacilityChild", (FacilityChildChannel,), {})
+ThemeParkFacilityChild = type("ThemeParkFacilityChild", (FacilityChildChannel,), {})
+TourFacilityChild = type("TourFacilityChild", (FacilityChildChannel,), {})
+TransportationFacilityChild = type("TransportationFacilityChild", (FacilityChildChannel,), {})
+WaterParkFacilityChild = type("WaterParkFacilityChild", (FacilityChildChannel,), {})
+RestaurantFacilityChild = type("RestaurantFacilityChild", (FacilityChildChannel,), {})
 
 
 class FacilityChannel(CouchbaseChannel):

{mousetools-4.1.1 → mousetools-4.3.0}/mousetools/channels/facilitystatus/__init__.py

@@ -1,47 +1,25 @@
 import logging
 import typing
-from datetime import datetime, timedelta
+from datetime import datetime
 
 from dateutil.parser import isoparse
 
-from mousetools.channels import CouchbaseChannel
-from mousetools.channels.enums import CouchbaseChannels, DestinationTimezones
+from mousetools.channels import CouchbaseChannel, CouchbaseChildChannel
+from mousetools.channels.enums import CouchbaseChannels
 from mousetools.decorators import disney_property
-from mousetools.enums import DestinationShort, EntityType
-from mousetools.mixins.couchbase import CouchbaseMixin
+from mousetools.enums import EntityType
 
 logger = logging.getLogger(__name__)
 
 
-class FacilityStatusChildChannel(CouchbaseMixin):
-    _subclasses: typing.ClassVar[dict[str, type["FacilityStatusChildChannel"]]] = {}
-
+class FacilityStatusChildChannel(CouchbaseChildChannel):
     def __init__(self, channel_id: str, 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.
         """
-        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._refresh_interval: timedelta = timedelta(minutes=10)
-        self._cb_data: typing.Optional[dict] = None
-        self._cb_data_pull_time: typing.Optional[datetime] = 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_data(self.channel_id)
-            self._cb_data_pull_time = datetime.now(tz=self._tz.value)
+        super().__init__(channel_id, lazy_load=lazy_load)
 
     def get_status(self) -> typing.Optional[str]:
         """Get the operating status of the facility
@@ -71,24 +49,6 @@ class FacilityStatusChildChannel(CouchbaseMixin):
             logger.debug("No wait time found for %s", self.channel_id)
             return None
 
-    @property
-    def last_update(self) -> typing.Optional[datetime]:
-        """The last time the data was updated.
-
-        Returns:
-            (typing.Optional[datetime]): The last time the entity's data was updated, or None if no such data exists.
-        """
-        if self._cb_data is None:
-            self._cb_data = self.get_channel_data(self.channel_id)
-
-        try:
-            dt = isoparse(self._cb_data["lastUpdate"])
-            dt = dt.replace(tzinfo=self._tz.value)
-            return dt
-        except (KeyError, TypeError, ValueError):
-            logger.debug("No last updated found for %s", self.channel_id)
-            return self._cb_data_pull_time
-
     @disney_property()
     def fast_pass_available(self) -> typing.Optional[bool]:
         return self._cb_data["fastPassAvailable"]
@@ -132,20 +92,14 @@ class FacilityStatusChildChannel(CouchbaseMixin):
             return self.channel_id == other.channel_id
         return False
 
-    @classmethod
-    def get_subclass(cls, type_name: str) -> type["FacilityStatusChildChannel"]:
-        if type_name not in cls._subclasses:
-            cls._subclasses[type_name] = type(type_name, (cls,), {"__doc__": f"Class for {type_name} Entities."})
-        return cls._subclasses[type_name]
 
-
-AttractionFacilityStatusChild = FacilityStatusChildChannel.get_subclass("AttractionFacilityStatusChild")
-EntertainmentFacilityStatusChild = FacilityStatusChildChannel.get_subclass("EntertainmentFacilityStatusChild")
-EntertainmentVenueFacilityStatusChild = FacilityStatusChildChannel.get_subclass("EntertainmentVenueFacilityStatusChild")
-LandFacilityStatusChild = FacilityStatusChildChannel.get_subclass("LandFacilityStatusChild")
-RestaurantFacilityStatusChild = FacilityStatusChildChannel.get_subclass("RestaurantFacilityStatusChild")
-ThemeParkFacilityStatusChild = FacilityStatusChildChannel.get_subclass("ThemeParkFacilityStatusChild")
-WaterParkFacilityStatusChild = FacilityStatusChildChannel.get_subclass("WaterParkFacilityStatusChild")
+AttractionFacilityStatusChild = type("AttractionFacilityStatusChild", (FacilityStatusChildChannel,), {})
+EntertainmentFacilityStatusChild = type("EntertainmentFacilityStatusChild", (FacilityStatusChildChannel,), {})
+EntertainmentVenueFacilityStatusChild = type("EntertainmentVenueFacilityStatusChild", (FacilityStatusChildChannel,), {})
+LandFacilityStatusChild = type("LandFacilityStatusChild", (FacilityStatusChildChannel,), {})
+RestaurantFacilityStatusChild = type("RestaurantFacilityStatusChild", (FacilityStatusChildChannel,), {})
+ThemeParkFacilityStatusChild = type("ThemeParkFacilityStatusChild", (FacilityStatusChildChannel,), {})
+WaterParkFacilityStatusChild = type("WaterParkFacilityStatusChild", (FacilityStatusChildChannel,), {})
 
 
 class FacilityStatusChannel(CouchbaseChannel):
@@ -165,6 +119,25 @@ class FacilityStatusChannel(CouchbaseChannel):
                 channels.append(FacilityStatusChildChannel(i["id"]))
         return channels
 
+    def get_all_statuses(self) -> dict[str, dict[str, typing.Any]]:
+        """Get all statuses for the channel
+
+        Returns:
+            (dict[str, dict[str, typing.Any]]): A dictionary of all statuses for the channel
+        """
+        logger.info("Getting all children statuses for %s", self.channel_id)
+        children = self.get_children_channels()
+        logger.debug("Got %d children for %s", len(children), self.channel_id)
+
+        statuses = {}
+        for child in children:
+            tmp = {}
+            tmp["status"] = child.get_status()
+            tmp["wait_time"] = child.get_wait_time()
+            statuses[child.entity_id] = tmp
+
+        return statuses
+
     def get_children_attractions(self) -> list[AttractionFacilityStatusChild]:  # type: ignore
         """Get AttractionFacilityStatusChild Children of a Facility
 

mousetools-4.3.0/mousetools/channels/forecastedwaittimes/__init__.py

@@ -0,0 +1,71 @@
+import logging
+
+from dateutil.parser import isoparse
+
+from mousetools.channels import CouchbaseChannel, CouchbaseChildChannel
+from mousetools.channels.enums import CouchbaseChannels
+
+logger = logging.getLogger(__name__)
+
+
+class ForecastedWaitTimesChildChannel(CouchbaseChildChannel):
+    def __init__(
+        self,
+        channel_id: str,
+        lazy_load: bool = True,
+    ):
+        """
+        Args:
+            channel_id (str): Forecasted Wait Times Channel ID
+            lazy_load (bool, optional): If True, will not pull data until a method or property is called. Defaults to True.
+        """
+        super().__init__(channel_id, lazy_load=lazy_load)
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}(channel_id='{self.channel_id}')"
+
+    def get_forecast(self) -> list[dict]:
+        """Returns a list of forecasted wait times sorted by timestamp
+
+        Returns:
+            (list[dict]): A list of dictionaries. Each dictionary contains forecasted wait minutes, bar graph percentage, accessibility label, and timestamp
+        """
+        self.refresh()
+        try:
+            if "forecasts" not in self._cb_data:
+                return []
+
+            forecasts = []
+            for forecast in self._cb_data["forecasts"]:
+                tmp = {}
+                dt = isoparse(forecast["timestamp"])
+                dt = dt.astimezone(self._tz.value)
+                tmp["forecasted_wait_minutes"] = forecast["forecastedWaitMinutes"]
+                tmp["bar_graph_percentage"] = forecast["percentage"]
+                tmp["accessibility_label"] = forecast["accessibility12h"].split(" ", 1)[-1]
+                tmp["timestamp"] = dt
+                forecasts.append(tmp)
+
+            return sorted(forecasts, key=lambda i: i["timestamp"])
+
+        except (KeyError, TypeError, ValueError):
+            logger.debug("No forecast found for %s", self.channel_id)
+            return []
+
+
+class ForecastedWaitTimesChannel(CouchbaseChannel):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def get_children_channels(self) -> list[ForecastedWaitTimesChildChannel]:
+        """Gets a list of children channels for the channel.
+
+        Returns:
+            (list[ForecastedWaitTimesChildChannel]): A list of ForecastedWaitTimesChildChannel
+        """
+        self.refresh()
+        channels = []
+        for i in self._cb_data["results"]:
+            if CouchbaseChannels.FORECASTED_WAIT_TIMES in i["id"]:
+                channels.append(ForecastedWaitTimesChildChannel(i["id"]))
+        return channels

{mousetools-4.1.1 → mousetools-4.3.0}/mousetools/decorators.py

@@ -7,9 +7,10 @@ logger = logging.getLogger(__name__)
 T = TypeVar("T")
 
 
-def disney_property(refresh: bool = True, default_value: Optional[T] = None) -> Callable:
+def disney_property(
+    refresh: bool = True, default_value: Optional[T] = None
+) -> Callable[[Callable[[Any], Optional[T]]], property]:
     def decorator(func: Callable) -> property:
-        @property
         @functools.wraps(func)
         def wrapper(self) -> Optional[T]:
             if refresh:
@@ -19,7 +20,9 @@ def disney_property(refresh: bool = True, default_value: Optional[T] = None) ->
             except (KeyError, TypeError, ValueError):
                 return default_value
 
-        return wrapper
+        wrapper.__annotations__ = func.__annotations__
+        wrapper.__doc__ = func.__doc__
+        return property(wrapper)
 
     return decorator
 

{mousetools-4.1.1 → mousetools-4.3.0}/mousetools/mixins/couchbase.py

@@ -11,7 +11,7 @@ logger = logging.getLogger(__name__)
 
 
 class CouchbaseMixin:
-    _couchbase_url = "https://" + auth_obj._environments["syncGatewayUrl"].split("//")[1]
+    _couchbase_url = "https://" + auth_obj._environments["syncGatewayUrl"].split("//")[1].rstrip("/")
     _headers: dict = auth_obj.get_couchbase_headers()
 
     def get_channel_data(self, channel_name: str) -> typing.Union[dict, None]:

{mousetools-4.1.1 → mousetools-4.3.0}/mousetools.egg-info/PKG-INFO

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

{mousetools-4.1.1 → mousetools-4.3.0}/mousetools.egg-info/SOURCES.txt

@@ -16,9 +16,11 @@ mousetools/api/search.py
 mousetools/channels/__init__.py
 mousetools/channels/enums.py
 mousetools/channels/calendar/__init__.py
+mousetools/channels/characters/__init__.py
 mousetools/channels/facilities/__init__.py
 mousetools/channels/facilities/enums.py
 mousetools/channels/facilitystatus/__init__.py
+mousetools/channels/forecastedwaittimes/__init__.py
 mousetools/mixins/__init__.py
 mousetools/mixins/couchbase.py
 mousetools/mixins/disney.py

{mousetools-4.1.1 → mousetools-4.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mousetools"
-version = "4.1.1"
+version = "4.3.0"
 authors = [{name = "Scott Caratozzolo"}]
 description = "An unofficial Python wrapper for Disney's API"
 readme = "README.md"
@@ -42,6 +42,7 @@ dev-dependencies = [
     "go-task-bin>=3.43.3",
     "icecream>=2.1.4",
     "pytest-mock>=3.14.0",
+    "pytest-httpx>=0.35.0",
 ]
 
 [build-system]