Refactor, add hon auth handler

pyhon/connection/handler.py

@@ -1,159 +0,0 @@
-import json
-from collections.abc import Generator, AsyncIterator, Coroutine
-from contextlib import asynccontextmanager
-from typing import Optional, Callable, Dict
-from typing_extensions import Self
-
-import aiohttp
-
-from pyhon import const, exceptions
-from pyhon.connection.auth import HonAuth, _LOGGER
-from pyhon.connection.device import HonDevice
-from pyhon.exceptions import HonAuthenticationError
-
-
-class HonBaseConnectionHandler:
-    _HEADERS: Dict = {
-        "user-agent": const.USER_AGENT,
-        "Content-Type": "application/json",
-    }
-
-    def __init__(self, session: Optional[aiohttp.ClientSession] = None) -> None:
-        self._create_session: bool = session is None
-        self._session: Optional[aiohttp.ClientSession] = session
-        self._auth: Optional[HonAuth] = None
-
-    async def __aenter__(self) -> Self:
-        return await self.create()
-
-    async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
-        await self.close()
-
-    @property
-    def auth(self) -> Optional[HonAuth]:
-        return self._auth
-
-    async def create(self) -> Self:
-        if self._create_session:
-            self._session = aiohttp.ClientSession()
-        return self
-
-    @asynccontextmanager
-    def _intercept(self, method: Callable, *args, loop: int = 0, **kwargs):
-        raise NotImplementedError
-
-    @asynccontextmanager
-    async def get(self, *args, **kwargs) -> AsyncIterator[Callable]:
-        if self._session is None:
-            raise exceptions.NoSessionException()
-        response: Callable
-        async with self._intercept(self._session.get, *args, **kwargs) as response:
-            yield response
-
-    @asynccontextmanager
-    async def post(self, *args, **kwargs) -> AsyncIterator[Callable]:
-        if self._session is None:
-            raise exceptions.NoSessionException()
-        response: Callable
-        async with self._intercept(self._session.post, *args, **kwargs) as response:
-            yield response
-
-    async def close(self) -> None:
-        if self._create_session and self._session is not None:
-            await self._session.close()
-
-
-class HonConnectionHandler(HonBaseConnectionHandler):
-    def __init__(
-        self, email: str, password: str, session: Optional[aiohttp.ClientSession] = None
-    ) -> None:
-        super().__init__(session=session)
-        self._device: HonDevice = HonDevice()
-        self._email: str = email
-        self._password: str = password
-        if not self._email:
-            raise HonAuthenticationError("An email address must be specified")
-        if not self._password:
-            raise HonAuthenticationError("A password address must be specified")
-
-    @property
-    def device(self) -> HonDevice:
-        return self._device
-
-    async def create(self) -> Self:
-        await super().create()
-        self._auth: HonAuth = HonAuth(
-            self._session, self._email, self._password, self._device
-        )
-        return self
-
-    async def _check_headers(self, headers: Dict) -> Dict:
-        if not (self._auth.cognito_token and self._auth.id_token):
-            await self._auth.authenticate()
-        headers["cognito-token"] = self._auth.cognito_token
-        headers["id-token"] = self._auth.id_token
-        return self._HEADERS | headers
-
-    @asynccontextmanager
-    async def _intercept(
-        self, method: Callable, *args, loop: int = 0, **kwargs
-    ) -> AsyncIterator:
-        kwargs["headers"] = await self._check_headers(kwargs.get("headers", {}))
-        async with method(*args, **kwargs) as response:
-            if (
-                self._auth.token_expires_soon or response.status in [401, 403]
-            ) and loop == 0:
-                _LOGGER.info("Try refreshing token...")
-                await self._auth.refresh()
-                async with self._intercept(
-                    method, *args, loop=loop + 1, **kwargs
-                ) as result:
-                    yield result
-            elif (
-                self._auth.token_is_expired or response.status in [401, 403]
-            ) and loop == 1:
-                _LOGGER.warning(
-                    "%s - Error %s - %s",
-                    response.request_info.url,
-                    response.status,
-                    await response.text(),
-                )
-                await self.create()
-                async with self._intercept(
-                    method, *args, loop=loop + 1, **kwargs
-                ) as result:
-                    yield result
-            elif loop >= 2:
-                _LOGGER.error(
-                    "%s - Error %s - %s",
-                    response.request_info.url,
-                    response.status,
-                    await response.text(),
-                )
-                raise HonAuthenticationError("Login failure")
-            else:
-                try:
-                    await response.json()
-                    yield response
-                except json.JSONDecodeError:
-                    _LOGGER.warning(
-                        "%s - JsonDecodeError %s - %s",
-                        response.request_info.url,
-                        response.status,
-                        await response.text(),
-                    )
-                    raise HonAuthenticationError("Decode Error")
-
-
-class HonAnonymousConnectionHandler(HonBaseConnectionHandler):
-    _HEADERS: Dict = HonBaseConnectionHandler._HEADERS | {"x-api-key": const.API_KEY}
-
-    @asynccontextmanager
-    async def _intercept(
-        self, method: Callable, *args, loop: int = 0, **kwargs
-    ) -> AsyncIterator:
-        kwargs["headers"] = kwargs.pop("headers", {}) | self._HEADERS
-        async with method(*args, **kwargs) as response:
-            if response.status == 403:
-                _LOGGER.error("Can't authenticate anymore")
-            yield response