Merge pull request #219 from Davi0kProgramsThings/feature/improvements

Merge branch `Davi0kProgramsThings:feature/improvements` into branch `bitfinexcom:v3-beta`.

Author: vigan-abd

bfxapi/client.py

@@ -1,7 +1,7 @@
-from typing import List, Optional
+from typing import List, Literal, Optional
 
 from .rest import BfxRestInterface
-from .websocket import BfxWebsocketClient
+from .websocket import BfxWebSocketClient
 from .urls import REST_HOST, WSS_HOST
 
 class Client:
@@ -13,8 +13,9 @@ def __init__(
             *,
             rest_host: str = REST_HOST,
             wss_host: str = WSS_HOST,
+            wss_timeout: Optional[float] = 60 * 15,
             log_filename: Optional[str] = None,
-            log_level: str = "INFO"
+            log_level: Literal["ERROR", "WARNING", "INFO", "DEBUG"] = "INFO"
     ):
         credentials = None
 
@@ -26,9 +27,10 @@ def __init__(
             credentials=credentials
         )
 
-        self.wss = BfxWebsocketClient(
+        self.wss = BfxWebSocketClient(
             host=wss_host,
             credentials=credentials,
+            wss_timeout=wss_timeout,
             log_filename=log_filename,
             log_level=log_level
         )

bfxapi/exceptions.py

@@ -1,16 +1,8 @@
 __all__ = [
     "BfxBaseException",
-
-    "LabelerSerializerException",
 ]
 
 class BfxBaseException(Exception):
     """
     Base class for every custom exception in bfxapi/rest/exceptions.py and bfxapi/websocket/exceptions.py.
     """
-
-class LabelerSerializerException(BfxBaseException):
-    """
-    This exception indicates an error thrown by the _Serializer class in bfxapi/labeler.py.
-    """
-    

bfxapi/rest/endpoints/rest_authenticated_endpoints.py

@@ -2,7 +2,11 @@
 from decimal import Decimal
 from datetime import datetime
 
-from .. types import Notification, \
+from ..middleware import Middleware
+
+from ..enums import Sort, OrderType, FundingOfferType
+
+from ...types import JSON, Notification, \
     UserInfo, LoginHistory, BalanceAvailable, \
     Order, Position, Trade, \
     FundingTrade, OrderTrade, Ledger, \
@@ -14,13 +18,9 @@
     PositionIncrease, PositionHistory, PositionSnapshot, \
     PositionAudit, DerivativePositionCollateral, DerivativePositionCollateralLimits
 
-from .. import serializers
-
-from .. serializers import _Notification
-from .. enums import Sort, OrderType, FundingOfferType
-from .. middleware import Middleware
+from ...types import serializers
 
-from ...utils.json_encoder import JSON
+from ...types.serializers import _Notification
 
 class RestAuthenticatedEndpoints(Middleware):
     def get_user_info(self) -> UserInfo:

bfxapi/rest/endpoints/rest_merchant_endpoints.py

@@ -1,16 +1,41 @@
-from typing import TypedDict, Dict, List, Union, Literal, Optional, Any
+import re
+
+from typing import Callable, TypeVar, cast, \
+    TypedDict, Dict, List, Union, Literal, Optional, Any
 
 from decimal import Decimal
 
-from .. types import \
+from ..middleware import Middleware
+
+from ..enums import MerchantSettingsKey
+
+from ...types import \
     InvoiceSubmission, InvoicePage, InvoiceStats, \
     CurrencyConversion, MerchantDeposit, MerchantUnlinkedDeposit
 
-from .. enums import MerchantSettingsKey
+#region Defining methods to convert dictionary keys to snake_case and camelCase.
+
+T = TypeVar("T")
+
+_to_snake_case: Callable[[str], str] = lambda string: re.sub(r"(?<!^)(?=[A-Z])", "_", string).lower()
+
+_to_camel_case: Callable[[str], str] = lambda string: \
+    (components := string.split("_"))[0] + str().join(c.title() for c in components[1:])
+
+def _scheme(data: T, adapter: Callable[[str], str]) -> T:
+    if isinstance(data, list):
+        return cast(T, [ _scheme(sub_data, adapter) for sub_data in data ])
+    if isinstance(data, dict):
+        return cast(T, { adapter(key): _scheme(value, adapter) for key, value in data.items() })
+    return data
+
+def _to_snake_case_keys(dictionary: T) -> T:
+    return _scheme(dictionary, _to_snake_case)
 
-from .. middleware import Middleware
+def _to_camel_case_keys(dictionary: T) -> T:
+    return _scheme(dictionary, _to_camel_case)
 
-from ...utils.camel_and_snake_case_helpers import to_snake_case_keys, to_camel_case_keys
+#endregion
 
 _CustomerInfo = TypedDict("_CustomerInfo", {
     "nationality": str, "resid_country": str, "resid_city": str, 
@@ -30,13 +55,13 @@ def submit_invoice(self,
                        duration: Optional[int] = None,
                        webhook: Optional[str] = None,
                        redirect_url: Optional[str] = None) -> InvoiceSubmission:
-        body = to_camel_case_keys({
+        body = _to_camel_case_keys({
             "amount": amount, "currency": currency, "order_id": order_id,
             "customer_info": customer_info, "pay_currencies": pay_currencies, "duration": duration,
             "webhook": webhook, "redirect_url": redirect_url
         })
 
-        data = to_snake_case_keys(self._post("auth/w/ext/pay/invoice/create", body=body))
+        data = _to_snake_case_keys(self._post("auth/w/ext/pay/invoice/create", body=body))
 
         return InvoiceSubmission.parse(data)
 
@@ -53,7 +78,7 @@ def get_invoices(self,
 
         response = self._post("auth/r/ext/pay/invoices", body=body)
 
-        return [ InvoiceSubmission.parse(sub_data) for sub_data in to_snake_case_keys(response) ]
+        return [ InvoiceSubmission.parse(sub_data) for sub_data in _to_snake_case_keys(response) ]
 
     def get_invoices_paginated(self,
                                page: int = 1,
@@ -66,13 +91,13 @@ def get_invoices_paginated(self,
                                crypto: Optional[List[str]] = None,
                                id: Optional[str] = None,
                                order_id: Optional[str] = None) -> InvoicePage:
-        body = to_camel_case_keys({
+        body = _to_camel_case_keys({
             "page": page, "page_size": page_size, "sort": sort,
             "sort_field": sort_field, "status": status, "fiat": fiat,
             "crypto": crypto, "id": id, "order_id": order_id
         })
 
-        data = to_snake_case_keys(self._post("auth/r/ext/pay/invoices/paginated", body=body))
+        data = _to_snake_case_keys(self._post("auth/r/ext/pay/invoices/paginated", body=body))
 
         return InvoicePage.parse(data)
 
@@ -94,15 +119,15 @@ def complete_invoice(self,
                          *,
                          deposit_id: Optional[int] = None,
                          ledger_id: Optional[int] = None) -> InvoiceSubmission:
-        return InvoiceSubmission.parse(to_snake_case_keys(self._post("auth/w/ext/pay/invoice/complete", body={
+        return InvoiceSubmission.parse(_to_snake_case_keys(self._post("auth/w/ext/pay/invoice/complete", body={
             "id": id, "payCcy": pay_currency, "depositId": deposit_id, 
             "ledgerId": ledger_id
         })))
 
     def expire_invoice(self, id: str) -> InvoiceSubmission:
         body = { "id": id }
         response = self._post("auth/w/ext/pay/invoice/expire", body=body)
-        return InvoiceSubmission.parse(to_snake_case_keys(response))
+        return InvoiceSubmission.parse(_to_snake_case_keys(response))
 
     def get_currency_conversion_list(self) -> List[CurrencyConversion]:
         return [
@@ -148,7 +173,7 @@ def get_deposits(self,
                      unlinked: Optional[bool] = None) -> List[MerchantDeposit]:
         body = { "from": start, "to": end, "ccy": ccy, "unlinked": unlinked }
         response = self._post("auth/r/ext/pay/deposits", body=body)
-        return [ MerchantDeposit(**sub_data) for sub_data in to_snake_case_keys(response) ]
+        return [ MerchantDeposit(**sub_data) for sub_data in _to_snake_case_keys(response) ]
 
     def get_unlinked_deposits(self,
                               ccy: str,
@@ -157,4 +182,4 @@ def get_unlinked_deposits(self,
                               end: Optional[int] = None) -> List[MerchantUnlinkedDeposit]:
         body = { "ccy": ccy, "start": start, "end": end }
         response = self._post("/auth/r/ext/pay/deposits/unlinked", body=body)
-        return [ MerchantUnlinkedDeposit(**sub_data) for sub_data in to_snake_case_keys(response) ]
+        return [ MerchantUnlinkedDeposit(**sub_data) for sub_data in _to_snake_case_keys(response) ]

bfxapi/rest/endpoints/rest_public_endpoints.py

@@ -1,8 +1,12 @@
-from typing import List, Union, Literal, Optional, Any, cast
+from typing import List, Dict, Union, Literal, Optional, Any, cast
 
 from decimal import Decimal
 
-from .. types import \
+from ..middleware import Middleware
+
+from ..enums import Config, Sort
+
+from ...types import \
     PlatformStatus, TradingPairTicker, FundingCurrencyTicker, \
     TickersHistory, TradingPairTrade, FundingCurrencyTrade, \
     TradingPairBook, FundingCurrencyBook, TradingPairRawBook, \
@@ -11,9 +15,7 @@
     FundingStatistic, PulseProfile, PulseMessage, \
     TradingMarketAveragePrice, FundingMarketAveragePrice, FxRate
 
-from .. import serializers
-from .. enums import Config, Sort
-from .. middleware import Middleware
+from ...types import serializers
 
 class RestPublicEndpoints(Middleware):
     def conf(self, config: Config) -> Any:
@@ -22,37 +24,46 @@ def conf(self, config: Config) -> Any:
     def get_platform_status(self) -> PlatformStatus:
         return serializers.PlatformStatus.parse(*self._get("platform/status"))
 
-    def get_tickers(self, symbols: List[str]) -> List[Union[TradingPairTicker, FundingCurrencyTicker]]:
+    def get_tickers(self, symbols: List[str]) -> Dict[str, Union[TradingPairTicker, FundingCurrencyTicker]]:
         data = self._get("tickers", params={ "symbols": ",".join(symbols) })
 
         parsers = { "t": serializers.TradingPairTicker.parse, "f": serializers.FundingCurrencyTicker.parse }
 
-        return [ cast(Union[TradingPairTicker, FundingCurrencyTicker], \
-            parsers[sub_data[0][0]](*sub_data)) for sub_data in data ]
+        return {
+            symbol: cast(Union[TradingPairTicker, FundingCurrencyTicker],
+                parsers[symbol[0]](*sub_data)) for sub_data in data
+                    if (symbol := sub_data.pop(0))
+        }
 
-    def get_t_tickers(self, pairs: Union[List[str], Literal["ALL"]]) -> List[TradingPairTicker]:
-        if isinstance(pairs, str) and pairs == "ALL":
-            return [ cast(TradingPairTicker, sub_data) for sub_data in self.get_tickers([ "ALL" ]) \
-                if cast(str, sub_data.symbol).startswith("t") ]
+    def get_t_tickers(self, symbols: Union[List[str], Literal["ALL"]]) -> Dict[str, TradingPairTicker]:
+        if isinstance(symbols, str) and symbols == "ALL":
+            return {
+                symbol: cast(TradingPairTicker, sub_data)
+                    for symbol, sub_data in self.get_tickers([ "ALL" ]).items()
+                        if symbol.startswith("t")
+            }
 
-        data = self.get_tickers(list(pairs))
+        data = self.get_tickers(list(symbols))
 
-        return cast(List[TradingPairTicker], data)
+        return cast(Dict[str, TradingPairTicker], data)
 
-    def get_f_tickers(self, currencies: Union[List[str], Literal["ALL"]]) -> List[FundingCurrencyTicker]:
-        if isinstance(currencies, str) and currencies == "ALL":
-            return [ cast(FundingCurrencyTicker, sub_data) for sub_data in self.get_tickers([ "ALL" ]) \
-                if cast(str, sub_data.symbol).startswith("f") ]
+    def get_f_tickers(self, symbols: Union[List[str], Literal["ALL"]]) -> Dict[str, FundingCurrencyTicker]:
+        if isinstance(symbols, str) and symbols == "ALL":
+            return {
+                symbol: cast(FundingCurrencyTicker, sub_data)
+                    for symbol, sub_data in self.get_tickers([ "ALL" ]).items()
+                        if symbol.startswith("f")
+            }
 
-        data = self.get_tickers(list(currencies))
+        data = self.get_tickers(list(symbols))
 
-        return cast(List[FundingCurrencyTicker], data)
+        return cast(Dict[str, FundingCurrencyTicker], data)
 
-    def get_t_ticker(self, pair: str) -> TradingPairTicker:
-        return serializers.TradingPairTicker.parse(*([pair] + self._get(f"ticker/{pair}")))
+    def get_t_ticker(self, symbol: str) -> TradingPairTicker:
+        return serializers.TradingPairTicker.parse(*self._get(f"ticker/{symbol}"))
 
-    def get_f_ticker(self, currency: str) -> FundingCurrencyTicker:
-        return serializers.FundingCurrencyTicker.parse(*([currency] + self._get(f"ticker/{currency}")))
+    def get_f_ticker(self, symbol: str) -> FundingCurrencyTicker:
+        return serializers.FundingCurrencyTicker.parse(*self._get(f"ticker/{symbol}"))
 
     def get_tickers_history(self,
                             symbols: List[str],
@@ -164,26 +175,29 @@ def get_candles_last(self,
         data = self._get(f"candles/trade:{tf}:{symbol}/last", params=params)
         return serializers.Candle.parse(*data)
 
-    def get_derivatives_status(self, keys: Union[List[str], Literal["ALL"]]) -> List[DerivativesStatus]:
+    def get_derivatives_status(self, keys: Union[List[str], Literal["ALL"]]) -> Dict[str, DerivativesStatus]:
         if keys == "ALL":
             params = { "keys": "ALL" }
         else:  params = { "keys": ",".join(keys) }
 
         data = self._get("status/deriv", params=params)
 
-        return [ serializers.DerivativesStatus.parse(*sub_data) for sub_data in data ]
+        return {
+            key: serializers.DerivativesStatus.parse(*sub_data)
+                for sub_data in data
+                    if (key := sub_data.pop(0))
+        }
 
     def get_derivatives_status_history(self,
-                                       type: str,
-                                       symbol: str,
+                                       key: str,
                                        *,
                                        sort: Optional[Sort] = None,
                                        start: Optional[str] = None,
                                        end: Optional[str] = None,
                                        limit: Optional[int] = None) -> List[DerivativesStatus]:
         params = { "sort": sort, "start": start, "end": end, "limit": limit }
-        data = self._get(f"status/{type}/{symbol}/hist", params=params)
-        return [ serializers.DerivativesStatus.parse(*([symbol] + sub_data)) for sub_data in data ]
+        data = self._get(f"status/deriv/{key}/hist", params=params)
+        return [ serializers.DerivativesStatus.parse(*sub_data) for sub_data in data ]
 
     def get_liquidations(self,
                          *,

bfxapi/rest/exceptions.py

@@ -1,4 +1,4 @@
-from .. exceptions import BfxBaseException
+from ..exceptions import BfxBaseException
 
 __all__ = [
     "BfxRestException",

bfxapi/tests/__init__.py

@@ -1,16 +1,14 @@
 import unittest
 
-from .test_rest_serializers import TestRestSerializers
-from .test_websocket_serializers import TestWebsocketSerializers
-from .test_labeler import TestLabeler
-from .test_notification import TestNotification
+from .test_types_labeler import TestTypesLabeler
+from .test_types_notification import TestTypesNotification
+from .test_types_serializers import TestTypesSerializers
 
 def suite():
     return unittest.TestSuite([
-        unittest.makeSuite(TestRestSerializers),
-        unittest.makeSuite(TestWebsocketSerializers),
-        unittest.makeSuite(TestLabeler),
-        unittest.makeSuite(TestNotification),
+        unittest.makeSuite(TestTypesLabeler),
+        unittest.makeSuite(TestTypesNotification),
+        unittest.makeSuite(TestTypesSerializers),
     ])
 
 if __name__ == "__main__":

bfxapi/tests/test_labeler.py bfxapi/tests/test_types_labeler.pybfxapi/tests/test_labeler.py renamed to bfxapi/tests/test_types_labeler.py

@@ -3,10 +3,10 @@
 from typing import Optional
 
 from dataclasses import dataclass
-from ..exceptions import LabelerSerializerException
-from ..labeler import _Type, generate_labeler_serializer, generate_recursive_serializer
 
-class TestLabeler(unittest.TestCase):
+from ..types.labeler import _Type, generate_labeler_serializer, generate_recursive_serializer
+
+class TestTypesLabeler(unittest.TestCase):
     def test_generate_labeler_serializer(self):
         @dataclass
         class Test(_Type):
@@ -24,8 +24,8 @@ class Test(_Type):
         self.assertListEqual(serializer.get_labels(), [ "A", "B", "C" ],
             msg="_Serializer::get_labels() should return the right list of labels.")
 
-        with self.assertRaises(LabelerSerializerException,
-                msg="_Serializer should raise LabelerSerializerException if given " \
+        with self.assertRaises(AssertionError,
+                msg="_Serializer should raise an AssertionError if given " \
                         "fewer arguments than the serializer labels."):
             serializer.parse(5, 65.0, "X")
 

bfxapi/tests/test_notification.py bfxapi/tests/test_types_notification.pybfxapi/tests/test_notification.py renamed to bfxapi/tests/test_types_notification.py

@@ -1,11 +1,11 @@
 import unittest
 
 from dataclasses import dataclass
-from ..labeler import generate_labeler_serializer
-from ..notification import _Type, _Notification, Notification
+from ..types.labeler import generate_labeler_serializer
+from ..types.notification import _Type, _Notification, Notification
 
-class TestNotification(unittest.TestCase):
-    def test_notification(self):
+class TestTypesNotification(unittest.TestCase):
+    def test_types_notification(self):
         @dataclass
         class Test(_Type):
             A: int