""" Copyright (c) 2023 Proton AG This file is part of Proton. Proton is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. Proton is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with ProtonVPN. If not, see . """ import weakref from dataclasses import dataclass from typing import Optional, Any, Tuple @dataclass class RawResponse: """ A response that contains the status code and headers along with the body as json. This gives more context to clients when receiving a response. This type is returned where return_raw is set to True. :param status_code: The status code of the response :param headers: The headers in the response :param json: The response parsed as json :param data: The response as a binary blob of bytes """ status_code: int headers: Tuple[Tuple[str, Any]] json: Optional[dict] data: Optional[bytes] def find_first_header(self, key, default=None): """ Searches for the given key in the headers and returns the first value if found, otherwise returns the default value. """ for k, v in self.headers: if key == k: return v return default class Transport: """ The base class of all transports. This class should be subclassed to implement the async_api_request method, which is the main method that is used to make requests to the API. A transport abstracts away the details of how requests are made to the API, for example, it could be using requests, aiohttp, or any other library. """ def __init__(self, session): self.__session = weakref.ref(session) @property def _session(self): return self.__session() @property def _environment(self): #Shortcut to access environment return self._session.environment def __eq__(self, other): # It's the same transport if it's the same type (that's what users would generally assume) return self.__class__ == other.__class__ async def is_working(self): try: return await self.async_api_request('/tests/ping').get('Code') == '1000' except: return False async def async_api_request( self, endpoint, jsondata=None, additional_headers=None, method=None, params=None ): raise NotImplementedError("async_api_request should be implemented") class TransportFactory: def __init__(self, cls, *args, **kwargs): self._cls = cls self._args = args self._kwargs = kwargs def __call__(self, session): return self._cls(session, *self._args, **self._kwargs) def __eq__(self, other): # It's the same transport if it's the same type (that's what users would generally assume) return self._cls == other._cls