pynintendoparental 2.1.3__tar.gz → 2.2.0__tar.gz

{pynintendoparental-2.1.3 → pynintendoparental-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pynintendoparental
-Version: 2.1.3
+Version: 2.2.0
 Summary: A Python module to interact with Nintendo Parental Controls
 Home-page: http://github.com/pantherale0/pynintendoparental
 Author: pantherale0
@@ -23,7 +23,7 @@ Requires-Dist: isort<7,>=5; extra == "dev"
 Requires-Dist: mypy<1.20,>=1.5; extra == "dev"
 Requires-Dist: pytest<9,>=7; extra == "dev"
 Requires-Dist: pytest-cov<8,>=4; extra == "dev"
-Requires-Dist: pytest-asyncio<1.0,>=0.21; extra == "dev"
+Requires-Dist: pytest-asyncio<2.0,>=0.21; extra == "dev"
 Requires-Dist: syrupy<6,>=5; extra == "dev"
 Requires-Dist: twine<7,>=4; extra == "dev"
 Dynamic: author

pynintendoparental-2.2.0/pynintendoparental/_version.py

@@ -0,0 +1 @@
+__version__ = "2.2.0"

{pynintendoparental-2.1.3 → pynintendoparental-2.2.0}/pynintendoparental/api.py

@@ -147,14 +147,26 @@ class Api:
             MONTH=f"{month:02d}",
         )
 
-    async def async_update_restriction_level(self, settings: dict) -> dict:
+    async def async_update_restriction_level(
+        self, device_id: str, parental_control_setting: dict
+    ) -> dict:
         """Update device restriction level."""
+        settings = {
+            "deviceId": device_id,
+            **parental_control_setting,
+        }
         return await self.send_request(
             endpoint="update_restriction_level", body=settings
         )
 
-    async def async_update_play_timer(self, settings: dict) -> dict:
+    async def async_update_play_timer(
+        self, device_id: str, play_timer_regulations: dict
+    ) -> dict:
         """Update device play timer settings."""
+        settings = {
+            "deviceId": device_id,
+            "playTimerRegulations": play_timer_regulations,
+        }
         return await self.send_request(endpoint="update_play_timer", body=settings)
 
     async def async_update_unlock_code(self, new_code: str, device_id: str) -> dict:

pynintendoparental-2.2.0/pynintendoparental/application.py

@@ -0,0 +1,132 @@
+"""A Nintendo application."""
+
+import copy
+from datetime import datetime
+from typing import Callable, TYPE_CHECKING
+
+from .api import Api
+from .const import _LOGGER
+from .enum import SafeLaunchSetting
+from .utils import is_awaitable
+
+if TYPE_CHECKING:
+    from .device import Device
+
+
+class Application:
+    """Model for an application"""
+
+    def __init__(
+        self,
+        app_id: str,
+        name: str,
+        device_id: str,
+        api: Api,
+        send_api_update: Callable,
+        callbacks: list,
+    ) -> None:
+        """Initialise a application."""
+        self.application_id: str = app_id
+        self._device_id: str = device_id
+        self._api: Api = api
+        self._send_api_update: Callable = send_api_update
+        self.first_played_date: datetime = None
+        self.has_ugc: bool = None
+        self.image_url: str = None  # uses small image from Nintendo
+        self.playing_days: int = None
+        self.shop_url: str = None
+        self.name: str = name
+        self.safe_launch_setting: SafeLaunchSetting = SafeLaunchSetting.NONE
+        self.today_time_played: int = 0
+        self._callbacks: list[Callable] = []
+        self._parental_control_settings: dict = {}
+        self._monthly_summary: dict = {}
+        self._daily_summary: dict = {}
+        self._device: "Device" | None = None
+
+        # Register internal callbacks
+        callbacks.append(self._internal_update_callback)
+
+    async def set_safe_launch_setting(self, safe_launch_setting: SafeLaunchSetting):
+        """Set the safe launch setting for the application."""
+        if (
+            not self._device
+            or "whitelistedApplicationList" not in self._parental_control_settings
+        ):
+            raise ValueError("Unable to set SafeLaunchSetting, callbacks not executed.")
+        # Update the application safe_launch_setting in the PCS
+        pcs = copy.deepcopy(self._parental_control_settings)
+        for app in pcs["whitelistedApplicationList"]:
+            if app["applicationId"].upper() == self.application_id.upper():
+                app["safeLaunch"] = str(safe_launch_setting)
+                break
+        else:
+            raise LookupError(
+                "Unable to set SafeLaunchSetting, application no longer in whitelist."
+            )
+
+        await self._send_api_update(
+            self._api.async_update_restriction_level,
+            self._device_id,
+            pcs,
+            now=datetime.now(),
+        )
+
+    async def _internal_update_callback(self, device: "Device"):
+        """Internal update callback method for the Device object to inform this Application has been updated."""
+        if not device:
+            return
+        _LOGGER.debug(
+            "Internal callback started for app %s - device %s",
+            self.application_id,
+            device.device_id,
+        )
+        self._device = device
+        self._device_id = device.device_id
+        self._parental_control_settings = device.parental_control_settings
+        self._monthly_summary = device.last_month_summary
+        self._daily_summary = device.daily_summaries
+        if "whitelistedApplicationList" not in self._parental_control_settings:
+            _LOGGER.warning(
+                ">> Device %s is missing a application whitelist, unable to update safe launch settings for %s",
+                device.device_id,
+                self.application_id,
+            )
+        for app in self._parental_control_settings.get(
+            "whitelistedApplicationList", []
+        ):
+            if app["applicationId"].upper() == self.application_id.upper():
+                self.safe_launch_setting = SafeLaunchSetting(
+                    app.get("safeLaunch", "NONE")
+                )
+                self.image_url = app["imageUri"]
+                break
+        total_time_played: int = 0
+        if self._daily_summary:
+            for player_summary in self._daily_summary[0].get("players", []):
+                for player_app in player_summary.get("playedGames", []):
+                    if (
+                        player_app["meta"]["applicationId"].upper()
+                        == self.application_id.upper()
+                    ):
+                        total_time_played += player_app["playingTime"]
+                        break
+        self.today_time_played = total_time_played
+
+        for cb in self._callbacks:
+            if is_awaitable(cb):
+                await cb(self)
+            else:
+                cb(self)
+
+    def add_application_callback(self, callback):
+        """Add a callback to the application."""
+        if not callable(callback):
+            raise ValueError("Object must be callable.")
+        self._callbacks.append(callback)
+
+    def remove_application_callback(self, callback):
+        """Remove a callback from the application."""
+        if callback not in self._callbacks:
+            raise ValueError("Callback not found.")
+        self._callbacks.remove(callback)

{pynintendoparental-2.1.3 → pynintendoparental-2.2.0}/pynintendoparental/const.py

@@ -6,13 +6,13 @@ import logging
 _LOGGER = logging.getLogger(__package__)
 CLIENT_ID = "54789befb391a838"
 MOBILE_APP_PKG = "com.nintendo.znma"
-MOBILE_APP_VERSION = "2.3.0"
-MOBILE_APP_BUILD = "600"
+MOBILE_APP_VERSION = "2.3.1"
+MOBILE_APP_BUILD = "620"
 OS_NAME = "ANDROID"
 OS_VERSION = "34"
 OS_STR = f"{OS_NAME} {OS_VERSION}"
 DEVICE_MODEL = "Pixel 4 XL"
-BASE_URL = "https://app.lp1.znma.srv.nintendo.net/v2"
+BASE_URL = "https://app.lp1.znma.srv.nintendo.net"
 USER_AGENT = f"moon_ANDROID/{MOBILE_APP_VERSION} ({MOBILE_APP_PKG}; build:{MOBILE_APP_BUILD}; {OS_STR})"
 
 DAYS_OF_WEEK = [
@@ -27,43 +27,43 @@ DAYS_OF_WEEK = [
 
 ENDPOINTS = {
     "get_account_devices": {
-        "url": "{BASE_URL}/actions/user/fetchOwnedDevices",
+        "url": "{BASE_URL}/v2/actions/user/fetchOwnedDevices",
         "method": "GET",
     },
     "get_account_device": {
-        "url": "{BASE_URL}/actions/user/fetchOwnedDevice?deviceId={DEVICE_ID}",
+        "url": "{BASE_URL}/v2/actions/user/fetchOwnedDevice?deviceId={DEVICE_ID}",
         "method": "GET",
     },
     "get_device_daily_summaries": {
-        "url": "{BASE_URL}/actions/playSummary/fetchDailySummaries?deviceId={DEVICE_ID}",
+        "url": "{BASE_URL}/v2/actions/playSummary/fetchDailySummaries?deviceId={DEVICE_ID}",
         "method": "GET",
     },
     "get_device_monthly_summaries": {
-        "url": "{BASE_URL}/actions/playSummary/fetchLatestMonthlySummary?deviceId={DEVICE_ID}",
+        "url": "{BASE_URL}/v2/actions/playSummary/fetchLatestMonthlySummary?deviceId={DEVICE_ID}",
         "method": "GET",
     },
     "get_device_parental_control_setting": {
-        "url": "{BASE_URL}/actions/parentalControlSetting/fetchParentalControlSetting?deviceId={DEVICE_ID}",
+        "url": "{BASE_URL}/v2/actions/parentalControlSetting/fetchParentalControlSetting?deviceId={DEVICE_ID}",
         "method": "GET",
     },
     "update_restriction_level": {
-        "url": "{BASE_URL}/actions/parentalControlSetting/updateRestrictionLevel",
+        "url": "{BASE_URL}/v2/actions/parentalControlSetting/updateRestrictionLevel",
         "method": "POST",
     },
     "update_play_timer": {
-        "url": "{BASE_URL}/actions/parentalControlSetting/updatePlayTimer",
+        "url": "{BASE_URL}/v3/actions/parentalControlSetting/updatePlayTimer",
         "method": "POST",
     },
     "update_unlock_code": {
-        "url": "{BASE_URL}/actions/parentalControlSetting/updateUnlockCode",
+        "url": "{BASE_URL}/v2/actions/parentalControlSetting/updateUnlockCode",
         "method": "POST",
     },
     "get_device_monthly_summary": {
-        "url": "{BASE_URL}/actions/playSummary/fetchMonthlySummary?deviceId={DEVICE_ID}&year={YEAR}&month={MONTH}&containLatest=false",
+        "url": "{BASE_URL}/v2/actions/playSummary/fetchMonthlySummary?deviceId={DEVICE_ID}&year={YEAR}&month={MONTH}&containLatest=false",
         "method": "GET",
     },
     "update_extra_playing_time": {
-        "url": "{BASE_URL}/actions/device/updateExtraPlayingTime",
+        "url": "{BASE_URL}/v2/actions/device/updateExtraPlayingTime",
         "method": "POST",
     },
 }

{pynintendoparental-2.1.3 → pynintendoparental-2.2.0}/pynintendoparental/device.py

@@ -13,8 +13,14 @@ from .const import _LOGGER, DAYS_OF_WEEK
 from .exceptions import (
     BedtimeOutOfRangeError,
     DailyPlaytimeOutOfRangeError,
+    InvalidDeviceStateError,
+)
+from .enum import (
+    AlarmSettingState,
+    DeviceTimerMode,
+    FunctionalRestrictionLevel,
+    RestrictionMode,
 )
-from .enum import AlarmSettingState, DeviceTimerMode, RestrictionMode
 from .player import Player
 from .utils import is_awaitable
 from .application import Application
@@ -39,6 +45,7 @@ class Device:
         self.today_playing_time: int | float = 0
         self.today_time_remaining: int | float = 0
         self.bedtime_alarm: time | None = None
+        self.bedtime_end: time | None = None
         self.month_playing_time: int | float = 0
         self.today_disabled_time: int | float = 0
         self.today_exceeded_time: int | float = 0
@@ -46,14 +53,14 @@ class Device:
         self.today_important_info: list = []
         self.today_observations: list = []
         self.last_month_summary: dict = {}
-        self.applications: list[Application] = []
+        self.applications: dict[str, Application] = {}
         self.whitelisted_applications: dict[str, bool] = {}
         self.last_month_playing_time: int = 0
         self.forced_termination_mode: bool = False
         self.alarms_enabled: bool = False
         self.stats_update_failed: bool = False
-        self.application_update_failed: bool = False
         self._callbacks: list[Callable] = []
+        self._internal_callbacks: list[Callable] = []
         _LOGGER.debug("Device init complete for %s", self.device_id)
 
     @property
@@ -86,6 +93,7 @@ class Device:
         )
         for player in self.players.values():
             player.update_from_daily_summary(self.daily_summaries)
+        self._update_applications()
         await self._execute_callbacks()
 
     def add_device_callback(self, callback):
@@ -104,6 +112,12 @@ class Device:
 
     async def _execute_callbacks(self):
         """Execute all callbacks."""
+        for cb in self._internal_callbacks:
+            if is_awaitable(cb):
+                await cb(device=self)
+            else:
+                cb(device=self)
+
         for cb in self._callbacks:
             if is_awaitable(cb):
                 await cb()
@@ -139,12 +153,8 @@ class Device:
             mode
         )
         response = await self._api.async_update_play_timer(
-            settings={
-                "deviceId": self.device_id,
-                "playTimerRegulations": self.parental_control_settings[
-                    "playTimerRegulations"
-                ],
-            }
+            self.device_id,
+            self.parental_control_settings["playTimerRegulations"],
         )
         now = datetime.now()
         self._parse_parental_control_setting(
@@ -155,37 +165,68 @@ class Device:
     async def set_bedtime_alarm(self, value: time):
         """Update the bedtime alarm for the device."""
         _LOGGER.debug(">> Device.set_bedtime_alarm(value=%s)", value)
-        if not (
-            (16 <= value.hour <= 22)
-            or (value.hour == 23 and value.minute == 0)
-            or (value.hour == 0 and value.minute == 0)
-        ):
+        if not ((16 <= value.hour <= 23) or (value.hour == 0 and value.minute == 0)):
             raise BedtimeOutOfRangeError(value=value)
         now = datetime.now()
-        bedtime = {
-            "enabled": value.hour != 0 and value.minute != 0,
-        }
-        if bedtime["enabled"]:
-            bedtime = {
-                **bedtime,
+        regulation = self._get_today_regulation(now).get("bedtime", {})
+        regulation["enabled"] = 16 <= value.hour <= 23
+
+        if regulation["enabled"]:
+            _LOGGER.debug(">> Device.set_bedtime_alarm(value=%s): Enabled", value)
+            regulation = {
+                **regulation,
                 "endingTime": {"hour": value.hour, "minute": value.minute},
             }
+        else:
+            regulation = {**regulation, "endingTime": None}
         if self.timer_mode == DeviceTimerMode.DAILY:
+            _LOGGER.debug(
+                ">> Device.set_bedtime_alarm(value=%s): Daily timer mode", value
+            )
             self.parental_control_settings["playTimerRegulations"]["dailyRegulations"][
                 "bedtime"
-            ] = bedtime
+            ] = regulation
         else:
+            _LOGGER.debug(
+                ">> Device.set_bedtime_alarm(value=%s): Each day timer mode", value
+            )
             self.parental_control_settings["playTimerRegulations"][
                 "eachDayOfTheWeekRegulations"
-            ][DAYS_OF_WEEK[now.weekday()]]["bedtime"] = bedtime
+            ][DAYS_OF_WEEK[now.weekday()]]["bedtime"] = regulation
+        _LOGGER.debug(
+            ">> Device.set_bedtime_alarm(value=%s): Updating bedtime with object %s",
+            value,
+            regulation,
+        )
         await self._send_api_update(
             self._api.async_update_play_timer,
-            settings={
-                "deviceId": self.device_id,
-                "playTimerRegulations": self.parental_control_settings[
-                    "playTimerRegulations"
-                ],
-            },
+            self.device_id,
+            self.parental_control_settings["playTimerRegulations"],
+            now=now,
+        )
+
+    async def set_bedtime_end_time(self, value: time):
+        """Update the bedtime end time for the device."""
+        _LOGGER.debug(">> Device.set_bedtime_end_time(value=%s)", value)
+        if not time(5, 0) <= value <= time(9, 0):
+            raise BedtimeOutOfRangeError(value=value)
+        now = datetime.now()
+        if self.timer_mode == DeviceTimerMode.DAILY:
+            regulation = self.parental_control_settings["playTimerRegulations"][
+                "dailyRegulations"
+            ]
+        else:
+            regulation = self.parental_control_settings["playTimerRegulations"][
+                "eachDayOfTheWeekRegulations"
+            ][DAYS_OF_WEEK[now.weekday()]]
+        regulation["bedtime"]["startingTime"] = {
+            "hour": value.hour,
+            "minute": value.minute,
+        }
+        await self._send_api_update(
+            self._api.async_update_play_timer,
+            self.device_id,
+            self.parental_control_settings["playTimerRegulations"],
             now=now,
         )
 
@@ -196,12 +237,90 @@ class Device:
         self.parental_control_settings["playTimerRegulations"]["timerMode"] = str(mode)
         await self._send_api_update(
             self._api.async_update_play_timer,
-            settings={
-                "deviceId": self.device_id,
-                "playTimerRegulations": self.parental_control_settings[
-                    "playTimerRegulations"
-                ],
-            },
+            self.device_id,
+            self.parental_control_settings["playTimerRegulations"],
+        )
+
+    async def set_daily_restrictions(
+        self,
+        enabled: bool,
+        bedtime_enabled: bool,
+        day_of_week: str,
+        bedtime_start: time | None = None,
+        bedtime_end: time | None = None,
+        max_daily_playtime: int | float | None = None,
+    ):
+        """Updates the daily restrictions of a device."""
+        _LOGGER.debug(
+            ">> Device.set_daily_restrictions(enabled=%s, bedtime_enabled=%s, day_of_week=%s, bedtime_start=%s, bedtime_end=%s, max_daily_playtime=%s)",
+            enabled,
+            bedtime_enabled,
+            day_of_week,
+            bedtime_start,
+            bedtime_end,
+            max_daily_playtime,
+        )
+        if self.timer_mode != DeviceTimerMode.EACH_DAY_OF_THE_WEEK:
+            raise InvalidDeviceStateError(
+                "Daily restrictions can only be set when timer_mode is EACH_DAY_OF_THE_WEEK."
+            )
+        if day_of_week not in DAYS_OF_WEEK:
+            raise ValueError(f"Invalid day_of_week: {day_of_week}")
+        regulation = self.parental_control_settings["playTimerRegulations"][
+            "eachDayOfTheWeekRegulations"
+        ][day_of_week]
+
+        if bedtime_enabled and bedtime_start is not None and bedtime_end is not None:
+            if not time(5, 0) <= bedtime_start <= time(9, 0):
+                raise BedtimeOutOfRangeError(value=bedtime_start)
+            if not (
+                (16 <= bedtime_end.hour <= 22)
+                or (bedtime_end.hour == 23 and bedtime_end.minute == 0)
+                or (bedtime_end.hour == 0 and bedtime_end.minute == 0)
+            ):
+                raise BedtimeOutOfRangeError(value=bedtime_end)
+            regulation["bedtime"] = {
+                "enabled": True,
+                "startingTime": {
+                    "hour": bedtime_start.hour,
+                    "minute": bedtime_start.minute,
+                },
+                "endingTime": {"hour": bedtime_end.hour, "minute": bedtime_end.minute},
+            }
+        elif bedtime_enabled:
+            raise BedtimeOutOfRangeError(value=None)
+        else:
+            # Even when disabled, the API seems to expect a starting time.
+            regulation["bedtime"] = {
+                "enabled": False,
+                "startingTime": None,
+                "endingTime": None,
+            }
+
+        regulation["timeToPlayInOneDay"] = {"enabled": enabled}
+        if enabled and max_daily_playtime is not None:
+            if isinstance(max_daily_playtime, float):
+                max_daily_playtime = int(max_daily_playtime)
+            if not 0 <= max_daily_playtime <= 360:
+                raise DailyPlaytimeOutOfRangeError(max_daily_playtime)
+            regulation["timeToPlayInOneDay"]["limitTime"] = max_daily_playtime
+        else:
+            regulation["timeToPlayInOneDay"]["limitTime"] = None
+
+        await self._send_api_update(
+            self._api.async_update_play_timer,
+            self.device_id,
+            self.parental_control_settings["playTimerRegulations"],
+        )
+
+    async def set_functional_restriction_level(self, level: FunctionalRestrictionLevel):
+        """Updates the functional restriction level of a device."""
+        _LOGGER.debug(">> Device.set_functional_restriction_level(level=%s)", level)
+        self.parental_control_settings["functionalRestrictionLevel"] = str(level)
+        await self._send_api_update(
+            self._api.async_update_restriction_level,
+            self.device_id,
+            self.parental_control_settings,
         )
 
     async def update_max_daily_playtime(self, minutes: int | float = 0):
@@ -262,27 +381,25 @@ class Device:
 
         await self._send_api_update(
             self._api.async_update_play_timer,
-            settings={
-                "deviceId": self.device_id,
-                "playTimerRegulations": self.parental_control_settings[
-                    "playTimerRegulations"
-                ],
-            },
+            self.device_id,
+            self.parental_control_settings["playTimerRegulations"],
             now=now,
         )
 
     def _update_applications(self):
-        """Updates applications from daily summary."""
+        """Updates applications from whitelisted applications list."""
         _LOGGER.debug(">> Device._update_applications()")
-        parsed_apps = Application.from_whitelist(
-            self.parental_control_settings.get("whitelistedApplications", [])
-        )
-        for app in parsed_apps:
-            try:
-                self.get_application(app.application_id).update(app)
-                # self.get_application(app.application_id).update_today_time_played(self.daily_summaries[0])
-            except ValueError:
-                self.applications.append(app)
+        for app in self.parental_control_settings.get("whitelistedApplicationList", []):
+            if app["applicationId"] in self.applications:
+                continue
+            self.applications[app["applicationId"]] = Application(
+                app_id=app["applicationId"],
+                name=app["title"],
+                device_id=self.device_id,
+                api=self._api,
+                send_api_update=self._send_api_update,
+                callbacks=self._internal_callbacks,
+            )
 
     def _get_today_regulation(self, now: datetime) -> dict:
         """Returns the regulation settings for the current day."""
@@ -336,15 +453,20 @@ class Device:
             )
 
         bedtime_setting = today_reg.get("bedtime", {})
-        if bedtime_setting.get("enabled"):
+        if bedtime_setting.get("enabled") and bedtime_setting["endingTime"]:
             self.bedtime_alarm = time(
                 hour=bedtime_setting["endingTime"]["hour"],
                 minute=bedtime_setting["endingTime"]["minute"],
             )
         else:
             self.bedtime_alarm = time(hour=0, minute=0)
-
-        self._update_applications()
+        if bedtime_setting.get("enabled") and bedtime_setting["startingTime"]:
+            self.bedtime_end = time(
+                hour=bedtime_setting["startingTime"]["hour"],
+                minute=bedtime_setting["startingTime"]["minute"],
+            )
+        else:
+            self.bedtime_end = time(hour=0, minute=0)
 
     def _calculate_times(self, now: datetime):
         """Calculate times from parental control settings."""
@@ -376,37 +498,6 @@ class Device:
                 month_playing_time += summary["playingTime"]
         self.month_playing_time = month_playing_time
         _LOGGER.debug("Cached current month playing time for device %s", self.device_id)
-        parsed_apps = Application.from_daily_summary(self.daily_summaries)
-        for app in parsed_apps:
-            try:
-                int_app = self.get_application(app.application_id)
-                _LOGGER.debug(
-                    "Updating cached app state %s for device %s",
-                    int_app.application_id,
-                    self.device_id,
-                )
-                int_app.update(app)
-            except ValueError:
-                _LOGGER.debug(
-                    "Creating new cached application entry %s for device %s",
-                    app.application_id,
-                    self.device_id,
-                )
-                self.applications.append(app)
-
-        # update application playtime
-        try:
-            for player in self.get_date_summary()[0].get("devicePlayers", []):
-                for app in player.get("playedApps", []):
-                    self.get_application(app["applicationId"]).update_today_time_played(
-                        app
-                    )
-            self.application_update_failed = False
-        except ValueError as err:
-            _LOGGER.debug(
-                "Unable to retrieve applications for device %s: %s", self.name, err
-            )
-            self.application_update_failed = True
 
     def _calculate_today_remaining_time(self, now: datetime):
         """Calculates the remaining playing time for today."""
@@ -541,7 +632,9 @@ class Device:
             if latest:
                 self.last_month_summary = summary = response["json"]["summary"]
                 # Generate player objects
-                for player in response.get("json", {}).get("summary", {}).get("players", []):
+                for player in (
+                    response.get("json", {}).get("summary", {}).get("players", [])
+                ):
                     profile = player.get("profile")
                     if not profile or not profile.get("playerId"):
                         continue
@@ -576,12 +669,8 @@ class Device:
 
     def get_application(self, application_id: str) -> Application:
         """Returns a single application."""
-        app = next(
-            (app for app in self.applications if app.application_id == application_id),
-            None,
-        )
-        if app:
-            return app
+        if application_id in self.applications:
+            return self.applications[application_id]
         raise ValueError(f"Application with id {application_id} not found.")
 
     def get_player(self, player_id: str) -> Player: