MouseTools 3.0.0.dev1__py3-none-any.whl → 3.0.0.dev2__py3-none-any.whl

mousetools/entities/base.py

@@ -1,22 +1,30 @@
 import logging
 import typing
-from datetime import datetime
+from datetime import datetime, time
 from zoneinfo import ZoneInfo
+
+from mousetools.exceptions import AncestorDestinationMissingError
+from mousetools.ids import DestinationIds, FacilityServiceEntityTypes
 from mousetools.mixins.disney import DisneyAPIMixin
 from mousetools.mixins.themeparksapi import ThemeParkAPIMixin
-from mousetools.ids import DestinationIds
-from mousetools.urls import ENTITY_DETAILS_SIMPLE_BASE_URL
-from mousetools.exceptions import AncestorDestinationMissing
-
+from mousetools.urls import WDPRO_FACILITY_SERVICE_BASE_URL
 
 logger = logging.getLogger(__name__)
 
 
-class Entity(DisneyAPIMixin, ThemeParkAPIMixin):
-    def __init__(self, id: str):
-        self.id: str = id
+class EntityBase(DisneyAPIMixin, ThemeParkAPIMixin):
+    def __init__(
+        self,
+        entity_id: str,
+        facility_service_entity_type: typing.Union[str, FacilityServiceEntityTypes],
+    ):
+        self.entity_id: str = entity_id
         self.disney_data: typing.Optional[dict] = None
 
+        if isinstance(facility_service_entity_type, FacilityServiceEntityTypes):
+            facility_service_entity_type = facility_service_entity_type.value
+        self.__facility_service_url = f"{WDPRO_FACILITY_SERVICE_BASE_URL}/{facility_service_entity_type}/{self.entity_id}"
+
     @property
     def name(self) -> typing.Optional[str]:
         """
@@ -27,11 +35,11 @@ class Entity(DisneyAPIMixin, ThemeParkAPIMixin):
         """
 
         if self.disney_data is None:
-            self.disney_data = self.get_disney_data()
+            self.disney_data = self.get_disney_data(self.__facility_service_url)
         try:
             return self.disney_data["name"]
         except KeyError:
-            logger.debug("No name found for %s", self.id)
+            logger.debug("No name found for %s", self.entity_id)
             return None
 
     @property
@@ -44,27 +52,27 @@ class Entity(DisneyAPIMixin, ThemeParkAPIMixin):
         """
 
         if self.disney_data is None:
-            self.disney_data = self.get_disney_data()
+            self.disney_data = self.get_disney_data(self.__facility_service_url)
         try:
-            return self.disney_data["entityType"]
+            return self.disney_data["type"]
         except KeyError:
-            logger.debug("No entity type found for %s", self.id)
+            logger.debug("No entity type found for %s", self.entity_id)
             return None
 
     @property
-    def entity_type_name(self) -> typing.Optional[str]:
+    def sub_type(self) -> typing.Optional[str]:
         """
-        The name of the type of entity.
+        The sub type of entity.
 
         Returns:
-            (typing.Optional[str]): The name of the type of entity, or None if it was not found.
+            (typing.Optional[str]): The sub type of entity, or None if it was not found.
         """
         if self.disney_data is None:
-            self.disney_data = self.get_disney_data()
+            self.disney_data = self.get_disney_data(self.__facility_service_url)
         try:
-            return self.disney_data["entityTypeName"]
+            return self.disney_data["subType"]
         except KeyError:
-            logger.debug("No entity type name found for %s", self.id)
+            logger.debug("No sub type found for %s", self.entity_id)
             return None
 
     @property
@@ -76,14 +84,12 @@ class Entity(DisneyAPIMixin, ThemeParkAPIMixin):
             (typing.Optional[str]): The url friendly id of the entity, or None if not found.
         """
         if self.disney_data is None:
-            self.disney_data = self.get_disney_data()
+            self.disney_data = self.get_disney_data(self.__facility_service_url)
         try:
-            id = self.disney_data["urlFriendlyId"]
-            # for some reason pirates in wdw has a -wdw and its wrong
-            id = id.replace("-wdw", "").replace("-dlr", "")
-            return id
+            _id = self.disney_data["urlFriendlyId"]
+            return _id
         except KeyError:
-            logger.debug("No url friendly id found for %s", self.id)
+            logger.debug("No url friendly id found for %s", self.entity_id)
             return None
 
     @property
@@ -95,146 +101,193 @@ class Entity(DisneyAPIMixin, ThemeParkAPIMixin):
             (typing.Optional[dict[str, float]]): A dict with "lat" and "lng" keys containing the coordinates of this entity as floats, or None if no coordinates are found
         """
         if self.disney_data is None:
-            self.disney_data = self.get_disney_data()
+            self.disney_data = self.get_disney_data(self.__facility_service_url)
         try:
             return {
-                "lat": float(self.disney_data["marker"]["lat"]),
-                "lng": float(self.disney_data["marker"]["lng"]),
+                "lat": float(
+                    self.disney_data["coordinates"]["Guest Entrance"]["gps"][
+                        "lattitude"
+                    ]
+                ),
+                "lng": float(
+                    self.disney_data["coordinates"]["Guest entrance"]["gps"][
+                        "longitude"
+                    ]
+                ),
             }
         except KeyError:
-            logger.debug("No coordinates found for %s", self.id)
+            logger.debug("No coordinates found for %s", self.entity_id)
             return None
 
     @property
-    def ancestor_destination_id(self) -> typing.Optional[str]:
+    def ancestor_destination_id(self) -> typing.Optional[str]:  # type: ignore
         """
         The id of the ancestor destination of this entity.
 
         Returns:
             (typing.Optional[str]): The id of the ancestor destination of this entity, or None if it was not found.
         """
-
+        # TODO check other ancestors to guess dest if not found
         if self.disney_data is None:
-            self.disney_data = self.get_disney_data()
+            self.disney_data = self.get_disney_data(self.__facility_service_url)
         try:
-            return self._ancestor_destination_id
+            return (
+                self.disney_data["links"]["ancestorDestination"]["href"]
+                .split("?")[0]
+                .split("/")[-1]
+            )
         except KeyError:
-            logger.debug("No ancestor destination id found for %s", self.id)
-            return None
+            try:
+                return (
+                    self.disney_data["ancestorDestination"]["id"]
+                    .split("?")[0]
+                    .split("/")[-1]
+                )
+            except KeyError:
+                logger.debug("No ancestor destination id found for %s", self.entity_id)
+                return None
 
-    @ancestor_destination_id.setter
-    def ancestor_destination_id(self, value: typing.Optional[str]):
+    @property
+    def ancestor_theme_park_id(self):
         """
-        Set the ancestor destination id
+        The id of the theme park of this entity.
 
-        Required for ThemeParkAPIMixin
-
-        Args:
-            value (typing.Optional[str]): Str to set ancestor_destination_id to
+        Returns:
+            (typing.Optional[str]): Theme park id, or None if no such id is found.
         """
-        self.ancestor_destination_id = value
+        if self.disney_data is None:
+            self.disney_data = self.get_disney_data(self.__facility_service_url)
+        try:
+            return (
+                self.disney_data["links"]["ancestorThemePark"]["href"]
+                .split("?")[0]
+                .split("/")[-1]
+            )
+        except KeyError:
+            logger.debug("No ancestor theme park id found for %s", self.entity_id)
+            return None
 
     @property
-    def ancestor_park_ids(self) -> typing.Optional[list[str]]:
+    def ancestor_water_park_id(self) -> typing.Optional[str]:
         """
-        The ids of parks that are ancestors of this entity.
+        The if of the water park of this entity.
 
         Returns:
-            (typing.Optional[list[str]]): A list of park ids that are ancestors of this entity, or None if no such ids are found.
+            (typing.Optional[str]): Water park id, or None if no such id is found.
         """
         if self.disney_data is None:
-            self.disney_data = self.get_disney_data()
+            self.disney_data = self.get_disney_data(self.__facility_service_url)
         try:
-            return [
-                i
-                for i in self.disney_data["parkIds"]
-                if any(j in i for j in ["theme-park", "water-park"])
-            ]
+            return (
+                self.disney_data["links"]["ancestorWaterPark"]["href"]
+                .split("?")[0]
+                .split("/")[-1]
+            )
         except KeyError:
-            logger.debug("No ancestor park ids found for %s", self.id)
+            logger.debug("No ancestor water park id found for %s", self.entity_id)
             return None
 
     @property
-    def ancestor_resort_ids(self) -> typing.Optional[list[str]]:
+    def ancestor_resort_id(self) -> typing.Optional[str]:
         """
-        The ids of resorts that are ancestors of this entity.
+        The id of the resort of the entity.
 
         Returns:
-            (typing.Optional[list[str]]): A list of resort ids that are ancestors of this entity, or None if no such ids are found.
+            (typing.Optional[str): Resort id, or None if no such id is found.
         """
 
         if self.disney_data is None:
-            self.disney_data = self.get_disney_data()
+            self.disney_data = self.get_disney_data(self.__facility_service_url)
         try:
-            return [i for i in self.disney_data["parkIds"] if "resort" in i]
+            return (
+                self.disney_data["links"]["ancestorResort"]["href"]
+                .split("?")[0]
+                .split("/")[-1]
+            )
         except KeyError:
-            logger.debug("No ancestor resort ids found for %s", self.id)
+            logger.debug("No ancestor resort ids found for %s", self.entity_id)
             return None
 
     @property
     def ancestor_land_id(self) -> typing.Optional[str]:
         """
-        The id of the land that is an ancestor of this entity.
+        The if of the land of this entity.
 
         Returns:
-            (typing.Optional[str]): The id of the land that is an ancestor of this entity, or None if no such id is found.
+            (typing.Optional[str]): Land id, or None if no such id is found.
         """
         if self.disney_data is None:
-            self.disney_data = self.get_disney_data()
+            self.disney_data = self.get_disney_data(self.__facility_service_url)
         try:
-            return self.disney_data["landId"]
+            return (
+                self.disney_data["links"]["ancestorLand"]["href"]
+                .split("?")[0]
+                .split("/")[-1]
+            )
         except KeyError:
-            logger.debug("No ancestor land id found for %s", self.id)
+            logger.debug("No ancestor land id found for %s", self.entity_id)
             return None
 
     @property
-    def ancestor_resort_area_ids(self) -> typing.Optional[list[str]]:
+    def ancestor_resort_area_id(self) -> typing.Optional[str]:
         """
-        The ids of resort areas that are ancestors of this entity.
+        The id of the resort area of this entity.
 
         Returns:
-            (typing.Optional[list[str]]): A list of resort area ids that are ancestors of this entity, or None if no such ids are found.
+            (typing.Optional[str]): Resort area id, or None if no such id is found.
         """
         if self.disney_data is None:
-            self.disney_data = self.get_disney_data()
+            self.disney_data = self.get_disney_data(self.__facility_service_url)
         try:
-            return [i for i in self.disney_data["parkIds"] if "resort-area" in i]
+            return (
+                self.disney_data["links"]["ancestorResortArea"]["href"]
+                .split("?")[0]
+                .split("/")[-1]
+            )
         except KeyError:
-            logger.debug("No ancestor resort area ids found for %s", self.id)
+            logger.debug("No ancestor resort area ids found for %s", self.entity_id)
             return None
 
     @property
-    def ancestor_entertainment_venue_ids(self) -> typing.Optional[list[str]]:
+    def ancestor_entertainment_venue_id(self) -> typing.Optional[str]:
         """
-        The ids of entertainment venues that are ancestors of this entity.
+        The id of entertainment venues of this entity.
 
         Returns:
-            (typing.Optional[list[str]]): A list of entertainment venue ids that are ancestors of this entity, or None if no such ids are found.
+            (typing.Optional[str]): Entertainment venue id, or None if no such id is found.
         """
         if self.disney_data is None:
-            self.disney_data = self.get_disney_data()
+            self.disney_data = self.get_disney_data(self.__facility_service_url)
         try:
-            return [
-                i for i in self.disney_data["parkIds"] if "Entertainment-Venue" in i
-            ]
+            return (
+                self.disney_data["links"]["ancestorEntertainmentVenue"]["href"]
+                .split("?")[0]
+                .split("/")[-1]
+            )
         except KeyError:
-            logger.debug("No ancestor entertainment venue ids found for %s", self.id)
+            logger.debug(
+                "No ancestor entertainment venue ids found for %s", self.entity_id
+            )
             return None
 
     @property
-    def ancestor_restaurant_ids(self) -> typing.Optional[list[str]]:
+    def ancestor_restaurant_id(self) -> typing.Optional[str]:
         """
-        The ids of restaurants that are ancestors of this entity.
+        The id of the restaurant of this entity.
 
         Returns:
-            (typing.Optional[list[str]]): A list of restaurant ids that are ancestors of this entity, or None if no such ids are found.
+            (typing.Optional[str]): Restaurant id, or None if no such id is found.
         """
         if self.disney_data is None:
-            self.disney_data = self.get_disney_data()
+            self.disney_data = self.get_disney_data(self.__facility_service_url)
         try:
-            return [i["id"] for i in self.disney_data["restaurants"]]
+            return (
+                self.disney_data["links"]["ancestorRestaurant"]["href"]
+                .split("?")[0]
+                .split("/")[-1]
+            )
         except KeyError:
-            logger.debug("No ancestor restaurant ids found for %s", self.id)
+            logger.debug("No ancestor restaurant ids found for %s", self.entity_id)
             return None
 
     @property
@@ -246,78 +299,98 @@ class Entity(DisneyAPIMixin, ThemeParkAPIMixin):
             (ZoneInfo): The time zone of the entity.
         """
 
-        if self.ancestor_destination_id == DestinationIds.WALT_DISNEY_WORLD:
+        if self.ancestor_destination_id is None:
+            return ZoneInfo("UTC")
+        if self.ancestor_destination_id in DestinationIds.WALT_DISNEY_WORLD.value:
             return ZoneInfo("America/New_York")
-        elif self.ancestor_destination_id == DestinationIds.DISNEYLAND_RESORT:
+        elif self.ancestor_destination_id in DestinationIds.DISNEYLAND_RESORT.value:
             return ZoneInfo("America/Los_Angeles")
-        else:
-            return ZoneInfo("UTC")
 
-    def details_simple_url(self) -> str:
+        return ZoneInfo("UTC")
+
+    @property
+    def related_location_ids(self) -> typing.List[str]:
         """
-        Gets the simple details url for this entity
+        The ids of the related locations of this entity.
 
         Returns:
-            (str): The simple details url
-
-        Raises:
-            AncestorDestinationMissing: If the ancestor destination id is not
-                either Walt Disney World or Disneyland Resort
+            (typing.List[str]): The ids of the related locations of this entity.
         """
-        if self.ancestor_destination_id == DestinationIds.WALT_DISNEY_WORLD:
-            dest_url_friendly_id = "wdw"
-        elif self.ancestor_destination_id == DestinationIds.DISNEYLAND_RESORT:
-            dest_url_friendly_id = "dlr"
-        else:
-            raise AncestorDestinationMissing
-        return f"{ENTITY_DETAILS_SIMPLE_BASE_URL}/{dest_url_friendly_id}/{self.url_friendly_id}/{datetime.now().strftime('%Y-%m-%d')}"
+        # https://api.wdprapps.disney.com/facility-service/entertainments/19322758
+        raise NotImplementedError
 
-    def status(self) -> typing.Optional[str]:
+    @property
+    def duration(self) -> typing.Optional[time]:
+        if self.disney_data is None:
+            self.disney_data = self.get_disney_data(self.__facility_service_url)
+        try:
+            return time.fromisoformat(
+                ":".join(self.disney_data["duration"].split(":")[:3])
+            )
+        except KeyError:
+            logger.debug("No duration found for %s", self.entity_id)
+            return None
+
+    def get_status(self) -> typing.Optional[str]:
         """
         The current status of the entity.
 
         Returns:
             (typing.Optional[str]): The current status of the entity, or None if no such data exists.
         """
+        try:
+            live_data = self.get_entity_live_tp()
+        except AncestorDestinationMissingError:
+            return None
 
-        live_data = self.get_entity_live_tp()
         try:
             return live_data["liveData"][0]["status"]
         except (KeyError, IndexError):
-            logger.debug("No status found for %s", self.id)
+            logger.debug("No status found for %s", self.entity_id)
             return None
 
-    def wait_time(self) -> typing.Optional[int]:
+    def get_wait_time(self) -> typing.Optional[int]:
         """
         The current wait time for the entity.
 
         Returns:
             (typing.Optional[int]): The current wait time for the entity, or None if no such data exists.
         """
-        live_data = self.get_entity_live_tp()
+        try:
+            live_data = self.get_entity_live_tp()
+        except AncestorDestinationMissingError:
+            return None
+
         try:
             return live_data["liveData"][0]["queue"]["STANDBY"]["waitTime"]
         except (KeyError, IndexError):
-            logger.debug("No wait time found for %s", self.id)
+            logger.debug("No wait time found for %s", self.entity_id)
             return None
 
-    def last_updated(self) -> typing.Optional[datetime]:
+    def get_last_updated(self) -> typing.Optional[datetime]:
         """
-        The last time the entity's data was updated.
+        The last time the entity's data was updated on ThemePark.wiki.
 
         Returns:
             (typing.Optional[datetime]): The last time the entity's data was updated, or None if no such data exists.
         """
-        live_data = self.get_entity_live_tp()
+        try:
+            live_data = self.get_entity_live_tp()
+        except AncestorDestinationMissingError:
+            return None
+
         try:
             return datetime.strptime(
-                live_data["liveData"][0]["lastUpdated"], "%Y-%m-%dT%H:%M:%SZ"
+                live_data["liveData"][0]["lastUpdated"],
+                "%Y-%m-%dT%H:%M:%SZ",
             ).replace(tzinfo=ZoneInfo("UTC"))
         except (KeyError, IndexError):
-            logger.debug("No last updated found for %s", self.id)
+            logger.debug("No last updated found for %s", self.entity_id)
             return None
 
-    def today_operating_hours(self) -> typing.Optional[dict[str, dict[str, datetime]]]:
+    def get_today_operating_hours(
+        self,
+    ) -> typing.Optional[dict[str, dict[str, datetime]]]:
         """
         The operating hours for today for the entity.
 
@@ -325,57 +398,90 @@ class Entity(DisneyAPIMixin, ThemeParkAPIMixin):
             (typing.Optional[dict[str, dict[str, datetime]]]): A dictionary of the operating hours for today, or None if no such data exists.
         """
 
-        live_data = self.get_entity_live_tp()
+        try:
+            live_data = self.get_entity_live_tp()
+        except AncestorDestinationMissingError:
+            return None
+
         temp = {}
 
         try:
             for i in live_data["liveData"][0]["operatingHours"]:
                 temp[i["type"]] = {
                     "start_time": datetime.strptime(
-                        i["startTime"], "%Y-%m-%dT%H:%M:%S%z"
+                        i["startTime"],
+                        "%Y-%m-%dT%H:%M:%S%z",
                     ).replace(tzinfo=self.time_zone),
                     "end_time": datetime.strptime(
-                        i["endTime"], "%Y-%m-%dT%H:%M:%S%z"
+                        i["endTime"],
+                        "%Y-%m-%dT%H:%M:%S%z",
                     ).replace(tzinfo=self.time_zone),
                 }
         except (KeyError, IndexError):
-            logger.debug("No operating hours found for %s", self.id)
+            logger.debug("No operating hours found for %s", self.entity_id)
             return None
 
         return temp
 
-    def today_showtimes(self) -> typing.Optional[list[datetime]]:
+    def get_today_showtimes(self) -> typing.Optional[list[datetime]]:
         """
         The showtimes for today for the entity.
 
         Returns:
             (typing.Optional[list[datetime]]): A list of the showtimes for today, or None if no such data exists.
         """
-        live_data = self.get_entity_live_tp()
+        try:
+            live_data = self.get_entity_live_tp()
+        except AncestorDestinationMissingError:
+            return None
+
         temp = []
 
         try:
             for i in live_data["liveData"][0]["showtimes"]:
                 temp.append(
                     datetime.strptime(i["startTime"], "%Y-%m-%dT%H:%M:%S%z").replace(
-                        tzinfo=self.time_zone
-                    )
+                        tzinfo=self.time_zone,
+                    ),
                 )
         except (KeyError, IndexError):
-            logger.debug("No showtimes found for %s", self.id)
+            logger.debug("No showtimes found for %s", self.entity_id)
             return None
 
         return temp
 
+    def get_children_entity_ids(
+        self, entity_type: typing.Union[str, FacilityServiceEntityTypes]
+    ) -> list[str]:
+        """
+        Get the children entity IDs for the given entity type.
+
+        Args:
+            entity_type (typing.Union[str, FacilityServiceEntityTypes]): The type of entity to get children for.
+
+        Returns:
+            (list[str]): A list of the children entity IDs, or an empty list if no such data exists
+        """
+        if isinstance(entity_type, FacilityServiceEntityTypes):
+            entity_type = entity_type.value
+
+        children_url = f"{self.__facility_service_url}/{entity_type}"
+        data = self.get_disney_data(children_url)
+        if data:
+            return [
+                i["links"]["self"]["href"].split("?")[0].split("/")[-1]
+                for i in data["entries"]
+            ]
+
+        return []
+
     def __str__(self) -> str:
-        return f"{self.entity_type}: {self.name} ({self.id})"
+        return f"{self.entity_type}: {self.name} ({self.entity_id})"
 
     def __repr__(self) -> str:
-        return f"Entity(id='{self.id}')"
+        return f"{self.__class__.__name__}(entity_id='{self.entity_id}')"
 
     def __eq__(self, other) -> bool:
-        if isinstance(other, Entity):
-            return self.id == other.id
+        if isinstance(other, EntityBase):
+            return self.entity_id == other.entity_id
         return False
-
-    # TODO virtual queue

mousetools/entities/character.py

@@ -0,0 +1,12 @@
+from mousetools.entities.base import EntityBase
+from mousetools.ids import FacilityServiceEntityTypes
+
+
+class Character(EntityBase):
+    """Class for Character Entities."""
+
+    def __init__(self, entity_id: str):
+        super().__init__(
+            entity_id=entity_id,
+            facility_service_entity_type=FacilityServiceEntityTypes.CHARACTERS,
+        )

mousetools/entities/destination.py

@@ -1,8 +1,16 @@
-from mousetools.entities.base import Entity
+import typing
 
+from mousetools.entities.base import EntityBase
+from mousetools.ids import DestinationIds, FacilityServiceEntityTypes
 
-class Destination(Entity):
+
+class Destination(EntityBase):
     """Class for Destination Entities."""
 
-    def __repr__(self) -> str:
-        return f"Destination(id='{self.id}')"
+    def __init__(self, entity_id: typing.Union[str, DestinationIds]):
+        if isinstance(entity_id, DestinationIds):
+            entity_id = entity_id.value
+        super().__init__(
+            entity_id=entity_id,
+            facility_service_entity_type=FacilityServiceEntityTypes.DESTINATIONS,
+        )

mousetools/entities/dining_event.py

@@ -1,15 +1,12 @@
-from mousetools.entities.base import Entity
+from mousetools.entities.base import EntityBase
+from mousetools.ids import FacilityServiceEntityTypes
 
 
-class DiningEvent(Entity):
+class DiningEvent(EntityBase):
     """Class for DiningEvent Entities."""
 
-    def __repr__(self) -> str:
-        return f"DiningEvent(id='{self.id}')"
-
-
-class DinnerShow(Entity):
-    """Class for DiningEvent Entities."""
-
-    def __repr__(self) -> str:
-        return f"DinnerShow(id='{self.id}')"
+    def __init__(self, entity_id: str):
+        super().__init__(
+            entity_id=entity_id,
+            facility_service_entity_type=FacilityServiceEntityTypes.DINING_EVENTS,
+        )

mousetools/entities/dinner_show.py

@@ -0,0 +1,12 @@
+from mousetools.entities.base import EntityBase
+from mousetools.ids import FacilityServiceEntityTypes
+
+
+class DinnerShow(EntityBase):
+    """Class for DiningEvent Entities."""
+
+    def __init__(self, entity_id: str):
+        super().__init__(
+            entity_id=entity_id,
+            facility_service_entity_type=FacilityServiceEntityTypes.DINNER_SHOWS,
+        )