pynintendoparental 2.1.3__py3-none-any.whl → 2.2.1__py3-none-any.whl

pynintendoparental/_version.py

@@ -1 +1 @@
-__version__ = "2.1.3"
+__version__ = "2.2.1"

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/application.py

@@ -1,102 +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) -> None:
+    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 = None
+        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 = None
-        self.today_time_played: int = 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
 
-    def update_today_time_played(self, daily_summary: dict):
-        """Updates the today time played for the given application."""
-        _LOGGER.debug("Updating today time played for app %s", self.application_id)
-        self.today_time_played = daily_summary.get("playingTime", 0)
+        # Register internal callbacks
+        callbacks.append(self._internal_update_callback)
 
-    def update(self, updated: "Application"):
-        """Updates self with a given application."""
-        _LOGGER.debug("Updating application %s", self.application_id)
-        self.application_id = updated.application_id
-        self.first_played_date = updated.first_played_date
-        self.has_ugc = updated.has_ugc
-        self.image_url = updated.image_url
-        self.playing_days = updated.playing_days
-        self.shop_url = updated.shop_url
-        self.name = updated.name
-        self.today_time_played = updated.today_time_played
+    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."
+            )
 
-    @classmethod
-    def from_daily_summary(cls, raw: list) -> list["Application"]:
-        """Converts a raw daily summary response into a list of applications."""
-        built = []
-        if "playedApps" in raw:
-            return cls.from_monthly_summary(raw.get("playedApps", []))
-        for summary in raw:
-            for app in cls.from_monthly_summary(summary.get("playedApps", [])):
-                if not cls.check_if_app_in_list(built, app):
-                    built.append(app)
-        return built
+        await self._send_api_update(
+            self._api.async_update_restriction_level,
+            self._device_id,
+            pcs,
+            now=datetime.now(),
+        )
 
-    @staticmethod
-    def check_if_app_in_list(app_list: list["Application"], app: "Application") -> bool:
-        """Checks if an app is in a list."""
-        for app_li in app_list:
-            if app_li.application_id == app.application_id:
-                return True
-        return False
+    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
 
-    @staticmethod
-    def return_app_from_list(
-        app_list: list["Application"], application_id: str
-    ) -> "Application":
-        """Returns a single app from a given list."""
-        for app in app_list:
-            if app.application_id == application_id:
-                return app
-        return None
+        for cb in self._callbacks:
+            if is_awaitable(cb):
+                await cb(self)
+            else:
+                cb(self)
 
-    @classmethod
-    def from_whitelist(cls, raw: dict) -> list["Application"]:
-        """Converts a raw whitelist response into a list of applications."""
-        parsed = []
-        for app_id in raw:
-            _LOGGER.debug("Parsing app %s", app_id)
-            internal = cls()
-            internal.application_id = raw[app_id]["applicationId"]
-            internal.first_played_date = datetime.strptime(
-                raw[app_id]["firstPlayDate"], "%Y-%m-%d"
-            )
-            internal.image_url = raw[app_id]["imageUri"]
-            internal.name = raw[app_id]["title"]
-            parsed.append(internal)
-        return parsed
+    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)
 
-    @classmethod
-    def from_monthly_summary(cls, raw: list) -> list["Application"]:
-        """Converts a raw monthly summary response into a list of applications."""
-        parsed = []
-        for app in raw:
-            _LOGGER.debug("Parsing app %s", app)
-            internal = cls()
-            internal.application_id = app.get("applicationId").capitalize()
-            internal.first_played_date = datetime.strptime(
-                app.get("firstPlayDate"), "%Y-%m-%d"
-            )
-            internal.has_ugc = app.get("hasUgc", False)
-            internal.image_url = app.get("imageUri").get("small")
-            internal.playing_days = app.get("playingDays", None)
-            internal.shop_url = app.get("shopUri")
-            internal.name = app.get("title")
-            parsed.append(internal)
-        return parsed
+    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/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/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."""
@@ -299,22 +416,8 @@ class Device:
         """Parse a parental control setting request response."""
         _LOGGER.debug(">> Device._parse_parental_control_setting()")
         self.parental_control_settings = pcs["parentalControlSetting"]
-
-        # Clean up bedtimeStartingTime if it's empty
-        if (
-            "bedtimeStartingTime"
-            in self.parental_control_settings["playTimerRegulations"]
-        ):
-            if (
-                self.parental_control_settings["playTimerRegulations"]
-                .get("bedtimeStartingTime", {})
-                .get("hour", 0)
-                == 0
-            ):
-                self.parental_control_settings["playTimerRegulations"].pop(
-                    "bedtimeStartingTime"
-                )
-
+        self.parental_control_settings["playTimerRegulations"].pop("bedtimeStartingTime", None)
+        self.parental_control_settings["playTimerRegulations"].pop("bedtimeEndingTime", None)
         self.forced_termination_mode = self.parental_control_settings[
             "playTimerRegulations"
         ]["restrictionMode"] == str(RestrictionMode.FORCED_TERMINATION)
@@ -336,15 +439,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 +484,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 +618,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 +655,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:

pynintendoparental/enum.py

@@ -3,7 +3,19 @@
 from enum import Enum, StrEnum
 
 
-class AlarmSettingState(Enum):
+class NintendoEnum(Enum):
+    """Base enum for Nintendo-related enums."""
+
+    def __str__(self) -> str:
+        return self.name
+
+    @classmethod
+    def options(cls) -> list[str]:
+        """Return a list of string representations of the enum members."""
+        return [str(e) for e in cls]
+
+
+class AlarmSettingState(NintendoEnum):
     """Alarm setting states."""
 
     SUCCESS = 0
@@ -12,25 +24,36 @@ class AlarmSettingState(Enum):
     VISIBLE = 4
     INVISIBLE = 8
 
-    def __str__(self) -> str:
-        return self.name
-
 
-class RestrictionMode(Enum):
+class RestrictionMode(NintendoEnum):
     """Restriction modes."""
 
     FORCED_TERMINATION = 0
     ALARM = 1
 
-    def __str__(self) -> str:
-        return self.name
+
+class SafeLaunchSetting(StrEnum, NintendoEnum):
+    """Safe launch settings."""
+
+    NONE = "NONE"
+    ALLOW = "ALLOW"
 
 
-class DeviceTimerMode(StrEnum):
+class DeviceTimerMode(StrEnum, NintendoEnum):
     """Device timer modes."""
 
     DAILY = "DAILY"
     EACH_DAY_OF_THE_WEEK = "EACH_DAY_OF_THE_WEEK"
 
+
+class FunctionalRestrictionLevel(StrEnum, NintendoEnum):
+    """Functional restriction levels."""
+
+    NONE = "NONE"
+    YOUNG_CHILD = "CHILDREN"
+    YOUNG_TEENS = "YOUNG_TEENS"
+    TEEN = "OLDER_TEENS"
+    CUSTOM = "CUSTOM"
+
     def __str__(self) -> str:
-        return self.name
+        return self.value

pynintendoparental/exceptions.py

@@ -8,20 +8,31 @@ class RangeErrorKeys(StrEnum):
 
     DAILY_PLAYTIME = "daily_playtime_out_of_range"
     BEDTIME = "bedtime_alarm_out_of_range"
+    INVALID_DEVICE_STATE = "invalid_device_state"
 
 
 class NoDevicesFoundException(Exception):
     """No devices were found for the account."""
 
 
-class InputValidationError(Exception):
+class DeviceError(Exception):
+    """Generic Device Error."""
+
+    error_key: str
+
+    def __init__(self, message: str) -> None:
+        super().__init__(f"{self.__doc__} {message}")
+        self.message = message
+
+
+class InputValidationError(DeviceError):
     """Input Validation Failed."""
 
     value: object
     error_key: str
 
     def __init__(self, value: object) -> None:
-        super().__init__(f"{self.__doc__} Received value: {value}")
+        super().__init__(f"Received value: {value}")
         self.value = value
 
 
@@ -35,3 +46,9 @@ class DailyPlaytimeOutOfRangeError(InputValidationError):
     """Daily playtime is outside of the allowed range."""
 
     error_key = RangeErrorKeys.DAILY_PLAYTIME
+
+
+class InvalidDeviceStateError(DeviceError):
+    """The device is in an invalid state for the requested operation."""
+
+    error_key = RangeErrorKeys.INVALID_DEVICE_STATE

{pynintendoparental-2.1.3.dist-info → pynintendoparental-2.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pynintendoparental
-Version: 2.1.3
+Version: 2.2.1
 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.1.dist-info/RECORD

@@ -0,0 +1,17 @@
+pynintendoparental/__init__.py,sha256=gO3rH9gukrFoACVkdqj_liqcgtHxSZlitE0PrVQZGok,2334
+pynintendoparental/_version.py,sha256=4dqvKTDgbqeyzbWj6hYiNdzxsI8j1YOKSLM8vF6a0j4,22
+pynintendoparental/api.py,sha256=DAbpkYWFcSXLpAgOUjvWOYg0y0yD02kggV9DuBdhMhU,6647
+pynintendoparental/application.py,sha256=4_38VBtoKddIXRRsegX9DB-BJ_CYIO4FhE1xC-VliOs,4961
+pynintendoparental/authenticator.py,sha256=WPAEAUKmIymIiQUXILYt4B2_3UgYRKEVi6btJRwzjmM,430
+pynintendoparental/const.py,sha256=owbzynb3eljPtvYr5vtg-B4UAIS5SGyumR8HDG6eB2Q,2201
+pynintendoparental/device.py,sha256=0KihypiPy2dcQUgsxAZw40GfxXF4lH8bOKKw0L3_6us,29222
+pynintendoparental/enum.py,sha256=orYspYYuiBeIbb1Scgkj0m3Cn_rV-wLBr-ozG1v6azk,1169
+pynintendoparental/exceptions.py,sha256=o1vpVIwa3CHyIxxqGjYX1hk2G5RMcZJN1T7lCA-fKzc,1308
+pynintendoparental/player.py,sha256=Zh3vi0IdOHtn5KW0tT9JigB315ftjQ4uEQylF3D4LWs,2084
+pynintendoparental/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pynintendoparental/utils.py,sha256=gLMibsEOnKUZJgCQKF4Zk517fawZ3mBqMK6MS2g-Um0,199
+pynintendoparental-2.2.1.dist-info/licenses/LICENSE,sha256=zsxHgHVMnyWq121yND8zBl9Rl9H6EF2K9N51B2ZSm_k,1071
+pynintendoparental-2.2.1.dist-info/METADATA,sha256=2jpLNDsIokGEuww-Kub-B8U6affC2VgfSM9CUL3a2is,2125
+pynintendoparental-2.2.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pynintendoparental-2.2.1.dist-info/top_level.txt,sha256=QQ5bAl-Ljso16P8KLf1NHrFmKk9jLT7bVJG_rVlIXWk,19
+pynintendoparental-2.2.1.dist-info/RECORD,,

pynintendoparental-2.1.3.dist-info/RECORD

@@ -1,17 +0,0 @@
-pynintendoparental/__init__.py,sha256=gO3rH9gukrFoACVkdqj_liqcgtHxSZlitE0PrVQZGok,2334
-pynintendoparental/_version.py,sha256=-5z5R8xV0UToQjp9-3ipF_dBiBdRXtdotx4_h9ZJZT8,22
-pynintendoparental/api.py,sha256=-w2YfCa5R472ZA4cu7rEEvEjPicNNBdZu4bQfcv-SCE,6325
-pynintendoparental/application.py,sha256=8zTisF3_COgIzKCLIgLpYdHcX4OiwRQU5NH2WUngvxc,3995
-pynintendoparental/authenticator.py,sha256=WPAEAUKmIymIiQUXILYt4B2_3UgYRKEVi6btJRwzjmM,430
-pynintendoparental/const.py,sha256=bKfv1O-eFbzvhz0EE2Cj6Px2b5yoq8HL7itMP4TWmwo,2174
-pynintendoparental/device.py,sha256=CiW-SXYGvjsZzW10Sf1Xu0PA6hkduabpWyWPIxgzKng,25541
-pynintendoparental/enum.py,sha256=NlkfrZTfiur6vTqqwHxeiM7wPQZ-1Y1PlY4Jh_gq4NQ,605
-pynintendoparental/exceptions.py,sha256=zOGZHlBFfdcBNNWHA7t_Ix2Qgd3ON2-SVjmA9dHs578,883
-pynintendoparental/player.py,sha256=Zh3vi0IdOHtn5KW0tT9JigB315ftjQ4uEQylF3D4LWs,2084
-pynintendoparental/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pynintendoparental/utils.py,sha256=gLMibsEOnKUZJgCQKF4Zk517fawZ3mBqMK6MS2g-Um0,199
-pynintendoparental-2.1.3.dist-info/licenses/LICENSE,sha256=zsxHgHVMnyWq121yND8zBl9Rl9H6EF2K9N51B2ZSm_k,1071
-pynintendoparental-2.1.3.dist-info/METADATA,sha256=elXY7lwZad6CPk6SzbbogXw_kSR_FtR7iqsc4czBquU,2125
-pynintendoparental-2.1.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pynintendoparental-2.1.3.dist-info/top_level.txt,sha256=QQ5bAl-Ljso16P8KLf1NHrFmKk9jLT7bVJG_rVlIXWk,19
-pynintendoparental-2.1.3.dist-info/RECORD,,