pynintendoparental 1.1.3__py3-none-any.whl → 2.0.0__py3-none-any.whl

pynintendoparental/__init__.py

@@ -3,34 +3,33 @@
 
 import asyncio
 
-from pynintendoparental.exceptions import HttpException, NoDevicesFoundException
+from pynintendoauth.exceptions import HttpException
 
-from .authenticator import Authenticator
 from .api import Api
 from .const import _LOGGER
 from .device import Device
+from .exceptions import NoDevicesFoundException
+from .authenticator import Authenticator
+
 
 class NintendoParental:
     """Core Python API."""
 
-    def __init__(self,
-                 auth: Authenticator,
-                 timezone,
-                 lang) -> None:
+    def __init__(self, auth: Authenticator, timezone, lang) -> None:
         self._api: Api = Api(auth=auth, tz=timezone, lang=lang)
         self.account_id = auth.account_id
         self.devices: dict[str, Device] = {}
 
     async def _get_devices(self):
         """Gets devices from the API and stores in self.devices"""
+
         async def update_device(dev: Device):
             """Update a device."""
             try:
                 await dev.update()
             except Exception as err:
-                _LOGGER.exception("Error updating device %s: %s",
-                              dev.device_id,
-                              err)
+                _LOGGER.exception("Error updating device %s: %s", dev.device_id, err)
+
         try:
             response = await self._api.async_get_account_devices()
         except HttpException as err:
@@ -55,10 +54,9 @@ class NintendoParental:
         _LOGGER.debug("Update complete.")
 
     @classmethod
-    async def create(cls,
-                 auth: Authenticator,
-                 timezone: str = "Europe/London",
-                 lang: str = "en-GB") -> 'NintendoParental':
+    async def create(
+        cls, auth: Authenticator, timezone: str = "Europe/London", lang: str = "en-GB"
+    ) -> "NintendoParental":
         """Create an instance of NintendoParental."""
         self = cls(auth, timezone, lang)
         await self.update()

pynintendoparental/_version.py

@@ -1 +1 @@
-__version__ = "1.1.3"
+__version__ = "2.0.0"

pynintendoparental/api.py

@@ -2,6 +2,8 @@
 
 import aiohttp
 
+from pynintendoauth.exceptions import HttpException
+
 from .authenticator import Authenticator
 from .const import (
     ENDPOINTS,
@@ -13,13 +15,14 @@ from .const import (
     OS_VERSION,
     OS_NAME,
     DEVICE_MODEL,
-    _LOGGER
+    _LOGGER,
 )
-from .exceptions import HttpException
+
 
 def _check_http_success(status: int) -> bool:
     return status >= 200 and status < 300
 
+
 class Api:
     """Nintendo Parental Controls API."""
 
@@ -48,10 +51,10 @@ class Api:
             "X-Moon-TimeZone": self._tz,
             "X-Moon-Os-Language": self._language,
             "X-Moon-App-Language": self._language,
-            "Authorization": self._auth.access_token
+            "Authorization": self._auth.access_token,
         }
 
-    async def send_request(self, endpoint: str, body: object=None, **kwargs):
+    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
@@ -66,46 +69,45 @@ class Api:
         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 self._auth.client_session.request(
-            method=e_point.get("method"),
-            url=url,
-            json=body,
-            headers=self._headers
-        ) 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: dict = {"status": 0, "text": "", "json": "", "headers": ""}
+        response = await self._auth.async_authenticated_request(
+            method=e_point.get("method"), url=url, headers=self._headers, body=body
+        )
+        _LOGGER.debug(
+            "%s request to %s status code %s",
+            e_point.get("method"),
+            url,
+            response.status,
+        )
+        if not _check_http_success(response.status):
+            if response.content_type == "application/problem+json":
                 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:
-                if response.content_type == "application/problem+json":
-                    try:
-                        error = await response.json()
-                        if "detail" in error:
-                            raise HttpException(response.status, error["detail"], error.get("errorCode"))
-                    except (aiohttp.ContentTypeError, ValueError):
-                        # Fall through to the generic exception below on parsing failure.
-                        pass
-                raise HttpException(response.status, await response.text())
+                    error: dict = await response.json()
+                    if "detail" in error:
+                        raise HttpException(
+                            response.status, error["detail"], error.get("errorCode")
+                        )
+                except (aiohttp.ContentTypeError, ValueError):
+                    # Fall through to the generic exception below on parsing failure.
+                    pass
+            raise HttpException(response.status, await response.text())
+
+        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
 
         # now return the resp dict
         return resp
@@ -113,109 +115,83 @@ class Api:
     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
+            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"
-        )
+        return await self.send_request(endpoint="get_account_devices")
 
     async def async_get_account_device(self, device_id: str) -> dict:
         """Get account device."""
         return await self.send_request(
-            endpoint="get_account_device",
-            DEVICE_ID=device_id
+            endpoint="get_account_device", 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
+            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
+            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
+            endpoint="get_device_parental_control_setting", DEVICE_ID=device_id
         )
 
-    async def async_get_device_parental_control_setting_state(self, device_id: str) -> dict:
+    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
+            endpoint="get_device_parental_control_setting_state", DEVICE_ID=device_id
         )
 
-    async def async_get_device_monthly_summary(self, device_id: str, year: int, month: int) -> dict:
+    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}"
+            MONTH=f"{month:02d}",
         )
 
-    async def async_update_restriction_level(
-            self,
-            settings: dict
-        ) -> dict:
+    async def async_update_restriction_level(self, settings: dict) -> dict:
         """Update device restriction level."""
         return await self.send_request(
-            endpoint="update_restriction_level",
-            body=settings
+            endpoint="update_restriction_level", body=settings
         )
 
-    async def async_update_play_timer(
-            self,
-            settings: dict
-        ) -> dict:
+    async def async_update_play_timer(self, settings: dict) -> dict:
         """Update device play timer settings."""
-        return await self.send_request(
-            endpoint="update_play_timer",
-            body=settings
-        )
+        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:
+    async def async_update_unlock_code(self, new_code: str, device_id: str) -> dict:
         """Update device unlock code."""
         return await self.send_request(
             endpoint="update_unlock_code",
-            body={
-                "deviceId": device_id,
-                "unlockCode": new_code
-            }
+            body={"deviceId": device_id, "unlockCode": new_code},
         )
 
     async def async_update_extra_playing_time(
-        self,
-        device_id: str,
-        additional_time: int
+        self, device_id: str, additional_time: int
     ) -> dict:
         """Update device extra playing time."""
         body = {
             "deviceId": device_id,
             "additionalTime": additional_time,
-            "status": "TO_ADDED"
+            "status": "TO_ADDED",
         }
         if additional_time == -1:
             body["status"] = "TO_INFINITY"
             body.pop("additionalTime")
-        return await self.send_request(
-            endpoint="update_extra_playing_time",
-            body=body
-        )
+        return await self.send_request(endpoint="update_extra_playing_time", body=body)

pynintendoparental/application.py

@@ -4,6 +4,7 @@ from datetime import datetime
 
 from .const import _LOGGER
 
+
 class Application:
     """Model for an application"""
 
@@ -12,7 +13,7 @@ class Application:
         self.application_id: str = None
         self.first_played_date: datetime = None
         self.has_ugc: bool = None
-        self.image_url: str = None # uses small image from Nintendo
+        self.image_url: str = None  # uses small image from Nintendo
         self.playing_days: int = None
         self.shop_url: str = None
         self.name: str = None
@@ -20,11 +21,10 @@ class Application:
 
     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)
+        _LOGGER.debug("Updating today time played for app %s", self.application_id)
         self.today_time_played = daily_summary.get("playingTime", 0)
 
-    def update(self, updated: 'Application'):
+    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
@@ -37,7 +37,7 @@ class Application:
         self.today_time_played = updated.today_time_played
 
     @classmethod
-    def from_daily_summary(cls, raw: list) -> list['Application']:
+    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:
@@ -49,7 +49,7 @@ class Application:
         return built
 
     @staticmethod
-    def check_if_app_in_list(app_list: list['Application'], app: 'Application') -> bool:
+    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:
@@ -57,7 +57,9 @@ class Application:
         return False
 
     @staticmethod
-    def return_app_from_list(app_list: list['Application'], application_id: str) -> 'Application':
+    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:
@@ -65,28 +67,32 @@ class Application:
         return None
 
     @classmethod
-    def from_whitelist(cls, raw: dict) -> list['Application']:
+    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.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
 
     @classmethod
-    def from_monthly_summary(cls, raw: list) -> list['Application']:
+    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.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)

pynintendoparental/authenticator.py

@@ -0,0 +1,18 @@
+"""Nintendo Authentication."""
+
+from __future__ import annotations
+
+from pynintendoauth import NintendoAuth
+
+from .const import CLIENT_ID
+
+
+class Authenticator(NintendoAuth):
+    """Authentication functions."""
+
+    def __init__(self, session_token=None, client_session=None):
+        super().__init__(
+            client_id=CLIENT_ID,
+            session_token=session_token,
+            client_session=client_session,
+        )

pynintendoparental/const.py

@@ -4,6 +4,7 @@
 import logging
 
 _LOGGER = logging.getLogger(__package__)
+CLIENT_ID = "54789befb391a838"
 MOBILE_APP_PKG = "com.nintendo.znma"
 MOBILE_APP_VERSION = "2.2.0"
 MOBILE_APP_BUILD = "560"
@@ -14,47 +15,55 @@ DEVICE_MODEL = "Pixel 4 XL"
 BASE_URL = "https://app.lp1.znma.srv.nintendo.net/v2"
 USER_AGENT = f"moon_ANDROID/{MOBILE_APP_VERSION} ({MOBILE_APP_PKG}; build:{MOBILE_APP_BUILD}; {OS_STR})"
 
-DAYS_OF_WEEK = ["monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday"]
+DAYS_OF_WEEK = [
+    "monday",
+    "tuesday",
+    "wednesday",
+    "thursday",
+    "friday",
+    "saturday",
+    "sunday",
+]
 
 ENDPOINTS = {
     "get_account_devices": {
         "url": "{BASE_URL}/actions/user/fetchOwnedDevices",
-        "method": "GET"
+        "method": "GET",
     },
     "get_account_device": {
         "url": "{BASE_URL}/actions/user/fetchOwnedDevice?deviceId={DEVICE_ID}",
-        "method": "GET"
+        "method": "GET",
     },
     "get_device_daily_summaries": {
         "url": "{BASE_URL}/actions/playSummary/fetchDailySummaries?deviceId={DEVICE_ID}",
-        "method": "GET"
+        "method": "GET",
     },
     "get_device_monthly_summaries": {
         "url": "{BASE_URL}/actions/playSummary/fetchLatestMonthlySummary?deviceId={DEVICE_ID}",
-        "method": "GET"
+        "method": "GET",
     },
     "get_device_parental_control_setting": {
         "url": "{BASE_URL}/actions/parentalControlSetting/fetchParentalControlSetting?deviceId={DEVICE_ID}",
-        "method": "GET"
+        "method": "GET",
     },
     "update_restriction_level": {
         "url": "{BASE_URL}/actions/parentalControlSetting/updateRestrictionLevel",
-        "method": "POST"
+        "method": "POST",
     },
     "update_play_timer": {
         "url": "{BASE_URL}/actions/parentalControlSetting/updatePlayTimer",
-        "method": "POST"
+        "method": "POST",
     },
     "update_unlock_code": {
         "url": "{BASE_URL}/actions/parentalControlSetting/updateUnlockCode",
-        "method": "POST"
+        "method": "POST",
     },
     "get_device_monthly_summary": {
         "url": "{BASE_URL}/actions/playSummary/fetchMonthlySummary?deviceId={DEVICE_ID}&year={YEAR}&month={MONTH}&containLatest=false",
-        "method": "GET"
+        "method": "GET",
     },
     "update_extra_playing_time": {
         "url": "{BASE_URL}/actions/device/updateExtraPlayingTime",
-        "method": "POST"
-    }
+        "method": "POST",
+    },
 }