pynintendoparental 0.6.8__tar.gz → 0.7.0__tar.gz

{pynintendoparental-0.6.8 → pynintendoparental-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pynintendoparental
-Version: 0.6.8
+Version: 0.7.0
 Summary: A Python module to interact with Nintendo Parental Controls
 Home-page: http://github.com/pantherale0/pynintendoparental
 Author: pantherale0

{pynintendoparental-0.6.8 → pynintendoparental-0.7.0}/pynintendoparental/__init__.py

@@ -30,10 +30,7 @@ class NintendoParental:
                               dev.device_id,
                               err)
 
-        response = await self._api.send_request(
-            endpoint="get_account_devices",
-            ACCOUNT_ID=self.account_id
-        )
+        response = await self._api.async_get_account_devices()
 
         for dev_raw in response["json"]["items"]:
             device: Device = Device.from_device_response(dev_raw, self._api)

pynintendoparental-0.7.0/pynintendoparental/_version.py

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

pynintendoparental-0.7.0/pynintendoparental/api.py

@@ -0,0 +1,222 @@
+"""API handler."""
+
+from datetime import datetime, timedelta
+
+import aiohttp
+
+from .authenticator import Authenticator
+from .const import (
+    ENDPOINTS,
+    BASE_URL,
+    USER_AGENT,
+    MOBILE_APP_PKG,
+    MOBILE_APP_BUILD,
+    MOBILE_APP_VERSION,
+    OS_VERSION,
+    OS_NAME,
+    DEVICE_MODEL,
+    _LOGGER
+)
+from .exceptions import HttpException
+
+def _check_http_success(status: int) -> bool:
+    return status >= 200 and status < 300
+
+class Api:
+    """Nintendo Parental Controls API."""
+
+    def __init__(self, auth, tz, lang, session: aiohttp.ClientSession=None):
+        """INIT"""
+        self._auth: Authenticator = auth
+        self._tz = tz
+        self._language = lang
+        if session is None:
+            session = aiohttp.ClientSession()
+            self._session_created_internally = True
+        self._session = session
+
+    @property
+    def _auth_token(self) -> str:
+        """Returns the auth token."""
+        return f"Bearer {self._auth.access_token}"
+
+    @property
+    def account_id(self):
+        """Return the account id."""
+        return self._auth.account_id
+
+    @property
+    def _headers(self) -> dict:
+        """Return web request headers."""
+        return {
+            "User-Agent": USER_AGENT,
+            "X-Moon-App-Id": MOBILE_APP_PKG,
+            "X-Moon-Os": OS_NAME,
+            "X-Moon-Os-Version": OS_VERSION,
+            "X-Moon-Model": DEVICE_MODEL,
+            "X-Moon-App-Display-Version": MOBILE_APP_VERSION,
+            "X-Moon-App-Internal-Version": MOBILE_APP_BUILD,
+            "X-Moon-TimeZone": self._tz,
+            "X-Moon-Os-Language": self._language,
+            "X-Moon-App-Language": self._language,
+            "Authorization": self._auth_token
+        }
+
+    async def async_close(self):
+        """Closes the underlying aiohttp.ClientSession if it was created by this instance."""
+        if hasattr(self, '_session_created_internally') and self._session_created_internally and self._session and not self._session.closed:
+            await self._session.close()
+            self._session = None # Optional: clear the session attribute
+
+    async def send_request(self, endpoint: str, body: object=None, **kwargs):
+        """Sends a request to a given endpoint."""
+        _LOGGER.debug("Sending request to %s", endpoint)
+        # Get the endpoint from the endpoints map
+        e_point = ENDPOINTS.get(endpoint, None)
+        if e_point is None:
+            raise ValueError("Endpoint does not exist")
+        # refresh the token if it has expired.
+        if self._auth.expires < (datetime.now()+timedelta(seconds=30)):
+            _LOGGER.debug("Access token expired, requesting refresh.")
+            await self._auth.perform_refresh()
+        # format the URL using the kwargs
+        url = e_point.get("url").format(BASE_URL=BASE_URL, **kwargs)
+        _LOGGER.debug("Built URL %s", url)
+        # now send the HTTP request
+        resp: dict = {
+            "status": 0,
+            "text": "",
+            "json": "",
+            "headers": ""
+        }
+        self._session.headers.update(self._headers)
+        async with self._session.request(
+            method=e_point.get("method"),
+            url=url,
+            json=body
+        ) as response:
+            _LOGGER.debug("%s request to %s status code %s",
+                            e_point.get("method"),
+                            url,
+                            response.status)
+            if _check_http_success(response.status):
+                resp["status"] = response.status
+                resp["text"] = await response.text()
+                try:
+                    resp["json"] = await response.json()
+                except (aiohttp.ContentTypeError, ValueError) as e:
+                    _LOGGER.warning(
+                        """Failed to decode JSON response from %s.
+                        Status: %s, Error: %s.
+                        Response text: %s...""",
+                        url, response.status, e, resp['text'][:200]
+                    )
+                    resp["json"] = {}
+                resp["headers"] = response.headers
+            else:
+                raise HttpException("HTTP Error", response.status, await response.text())
+
+        # now return the resp dict
+        return resp
+
+    async def async_get_account_details(self) -> dict:
+        """Get account details."""
+        return await self.send_request(
+            endpoint="get_account_details",
+            ACCOUNT_ID=self.account_id
+        )
+
+    async def async_get_account_devices(self) -> dict:
+        """Get account devices."""
+        return await self.send_request(
+            endpoint="get_account_devices",
+            ACCOUNT_ID=self.account_id
+        )
+
+    async def async_get_account_device(self, device_id: str) -> dict:
+        """Get account device."""
+        return await self.send_request(
+            endpoint="get_account_device",
+            ACCOUNT_ID=self.account_id,
+            DEVICE_ID=device_id
+        )
+
+    async def async_get_device_daily_summaries(self, device_id: str) -> dict:
+        """Get device daily summaries."""
+        return await self.send_request(
+            endpoint="get_device_daily_summaries",
+            DEVICE_ID=device_id
+        )
+
+    async def async_get_device_monthly_summaries(self, device_id: str) -> dict:
+        """Get device monthly summaries."""
+        return await self.send_request(
+            endpoint="get_device_monthly_summaries",
+            DEVICE_ID=device_id
+        )
+
+    async def async_get_device_parental_control_setting(self, device_id: str) -> dict:
+        """Get device parental control setting."""
+        return await self.send_request(
+            endpoint="get_device_parental_control_setting",
+            DEVICE_ID=device_id
+        )
+
+    async def async_get_device_parental_control_setting_state(self, device_id: str) -> dict:
+        """Get device parental control setting state."""
+        return await self.send_request(
+            endpoint="get_device_parental_control_setting_state",
+            DEVICE_ID=device_id
+        )
+
+    async def async_get_device_alarm_setting_state(self, device_id: str) -> dict:
+        """Get device alarm setting state."""
+        return await self.send_request(
+            endpoint="get_device_alarm_setting_state",
+            DEVICE_ID=device_id
+        )
+
+    async def async_get_device_monthly_summary(self, device_id: str, year: int, month: int) -> dict:
+        """Get device monthly summary."""
+        return await self.send_request(
+            endpoint="get_device_monthly_summary",
+            DEVICE_ID=device_id,
+            YEAR=year,
+            MONTH=f"{month:02d}"
+        )
+
+    async def async_set_device_parental_control_setting(
+            self,
+            device_id: str,
+            settings: dict
+        ) -> dict:
+        """Update device parental control setting."""
+        return await self.send_request(
+            endpoint="update_device_parental_control_setting",
+            DEVICE_ID=device_id,
+            body=settings
+        )
+
+    async def async_set_device_whitelisted_applications(
+            self,
+            device_id: str,
+            applications: dict
+        ) -> dict:
+        """Update device whitelisted applications."""
+        return await self.send_request(
+            endpoint="update_device_whitelisted_applications",
+            DEVICE_ID=device_id,
+            body=applications
+        )
+
+    async def async_set_device_alarm_setting_state(
+            self,
+            device_id: str,
+            alarm_state: dict
+        ) -> dict:
+        """Update device alarm setting state."""
+        return await self.send_request(
+            endpoint="update_device_alarm_setting_state",
+            DEVICE_ID=device_id,
+            body=alarm_state
+        )

{pynintendoparental-0.6.8 → pynintendoparental-0.7.0}/pynintendoparental/device.py

@@ -27,13 +27,14 @@ class Device:
         self.daily_summaries: dict = {}
         self.parental_control_settings: dict = {}
         self.players: list[Player] = []
-        self.limit_time: int = 0
+        self.limit_time: int | float | None = 0
         self.timer_mode: str = ""
-        self.today_playing_time: int = 0
-        self.bedtime_alarm: time
-        self.month_playing_time: int = 0
-        self.today_disabled_time: int = 0
-        self.today_exceeded_time: int = 0
+        self.today_playing_time: int | float = 0
+        self.today_time_remaining: int | float = 0
+        self.bedtime_alarm: time | None = None
+        self.month_playing_time: int | float = 0
+        self.today_disabled_time: int | float = 0
+        self.today_exceeded_time: int | float = 0
         self.today_notices: list = []
         self.today_important_info: list = []
         self.today_observations: list = []
@@ -114,10 +115,9 @@ class Device:
     async def _set_parental_control_setting(self):
         """Shortcut method to deduplicate code used to update parental control settings."""
         _LOGGER.debug(">> Device._set_parental_control_setting()")
-        await self._api.send_request(
-            endpoint="update_device_parental_control_setting",
-            body=self._get_update_parental_control_setting_body(),
-            DEVICE_ID=self.device_id
+        await self._api.async_set_device_parental_control_setting(
+            settings=self._get_update_parental_control_setting_body(),
+            device_id=self.device_id
         )
         await self._get_parental_control_setting()
 
@@ -183,9 +183,10 @@ class Device:
         current_day = day_of_week_regs.get(DAYS_OF_WEEK[datetime.now().weekday()], {})
         self.timer_mode = self.parental_control_settings["playTimerRegulations"]["timerMode"]
         if self.timer_mode == "EACH_DAY_OF_THE_WEEK":
-            self.limit_time = current_day["timeToPlayInOneDay"]["limitTime"]
+            self.limit_time = current_day.get("timeToPlayInOneDay", {}).get("limitTime", None)
         else:
-            self.limit_time = self.parental_control_settings["playTimerRegulations"]["dailyRegulations"]["timeToPlayInOneDay"]["limitTime"]
+            self.limit_time = self.parental_control_settings.get("playTimerRegulations", {}).get(
+                "dailyRegulations", {}).get("timeToPlayInOneDay", {}).get("limitTime", None)
 
         if self.timer_mode == "EACH_DAY_OF_THE_WEEK":
             if current_day["bedtime"]["enabled"]:
@@ -207,9 +208,8 @@ class Device:
     async def _get_parental_control_setting(self):
         """Retreives parental control settings from the API."""
         _LOGGER.debug(">> Device._get_parental_control_setting()")
-        response = await self._api.send_request(
-            endpoint="get_device_parental_control_setting",
-            DEVICE_ID=self.device_id
+        response = await self._api.async_get_device_parental_control_setting(
+            device_id=self.device_id
         )
         self.parental_control_settings = response["json"]
         if "bedtimeStartingTime" in self.parental_control_settings["playTimerRegulations"]:
@@ -233,22 +233,53 @@ class Device:
     async def _get_daily_summaries(self):
         """Retrieve daily summaries."""
         _LOGGER.debug(">> Device._get_daily_summaries()")
-        response = await self._api.send_request(
-            endpoint="get_device_daily_summaries",
-            DEVICE_ID = self.device_id
+        response = await self._api.async_get_device_daily_summaries(
+            device_id = self.device_id
         )
         self.daily_summaries = response["json"]["items"]
         _LOGGER.debug("New daily summary %s", self.daily_summaries)
         try:
             today_playing_time = self.get_date_summary()[0].get("playingTime", 0)
-            self.today_playing_time = None if today_playing_time is None else today_playing_time/60
+            self.today_playing_time = 0 if today_playing_time is None else today_playing_time/60
             today_disabled_time = self.get_date_summary()[0].get("disabledTime", 0)
-            self.today_disabled_time = None if today_disabled_time is None else today_disabled_time/60
+            self.today_disabled_time = 0 if today_disabled_time is None else today_disabled_time/60
             today_exceeded_time = self.get_date_summary()[0].get("exceededTime", 0)
-            self.today_exceeded_time = None if today_exceeded_time is None else today_exceeded_time/60
+            self.today_exceeded_time = 0 if today_exceeded_time is None else today_exceeded_time/60
             _LOGGER.debug("Cached playing, disabled and exceeded time for today for device %s",
                         self.device_id)
+            now = datetime.now()
+            current_minutes_past_midnight = now.hour * 60 + now.minute
+            minutes_in_day = 1440 # 24 * 60
+
+            # 1. Calculate remaining time based on play limit
+
+            time_remaining_by_play_limit = 0.0
+            if self.limit_time is None:
+                # No specific play limit, effectively limited by end of day for this calculation step.
+                time_remaining_by_play_limit = float(minutes_in_day - current_minutes_past_midnight)
+            elif self.limit_time == 0:
+                time_remaining_by_play_limit = 0.0
+            else:
+                time_remaining_by_play_limit = float(self.limit_time - self.today_playing_time)
+
+            time_remaining_by_play_limit = max(0.0, time_remaining_by_play_limit)
+
+            # Initialize overall remaining time with play limit constraint
+            effective_remaining_time = time_remaining_by_play_limit
+
+            # 2. Factor in bedtime alarm, if any, to further constrain remaining time
+            if self.bedtime_alarm is not None:
+                bedtime_dt = datetime.combine(now.date(), self.bedtime_alarm)
+                time_remaining_by_bedtime = 0.0
+                if bedtime_dt > now: # Bedtime is in the future today
+                    time_remaining_by_bedtime = (bedtime_dt - now).total_seconds() / 60
+                    time_remaining_by_bedtime = max(0.0, time_remaining_by_bedtime) 
+                # else: Bedtime has passed for today or is now, so time_remaining_by_bedtime remains 0.0
+
+                effective_remaining_time = min(effective_remaining_time, time_remaining_by_bedtime)
 
+            self.today_time_remaining = int(max(0.0, effective_remaining_time)) # Ensure non-negative and integer
+            _LOGGER.debug("Calculated and updated the amount of time remaining for today: %s", self.today_time_remaining)
             self.today_important_info = self.get_date_summary()[0].get("importantInfos", [])
             self.today_notices = self.get_date_summary()[0].get("notices", [])
             self.today_observations = self.get_date_summary()[0].get("observations", [])
@@ -300,10 +331,8 @@ class Device:
         _LOGGER.debug(">> Device._get_extras()")
         if self.alarms_enabled is not None:
             # first refresh can come from self.extra without http request
-            response = await self._api.send_request(
-                endpoint="get_account_device",
-                ACCOUNT_ID = self._api.account_id,
-                DEVICE_ID = self.device_id
+            response = await self._api.async_get_account_device(
+                device_id = self.device_id
             )
             self.extra = response["json"]
         status = self.extra["device"]["alarmSetting"]["visibility"]
@@ -317,9 +346,8 @@ class Device:
         _LOGGER.debug(">> Device.get_monthly_summary(search_date=%s)", search_date)
         latest = False
         if search_date is None:
-            response = await self._api.send_request(
-                endpoint="get_device_monthly_summaries",
-                DEVICE_ID=self.device_id
+            response = await self._api.async_get_device_monthly_summaries(
+                device_id=self.device_id
             )
             _LOGGER.debug("Available monthly summaries: %s", response)
             response = response["json"]["indexes"][0]
@@ -328,11 +356,10 @@ class Device:
             latest = True
 
         try:
-            response = await self._api.send_request(
-                endpoint="get_device_monthly_summary",
-                DEVICE_ID = self.device_id,
-                YEAR=search_date.year,
-                MONTH=str(search_date.month).zfill(2)
+            response = await self._api.async_get_device_monthly_summary(
+                device_id = self.device_id,
+                year=search_date.year,
+                month=search_date.month
             )
             _LOGGER.debug("Monthly summary query complete for device %s: %s",
                         self.device_id,
@@ -351,12 +378,11 @@ class Device:
         """Updates the alarm state for the device."""
         _LOGGER.debug(">> Device.set_alarm_state(state=%s)",
                       state)
-        await self._api.send_request(
-            endpoint="update_device_alarm_setting_state",
-            body={
+        await self._api.async_set_device_alarm_setting_state(
+            alarm_state={
                 "status": str(state)
             },
-            DEVICE_ID = self.device_id
+            device_id = self.device_id
         )
 
     async def set_whitelisted_application(self, app_id: str, allowed: bool):
@@ -369,10 +395,9 @@ class Device:
         # take a snapshot of the whitelisted apps state
         current_state = self.parental_control_settings["whitelistedApplications"]
         current_state[app_id]["safeLaunch"] = "ALLOW" if allowed else "NONE"
-        await self._api.send_request(
-            endpoint="update_device_whitelisted_applications",
-            body=current_state,
-            DEVICE_ID=self.device_id
+        await self._api.async_set_device_whitelisted_applications(
+            applications=current_state,
+            device_id=self.device_id
         )
         await self._get_parental_control_setting()
 

{pynintendoparental-0.6.8 → pynintendoparental-0.7.0}/pynintendoparental.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pynintendoparental
-Version: 0.6.8
+Version: 0.7.0
 Summary: A Python module to interact with Nintendo Parental Controls
 Home-page: http://github.com/pantherale0/pynintendoparental
 Author: pantherale0

pynintendoparental-0.6.8/pynintendoparental/_version.py

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

pynintendoparental-0.6.8/pynintendoparental/api.py

@@ -1,96 +0,0 @@
-"""API handler."""
-
-from datetime import datetime, timedelta
-
-import aiohttp
-
-from .authenticator import Authenticator
-from .const import (
-    ENDPOINTS,
-    BASE_URL,
-    USER_AGENT,
-    MOBILE_APP_PKG,
-    MOBILE_APP_BUILD,
-    MOBILE_APP_VERSION,
-    OS_VERSION,
-    OS_NAME,
-    DEVICE_MODEL,
-    _LOGGER
-)
-from .exceptions import HttpException
-
-def _check_http_success(status: int) -> bool:
-    return status >= 200 and status < 300
-
-class Api:
-    """Nintendo Parental Controls API."""
-
-    def __init__(self, auth, tz, lang):
-        """INIT"""
-        self._auth: Authenticator = auth
-        self._tz = tz
-        self._language = lang
-
-    @property
-    def _auth_token(self) -> str:
-        """Returns the auth token."""
-        return f"Bearer {self._auth.access_token}"
-
-    @property
-    def account_id(self):
-        """Return the account id."""
-        return self._auth.account_id
-
-    async def send_request(self, endpoint: str, body: object=None, **kwargs):
-        """Sends a request to a given endpoint."""
-        _LOGGER.debug("Sending request to %s", endpoint)
-        # Get the endpoint from the endpoints map
-        e_point = ENDPOINTS.get(endpoint, None)
-        if e_point is None:
-            raise ValueError("Endpoint does not exist")
-        # refresh the token if it has expired.
-        if self._auth.expires < (datetime.now()+timedelta(seconds=30)):
-            _LOGGER.debug("Access token expired, requesting refresh.")
-            await self._auth.perform_refresh()
-        # format the URL using the kwargs
-        url = e_point.get("url").format(BASE_URL=BASE_URL, **kwargs)
-        _LOGGER.debug("Built URL %s", url)
-        # now send the HTTP request
-        resp: dict = {
-            "status": 0,
-            "text": "",
-            "json": "",
-            "headers": ""
-        }
-        async with aiohttp.ClientSession() as session:
-            # Add auth header
-            session.headers.add("Authorization", self._auth_token)
-            session.headers.add("User-Agent", USER_AGENT)
-            session.headers.add("X-Moon-App-Id", MOBILE_APP_PKG)
-            session.headers.add("X-Moon-Os", OS_NAME)
-            session.headers.add("X-Moon-Os-Version", OS_VERSION)
-            session.headers.add("X-Moon-Model", DEVICE_MODEL)
-            session.headers.add("X-Moon-TimeZone", self._tz)
-            session.headers.add("X-Moon-Os-Language", self._language)
-            session.headers.add("X-Moon-App-Language", self._language)
-            session.headers.add("X-Moon-App-Display-Version", MOBILE_APP_VERSION)
-            session.headers.add("X-Moon-App-Internal-Version", MOBILE_APP_BUILD)
-            async with session.request(
-                method=e_point.get("method"),
-                url=url,
-                json=body
-            ) as response:
-                _LOGGER.debug("%s request to %s status code %s",
-                              e_point.get("method"),
-                              url,
-                              response.status)
-                if _check_http_success(response.status):
-                    resp["status"] = response.status
-                    resp["text"] = await response.text()
-                    resp["json"] = await response.json()
-                    resp["headers"] = response.headers
-                else:
-                    raise HttpException("HTTP Error", response.status, await response.text())
-
-        # now return the resp dict
-        return resp