Move _Delay local class in global scope (bfxapi.websocket.client.bfx_websocket_client).

Apply pylint's linting rules to bfxapi/rest/__init__.py, bfxapi/rest/enums.py, bfxapi/rest/exceptions.py, bfxapi/rest/serializers.py and bfxapi/rest/types.py."
Apply pylint's linting rules to bfxapi/rest/endpoints/__init__.py, bfxapi/rest/endpoints/bfx_rest_interface.py and bfxapi/rest/endpoints/rest_public_endpoints.py.

bfxapi/rest/middleware/middleware.py

@@ -1,45 +1,51 @@
-import time, hmac, hashlib, json, requests
-
-from typing import TYPE_CHECKING, Optional, Any, cast
+from typing import TYPE_CHECKING, Optional, Any
 
 from http import HTTPStatus
+
+import time, hmac, hashlib, json, requests
+
 from ..enums import Error
 from ..exceptions import ResourceNotFound, RequestParametersError, InvalidAuthenticationCredentials, UnknownGenericError
-
 from ...utils.json_encoder import JSONEncoder
 
 if TYPE_CHECKING:
     from requests.sessions import _Params
 
-class Middleware(object):
-    def __init__(self, host: str, API_KEY: Optional[str] = None, API_SECRET: Optional[str] = None):
-        self.host, self.API_KEY, self.API_SECRET = host, API_KEY, API_SECRET
+class Middleware:
+    TIMEOUT = 30
+
+    def __init__(self, host: str, api_key: Optional[str] = None, api_secret: Optional[str] = None):
+        self.host, self.api_key, self.api_secret = host, api_key, api_secret
 
     def __build_authentication_headers(self, endpoint: str, data: Optional[str] = None):
-        assert isinstance(self.API_KEY, str) and isinstance(self.API_SECRET, str), \
+        assert isinstance(self.api_key, str) and isinstance(self.api_secret, str), \
             "API_KEY and API_SECRET must be both str to call __build_authentication_headers"
 
         nonce = str(round(time.time() * 1_000_000))
 
-        if data == None:
+        if data is None:
             path = f"/api/v2/{endpoint}{nonce}"
         else: path = f"/api/v2/{endpoint}{nonce}{data}"
 
         signature = hmac.new(
-            self.API_SECRET.encode("utf8"),
+            self.api_secret.encode("utf8"),
             path.encode("utf8"),
-            hashlib.sha384 
+            hashlib.sha384
         ).hexdigest()
 
         return {
             "bfx-nonce": nonce,
             "bfx-signature": signature,
-            "bfx-apikey": self.API_KEY
+            "bfx-apikey": self.api_key
         }
 
-    def _GET(self, endpoint: str, params: Optional["_Params"] = None) -> Any:
-        response = requests.get(f"{self.host}/{endpoint}", params=params)
-        
+    def _get(self, endpoint: str, params: Optional["_Params"] = None) -> Any:
+        response = requests.get(
+            url=f"{self.host}/{endpoint}",
+            params=params,
+            timeout=Middleware.TIMEOUT
+        )
+
         if response.status_code == HTTPStatus.NOT_FOUND:
             raise ResourceNotFound(f"No resources found at endpoint <{endpoint}>.")
 
@@ -47,23 +53,32 @@ class Middleware(object):
 
         if len(data) and data[0] == "error":
             if data[1] == Error.ERR_PARAMS:
-                raise RequestParametersError(f"The request was rejected with the following parameter error: <{data[2]}>")
+                raise RequestParametersError("The request was rejected with the "
+                    + f"following parameter error: <{data[2]}>")
 
-            if data[1] == None or data[1] == Error.ERR_UNK or data[1] == Error.ERR_GENERIC:
-                raise UnknownGenericError(f"The server replied to the request with a generic error with message: <{data[2]}>.")
+            if data[1] is None or data[1] == Error.ERR_UNK or data[1] == Error.ERR_GENERIC:
+                raise UnknownGenericError("The server replied to the request with "
+                    + f"a generic error with message: <{data[2]}>.")
 
         return data
 
-    def _POST(self, endpoint: str, params: Optional["_Params"] = None, body: Optional[Any] = None, _ignore_authentication_headers: bool = False) -> Any:
+    def _post(self, endpoint: str, params: Optional["_Params"] = None,
+            body: Optional[Any] = None, _ignore_authentication_headers: bool = False) -> Any:
         data = body and json.dumps(body, cls=JSONEncoder) or None
 
         headers = { "Content-Type": "application/json" }
 
-        if self.API_KEY and self.API_SECRET and _ignore_authentication_headers == False:
+        if self.api_key and self.api_secret and not _ignore_authentication_headers:
             headers = { **headers, **self.__build_authentication_headers(endpoint, data) }
 
-        response = requests.post(f"{self.host}/{endpoint}", params=params, data=data, headers=headers)
-        
+        response = requests.post(
+            url=f"{self.host}/{endpoint}",
+            params=params,
+            data=data,
+            headers=headers,
+            timeout=Middleware.TIMEOUT
+        )
+
         if response.status_code == HTTPStatus.NOT_FOUND:
             raise ResourceNotFound(f"No resources found at endpoint <{endpoint}>.")
 
@@ -71,12 +86,14 @@ class Middleware(object):
 
         if isinstance(data, list) and len(data) and data[0] == "error":
             if data[1] == Error.ERR_PARAMS:
-                raise RequestParametersError(f"The request was rejected with the following parameter error: <{data[2]}>")
+                raise RequestParametersError("The request was rejected with the "
+                    + f"following parameter error: <{data[2]}>")
 
             if data[1] == Error.ERR_AUTH_FAIL:
                 raise InvalidAuthenticationCredentials("Cannot authenticate with given API-KEY and API-SECRET.")
 
-            if data[1] == None or data[1] == Error.ERR_UNK or data[1] == Error.ERR_GENERIC:
-                raise UnknownGenericError(f"The server replied to the request with a generic error with message: <{data[2]}>.")
+            if data[1] is None or data[1] == Error.ERR_UNK or data[1] == Error.ERR_GENERIC:
+                raise UnknownGenericError("The server replied to the request with "
+                    + f"a generic error with message: <{data[2]}>.")
 
         return data