pynintendoparental 0.6.9__tar.gz → 0.7.1__tar.gz

{pynintendoparental-0.6.9 → pynintendoparental-0.7.1}/PKG-INFO

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

{pynintendoparental-0.6.9 → pynintendoparental-0.7.1}/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.1/pynintendoparental/_version.py

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

pynintendoparental-0.7.1/pynintendoparental/api.py

@@ -0,0 +1,205 @@
+"""API handler."""
+
+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 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": ""
+        }
+        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()
+                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.9 → pynintendoparental-0.7.1}/pynintendoparental/authenticator/__init__.py

@@ -2,7 +2,6 @@
 from __future__ import annotations
 
 import logging
-import re
 import base64
 import hashlib
 import random
@@ -60,11 +59,16 @@ def _rand():
 class Authenticator:
     """Authentication functions."""
 
-    def __init__(self, session_token = None, auth_code_verifier = None):
+    def __init__(
+            self,
+            session_token = None,
+            auth_code_verifier = None,
+            session: aiohttp.ClientSession = None
+        ):
         """Basic init."""
         _LOGGER.debug(">> Init authenticator.")
-        self.expires: datetime = None
-        self.access_token: str = None
+        self._at_expiry: datetime = None
+        self._access_token: str = None
         self.available_scopes: dict = None
         self.account_id: str = None
         self.account: dict = None
@@ -73,12 +77,25 @@ class Authenticator:
         self._id_token: str = None
         self._session_token: str = session_token
         self.login_url: str = None
+        if session is None:
+            session = aiohttp.ClientSession()
+        self.client_session: aiohttp.ClientSession = session
 
     @property
     def get_session_token(self) -> str:
         """Return the session token."""
         return self._session_token
 
+    @property
+    def access_token(self) -> str:
+        """Return the formatted access token."""
+        return f"Bearer {self._access_token}"
+
+    @property
+    def access_token_expired(self) -> bool:
+        """Check if the access token has expired."""
+        return self._at_expiry < (datetime.now()+timedelta(minutes=1))
+
     async def _request_handler(self, method, url, json=None, data=None, headers: dict=None):
         """Send a HTTP request"""
         if headers is None:
@@ -89,28 +106,25 @@ class Authenticator:
             "json": "",
             "headers": ""
         }
-        async with aiohttp.ClientSession() as session:
-            session.headers.add("Accept", "application/json")
-            for header in headers.keys():
-                session.headers.add(header, headers[header])
-            async with session.request(
-                method=method,
-                url=url,
-                json=json,
-                data=data
-            ) as resp:
-                response["status"] = resp.status
-                response["text"] = await resp.text()
-                response["json"] = await resp.json()
-                response["headers"] = resp.headers
+        async with self.client_session.request(
+            method=method,
+            url=url,
+            json=json,
+            data=data,
+            headers=headers
+        ) as resp:
+            response["status"] = resp.status
+            response["text"] = await resp.text()
+            response["json"] = await resp.json()
+            response["headers"] = resp.headers
         return response
 
     def _read_tokens(self, tokens: dict):
         """Reads tokens into self."""
         self.available_scopes = tokens.get("scope")
-        self.expires = datetime.now() + timedelta(seconds=tokens.get("expires_in"))
+        self._at_expiry = datetime.now() + timedelta(seconds=tokens.get("expires_in"))
         self._id_token = tokens.get("id_token")
-        self.access_token = tokens.get("access_token")
+        self._access_token = tokens.get("access_token")
 
     async def perform_login(self, session_token_code):
         """Retrieves initial tokens."""
@@ -159,7 +173,7 @@ class Authenticator:
                 method="GET",
                 url=MY_ACCOUNT_ENDPOINT,
                 headers={
-                    "Authorization": f"Bearer {self.access_token}"
+                    "Authorization": self.access_token
                 }
             )
             if account["status"] != 200:

{pynintendoparental-0.6.9 → pynintendoparental-0.7.1}/pynintendoparental/device.py

@@ -76,6 +76,13 @@ class Device:
         if callback not in self._callbacks:
             self._callbacks.append(callback)
 
+    def remove_device_callback(self, callback):
+        """Remove a given device callback."""
+        if not callable(callback):
+            raise ValueError("Object must be callable.")
+        if callback in self._callbacks:
+            self._callbacks.remove(callback)
+
     async def set_new_pin(self, pin: str):
         """Updates the pin for the device."""
         _LOGGER.debug(">> Device.set_new_pin(pin=REDACTED)")
@@ -115,10 +122,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()
 
@@ -209,9 +215,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"]:
@@ -235,9 +240,8 @@ 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)
@@ -276,7 +280,7 @@ class Device:
                 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) 
+                    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)
@@ -334,10 +338,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"]
@@ -351,9 +353,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]
@@ -362,11 +363,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,
@@ -385,12 +385,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):
@@ -403,10 +402,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.9 → pynintendoparental-0.7.1}/pynintendoparental.egg-info/PKG-INFO

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

pynintendoparental-0.6.9/pynintendoparental/_version.py

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

pynintendoparental-0.6.9/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