pynintendoparental 1.1.3__tar.gz → 2.1.0__tar.gz

{pynintendoparental-1.1.3 → pynintendoparental-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pynintendoparental
-Version: 1.1.3
+Version: 2.1.0
 Summary: A Python module to interact with Nintendo Parental Controls
 Home-page: http://github.com/pantherale0/pynintendoparental
 Author: pantherale0
@@ -11,15 +11,20 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.8, <4
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: pynintendoauth==1.0.0
 Provides-Extra: dev
+Requires-Dist: aiofiles<26,>=23; extra == "dev"
 Requires-Dist: bandit<1.9,>=1.7; extra == "dev"
 Requires-Dist: black<26,>=23; extra == "dev"
 Requires-Dist: build<1.4,>=0.10; extra == "dev"
+Requires-Dist: Faker<39,>=38; extra == "dev"
 Requires-Dist: flake8<8,>=6; extra == "dev"
 Requires-Dist: isort<7,>=5; extra == "dev"
-Requires-Dist: mypy<1.19,>=1.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: syrupy<6,>=5; extra == "dev"
 Requires-Dist: twine<7,>=4; extra == "dev"
 Dynamic: author
 Dynamic: classifier
@@ -29,6 +34,7 @@ Dynamic: home-page
 Dynamic: license
 Dynamic: license-file
 Dynamic: provides-extra
+Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
 

{pynintendoparental-1.1.3 → pynintendoparental-2.1.0}/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-2.1.0/pynintendoparental/_version.py

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

pynintendoparental-2.1.0/pynintendoparental/api.py

@@ -0,0 +1,183 @@
+"""API handler."""
+
+import aiohttp
+
+from pynintendoauth.exceptions import HttpException
+
+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,
+)
+
+
+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 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.access_token,
+        }
+
+    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.access_token_expired:
+            _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": ""}
+        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:
+                    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
+
+    async def async_get_account_devices(self) -> dict:
+        """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
+        )
+
+    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_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_update_restriction_level(self, settings: dict) -> dict:
+        """Update device restriction level."""
+        return await self.send_request(
+            endpoint="update_restriction_level", body=settings
+        )
+
+    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)
+
+    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},
+        )
+
+    async def async_update_extra_playing_time(
+        self, device_id: str, additional_time: int
+    ) -> dict:
+        """Update device extra playing time."""
+        body = {
+            "deviceId": device_id,
+            "additionalTime": additional_time,
+            "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)

{pynintendoparental-1.1.3 → pynintendoparental-2.1.0}/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-2.1.0/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-1.1.3 → pynintendoparental-2.1.0}/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",
+    },
 }